\j]dZddlmZmZmZmZmZddlmZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZdd lmZmZdd lmZdd lmZdd lmZdd lmZddlm Z m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6ddlm2Z2ddl m7Z7Gdde2Z8de6de9defdZ:GddZ;dd gZcp|j||d}t|tr|j|S|S)Nc|Sr(rIxs r*z!_get_store_item..Fs!r,)r2 isinstancedictdecode)r&r3r4r=s r*_get_store_itemrRBs3 99T3 ,D *4 64;;t @D@r,c leZdZdZddedefdZdZdZde e fdZ d Z d Z d Zd Z d de deeefde ede efdZdeeeffdZdefdZdefdZdZde deeefdedefdZde deeefdedefdZde deeefdefdZdeeefdefdZ deeefde fdZ!e"de#fdZ$y )!LDClientaThe LaunchDarkly SDK client object. Applications should configure the client at startup time and continue to use it throughout the lifetime of the application, rather than creating instances on the fly. The best way to do this is with the singleton methods :func:`ldclient.set_config()` and :func:`ldclient.get()`. However, you may also call the constructor directly if you need to maintain multiple instances. Client instances are thread-safe. config start_waitct||_|jjd|_t |_t d|_t d|_t|jj|_ t|jj|_tfdfdfdt |_|jj$rt!j&d|jj(rt!j&d|j+|j}t-j.}|j1|j|j|||_|j2j5|d kDra|jj$sK|jj(s5t!j&d t7|zd z|j9||j2j;durt!j&d yt!j<d y)zConstructs a new LDClient instance. :param config: optional custom configuration :param start_wait: the number of seconds to wait for a successful connection to LaunchDarkly NFTc&tt|Sr()rRr r4r&s r*rNz#LDClient.__init__..kx=r,c&tt|Sr()rRr!rYs r*rNz#LDClient.__init__..lrZr,c&j|Sr()get_user_membership)r4big_segment_store_managers r*rNz#LDClient.__init__..ms1EEcJr,z+Started LaunchDarkly Client in offline modez'Started LaunchDarkly Client in LDD moderzWaiting up to z1 seconds for LaunchDarkly client to initialize...zStarted LaunchDarkly Client: OKzuInitialization timeout exceeded for LaunchDarkly Client or an error occurred. Feature Flags may not yet be available.)r_config _validate_event_processorr#_lockr_event_factory_default_event_factory_with_reasonsr% feature_store_storer big_segments$_LDClient__big_segment_store_managerrr _evaluatorofflineinfouse_ldd_set_event_processor threadingEvent_make_update_processor_update_processorstartrFwaitr@warning)r)rUrVdiagnostic_accumulatorupdate_processor_readyr^r&s @@r*r+zLDClient.__init__Ts     $V &25&9#+7+=(*4<<+E+EF $:4<<;T;T$U!+D(# = = J    <<   HHB C <<   HH> ?!%!:!:4<$,,"6"6t||?S?S HH%J7:mm n " ' ' 3  ! ! - - /4 7 HH6 7 KK? @r,c|js |jst|_y|js8t |}|j rdn t|}t|||_|S|j ||_y)N)ru) rj send_eventsrraevent_processor_classrdiagnostic_opt_outrr)r)rU diagnostic_idrus r*rmzLDClient._set_event_processorsu >>!3!3$6$8D !++08M-3-F-FTLbcpLq "$9&[q$rD !) ) & < tjdt|jz|j|||S|js |j r t |||S|jrt||||Stjdtjd|jr|j|}n t|}t||||S)Nz'Using user-specified update processor: zDisabling streaming APIzXYou should only disable the streaming API if instructed to do so by LaunchDarkly support) update_processor_classrrkrFrjrlrstreamrrtfeature_requester_classrr)r)rUr&readyrufeature_requesters r*rpzLDClient._make_update_processors  ( ( HH>VEbEbAcc d00F F >>V^^&vue< < ==+FE5BXY Y *+ no  ) ) & > >v F  4V < %f.?NNr,r>c.|jjS)z(Returns the configured SDK key. )r_sdk_keyrAs r* get_sdk_keyzLDClient.get_sdk_key||###r,ctjd|jj|jj|j jy)zReleases all threads and network connections used by the LaunchDarkly client. Do not attempt to use the client after calling this method. zClosing LaunchDarkly client..N)rrkrastoprqrhrAs r*closezLDClient.closesG 01 ""$ ##% ((--/r,c|Sr(rIrAs r* __enter__zLDClient.__enter__s r,c$|jyr()r)r)typevalue tracebacks r*__exit__zLDClient.__exit__s  r,c:|jj|yr()ra send_event)r)events r* _send_eventzLDClient._send_events ((/r,N event_namecontextdata metric_valuec:t|ts/tjdttj |}|j s#tjd|jzy|j|jj||||y)aTracks that an application-defined event occurred. This method creates a "custom" analytics event containing the specified event name (key) and context properties. You may attach arbitrary data or a metric value to the event with the optional ``data`` and ``metric_value`` parameters. Note that event delivery is asynchronous, so the event may not actually be sent until later; see :func:`flush()`. If you pass a dictionary of user attributes instead of a :class:`ldclient.Context`, the SDK will convert the user to a Context. There is some overhead to this conversion, so it is more efficient to pass a Context. DEPRECATED: This method will no longer accept a dictionary for the context parameter starting in 9.0.0 :param event_name: the name of the event :param context: the evaluation context or user associated with the event :param data: optional additional data associated with the event :param metric_value: a numeric value used by the LaunchDarkly experimentation feature in numeric custom metrics; can be omitted if this event is used by only non-numeric metrics z.track will require a Context instance in 9.0.0zInvalid context for track (%s)N) rOr warningswarnDeprecationWarning from_dictvalidrrterrorrrcnew_custom_event)r)rrrrs r*trackzLDClient.tracksu.'7+ MMJL^ _''0G}} KK87==H I   T88II*|- .r,ct|ts/tjdttj |}|j s#tjd|jzy|jdk(r"|jstjdy|j|jj|y)aReports details about an evaluation context. This method simply creates an analytics event containing the context properties, to that LaunchDarkly will know about that context if it does not already. Evaluating a flag, by calling :func:`variation()` or :func:`variation_detail()`, also sends the context information to LaunchDarkly (if events are enabled), so you only need to use :func:`identify()` if you want to identify the context without evaluating a flag. If you pass a dictionary of user attributes instead of a :class:`ldclient.Context`, the SDK will convert the user to a Context. There is some overhead to this conversion, so it is more efficient to pass a Context. DEPRECATED: This method will no longer accept a dictionary for the context parameter starting in 9.0.0 :param context: the context to register z1identify will require a Context instance in 9.0.0z!Invalid context for identify (%s)zEmpty user key for identifyN)rOr rrrrrrrtrr4multiplerrcnew_identify_eventr)rs r*identifyzLDClient.identifys&'7+ MMMOa b''0G}} KK;gmmK L [[B w'7'7 KK5 6   T88KKGT Ur,c.|jjS)z7Returns true if the client is in offline mode. )r_rjrAs r* is_offlinezLDClient.is_offlinerr,c|jxs2|jjxs|jj S)aReturns true if the client has successfully connected to LaunchDarkly. If this returns false, it means that the client has not yet successfully connected to LaunchDarkly. It might still be in the process of starting up, or it might be attempting to reconnect after an unsuccessful attempt, or it might have received an unrecoverable error (such as an invalid SDK key) and given up. )rr_rlrqr@rAs r*is_initializedzLDClient.is_initializeds4 `DLL$8$8`DY>YZ```r,c>|j||||jS)aCalculates the value of a feature flag for a given context, and returns an object that describes the way the value was determined. The ``reason`` property in the result will also be included in analytics events, if you are capturing detailed event data for this flag. If you pass a dictionary of user attributes instead of a :class:`ldclient.Context`, the SDK will convert the user to a Context. There is some overhead to this conversion, so it is more efficient to pass a Context. DEPRECATED: This method will no longer accept a dictionary for the context parameter starting in 9.0.0 :param key: the unique key for the feature flag :param context: the evaluation context or user :param default: the default value of the flag, to be used if the value is not available from LaunchDarkly :return: an :class:`ldclient.evaluation.EvaluationDetail` object that includes the feature flag value and evaluation reason )rrdrs r*variation_detailzLDClient.variation_detail,s!(&&sGWd>^>^__r,c 4|jj||}|jjrt|dt dS|j s|j jrtjd|znbtjdt|zdz|zt d}|j|j||||t|d|St|ts/tj dt"tj$|}|j&s8tjd|j(zt|dt dS t+|j t,|}|s;t d }|j|j||||t|d|S |j8j;|||}|j<xsgD]} |j| |j>} | jArt|d| jB} |j|jE||| || S#t.$r}tj(d|d t1|tj2t5j6t d }|j|j||||t|d|cYd}~Sd}~wwxYw#t.$r}tj(d |d t1|tj2t5j6t d }|j|jG||||t|d|cYd}~Sd}~wwxYw) NCLIENT_NOT_READYz~Feature Flag evaluation attempted before client has initialized - using last known values from feature store for feature key: zpFeature Flag evaluation attempted before client has initialized! Feature store unavailable - returning default: z for feature key: z:variation methods will require a Context instance in 9.0.0zEContext was invalid for flag evaluation (%s); returning default valueUSER_NOT_SPECIFIEDz0Unexpected error while retrieving feature flag "z": EXCEPTIONFLAG_NOT_FOUNDz0Unexpected error while evaluating feature flag ")$r_ get_defaultrjr rrrfr@rrtrFrnew_unknown_flag_eventrOr rrrrrrrRr Exceptionreprdebugr format_excrievaluateeventsdetailis_default_valuereasonnew_eval_eventnew_default_event) r)r4rr event_factoryrflageresultrrs r*rzLDClient._evaluate_internalBs,,**38 <<  #GT<@R3ST T""${{&& ]`ccd Ow<(*>?ADEF%&89  !E!Ec7T[]c!de'v>>'7+ MMVXj k''0G}} KK_biboboo p#GT<@T3UV V ;"4;;#>D!"23F   ]AA#wPWY_` a#GT6: : ?11$O#]]0b,E$$U+,**,-gtV]]KF  !=!=dGVU\!]^ ' ; IIUXZ^_`Zab c IIi**, -!+.F   ]AA#wPWY_` a#GT6: :  ;( ? Y\^bcd^efg )..01%k2  !@!@wPWY_!`a'v>>  ?s?.I"BK>" K;+BK60K;6K;> NBN NNc 2|jjr tjdt dS|j sL|j jrtjdn tjdt dSt|ts/tjdttj|}|js-tjd|jzt dSt d}|j!dd}|j!d d}|j!d d} |j j#t$d }| t'd  |j-D]\} } |r| j!dds |j.j1| ||j2j4} t?j@| | jB} | d| jD| jF| jB| d| j!ddxs| | | j!dd d}|jI||||S#t($r6}tjdt+|zt dcYd }~Sd }~wwxYw#t($rh}tjd| dt+|tj6t9j:ddd} t=d d | } Yd }~8d }~wwxYw)aReturns an object that encapsulates the state of all feature flags for a given user, including the flag values and also metadata that can be used on the front end. See the JavaScript SDK Reference Guide on `Bootstrapping `_. This method does not send analytics events back to LaunchDarkly. DEPRECATED: This method will no longer accept a dictionary for the context parameter starting in 9.0.0 :param user: the end user requesting the feature flags :param kwargs: optional parameters affecting how the state is computed - see below :Keyword Arguments: * **client_side_only** (*boolean*) -- set to True to limit it to only flags that are marked for use with the client-side SDK (by default, all flags are included) * **with_reasons** (*boolean*) -- set to True to include evaluation reasons in the state (see :func:`variation_detail()`) * **details_only_for_tracked_flags** (*boolean*) -- set to True to omit any metadata that is normally only used for event generation, such as flag versions and evaluation reasons, unless the flag has event tracking or debugging turned on :return: a FeatureFlagsState object (will never be None; its ``valid`` property will be False if the client is offline, has not been initialized, or the user is None or has no key) zNall_flags_state() called, but client is in offline mode. Returning empty stateFzlall_flags_state() called before client has finished initializing! Using last known values from feature storezsall_flags_state() called before client has finished initializing! Feature store unavailable - returning empty statez8all_flags_state will require a Context instance in 9.0.0zEContext was invalid for all_flags_state (%s); returning default valueTclient_side_only with_reasonsdetails_only_for_tracked_flagsc|Sr(rIrLs r*rNz*LDClient.all_flags_state..sAr,Nzfeature store errorz+Unable to read flags for all_flag_state: %s clientSidezError evaluating flag "z" in all_flags_state: ERRORr)r3 errorKindr4r: trackEventsdebugEventsUntilDate)r4rrrr:r trackReasonr)%r_rjrrtrrrfr@rOr rrrrrrr2r7r ValueErrorrritemsrirrcrrrrr r is_experimentrrvariation_indexadd_flag)r)rkwargsstate client_onlyrdetails_only_if_tracked flags_maprr4rrrrequires_experiment_data flag_states r*all_flags_statezLDClient.all_flags_statevs6 <<   KKh i$U+ +""${{&& KL RS(//'7+ MMTVh i''0G}} KK_biboboo p$U+ +!$'jj!3U; zz.%8 "(**-Mu"U , +>I  !677! #* NIC488L%#@ >11$A\A\]dd(4'A'A$ 'V $E{#33 -- ?#xx u=YAY7(,1G(N J NN:|5L M/ N2 ; , IICd1gM N$U+ + , > SVX\]^X_`a )..01") D)$f=  >s7 .I#(1J%# J",+JJ"J"% L.ALLct|ts/tjdttj |}|j s#tjd|jzytjt|jjj|j jt"j$j'S)aCreates a hash string that can be used by the JavaScript SDK to identify a context. For more information, see the documentation on `Secure mode `_. DEPRECATED: This method will no longer accept a dictionary for the context parameter starting in 9.0.0 :param context: the evaluation context or user :return: the hash string z9secure_mode_hash will require a Context instance in 9.0.0zCContext was invalid for secure_mode_hash (%s); returning empty hashr)rOr rrrrrrrtrhmacnewrFr_rencodefully_qualified_keyhashlibsha256 hexdigestrs r*secure_mode_hashzLDClient.secure_mode_hashs'7+ MMUWi j''0G}} KK]`g`m`mm nxxDLL00188:G$D$ aa -aSa5$+?a#aRUa"`C`% 2F`QT`Yi`,2?c2?E'4-4H2?SV2?hRuWd]';RJ[Rh~gtm(<~~&@3P@@r,rTr )=rEtypingrrrrrimplr rrrnrrldclient.configr ldclient.contextr ldclient.feature_storer ldclient.evaluationr rldclient.impl.big_segmentsr*ldclient.impl.datasource.feature_requesterr ldclient.impl.datasource.pollingr"ldclient.impl.datasource.streamingrldclient.impl.evaluatorrr ldclient.impl.events.diagnosticsrr$ldclient.impl.events.event_processorrldclient.impl.events.typesrldclient.impl.stubsrrldclient.impl.utilrrldclient.interfacesrrrldclient.versioned_data_kindr r!r"r#r%rFrRrT__all__rIr,r*rs76 "$=C=KCG;YF3G/]]NN/&&:A!2AAA\@\@~ x r,