\j[dZddlmZddlmZddlZddlZddlZddlm Z m Z m Z m Z ejdZhdZddZdd ZGd d ZGd d ZGddZgdZy)z? This submodule implements the SDK's evaluation context model. ) annotations)IterableN)AnyDictOptionalUnionz[^-a-zA-Z0-9._]>ipnameemailavatarcountrylastName firstNamecF|jddjddS)N%z%25:z%3A)replacekeys :/root/env/lib/python3.12/site-packages/ldclient/context.py#_escape_key_for_fully_qualified_keyrs" ;;sE " * *3 66cT|dk(ry|dk(ry|dk(rytj|ryy)Nzcontext kind must not be emptykindz""kind" is not a valid context kindmultizJcontext of kind "multi" must be created with create_multi or multi_builderz+context kind contains disallowed characters)_INVALID_KIND_REGEXsearchrs r_validate_kindr s4 rz/ v~3 w[!!$'< rcFeZdZdZdZ dZ d' d(dZed)d*dZed+dZ ed,dZ ed-d Z ed.d Z ed/d Z ed0d Zed1d Zed0dZed2dZed2dZed1dZed0dZd3dZed4dZd5dZed6dZed7dZed6dZed8dZed2dZd9dZd2dZd:dZ ed;dZ!ed,dZ"dd%Z(ed?d&Z)y)@Contexta} A collection of attributes that can be referenced in flag evaluations and analytics events. This entity is also called an "evaluation context." To create a Context of a single kind, such as a user, you may use :func:`create()` when only the key and the kind are relevant; or, to specify other attributes, use :func:`builder()`. To create a Context with multiple kinds (a multi-context), use :func:`create_multi()` or :func:`multi_builder()`. A Context can be in an error state if it was built with invalid attributes. See :attr:`valid` and :attr:`error`. A Context is immutable once created. userrNc | |j| y|*t|dk(r|jdyt|d}d} d} d} |D]} | j | g} | j | j/| j | k(r|jdy| j } | dk7r| dz } | | j dzt | jzz } | r!|jd j| yd |_ ||_ d|_ d|_ d |_ d|_d|_| |_d|_y|t$j&}t)|}|r|j|y|dk(r|s|jd y||_ ||_ ||_ ||_ ||_||_d|_ |t$j&k(r|n|dt ||_d|_y) aK Constructs an instance, setting all properties. Avoid using this constructor directly. Applications should not normally use this constructor; the intended pattern is to use factory methods or builders. Calling this constructor directly may result in some context validation being skipped. Nrz,multi-context must contain at least one kindc|jSNr)cs rz"Context.__init__..Ts !&&rrrz7multi-kind context cannot have same kind more than oncerz, rFz%context key must not be None or empty)_Context__make_invalidlensortederrorappendrrrjoin_Context__kind_Context__multi _Context__key_Context__name_Context__anonymous_Context__attributes_Context__private_Context__full_key_Context__errorr" DEFAULT_KINDr )selfrrr anonymous attributesprivate_attributesmulti_contextsallow_empty_keyr, last_kinderrorsfull_keyr' kind_errors r__init__zContext.__init__8s&      &   %>"a'##$RS$N8HINIFH# V77&~!#MM!''*66Y&''(abFF r>OHAFFSL+Nquu+UUU V##DIIf$56!DK)DLDJDK$D  $D !DN&DODL  <''D#D)     +  "9_    G H    $&+ !%)=)=!=#@E F  rc &t||ddddddS)a Creates a single-kind Context with only the key and the kind specified. If you omit the kind, it defaults to "user" (:const:`DEFAULT_KIND`). :param key: the context key :param kind: the context kind; if omitted, it is :const:`DEFAULT_KIND` ("user") :return: a context :see: :func:`builder()` :see: :func:`create_multi()` NFr")clsrrs rcreatezContext.createstS$tT4GGrcft}|D]}|j||jS)a Creates a multi-context out of the specified single-kind Contexts. To create a Context for a single context kind, use :func:`create()` or :func:`builder()`. You may use :func:`multi_builder()` instead if you want to add contexts one at a time using a builder pattern. For the returned Context to be valid, the contexts list must not be empty, and all of its elements must be valid Contexts. Otherwise, the returned Context will be invalid as reported by :func:`error()`. If only one context parameter is given, the method returns that same context. If a nested context is a multi-context, this is exactly equivalent to adding each of the individual kinds from it separately. See :func:`ldclient.ContextMultiBuilder.add()`. :param contexts: the individual contexts :return: a multi-context :see: :func:`create()` :see: :func:`multi_builder()` )ContextMultiBuilderaddbuild)rFcontextsbuilderr's r create_multizContext.create_multis26&' A KKN }}rc|tjdSd|vrtj|S|d}t|tstj dS|dk(rt }|jD]Y\}}|dk7s t|tstj |cStj||}|j|[|jStj||dS)a Creates a Context from properties in a dictionary, corresponding to the JSON representation of a context or a user. If the dictionary has a "kind" property, then it is interpreted as a context using the LaunchDarkly JSON schema for contexts. If it does not have a "kind" property, it is interpreted as a context with "user" kind using the somewhat different LaunchDarkly JSON schema for users in older LaunchDarkly SDKs. DEPRECATED: The legacy user format is deprecated and will be removed in 9.0.0 :param props: the context/user properties :return: a context zCannot use None as a contextrr) r"_Context__create_with_error_Context__from_dict_old_user isinstancestr'_Context__create_with_schema_type_errorrIitemsdict_Context__from_dict_singlerJrK)rFpropsrbkvr's r from_dictzContext.from_dicts =../MN N  //6 6V}$$::6B B 7?#%A  1;%a.&FFqII221a8AEE!H   779 ))%v??rct|S)a: Creates a builder for building a Context. You may use :class:`ldclient.ContextBuilder` methods to set additional attributes and/or change the context kind before calling :func:`ldclient.ContextBuilder.build()`. If you do not change any values, the defaults for the Context are that its ``kind`` is :const:`DEFAULT_KIND`, its :attr:`key` is set to the key parameter specified here, :attr:`anonymous` is False, and it has no values for any other attributes. This method is for building a Context that has only a single kind. To define a multi-context, use :func:`create_multi()` or :func:`multi_builder()`. :param key: the context key :return: a new builder :see: :func:`create()` :see: :func:`create_multi()` )ContextBuilder)rFrs rrMzContext.builders*c""rc.t|j|S)aX Creates a builder whose properties are the same as an existing single-kind Context. You may then change the builder's state in any way and call :func:`ldclient.ContextBuilder.build()` to create a new independent Context. :param context: the context to copy from :return: a new builder )r^r)rFcontexts rbuilder_from_contextzContext.builder_from_contextsgkk733rctS)a0 Creates a builder for building a multi-context. This method is for building a Context that contains multiple contexts, each for a different context kind. To define a single context, use :func:`create()` or :func:`builder()` instead. The difference between this method and :func:`create_multi()` is simply that the builder allows you to add contexts one at a time, if that is more convenient for your logic. :return: a new builder :see: :func:`builder()` :see: :func:`create_multi()` )rI)rFs r multi_builderzContext.multi_builders #$$rc|jduS)aj True for a valid Context, or False for an invalid one. A valid context is one that can be used in SDK operations. An invalid context is one that is missing necessary attributes or has invalid attributes, indicating an incorrect usage of the SDK API. The only ways for a context to be invalid are: * The :attr:`kind` property had a disallowed value. See :func:`ldclient.ContextBuilder.kind()`. * For a single context, the :attr:`key` property was None or empty. * You tried to create a multi-context without specifying any contexts. * You tried to create a multi-context using the same context kind more than once. * You tried to create a multi-context where at least one of the individual Contexts was invalid. In any of these cases, :attr:`valid` will be False, and :attr:`error` will return a description of the error. Since in normal usage it is easy for applications to be sure they are using context kinds correctly, and because throwing an exception is undesirable in application code that uses LaunchDarkly, the SDK stores the error state in the Context itself and checks for such errors at the time the Context is used, such as in a flag evaluation. At that point, if the context is invalid, the operation will fail in some well-defined way as described in the documentation for that method, and the SDK will generally log a warning as well. But in any situation where you are not sure if you have a valid Context, you can check :attr:`valid` or :attr:`error`. Nr7r9s rvalidz Context.valids6||t##rc|jS)z Returns None for a valid Context, or an error message for an invalid one. If this is None, then :attr:`valid` is True. If it is not None, then :attr:`valid` is False. rerfs rr,z Context.error+s||rc|jduS)a True if this is a multi-context. If this value is True, then :attr:`kind` is guaranteed to be :const:`MULTI_KIND`, and you can inspect the individual context for each kind with :func:`get_individual_context()`. If this value is False, then :attr:`kind` is guaranteed to return a value that is not :const:`MULTI_KIND`. :see: :func:`create_multi()` N)r0rfs rmultiplezContext.multiple5s||4''rc|jS)aj Returns the context's ``kind`` attribute. Every valid context has a non-empty kind. For multi-contexts, this value is :const:`MULTI_KIND` and the kinds within the context can be inspected with :func:`get_individual_context()`. :see: :func:`ldclient.ContextBuilder.kind()` :see: :func:`create()` )r/rfs rrz Context.kindDs{{rc|jS)a Returns the context's ``key`` attribute. For a single context, this value is set by :func:`create`, or :func:`ldclient.ContextBuilder.key()`. For a multi-context, there is no single value and :attr:`key` returns an empty string. Use :func:`get_individual_context()` to get the Context for a particular kind, then get the :attr:`key` of that Context. :see: :func:`ldclient.ContextBuilder.key()` :see: :func:`create()` )r1rfs rrz Context.keyRszzrc|jS)a Returns the context's ``name`` attribute. For a single context, this value is set by :func:`ldclient.ContextBuilder.name()`. It is None if no value was set. For a multi-context, there is no single value and :attr:`name` returns None. Use :func:`get_individual_context()` to get the Context for a particular kind, then get the :attr:`name` of that Context. :see: :func:`ldclient.ContextBuilder.name()` )r2rfs rr z Context.namebs{{rc|jS)a+ Returns True if this context is only intended for flag evaluations and will not be indexed by LaunchDarkly. The default value is False. False means that this Context represents an entity such as a user that you want to be able to see on the LaunchDarkly dashboard. Setting ``anonymous`` to True excludes this context from the database that is used by the dashboard. It does not exclude it from analytics event data, so it is not the same as making attributes private; all non-private attributes will still be included in events and data export. There is no limitation on what other attributes may be included (so, for instance, ``anonymous`` does not mean there is no :attr:`name`), and the context will still have whatever :attr:`key` you have given it. This value is also addressable in evaluations as the attribute name "anonymous". It is always treated as a boolean true or false in evaluations. :see: :func:`ldclient.ContextBuilder.anonymous()` )r3rfs rr:zContext.anonymousrs*rc|dk(r |jS|dk(r |jS|dk(r |jS|dk(r |jS|jy|jj |S)a Looks up the value of any attribute of the context by name. For a single-kind context, the attribute name can be any custom attribute that was set by :func:`ldclient.ContextBuilder.set()`. It can also be one of the built-in ones like "kind", "key", or "name"; in such cases, it is equivalent to :attr:`kind`, :attr:`key`, or :attr:`name`. For a multi-context, the only supported attribute name is "kind". Use :func:`get_individual_context()` to get the context for a particular kind and then get its attributes. If the value is found, the return value is the attribute value. If there is no such attribute, the return value is None. An attribute that actually exists cannot have a value of None. Context has a ``__getitem__`` magic method equivalent to ``get``, so ``context['attr']`` behaves the same as ``context.get('attr')``. :param attribute: the desired attribute name :return: the attribute value, or None if there is no such attribute :see: :func:`ldclient.ContextBuilder.set()` rrr r:N)r1r/r2r3r4getr9 attributes rrpz Context.getst2  ::   ;;   ;;   ### #    $  $$Y//rc`|jy|jyt|jS)aK Returns the number of context kinds in this context. For a valid individual context, this returns 1. For a multi-context, it returns the number of context kinds. For an invalid context, it returns zero. :return: the number of context kinds :see: :func:`get_individual_context()` r)r7r0r*rfs rindividual_context_countz Context.individual_context_counts- << # << 4<<  rcH|jyt|trD|j||jk(r|SdS|jD]}|j |k(s|cSy|j |dk(r|SdS|dks|t |jk\ry|j|S)a Returns the single-kind Context corresponding to one of the kinds in this context. The ``kind`` parameter can be either a number representing a zero-based index, or a string representing a context kind. If this method is called on a single-kind Context, then the only allowable value for ``kind`` is either zero or the same value as the Context's :attr:`kind`, and the return value on success is the same Context. If the method is called on a multi-context, and ``kind`` is a number, it must be a non-negative index that is less than the number of kinds (that is, less than the value of :attr:`individual_context_count`), and the return value on success is one of the individual Contexts within. Or, if ``kind`` is a string, it must match the context kind of one of the individual contexts. If there is no context corresponding to ``kind``, the method returns None. :param kind: the index or string value of a context kind :return: the context corresponding to that index or kind, or None :see: :attr:`individual_context_count` Nr)r7rRrSr0r/rr*)r9rr's rget_individual_contextzContext.get_individual_contexts0 << # dC ||##t{{2t<<\\ 66T>H  << 194 .$ . !8ts4<<00||D!!rc6|jdS|jS)a Gets the names of all non-built-in attributes that have been set in this context. For a single-kind context, this includes all the names that were passed to :func:`ldclient.ContextBuilder.set()` as long as the values were not None (since a value of None in LaunchDarkly is equivalent to the attribute not being set). For a multi-context, there are no such names. :return: an iterable r4rfs rcustom_attributeszContext.custom_attributess &&.rED4E4EErc|jSr&rzrfs r _attributeszContext._attributess   rc6|jdS|jS)a Gets the list of all attribute references marked as private for this specific Context. This includes all attribute names/paths that were specified with :func:`ldclient.ContextBuilder.private()`. :return: an iterable ryr5rfs rr<zContext.private_attributess^^+r??rc|jSr&rrfs r_private_attributeszContext._private_attributess~~rc|jS)a. A string that describes the Context uniquely based on ``kind`` and ``key`` values. This value is used whenever LaunchDarkly needs a string identifier based on all of the :attr:`kind` and :attr:`key` values in the context. Applications typically do not need to use it. )r6rfs rfully_qualified_keyzContext.fully_qualified_keysrc|jsiS|j5ddi}|jD] }|jd||j<"|S|jdS)a Returns a dictionary of properties corresponding to the JSON representation of the context (as an associative array), in the standard format used by LaunchDarkly SDKs. Use this method if you are passing context data to the front end for use with the LaunchDarkly JavaScript SDK. :return: a dictionary corresponding to the JSON representation rrFT)rgr0_Context__to_dict_singler)r9retr's rto_dictzContext.to_dictsezzI << #7#C\\ 8007AFF  8J$$T**rcLtj|jdS)a Returns the JSON representation of the context as a string, in the standard format used by LaunchDarkly SDKs. This is equivalent to calling :func:`to_dict()` and then ``json.dumps()``. :return: the JSON representation as a string ),r) separators)jsondumpsrrfs rto_json_stringzContext.to_json_string+szz$,,.Z@@rc<d|ji}|r|j|d<|j|j|d<|jrd|d<|j'|jj D] \}}|||< |j d|j i|d<|S)Nrrr Tr:privateAttributes_meta)r1r/r2r3r4rUr5)r9 with_kindrrZr[s r__to_dict_singlezContext.__to_dict_single6sdjj! ++CK ;; "++CK   #C     ())//1 1A  >> %/@CL rc8td}||j||jD]\}}|dk(r|t|tst j |cS|jd}|It|tst j dcS|D]<}t|tst j dccS|j|>|j||rt j |cS|jS)Nrrr) r^rrUrRrVr"rTrplistrSprivatetry_setrK)r9rXrrYrZr[ppas r__from_dict_singlezContext.__from_dict_singleEs 2    FF4LKKM FDAqG|9!!T*"BB1EEEE-.=%a.&FFGZ[[&)"c2#*#J#JK^#__ " & yyA"BB1EE! F"wwyrc|tjdttdj d}d}|j D]R\}}|dk(rU|t |tstj|cS|j D]\}}|j||a|dk(rl|it |tstj|cS|D]<}t |tstj|ccS|j|>|tvr>|t |tstj|cS|j|||dk(r|d}|j||stj|cS|dk(sQd }U|j!||j#S) Nz+legacy user format will be removed in 9.0.0rr#FcustomprivateAttributeNamesr:rT)warningswarnDeprecationWarningr^rrUrRrVr"rTsetrrSr_USER_STRING_ATTRSr_allow_empty_keyrK) r9rXrYhas_keyrZr[k1v1rs r__from_dict_old_userzContext.__from_dict_old_user]s CEWX 2  # #F +KKM #DAqH}9!!T*"BB1EEggi"FBEE"bM"--9!!T*"BB1EE"B%b#.&FFqIIIIbM"((9!!S)"BB1EEa  # AyyA"BB1EE:"G; #< 7#wwyrcHt|tr|j|SdSr&)rRrSrprqs r __getitem__zContext.__getitem__s&0C&@txx "JdJrcX|jsd|jzS|jS)aC Returns a standard string representation of a context. For a valid Context, this is currently defined as being the same as the JSON representation, since that is the simplest way to represent all of the Context properties. However, application code should not rely on ``__repr__`` always being the same as the JSON representation. If you specifically want the latter, use :func:`to_json_string()`. For an invalid Context, ``__repr__`` returns a description of why it is invalid. :return: a string representation z[invalid context: %s])rgr7rrfs r__repr__zContext.__repr__s)zz*T\\9 9""$$rct|tsy|j|jk7s|j|jk7s}|j|jk7sd|j |j k7sK|j |j k7s2|j|jk7s|j|jk7ry|jy|j+t|jt|jk7rytt|jD]#}|j||j|k7s#yy)z{ Compares contexts for deep equality of their attributes. :return: true if the Contexts are equal FT) rRr"r/r1r2r3r4r5r7r0r*range)r9otheris r__eq__zContext.__eq__s %) ;;%,, &$** *Ct{{V[VbVbGb    1 1 1T5F5F%J\J\5\ NNeoo -1N <<  == C $6#dll:K$Ks4<<() A}}Q4<<?2 rc&|j| Sr&)r)r9rs r__ne__zContext.__ne__s;;u%%%rc||_d|_d|_d|_d|_d|_d|_d|_d|_yNrF) r7r/r1r2r3r4r5r0r6)r9r,s r__make_invalidzContext.__make_invalidsC       rc (tdddddddd| SrrE)rFr,s r__create_with_errorzContext.__create_with_errorsr2tUD$eUKKrc2tjd|zS)Nzinvalid data type for "%s")r"rP)rFpropnames r__create_with_schema_type_errorz'Context.__create_with_schema_type_errors**+G(+RSSr)NFNNNFN)r Optional[str]rrSr rr:boolr;zOptional[dict]r<Optional[list[str]]r=zOptional[list[Context]]r>rr,rr&)rrSrrreturnr")rLr"rr")rXrVrr"rrSrr^)r`r"rr^)rrI)rr)rr)rrS)rrrSrr)rint)rzUnion[int, str]rOptional[Context])rz Iterable[str])rzOptional[dict[str, Any]])rr)rdict[str, Any])rrrr)rXrVrrrr")rr)r,rS)r,rSrr")rrSrr")*__name__ __module__ __qualname____doc__r8 MULTI_KINDrC classmethodrGrNr\rMrarcpropertyrgr,rjrrr r:rprurwr{r}r<rrrrrrWrQrrrrr)rPrTryrrr"r"!s L<J? #%)2626 %#LLL L  L # L0L0LLL\ H H>@@B##, 4 4%%"$$8 ( (        ,#0J!!"%"N F F!!  @ @ +& A .##JK% .& LLTTrr"cbeZdZdZd ddZddZddZddZddZddZ dd Z dd Z dd Z dd Z y)r^a8 A mutable object that uses the builder pattern to specify properties for :class:`ldclient.Context`. Use this type if you need to construct a context that has only a single kind. To define a multi-context, use :func:`ldclient.Context.create_multi()` or :func:`ldclient.Context.multi_builder()`. Obtain an instance of ContextBuilder by calling :func:`ldclient.Context.builder()`. Then, call setter methods such as :func:`name()` or :func:`set()` to specify any additional attributes. Then, call :func:`build()` to create the context. ContextBuilder setters return a reference to the same builder, so calls can be chained: :: context = Context.builder('user-key') .name('my-name') .set('country', 'us') .build :param key: the context key Nc||_|Gtj|_d|_d|_d|_d|_d|_d|_ d|_y|j|_|j|_|j|_|j|_|j|_|j du|_|jdu|_ d|_yNF)_ContextBuilder__keyr"r8_ContextBuilder__kind_ContextBuilder__name_ContextBuilder__anonymous_ContextBuilder__attributes_ContextBuilder__private$_ContextBuilder__copy_on_write_attrs&_ContextBuilder__copy_on_write_privaterr r:r}r _ContextBuilder__allow_empty_key)r9r copy_froms rrCzContextBuilder.__init__s  !..DKDK$D  $D !DN).D &+0D ("'$..DK#..DK(22D  ) 5 5D &::DN)-):):$)FD &+/>>+ED (!&rc |jdu|_|jdu|_t |j |j |j|j|j|jd|jS)a Creates a Context from the current builder properties. The Context is immutable and will not be affected by any subsequent actions on the builder. It is possible to specify invalid attributes for a ContextBuilder, such as an empty key. Instead of throwing an exception, the ContextBuilder always returns an Context and you can check :attr:`ldclient.Context.valid` or :attr:`ldclient.Context.error` to see if it has an error. See :attr:`ldclient.Context.valid` for more information about invalid conditions. If you pass an invalid Context to an SDK method, the SDK will detect this and will log a description of the error. :return: a new :class:`ldclient.Context` N) rrrrr"rrrrrrfs rrKzContextBuilder.buildsk'+&7&7t&C"(,d(B$t{{DJJ T=M=MtO`O`bfbpbp $((* *rc||_|S)an Sets the context's key attribute. Every context has a key, which is always a string. It cannot be an empty string, but there are no other restrictions on its value. The key attribute can be referenced by flag rules, flag target lists, and segments. :param key: the context key :return: the builder )r)r9rs rrzContextBuilder.keys  rc||_|S)aw Sets the context's kind attribute. Every context has a kind. Setting it to an empty string or None is equivalent to :const:`ldclient.Context.DEFAULT_KIND` ("user"). This value is case-sensitive. The meaning of the context kind is completely up to the application. Validation rules are as follows: * It may only contain letters, numbers, and the characters ``.``, ``_``, and ``-``. * It cannot equal the literal string "kind". * For a single context, it cannot equal "multi". :param kind: the context kind :return: the builder )r)r9rs rrzContextBuilder.kinds"  rc||_|S)a Sets the context's name attribute. This attribute is optional. It has the following special rules: * Unlike most other attributes, it is always a string if it is specified. * The LaunchDarkly dashboard treats this attribute as the preferred display name for contexts. :param name: the context name (None to unset the attribute) :return: the builder )r)r9r s rr zContextBuilder.name#s  rc||_|S)a Sets whether the context is only intended for flag evaluations and should not be indexed by LaunchDarkly. The default value is False. False means that this Context represents an entity such as a user that you want to be able to see on the LaunchDarkly dashboard. Setting ``anonymous`` to True excludes this context from the database that is used by the dashboard. It does not exclude it from analytics event data, so it is not the same as making attributes private; all non-private attributes will still be included in events and data export. There is no limitation on what other attributes may be included (so, for instance, ``anonymous`` does not mean there is no ``name``), and the context will still have whatever ``key`` you have given it. This value is also addressable in evaluations as the attribute name "anonymous". It is always treated as a boolean true or false in evaluations. :param anonymous: true if the context should be excluded from the LaunchDarkly database :return: the builder :see: :attr:`ldclient.Context.anonymous` )r)r9r:s rr:zContextBuilder.anonymous3s.% rc*|j|||S)a Sets the value of any attribute for the context. This includes only attributes that are addressable in evaluations-- not metadata such as :func:`private()`. If ``attributeName`` is ``"private"``, you will be setting an attribute with that name which you can use in evaluations or to record data for your own purposes, but it will be unrelated to :func:`private()`. The allowable types for context attributes are equivalent to JSON types: boolean, number, string, array (list), or object (dictionary). For all attribute names that do not have special meaning to LaunchDarkly, you may use any of those types. Values of different JSON types are always treated as different values: for instance, the number 1 is not the same as the string "1". The following attribute names have special restrictions on their value types, and any value of an unsupported type will be ignored (leaving the attribute unchanged): * ``"kind"``, ``"key"``: Must be a string. See :func:`kind()` and :func:`key()`. * ``"name"``: Must be a string or None. See :func:`name()`. * ``"anonymous"``: Must be a boolean. See :func:`anonymous()`. The attribute name ``"_meta"`` is not allowed, because it has special meaning in the JSON schema for contexts; any attempt to set an attribute with this name has no effect. Values that are JSON arrays or objects have special behavior when referenced in flag/segment rules. A value of None is equivalent to removing any current non-default value of the attribute. Null/None is not a valid attribute value in the LaunchDarkly model; any expressions in feature flags that reference an attribute with a null value will behave as if the attribute did not exist. :param attribute: the attribute name to set :param value: the value to set :return: the builder )rr9rrvalues rrzContextBuilder.setMsL Y& rc|dk(s|dk(ry|dk(rt|tr||_yy|dk(rt|tr||_yy|dk(r|t|tr||_yy|d k(rt|t r||_yy|jr4d|_|jxr|jj|_|ji|_||jj|dy||j|<y) af Same as :func:`set()`, but returns a boolean indicating whether the attribute was successfully set. :param attribute: the attribute name to set :param value: the value to set :return: True if successful; False if the name was invalid or the value was not an allowed type for that attribute rrFrTrr Nr:) rRrSrrrrrrrcopypoprs rrzContextBuilder.try_setvs ?i72  %%"   %%#   } 5# 6#   #%&#(   % %).D & $ 1 1 Nd6G6G6L6L6ND     $ "D  =    ! !)T 2,1D  i (rct|dk7rn|jr4d|_|jxr|jj|_|jg|_|jj ||S)a Designates any number of Context attributes, or properties within them, as private: that is, their values will not be sent to LaunchDarkly. Each parameter can be either a simple attribute name, or a slash-delimited path referring to a JSON object property within an attribute. :param attributes: attribute names or references to mark as private :return: the builder rF)r*rrrextend)r9r;s rrzContextBuilder.privatesf z?a ++/4,!%!IDNN4G4G4I~~%!# NN ! !* - rc||_yr&)r)r9allows rrzContextBuilder._allow_empty_keys "'rr&)rrSrrrr"r)rrSrr^)r rrr^)r:rrr^)rrrSrrrr^)rrrSrrrr)r;rSrr^)rr)rrrrrCrKrrr r:rrrrryrrr^r^s;&'(*( ( 4'R)V('rr^c&eZdZdZdZddZddZy)rIa+ A mutable object that uses the builder pattern to specify properties for a multi-context. Use this builder if you need to construct a :class:`ldclient.Context` that contains multiple contexts, each for a different context kind. To define a regular context for a single kind, use :func:`ldclient.Context.create()` or :func:`ldclient.Context.builder()`. Obtain an instance of ContextMultiBuilder by calling :func:`ldclient.Context.multi_builder()`; then, call :func:`add()` to specify the individual context for each kind. The method returns a reference to the same builder, so calls can be chained: :: context = Context.multi_builder() .add(Context.new("my-user-key")) .add(Context.new("my-org-key", "organization")) .build c g|_d|_yr)_ContextMultiBuilder__contexts#_ContextMultiBuilder__copy_on_writerfs rrCzContextMultiBuilder.__init__s$rc t|jdk(r|jdSd|_tdddddd|jS)aZ Creates a Context from the current builder properties. The Context is immutable and will not be affected by any subsequent actions on the builder. It is possible for a ContextMultiBuilder to represent an invalid state. Instead of throwing an exception, the ContextMultiBuilder always returns a Context, and you can check :attr:`ldclient.Context.valid` or :attr:`ldclient.Context.error` to see if it has an error. See :attr:`ldclient.Context.valid` for more information about invalid context conditions. If you pass an invalid context to an SDK method, the SDK will detect this and will log a description of the error. If only one context was added to the builder, this method returns that context rather than a multi-context. :return: a new Context rtrTNrF)r*rrr"rfs rrKzContextMultiBuilder.buildsG$ t 1 $??1% %#tRudD$//JJrc:|jrAt|jD]'}|j|}||j |)|S|j r&d|_|j j|_|j j||S)a Adds an individual Context for a specific kind to the builer. It is invalid to add more than one Context for the same kind, or to add an LContext that is itself invalid. This error is detected when you call :func:`build()`. If the nested context is a multi-context, this is exactly equivalent to adding each of the individual contexts from it separately. For instance, in the following example, ``multi1`` and ``multi2`` end up being exactly the same: :: c1 = Context.new("key1", "kind1") c2 = Context.new("key2", "kind2") c3 = Context.new("key3", "kind3") multi1 = Context.multi_builder().add(c1).add(c2).add(c3).build() c1plus2 = Context.multi_builder.add(c1).add(c2).build() multi2 = Context.multi_builder().add(c1plus2).add(c3).build() :param context: the context to add :return: the builder F) rjrrurwrJrrrr-)r9r`rr's rrJzContextMultiBuilder.adds0   7;;< 2215=HHQK  ##',$"&//"6"6"8 OO " "7 + rNr)r`r"rrI)rrrrrCrKrJryrrrIrIs"%K0"rrI)r"r^rI)rrSrrS)rrSrr)r __future__rcollections.abcrrrertypingrrrrcompilerrrr r"r^rI__all__ryrrrsu#$ --!bjj!23Z7 ` T` TFt't'nPPf ?r