\jnddlZddlmZmZmZmZmZmZddlm Z ddl m Z ddl m Z ddlmZdZdZdZGd d ZGd d ZGd dZy)N)AnyDictListOptionalSetUnion)Context)FEATURES)_TestDataSource) ReadWriteLockc|rtStSN)TRUE_VARIATION_INDEXFALSE_VARIATION_INDEX) variations I/root/env/lib/python3.12/site-packages/ldclient/integrations/test_data.py_variation_for_booleanr s##$$c\eZdZdZdZdZdZeddZde ddfd Z dd Z de fd Z d Zy )TestDataaA mechanism for providing dynamically updatable feature flag state in a simplified form to an SDK client in test scenarios. Unlike ``Files``, this mechanism does not use any external resources. It provides only the data that the application has put into it using the ``update`` method. :: td = TestData.data_source() td.update(td.flag('flag-key-1').variation_for_all_users(True)) client = LDClient(config=Config('SDK_KEY', update_processor_class = td)) # flags can be updated at any time: td.update(td.flag('flag-key-1'). \ variation_for_user('some-user-key', True). \ fallthrough_variation(False)) The above example uses a simple boolean flag, but more complex configurations are possible using the methods of the ``FlagBuilder`` that is returned by ``flag``. ``FlagBuilder`` supports many of the ways a flag can be configured on the LaunchDarkly dashboard, but does not currently support 1. rule operators other than "in" and "not in", or 2. percentage rollouts. If the same ``TestData`` instance is used to configure multiple ``LDClient`` instances, any changes made to the data will propagate to all of the ``LDClient`` instances. FcLi|_i|_t|_g|_yr)_flag_builders_current_flagsr _lock _instancesselfs r__init__zTestData.__init__0s"  "_ rct|||} |jj|jj ||jj |S#|jj wxYwr)r rlockrappendunlock)rconfigstoreready data_sources r__call__zTestData.__call__6s_%eT59  JJOO  OO " "; / JJ    JJ   s 5A A<returnctS)znCreates a new instance of the test data source. :return: a new configurable test data source )rrrr'zTestData.data_source@s zrkey FlagBuilderc |jj||jvrF|j|r7|j|j|jj St |j |jj S#|jj wxYw)a/Creates or copies a ``FlagBuilder`` for building a test flag configuration. If this flag key has already been defined in this ``TestData`` instance, then the builder starts with the same configuration that was last provided for this flag. Otherwise, it starts with a new default configuration in which the flag has ``True`` and ``False`` variations, is ``True`` for all users when targeting is turned on and ``False`` otherwise, and currently has targeting turned on. You can change any of those properties, and provide more complex behavior, using the ``FlagBuilder`` methods. Once you have set the desired configuration, pass the builder to ``update``. :param str key: the flag key :return: the flag configuration builder object )rrlockr_copyrunlockr- boolean_flagrr,s rflagz TestData.flagHs  ! JJ   d)))d.A.A#.F**3/557 JJ   #3'446 JJ   DJJ   sAB#0B##B?c |jjd}|j|jvr |j|j}|r|d}|j |dz}||j|j<|j |j |j<|jj|jD]}|j||S#|jjwxYw)aUpdates the test data with the specified flag configuration. This has the same effect as if a flag were added or modified on the LaunchDarkly dashboard. It immediately propagates the flag change to any ``LDClient`` instance(s) that you have already configured to use this ``TestData``. If no ``LDClient`` has been started yet, it simply adds this flag to the test data which will be provided to any ``LDClient`` that you subsequently configure. Any subsequent changes to this ``FlagBuilder`` instance do not affect the test data, unless you call ``update`` again. :param flag_builder: a flag configuration builder :return: self (the TestData object) rversionr ) rr!_keyr_buildr0rr#rupsert)r flag_builder old_versionold_flagnew_flaginstances rupdatezTestData.updateas JJOO K  D$7$77..|/@/@A"*9"5K#**;?;H5=D   1 1 25A5G5G5ID   1 1 2 JJ    &H OOH % & JJ   s B(C((DcLttj|jiSr)r copyrrs r_make_init_datazTestData._make_init_datas499T%8%89;;rc |jj|jj||jj y#|jj wxYwr)rr!rremover#)rr>s r_closed_instancezTestData._closed_instancesH JJOO  OO " "8 , JJ   DJJ   s 5AA.N)r)r)r:r-r)r)__name__ __module__ __qualname____doc____test__rr( staticmethodr'strr4r?dictrBrEr+rrrrsV6H !! !2"H<< rrceZdZdZdefdZd$dZdeddfdZde ee fddfd Z de ee fddfd Z d$d Z d Zd$d Zde ee fddfdZde ee fddfdZdeddfdZdeddfdZdede ee fddfdZdedede ee fddfdZd%dZdeddfdZdededdfdZdeddfdZdededdfdZd$dZd$d Zd!e defd"Zy#)&r-zA builder for feature flag configurations to be used with :class:`ldclient.integrations.test_data.TestData`. :see: :meth:`ldclient.integrations.test_data.TestData.flag()` :see: :meth:`ldclient.integrations.test_data.TestData.update()` r,cf||_d|_g|_d|_d|_i|_g|_y)z-:param str key: The name of the flag TN)r7_on _variations_off_variation_fallthrough_variation_targets_rulesr3s rrzFlagBuilder.__init__s8 "&*#  rr)ct|j}|j|_tj|j|_|j |_|j |_t|_|jjD]'\}}tj||j|<)tj|j|_ |S)zCreates a deep copy of the flag builder. Subsequent updates to the original ``FlagBuilder`` object will not update the copy and vise versa. :return: a copy of the flag builder object ) r-r7rPrArQrRrSrMrTitemsrU)rtokvs rr0zFlagBuilder._copys  #4#3#34 //$($?$?!f MM'') *DAq!YYq\BKKN *IIdkk*  ronc||_|S)aSets targeting to be on or off for this flag. The effect of this depends on the rest of the flag configuration, just as it does on the real LaunchDarkly dashboard. In the default configuration that you get from calling :meth:`ldclient.integrations.test_data.TestData.flag()` with a new flag key, the flag will return ``False`` whenever targeting is off, and ``True`` when targeting is on. :param on: ``True`` if targeting should be on :return: the flag builder )rP)rr[s rr[zFlagBuilder.ons rrctt|tr t||j_|S||_|S)a!Specifies the fallthrough variation. The fallthrough is the value that is returned if targeting is on and the user was not matched by a more specific target or rule. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param bool|int variation: ``True`` or ``False`` or the desired fallthrough variation index: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder ) isinstanceboolrr2rSrrs rfallthrough_variationz!FlagBuilder.fallthrough_variations7 i &9OPY9ZD    6K*3D 'Krctt|tr t||j_|S||_|S)aSpecifies the fallthrough variation. This is the variation that is returned whenever targeting is off. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param bool|int variation: ``True`` or ``False`` or the desired off variation index: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder )r^r_rr2rRr`s r off_variationzFlagBuilder.off_variations6 i &1G 1RD    .K"+D Krc|jr|S|jddjtj t S)aA shortcut for setting the flag to use the standard boolean configuration. This is the default for all new flags created with :meth:`ldclient.integrations.test_data.TestData.flag()`. The flag will have two variations, ``True`` and ``False`` (in that order); it will return ``False`` whenever targeting is off, and ``True`` when targeting is on if no other settings specify otherwise. :return: the flag builder TF)_is_boolean_flag variationsrarrcrrs rr2zFlagBuilder.boolean_flags?  "KOOD%0&&';<45 7rct|jdk(xr.|jtdk(xr|jtdk(S)NTF)lenrQrrrs rrezFlagBuilder._is_boolean_flagsOD$$%*A  !56$>A  !675@ Brc&t||_|S)a,Changes the allowable variation values for the flag. The value may be of any valid JSON type. For instance, a boolean flag normally has ``True, False``; a string-valued flag might have ``'red', 'green'``; etc. **Example:** A single variation :: td.flag('new-flag').variations(True) **Example:** Multiple variations :: td.flag('new-flag').variations('red', 'green', 'blue') :param variations: the the desired variations :return: the flag builder )listrQ)rrfs rrfzFlagBuilder.variationss( + rc$|j|S)zDeprecated name for variation_for_all(). .. deprecated:: 8.0.0 Use :meth:`ldclient.integrations.test_data.FlagBuilder.variation_for_all()`. )variation_for_allr`s rvariation_for_all_usersz#FlagBuilder.variation_for_all_userss %%i00rct|tr(|jjt |S|j j jdj|S)aSets the flag to always return the specified variation for all contexts. The variation is specified, targeting is switched on, and any existing targets or rules are removed. The fallthrough variation is set to the specified value. The off variation is left unchanged. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param bool|int variation: ``True`` or ``False`` or the desired variation index to return: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder T) r^r_r2rnr clear_rules clear_targetsr[rar`s rrmzFlagBuilder.variation_for_all!s^ i &$$&>>?UV_?`a a##%33588>TTU^_ _rvaluec$|j|S)zDeprecated name for value_for_all(). .. deprecated:: 8.0.0 Use :meth:`ldclient.integrations.test_data.FlagBuilder.value_for_all()`. ) value_for_allrrrs rvalue_for_all_userszFlagBuilder.value_for_all_users3s !!%((rcB|j|jdS)a Sets the flag to always return the specified variation value for all users. The value may be of any JSON type. This method changes the flag to have only a single variation, which is this value, and to return the same variation regardless of whether targeting is on or off. Any existing targets or rules are removed. :param value the desired value to be returned for all users :return the flag builder r)rfrnrus rrtzFlagBuilder.value_for_all;su%==a@@ruser_keycD|jtj||S)a:Sets the flag to return the specified variation for a specific user key when targeting is on. This has no effect when targeting is turned off for the flag. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param user_key: a user key :param bool|int variation: ``True`` or ``False`` or the desired variation index to return: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder )variation_for_keyr DEFAULT_KIND)rrxrs rvariation_for_userzFlagBuilder.variation_for_userIs%%g&:&:HiPPr context_kind context_keyct|tr*|jj||t |S|j j |}|i}||j |<t|jD]W\}}||k(r4|j |}|t}|||<|j|?||vsD||j|Y|S)aSets the flag to return the specified variation for a specific context, identified by context kind and key, when targeting is on. This has no effect when targeting is turned off for the flag. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param context_kind: the context kind :param context_key: the context key :param bool|int variation: ``True`` or ``False`` or the desired variation index to return: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder ) r^r_r2rzrrTget enumeraterQsetadddiscard)rr}r~rtargetsidxvartarget_for_variations rrzzFlagBuilder.variation_for_keyYs i &$$&88{TjktTuv v--##L1 ?G*1DMM, '!$"2"23 6HCy '.{{3'7$'/+.5(#7GCL%((5'>CL((5 6  rFlagRuleBuilderc:|jj|yr)rUr")rflag_rule_builders r _add_rulezFlagBuilder._add_rules ,-r attributecF|jtj|g|S)aNStarts defining a flag rule, using the "is one of" operator. This is a shortcut for calling :meth:`ldclient.integrations.test_data.FlagBuilder.if_match_context()` with "user" as the context kind. **Example:** create a rule that returns ``True`` if the name is "Patsy" or "Edina" :: td.flag("flag") \ .if_match('name', 'Patsy', 'Edina') \ .then_return(True) :param attribute: the user attribute to match against :param values: values to compare to :return: the flag rule builder )if_match_contextr r{rrvaluess rif_matchzFlagBuilder.if_matchs$"%t$$W%9%99NvNNrc@t|}|j||g|S)avStarts defining a flag rule, using the "is one of" operator. This matching expression only applies to contexts of a specific kind. **Example:** create a rule that returns ``True`` if the name attribute for the company" context is "Ella" or "Monsoon": :: td.flag("flag") \ .if_match_context('company', 'name', 'Ella', 'Monsoon') \ .then_return(True) :param context_kind: the context kind :param attribute: the context attribute to match against :param values: values to compare to :return: the flag rule builder )rand_match_contextrr}rrrs rrzFlagBuilder.if_match_contexts*",D12 22<TVTTrcF|jtj|g|S)aiStarts defining a flag rule, using the "is not one of" operator. This is a shortcut for calling :meth:`ldclient.integrations.test_data.FlagBuilder.if_not_match_context()` with "user" as the context kind. **Example:** create a rule that returns ``True`` if the name is neither "Saffron" nor "Bubble" :: td.flag("flag") \ .if_not_match('name', 'Saffron', 'Bubble') \ .then_return(True) :param attribute: the user attribute to match against :param values: values to compare to :return: the flag rule builder )if_not_match_contextr r{rs r if_not_matchzFlagBuilder.if_not_matchs$")t(()=)=yR6RRrc@t|}|j||g|S)aStarts defining a flag rule, using the "is not one of" operator. This matching expression only applies to contexts of a specific kind. **Example:** create a rule that returns ``True`` if the name attribute for the "company" context is neither "Pendant" nor "Sterling Cooper": :: td.flag("flag") \ .if_not_match('company', 'name', 'Pendant', 'Sterling Cooper') \ .then_return(True) :param context_kind: the context kind :param attribute: the context attribute to match against :param values: values to compare to :return: the flag rule builder )rand_not_match_contextrs rrz FlagBuilder.if_not_match_contexts+",D16 66|YXQWXXrcg|_|S)zRemoves any existing rules from the flag. This undoes the effect of methods like :meth:`ldclient.integrations.test_data.FlagBuilder.if_match()`. :return: the same flag builder )rUrs rrpzFlagBuilder.clear_ruless  rci|_|S)zRemoves any existing targets from the flag. This undoes the effect of methods like :meth:`ldclient.integrations.test_data.FlagBuilder.variation_for_user()`. :return: the same flag builder )rTrs rrqzFlagBuilder.clear_targetss  rr6c |j||j|jgdd}|j|d<d|ji|d<g}g}|j j D]\}}|j D]{\}}|tjk(r<|j|tt|d|j||gdU|j||tt|d}||d<||d <g} t|jD].\} } | j| jt| 0| |d <|S) zCreates a dictionary representation of the flag :param version: the version number of the rule :return: the dictionary representation of the flag )r,r6r[rf prerequisitessalt offVariationr fallthrough)rr) contextKindrrrcontextTargetsrules)r7rPrQrRrSrTrWr r{r"sortedrkrrUr8rL) rr6base_flag_objectrcontext_targetstarget_context_kindtarget_variations var_index target_keysrrrules rr8zFlagBuilder._builds|99((**  ,0+>+>(T88+'6:mm6I6I6K  2 !2*;*A*A*C & ;&'*>*>>NN%."(k):";$$**':%."$, $**':%."(k):";,  $'.#-<)*"4;;/ 0IC LLSX. / 0$)!rN)r)r-)rr) rFrGrHrIrLrr0r_r[rintrarcr2rerfrnrmrrvrtr|rzrrrrrrprqrMr8r+rrr-r-s C & T m uT3Y/?M&uT3Y'7M$7&B 01tSy1A1m1`5s+;` `$))) A3 A= AQ3Q5s;KQP]Q )c))PUVZ\_V_P`)er)V.O#O3DO&USUSUN_U(ScS7HS&YYYRcY(0 c0 d0 rr-ceZdZdZdefdZdeddfdZdededdfdZdeddfd Z dededdfd Z d e e e fdd fd ZdedefdZy)ra A builder for feature flag rules to be used with :class:`ldclient.integrations.test_data.FlagBuilder`. In the LaunchDarkly model, a flag can have any number of rules, and a rule can have any number of clauses. A clause is an individual test such as "name is 'X'". A rule matches a user if all of the rule's clauses match the user. To start defining a rule, use one of the flag builder's matching methods such as :meth:`ldclient.integrations.test_data.FlagBuilder.if_match()`. This defines the first clause for the rule. Optionally, you may add more clauses with the rule builder's methods such as :meth:`ldclient.integrations.test_data.FlagRuleBuilder.and_match()` or :meth:`ldclient.integrations.test_data.FlagRuleBuilder.and_not_match()`. Finally, call :meth:`ldclient.integrations.test_data.FlagRuleBuilder.then_return()` to finish defining the rule. r:c.||_g|_d|_yr) _flag_builder_clauses _variation)rr:s rrzFlagRuleBuilder.__init__/s) rrr)cF|jtj|g|S)a}Adds another clause, using the "is one of" operator. This is a shortcut for calling :meth:`ldclient.integrations.test_data.FlagRuleBuilder.and_match_context()` with "user" as the context kind. **Example:** create a rule that returns ``True`` if the name is "Patsy" and the country is "gb" :: td.flag('flag') \ .if_match('name', 'Patsy') \ .and_match('country', 'gb') \ .then_return(True) :param attribute: the user attribute to match against :param values: values to compare to :return: the flag rule builder )rr r{rs r and_matchzFlagRuleBuilder.and_match4s$$&t%%g&:&:IOOOrr}cZ|jj||dt|dd|S)aAdds another clause, using the "is one of" operator. This matching expression only applies to contexts of a specific kind. **Example:** create a rule that returns ``True`` if the name attribute for the "company" context is "Ella", and the country attribute for the "company" context is "gb": :: td.flag('flag') \ .if_match_context('company', 'name', 'Ella') \ .and_match_context('company', 'country', 'gb') \ .then_return(True) :param context_kind: the context kind :param attribute: the context attribute to match against :param values: values to compare to :return: the flag rule builder inFrroprnegaterr"rkrr}rrs rrz!FlagRuleBuilder.and_match_contextHs5$ +&v,   rcF|jtj|g|S)aAdds another clause, using the "is not one of" operator. This is a shortcut for calling :meth:`ldclient.integrations.test_data.FlagRuleBuilder.and_not_match_context()` with "user" as the context kind. **Example:** create a rule that returns ``True`` if the name is "Patsy" and the country is not "gb" :: td.flag('flag') \ .if_match('name', 'Patsy') \ .and_not_match('country', 'gb') \ .then_return(True) :param attribute: the user attribute to match against :param values: values to compare to :return: the flag rule builder )rr r{rs r and_not_matchzFlagRuleBuilder.and_not_matchcs$$*t))'*>*> SFSSrcZ|jj||dt|dd|S)aAdds another clause, using the "is not one of" operator. This matching expression only applies to contexts of a specific kind. **Example:** create a rule that returns ``True`` if the name attribute for the "company" context is "Ella", and the country attribute for the "company" context is not "gb": :: td.flag('flag') \ .if_match_context('company', 'name', 'Ella') \ .and_not_match_context('company', 'country', 'gb') \ .then_return(True) :param context_kind: the context kind :param attribute: the context attribute to match against :param values: values to compare to :return: the flag rule builder rTrrrs rrz%FlagRuleBuilder.and_not_match_contextws5$ +&v,   rrr-ct|tr4|jj|j t |S||_|jj||jS)aFinishes defining the rule, specifying the result as either a boolean or a variation index. If the flag was previously configured with other variations and the variation specified is a boolean, this also changes it to a boolean flag. :param bool|int variation: ``True`` or ``False`` or the desired variation index: ``0`` for the first, ``1`` for the second, etc. :return: the flag builder with this rule added )r^r_rr2 then_returnrrrr`s rrzFlagRuleBuilder.then_returns^ i &    + + -##$:9$EF F'DO    ( ( .%% %ridc<d|z|j|jdS)zCreates a dictionary representation of the rule :param id: the rule id :return: the dictionary representation of the rule r)rrclauses)rr)rrs rr8zFlagRuleBuilder._builds#2+}}  rN)rFrGrHrIr-rrLrrrrrr_rrrMr8r+rrrrs [ P3P4EP(ccO`6TsT8IT(##Sd6&U49%5&-&*      rr)rAtypingrrrrrrldclient.contextr ldclient.versioned_data_kindr 5ldclient.impl.integrations.test_data.test_data_sourcer ldclient.impl.rwlockr rrrrr-rr+rrrsQ 88$1Q.% { { zL L ^ S S r