jddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZddlmZddlmZmZmZddlmZmZmZddlmZmZmZmZmZmZdd l m!Z!m"Z"m#Z#m$Z$e%j&Z'd Z(d Z)d Z*e j+iZ,e%Z-ej.ej/ej0Z1Gd dej2Z3e3j4Z4 Gdde5Z6e4ddddddddddddddfdZ7 dddZ8 ddd Z9dd%Z:Gd&d'eZ;d(Zd,Z?dd-Z@d.ZAd/ZBd0ZCd1ZDGd2d3ZEd4ZFd5ZG dd6ZH dd8ZIeIZJ d9ZKdd<ZLddCZMddDZNdEZOddGZPdHZQddIZRddJZSddKZTdLZUdMZVdNZ0dOZWddQZXddUZYddXZZddZZ[dd[Z\dd_Z]ddjZ^ddlZ_GdmdnZ`doe`jaDZbeNeReTe`ebpdqebDpdrebDpZ`GdsdtZceReTecZcGdudvZddwedjaDZeeReTedeepeepZdGdxdyZfdzefjaDZgeNeReTefegpegpegpZfGd{dWZhd|d}DZgeNeReTehegpegpegpZhe%fdfd~ZieIddGddZjdZkdZ.dS)) annotationsN)CallableMapping)cached_property)Any NamedTupleTypeVar)_compat_configsetters) PY_3_10_PLUS PY_3_11_PLUS PY_3_13_PLUS_AnnotationExtractor_get_annotationsget_generic_base)DefaultAlreadySetErrorFrozenInstanceErrorNotAnAttrsClassErrorUnannotatedAttributeErrorz__attr_factory_%s)ztyping.ClassVarz t.ClassVarClassVarztyping_extensions.ClassVar_attrs_cached_hashc<eZdZdZejZdZdZdS)_NothingaF Sentinel to indicate the lack of a value when `None` is ambiguous. If extending attrs, you can use ``typing.Literal[NOTHING]`` to show that a value may be ``NOTHING``. .. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False. .. versionchanged:: 22.2.0 ``NOTHING`` is now an ``enum.Enum`` variant. cdS)NNOTHINGselfs Y/var/www/finuniver-perm.ru/html/portfolio/venv/lib/python3.11/site-packages/attr/_make.py__repr__z_Nothing.__repr__KsycdS)NFrrs r!__bool__z_Nothing.__bool__Nsur#N) __name__ __module__ __qualname____doc__enumautorr"r%rr#r!rr>sKdikkGr#rc0eZdZdZeddfdZdS)_CacheHashWrappera An integer subclass that pickles / copies as None This is used for non-slots classes with ``cache_hash=True``, to avoid serializing a potentially (even likely) invalid hash value. Since `None` is the default value for uncalculated hashes, whenever this is copied, the copy's value for the hash should automatically reset. See GH #613 for more details. Nrc ||fSNr)r _none_constructor_argss r! __reduce__z_CacheHashWrapper.__reduce__fs  %''r#)r&r'r(r)typer2rr#r!r-r-ZsA  ,04::R((((((r#r-Tcht|| | d\} }} }||dur|durd}t|| I|turd}t|t | sd}t|t | }|i}t | ttfrtj | } |r%t |ttfr t|}|r%t |ttfr t|}tdid|d|d |d dd |d |d |d|d|d| d| d|d| d|d| d|S)a; Create a new field / attribute on a class. Identical to `attrs.field`, except it's not keyword-only. Consider using `attrs.field` in new code (``attr.ib`` will *never* go away, though). .. warning:: Does **nothing** unless the class is also decorated with `attr.s` (or similar)! .. versionadded:: 15.2.0 *convert* .. versionadded:: 16.3.0 *metadata* .. versionchanged:: 17.1.0 *validator* can be a ``list`` now. .. versionchanged:: 17.1.0 *hash* is `None` and therefore mirrors *eq* by default. .. versionadded:: 17.3.0 *type* .. deprecated:: 17.4.0 *convert* .. versionadded:: 17.4.0 *converter* as a replacement for the deprecated *convert* to achieve consistency with other noun-based arguments. .. versionadded:: 18.1.0 ``factory=f`` is syntactic sugar for ``default=attr.Factory(f)``. .. versionadded:: 18.2.0 *kw_only* .. versionchanged:: 19.2.0 *convert* keyword argument removed. .. versionchanged:: 19.2.0 *repr* also accepts a custom callable. .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01. .. versionadded:: 19.2.0 *eq* and *order* .. versionadded:: 20.1.0 *on_setattr* .. versionchanged:: 20.3.0 *kw_only* backported to Python 2 .. versionchanged:: 21.1.0 *eq*, *order*, and *cmp* also accept a custom callable .. versionchanged:: 21.1.0 *cmp* undeprecated .. versionadded:: 22.2.0 *alias* .. versionchanged:: 25.4.0 *kw_only* can now be None, and its default is also changed from False to None. TNF6Invalid value for hash. Must be True, False, or None.z=The `default` and `factory` arguments are mutually exclusive.z*The `factory` argument must be a callable.default validatorreprcmphashinit convertermetadatar3kw_onlyeqeq_keyorder order_key on_setattraliasr) _determine_attrib_eq_order TypeErrorr ValueErrorcallableFactory isinstancelisttupler pipeand_ _CountingAttr)r6r7r8r9r:r;r=r3r<factoryr>r?rArCrDr@rBmsgs r!attribrRjst$> R$$ By D,,U1B1BFnn ' ! !O S// !   ">CS// !'""*tUm,,/\:. %Z D%=99%)$ %Z D%=99%)$     ) T  D   T   T  )  T   2 v e ) :  e! r#scriptstrglobsdict[str, Any] | NonelocsMapping[str, object] | NonefilenamereturnNonecJt||d}t|||dS)z[ Evaluate the script with the given global (globs) and local (locs) variables. execN)compileeval)rTrVrXrZbytecodes r!_compile_and_evalrbs-vx00H5$r#localsdict[str, Any]c|in|}d}|} t|d|d|f}tj||}||krn|ddd|d}|dz }ct |||||S)zP Cache the script with _linecache_, compile it and return the _locals_. Nr T->)len splitlines linecachecache setdefaultrb) rTrZrVrcrXcount base_filenamelinecache_tupleold_vals r!_linecache_and_compilerrs22VD EM  KK    d # #    /,,XGG o % % #CRC(335333   feT8444 Kr#cls_name attr_names list[str]r3c|d}i}t|D]\}}|fd}t|||<t|tf|S)z Create a tuple subclass to hold `Attribute`s for an `attrs` class. The subclass is a bare tuple with properties for names. class MyClassAttributes(tuple): __slots__ = () x = property(itemgetter(0)) Attributesc||Sr/r)r is r!getterz&_make_attr_tuple_class..getters 7Nr#) enumeratepropertyr3rL)rsrtattr_class_namebodyry attr_namerzs r!_make_attr_tuple_classr sr"---O D!*--++ 9    #6**Y %4 0 00r#c.eZdZUded<ded<ded<dS) _Attributesr3attrslist[Attribute] base_attrsdict[str, type]base_attrs_mapN)r&r'r(__annotations__rr#r!rr s3KKK######r#rct|}|dr|dr |dd}|tS)z Check whether *annot* is a typing.ClassVar. The string comparison hack is used to avoid evaluating all string annotations which would put attrs-based classes at a performance disadvantage compared to plain old classes. )'"r rf)rU startswithendswith_CLASSVAR_PREFIXES)annots r! _is_class_varr&s\ JJE  ##z(B(Bad    . / //r#c||jvS)zR Check whether *cls* defines *attrib_name* (and doesn't just inherit it). )__dict__)cls attrib_names r!_has_own_attributer7s #, &&r#'tuple[list[Attribute], dict[str, type]]cg}i}t|jddD]\}t|dgD]H}|js |j|vr|d}|||||j<I]g}t}t|D]<}|j|vr |d|| |j=||fS)zQ Collect attr.ibs from base classes of *cls*, except *taken_attr_names*. r rf__attrs_attrs__T inheritedr) reversed__mro__getattrrnameevolveappendsetinsertadd)rtaken_attr_namesr base_attr_mapbase_clsafilteredseens r!_collect_base_attrsr>s JMS[2.//--#4b99 - -A{ af(8884((A   a $,M!& ! !  -H 55D j ! ! 6T>> 1  ] ""r#cg}i}|jddD]o}t|dgD][}|j|vr |d}||j|||||j<\p||fS)a- Collect attr.ibs from base classes of *cls*, except *taken_attr_names*. N.B. *taken_attr_names* will be mutated. Adhere to the old incorrect behavior. Notably it collects from the front and considers inherited attributes which leads to the buggy behavior reported in #428. r rfrTr)rrrrrr)rrrrrrs r!_collect_base_attrs_brokenr_sJMK"%--#4b99 - -Av)))4((A   ( ( (   a $,M!& ! ! - } $$r#c |jt||#t|}n0|durdD}g}t }D]y\} } t | r|| | t} | j turt| } | | | fz||z } | r:tddt| fdzdzn.td Dd }t jt$jjfd |D} |rt+|d | D\}}nt-|d | D\}}t$jjurd| D} d|D}|| z}|D]a} | jsXt3| dt7| jt3| ddb|t;|||}d}d|DD]<} |dur"| jturd| }t?||dur| jturd}=|D]a} | jsXt3| dt7| jt3| ddbd|D}tA|j!|}tE||||S)a3 Transform all `_CountingAttr`s on a class into `Attribute`s. If *these* is passed, use that and don't look for them on the class. If *collect_by_mro* is True, collect them in the correct MRO order, otherwise use the old -- incorrect -- order. See #428. Return an `_Attributes`. NTc4h|]\}}|jtu|Sr __class__rO.0rattrs r! z#_transform_attrs..s3   d~.. ...r#z1The following `attr.ib`s lack a type annotation: , c8|jSr/)getcounter)ncds r!z"_transform_attrs..sbffQii6Gr#)key.c3@K|]\}}|jtu||fVdSr/rrs r! z#_transform_attrs..sC  D$>]22t 2222  r#c|djSNr )r)es r!rz"_transform_attrs..s !A$,r#c \g|](\}}||u|)Sr)r)rrcaannsfcar>nos r! z$_transform_attrs..sX Ir    2  HHY     r#ch|] }|j Srrrrs r!rz#_transform_attrs..,,,Q!&,,,r#ch|] }|j Srrrs r!rz#_transform_attrs..rr#c:g|]}|dST)r>rrs r!rz$_transform_attrs..s&???QXXdX++???r#c:g|]}|dSrrrs r!rz$_transform_attrs..s&AAAahhth,,AAAr#rDalias_is_defaultFc3>K|]}|jdu |jdu|VdS)FN)r;r>rs r!rz#_transform_attrs..s: M MA!&"5"5!)u:L:La:L:L:L:L M Mr#zlNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: cg|] }|j Srrrs r!rz$_transform_attrs..s(((Q!&(((r#)#rrrKitemsrrrrrrrOrRrrjoinsorted Attributefrom_counting_attr ClassProps KeywordOnlyNOrrFORCErD _OBJ_SETATTR__get___default_init_alias_forrrLr6rGrr&r)rthese auto_attribsr>collect_by_mrofield_transformerca_listca_names annot_namesrr3r unannotated own_attrsrrr had_defaultrQrt AttrsClassrrrrs ` @@@@r!_transform_attrsr{s@$ B C D u{{}}%%      hhjj    ee #zz|| + +OItT""  OOI & & &y'**A{-//1II NNIq> * * * *,  +C));,G,G,G,GHHH     "$((**    '&      &C   "B%I $7 ,,),,,% % ! MM%? ,,),,,% % ! M*(...??Y??? AAjAAA  "E >>w >   # #G-DQV-L-L M M M   # #$6 = = =$''U3344K M M M M M $  19#7#7GBCGGCS// ! %  AIW$<$<K>>w >   # #G-DQV-L-L M M M   # #$6 = = =)(%(((J' jAAJ zz%((*m D DDr#c2gd}||dn|gd|ddgt|d}|tj|d}t d|||d |i d S) N) zdef wrapper(_cls):z __class__ = _clsz def __getattr__(self, item, cached_properties=cached_properties, original_getattr=original_getattr, _cached_setattr_get=_cached_setattr_get):z+ func = cached_properties.get(item)z if func is not None:z! result = func(self)z1 _setter = _cached_setattr_get(self)z# _setter(item, result)z return resultz, return original_getattr(self, item))z try:z2 return super().__getattribute__(item)z except AttributeError:z4 if not hasattr(super(), '__getattr__'):z raisez- return super().__getattr__(item)zY original_error = f"'{self.__class__.__name__}' object has no attribute '{item}'"z- raise AttributeError(original_error)z return __getattr__z__getattr__ = wrapper(_cls)r)cached_properties_cached_setattr_getoriginal_getattr _cls)rc __getattr__)rextend_generate_unique_filenamerrrrr)rrrlinesunique_filenameglobs r!_make_cached_property_getattrrs   E# :           LL $ ) 0Y??O/+3,  D " %/4     r#c~t|tr"|dvrt|||dSt)z4 Attached to frozen classes as __setattr__. ) __cause__ __context__ __traceback____suppress_context__ __notes__N)rJ BaseException __setattr__rr rvalues r!_frozen_setattrsr/sL$ &&44,, !!$e444 r#ct|tr#|dkrt||dSt)z4 Attached to frozen classes as __delattr__. rN)rJr __delattr__r)r rs r!_frozen_delattrsr@sA$ &&4;+>+>!!$--- r#c |\}n1#t$r$dt|d}t|dwxYw|j}t |}|D]/}|js |j}|j}||vrt||||<0|di|S)a Create a new instance, based on the first positional argument with *changes* applied. .. tip:: On Python 3.13 and later, you can also use `copy.replace` instead. Args: inst: Instance of a class with *attrs* attributes. *inst* must be passed as a positional argument. changes: Keyword changes in the new copy. Returns: A copy of inst with *changes* incorporated. Raises: TypeError: If *attr_name* couldn't be found in the class ``__init__``. attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs* class. .. versionadded:: 17.1.0 .. deprecated:: 23.1.0 It is now deprecated to pass the instance using the keyword argument *inst*. It will raise a warning until at least April 2024, after which it will become an error. Always pass the instance as a positional argument. .. versionchanged:: 24.1.0 *inst* can't be passed as a keyword argument anymore. z*evolve() takes 1 positional argument, but z were givenNr) rGrirFrfieldsr;rrDr) argschangesinstrQrrrr init_names r!rrKsJ' ''' OT O O O nn$& ' .C 3KKE ::v  F G G # #!(y!9!9GI  3>>>>s.5ceZdZdZdZd#d Zd Zd$dZdZdZ dZ dZ dZ dZ dZdZdZdZdZdZdZdZdZd%d Zd%d!Zd"S)& _ClassBuilderz( Iteratively build *one* class. )_add_method_dunders _attr_names_attrs_base_attr_map _base_names _cache_hashr _cls_dict_delete_attribs_frozen_has_custom_setattr_has_post_init _has_pre_init_is_exc _on_setattr_pre_init_has_args _repr_added_script_snippets_slots _weakref_slot_wrote_own_setattrrr3rboolpropsrhas_custom_setattrct||||j|j|j\}}}||_|jrt |jni|_||_ d|D|_ ||_ td|D|_ |j|_|j|_|j|_|jt(jju|_t1t3|dd|_d|_|jr8|j} t;j| } t?| j dk|_t1t3|dd|_!t1| |_"|j#|_$|j%|_&||_'d|_(|j |jd<||jd<|jr&tR|jd <tT|jd <d |_(n|j&tVtXj-tXj.fvrjdx} } |D]} | j/d } | j0d } | r| rn|j&tVkr| s| r.|j&tXj-kr| r|j&tXj.kr | sd|_&|j1r'|2\|jd <|jd <g|_3d|_4tk|jdrtk|jds|j6|_7dS|j8|_7dS)Nch|] }|j Srrrs r!rz)_ClassBuilder.__init__..s777qAF777r#c3$K|] }|jV dSr/rrs r!rz)_ClassBuilder.__init__..s$ 7 7A 7 7 7 7 7 7r#__attrs_pre_init__Fr __attrs_post_init__r__attrs_props__rrT __getstate__ __setstate__r'r()9rr>collected_fields_by_mrorr is_slotteddictrrrrrrLrr! is_frozenrhas_weakref_slotr" hashabilityr HashabilityHASHABLE_CACHEDrr$rrrr*inspect signatureri parametersrr is_exceptionron_setattr_hookrrr#rr_DEFAULT_ON_SETATTRr validateconvertr7r<added_pickling_make_getstate_setstater rhasattr_add_method_dunders_safer_add_method_dunders_unsafe)r rrrr%r&rrbase_map pre_init_funcpre_init_signature has_validator has_converterrs r!__init__z_ClassBuilder.__init__s='7    M  )  # ' ' #z8 /4/?Gcl+++R 77J777& 7 7 7 7 777&  "3  !7!G G "'#/CU"K"KLL"'   M 2M!(!2=!A!A &)*<*G&H&H1&LD #"730Eu#M#MNN#';;)  0#5 "',0K(),1() ? (,)rr&rs r!r"z_ClassBuilder.__repr__s;TY%7;;;;r#r[r\cdd|jD}i}|jD]\}}}||t|t |jd|}|jD]\}}}||j|dS)z= Evaluate any registered snippets in one go. rcg|] }|d S)rr)rsnippets r!rz0_ClassBuilder._eval_snippets..sLLL7GAJLLLr#methodsN)rr updaterrrrr)r rTrV_ snippet_globsrXhooks r!_eval_snippetsz_ClassBuilder._eval_snippets sLLd6KLLLMM#'#8 ( ( A}a LL ' ' ' '%  %di ; ;    / ' 'JAq$ D & & & & ' 'r#c`||jdur3|}tj||j_n/|}trtj |}t|ddrd|j vr| |S)z Finalize class based on the accumulated configuration. Builder cannot be used after calling this method. T__attrs_init_subclass__N)rSr!_create_slots_classweakrefrefr__attrs_base_of_slotted___patch_original_classrabcupdate_abstractmethodsrrrU)r rs r! build_classz_ClassBuilder.build_classs  ;$  **,,C29+c2B2BDI / /,,..C 6055 C2D 9 9 *)==  ' ' ) ) ) r#c|j}|j}|jrl|jD]d}||vr^t ||t t urAt jt5t||dddn #1swxYwYe|j D]\}}t||||j s+t |ddrd|_|js t |_|S)zA Apply accumulated methods and return the class. N__attrs_own_setattr__F)rrrrr _SENTINEL contextlibsuppressAttributeErrordelattrrrsetattrr#r_rrr)r r base_namesrrs r!rZz#_ClassBuilder._patch_original_class5sLi%    +( + + **T955YFF $,^<<++T***+++++++++++++++ >//11 & &KD% Cu % % % %& /7 (%, ,  /).C %+ /". sA66A: =A: c fdjD}ttdrtjjjsBd|d<js6jjD])j ddr t|d<n*i}d}jj ddD]Oj dd d }| fd td gDPtjj}jr#dtjd d vr d|vr|s|dz }d|D}g}|rt'j}|D]T\}} ||fz }||=|| t+j| j} | t*jjur| ||<U| d} | || t5|| j|d<fd|Dfd|DfdD| jrt8t;|d <jj|d<t?jjj jj|} tCj"| j #|D]} tI| tJtLfrt| j'dd }n=tI| tPrt| j)dd }nt| dd }|su|D]*} |j*ju}|r| |_*#tV$rY'wxYw| S)zL Build and return a new class with a `__slots__` attribute. cVi|]%\}}|gtjddRv"||&S)r __weakref__)rLr)rkvr s r! z5_ClassBuilder._create_slots_class..]sR   1M% 011M:M}MMMM qMMMr#_clear_type_descriptorsFr_rr rfriNTc2i|]}|t|Srr)rrrs r!rlz5_ClassBuilder._create_slots_class..s5'(D11r# __slots__r)ricNi|]"\}}t|t||j#Sr)rJrfunc)rr cached_props r!rlz5_ClassBuilder._create_slots_class..sA   !k+77 +"   r#rcg|]}|v| Srr)rrrfs r!rz5_ClassBuilder._create_slots_class..s#GGGtJ0F0Fd0F0F0Fr#c$i|] \}}|v || Srr)rslotslot_descriptor slot_namess r!rlz5_ClassBuilder._create_slots_class..s4   %oz!! /!!!r#cg|]}|v| Srr)rr reused_slotss r!rz5_ClassBuilder._create_slots_class..s#NNNtT5M5Md5M5M5Mr#r( __closure__),rrrAsysrmrr#r __bases__rrrrrOrrrrr"rrr7r8return_annotation Parameteremptyrr_HASH_CACHE_FIELDrLr(r3r& itertoolschainvaluesrJ classmethod staticmethod__func__r|fget cell_contentsrG)r rexisting_slotsweakref_inheritednamesr&additional_closure_functions_to_updateclass_annotationsrrr annotationrritem closure_cellscellmatchrrfrzrxs` @@@@r!rVz!_ClassBuilder._create_slots_classYs    ,,..    31 2 2 3  ' 2 2 2& */B& '+  $ 3H(,,-DeLL,8=) ! )!B$/  H $$]D99E$(!  ! ! '+r B B    )**     &WTY R%H%HHHU**%+ % %E  %'XXZZ   24.   0 ; ; /5577 9 9 d$ tH6==dCCC$.t44F W%6%<<<.8%d+!vvm44 +6==>NOOO =!#3TY!!B}  HGGGuGGG     )7)=)=)?)?   ONNNzNNN  ,   1   / 0 0 0 ++;!Y3>d49oodi0$)2ErJJO L   ! !#I   1 1D$l ;<< C!( }d K K D(++ C!( =$ G G 'mT B B   % 1 11 .$);E 1-0* "D 1 sN77 OOctj|\}}fd}j|||fd_S)NcD|d|d<dS)Nr"rcls_dictrVr s r! _attach_reprz,_ClassBuilder.add_repr.._attach_reprs&#'#;#;E*.__str__s==?? "r#r)rrGrr)r rQrs r!add_strz_ClassBuilder.add_strsN "GCS// ! # # #%)$<$.s5! ! R=-@-@B-@-@-@-@! ! r#c"fdDS)9 Automatically created by attrs. c2i|]}|t|Srrorrr s r!rlzQ_ClassBuilder._make_getstate_setstate..slots_getstate.. s%KKK$D'$--KKKr#r)r state_attr_namess`r!slots_getstatez=_ClassBuilder._make_getstate_setstate..slots_getstates"LKKK:JKKK Kr#c t|}t|tr#t |D]\}}|||nD]}||vr||||r|t ddSdS)rN)rrrJrLzipr)r state_ClassBuilder__bound_setattrrrhash_caching_enabledrs r!slots_setstatez=_ClassBuilder._make_getstate_setstate..slots_setstates+22488O%'' ;$''7#?#?11KD%#OD%00001-;;Du}}'eDk::: $ 9 1488888 9 9r#)rLrr)r rrrrs @@r!r@z%_ClassBuilder._make_getstate_setstates !! ! )! ! !    L L L L L $/ 9 9 9 9 9 9,~--r#cd|jd<|SN__hash__)rrs r!make_unhashablez_ClassBuilder.make_unhashable&s%)z" r#ctjjjj\}}dfd }j|||fS) Nfrozen cache_hashrr1rXr[r\cD|d|d<dSrr)rrXr s r! attach_hashz+_ClassBuilder.add_hash..attach_hash2s&#'#;#;D._attach_initIs3$D#.D #'#;#;D#A#AHZ r#_make_init_scriptrrrrrrr!rrrrr r)r rTrVrrs` @r!add_initz_ClassBuilder.add_init9s%6 I K    #   L K     L   & & & "{ B B B B B B $$fe\%BCCC r#cJ|t|jd<|S)N __replace__)rrrrs r! add_replacez_ClassBuilder.add_replaceRs!(,(@(@(H(H}% r#cRtd|jD|jd<dS)Nc3@K|]}|j |j|jVdSr/)r;r>r)rfields r!rz/_ClassBuilder.add_match_args..WsL1 1 z1 #(-1 J1 1 1 1 1 1 r#__match_args__)rLrrrs r!add_match_argsz_ClassBuilder.add_match_argsVs=+01 1 1 1 1 , , '(((r#ctjjjjjjjjj j j d \}}fd}j |||fS)NTrcV|d}|_||d<dS)N__attrs_init__rrs r!_attach_attrs_initz8_ClassBuilder.add_attrs_init.._attach_attrs_initms5)*D#.D )-)A)A$)G)GH% & & &r#r)r rTrVrrs` @r!add_attrs_initz_ClassBuilder.add_attrs_init]s%6 I K    #   L K     L   & & & "{ H H H H H H $$fe5G%HIII r#cj}tj\}}fd}j|||ft |d<S)NcD|d|d<dS)N__eq__rrs r! _attach_eqz(_ClassBuilder.add_eq.._attach_eq{s%!%!9!9%/!J!JHX   r#__ne__)r_make_eq_scriptrr rr)r rrTrVrs` r!add_eqz_ClassBuilder.add_eqvsi ^' 44  K K K K K $$feZ%@AAA8  r#cj}fdtjjD\|d<|d<|d<|d<S)Nc3BK|]}|VdSr/r)rmethr s r!rz*_ClassBuilder.add_order..sMB B   $ $T * *B B B B B B r#__lt____le____gt____ge__)r _make_orderrr)r rs` r! add_orderz_ClassBuilder.add_ordersg ^B B B B #DIt{;;B B B >8 blBxL"X,  r#ci|jD],}|jp|j}|r|tjur ||f|j<-s|S|jrd}t|fd}d|jd<| ||jd<d|_ |S)Nz7Can't combine custom __setattr__ with on_setattr hooks.c |\}}||||}n#t$r|}YnwxYwt|||dSr/)KeyErrorr)r rvalrrRnvalsa_attrss r!rz._ClassBuilder.add_setattr..__setattr__sl *"4.4tD!S))     tT * * * * *s  ++Tr_r) rrCrr NO_OPrrrGrrr#)r rrCrQrrs @r! add_setattrz_ClassBuilder.add_setattrs 1 1A9)9J 1j ==#$j=  K  # "KCS// ! + + + + +37./(,(@(@(M(M}%"& r#methodrc|jj|_|jjd|j|_d|jjd|_|S)z@ Add __module__ and __qualname__ to a *method*. r$Method generated by attrs for class )rr'r(r&r)r rs r!rCz(_ClassBuilder._add_method_dunders_unsafesR!I0!%!7KK&/KK M493I L L L  r#ctjt5|jj|_dddn #1swxYwYtjt5|jjd|j|_dddn #1swxYwYtjt5d|jjd|_dddn #1swxYwY|S)zL Add __module__ and __qualname__ to a *method* if possible. Nrr)rarbrcrr'r(r&r)rs r!rBz&_ClassBuilder._add_method_dunders_safes  0 0 5 5 $ 4F  5 5 5 5 5 5 5 5 5 5 5 5 5 5 5  0 0 P P%)Y%;"O"Ofo"O"OF  P P P P P P P P P P P P P P P  0 0 ^ ^]DIDZ]]]FN ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ s08<<BB B(C  CCN)rr3rr$r%rr&r$)r[r\)rrr[r)r&r'r(r)rprIr"rSr]rZrVrrr@rrrrrrrrrrCrBrr#r!rrsuI0cGcGcGcGJ<<<''''$2"""HMMM^   '.'.'.R   2   2   @          r#rc|&t|du|dufrd}t||||fS||}||}|dur|durd}t|||fS) Validate the combination of *cmp*, *eq*, and *order*. Derive the effective values of eq and order. If *eq* is None, set it to *default_eq*. N&Don't mix `cmp` with `eq' and `order`.FT-`order` can only be True if `eq` is True too.anyrG)r9r?rA default_eqrQs r!_determine_attrs_eq_orderrs  3$T0ABCC6oo Cx z  } U{{u}}=oo u9r#c|&t|du|dufrd}t|d}|||\}}||||fS||d}}n||\}}|||}}n||\}}|dur|durd}t|||||fS)rNrc6t|rd|}}nd}||fS)z8 Decide whether a key function is used. TN)rH)rrs r!decide_callable_or_booleanz>_determine_attrib_eq_order..decide_callable_or_booleans, E?? u3EECczr#FTrr) r9r?rArrQrcmp_keyr@rBs r!rErEs  3$T0ABCC6oo 11#66 WGS')) zF//33 F }vy55e<<y U{{u}}=oo vui ''r#cZ|dus|dur|S||dur|S|D]}t||rdS|S)ap Check whether we should implement a set of methods for *cls*. *flag* is the argument passed into @attr.s like 'init', *auto_detect* the same as passed into @attr.s and *dunders* is a tuple of attribute names whose presence signal that the user has implemented it themselves. Return *default* if no reason for either for or against is found. TF)r)rflag auto_detectdundersr6dunders r!_determine_whether_to_implementrsd t||tu}}  | u,, c6 * * 55  Nr#FcZ (ddl}|tddt|||d\||t t t frtj     fd}||S||S)a A class decorator that adds :term:`dunder methods` according to the specified attributes using `attr.ib` or the *these* argument. Consider using `attrs.define` / `attrs.frozen` in new code (``attr.s`` will *never* go away, though). Args: repr_ns (str): When using nested classes, there was no way in Python 2 to automatically detect that. This argument allows to set a custom name for a more meaningful ``repr`` output. This argument is pointless in Python 3 and is therefore deprecated. .. caution:: Refer to `attrs.define` for the rest of the parameters, but note that they can have different defaults. Notably, leaving *on_setattr* as `None` will **not** add any hooks. .. versionadded:: 16.0.0 *slots* .. versionadded:: 16.1.0 *frozen* .. versionadded:: 16.3.0 *str* .. versionadded:: 16.3.0 Support for ``__attrs_post_init__``. .. versionchanged:: 17.1.0 *hash* supports `None` as value which is also the default now. .. versionadded:: 17.3.0 *auto_attribs* .. versionchanged:: 18.1.0 If *these* is passed, no attributes are deleted from the class body. .. versionchanged:: 18.1.0 If *these* is ordered, the order is retained. .. versionadded:: 18.2.0 *weakref_slot* .. deprecated:: 18.2.0 ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now raise a `DeprecationWarning` if the classes compared are subclasses of each other. ``__eq`` and ``__ne__`` never tried to compared subclasses to each other. .. versionchanged:: 19.2.0 ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now do not consider subclasses comparable anymore. .. versionadded:: 18.2.0 *kw_only* .. versionadded:: 18.2.0 *cache_hash* .. versionadded:: 19.1.0 *auto_exc* .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01. .. versionadded:: 19.2.0 *eq* and *order* .. versionadded:: 20.1.0 *auto_detect* .. versionadded:: 20.1.0 *collect_by_mro* .. versionadded:: 20.1.0 *getstate_setstate* .. versionadded:: 20.1.0 *on_setattr* .. versionadded:: 20.3.0 *field_transformer* .. versionchanged:: 21.1.0 ``init=False`` injects ``__attrs_init__`` .. versionchanged:: 21.1.0 Support for ``__attrs_pre_init__`` .. versionchanged:: 21.1.0 *cmp* undeprecated .. versionadded:: 21.3.0 *match_args* .. versionadded:: 22.2.0 *unsafe_hash* as an alias for *hash* (for :pep:`681` compliance). .. deprecated:: 24.1.0 *repr_ns* .. versionchanged:: 24.1.0 Instances are not compared as tuples of attributes anymore, but using a big ``and`` condition. This is faster and has more correct behavior for uncomparable values like `math.nan`. .. versionadded:: 24.1.0 If a class has an *inherited* classmethod called ``__attrs_init_subclass__``, it is executed after the class is created. .. deprecated:: 24.1.0 *hash* is deprecated in favor of *unsafe_hash*. .. versionchanged:: 25.4.0 *kw_only* now only applies to attributes defined in the current class, and respects attribute-level ``kw_only=False`` settings. .. versionadded:: 25.4.0 *force_kw_only* NrzQThe `repr_ns` argument is deprecated and will be removed in or after August 2025.) stacklevelc |pt|}duot|t} ot|d}|r|rd}t || ot | d}t j}|r|j}n}durr|j n|j }nhdur|j}n\I durt|dr|j}n>|dur|durr|j n|j }n%|dur|j}n|j }nd}t|t j }rr|jn|j} n|j} t d"id|d |d d d t | d dt | dd|d| ot | dd|dd| d!ddt | ddd} | jsrd}t|t%| | |} | jr| | jr| | jr| | jr| s| | jr| n"| j|j ur| | jr| n'| !rd}t|tDr$t|d s| #tHr&r$t|d!s| %| &S)#NTrz/Can't freeze a class with a custom __setattr__.)rrFrr5r:r2r0r/ added_initrI added_reprradded_eqadded_ordering)rrrrr4added_match_argsr>r3 added_strr?)r-r.)r6r;rzlInvalid value for cache_hash. To use hash caching, hashing must be either explicitly or implicitly enabled.)rr%r&zFInvalid value for cache_hash. To use hash caching, init must be True.rrr)'_has_frozen_base_class issubclassrrrGrrr5 LEAVE_ALONEr6HASHABLE UNHASHABLErFrrYESr is_hashablerr rr rr rr rrrr4rrrrrrrrr])"rr2is_exchas_own_setattrrQr?r5r4rkwor%builderrrauto_excrreq_r force_kw_onlyrgetstate_setstater:r;r> match_argsrCorder_r8repr_nsslotsrUr weakref_slots" r!wrapzattrs..wraps94S99 T!Djm&D&D% *< + +   "y "CCS// !Z ; k#7  !,  !%1KK T\\* ++ ) K U]]%1KK \d""'9#z'J'J")5 t T 1 1".K//$- u)5 )4 JCC..  ,  !'4I+##+/CC.C! ! ! ! i! u! %3N ! 7T;  ! 7T; ! R!  &:/8 ! &$ '! ((Z)! *C+! ,*\-! .c/! 0;!0 1! >'J?! @0/A! F  !Z !ACC..   %.       &   W % % % ?  OO    >  NN            "    ! ! !   &         +"8 8 8  # # % % %   %         " " $ $ $ %^nn$  " 23 F F "    ! ! !  % %'s,<== %  " " $ $ $""$$$r#) warningswarnDeprecationWarningrrJrKrLr rM) maybe_clsrrr8r9r:r;r rr!rUrr>rrr?rArrrrCrr unsafe_hashrr#r"rrs ``` `````````` `````` ` @@r!rr-sZB c      ,CUDAAKC*tUm,,/\:. G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%G%V 4 ??r#c|jtuS)zV Check whether *cls* has a frozen ancestor by looking at its __setattr__. )rr)rs r!rr9s ?. ..r#r func_namec Ld|d|jdt|d|jdS)zF Create a "filename" suitable for a function being generated. z.NsAAFdNNqv~!$$,,,,,,r# r:zdef __hash__(selfzhash((z))z):z, *zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper()c T||zz|d dzgD]d}|jr:d|jd}|j|<|d|d|jdzC|d|jdze|dzzd S) z Generate the code for actually computing the hash code. Below this will either be returned directly or used to compute a value which is then cached, depending on the value of cache_hash r/,rP_key(self.z), self. N)rr@rr) prefixindentrcmp_namerclosing_bracesrV hash_func method_lines type_hashs r!append_hash_computation_linesz8_make_hash_script..append_hash_computation_linesfs )+0I0000     H HAx H+qv+++"#(h##BBBBBBB##F-FQV-F-F-F$FGGGGFVOn<=====r#zif self.z is None:zobject.__setattr__(self, '', rself. = z return self.zreturn r)rLr:rrrr) rrrrtabhash_defr>rTr:rVr;r<r=s ` @@@@@r!rrKs   E C.sF;;<>>>>>>>>>4 6C"I->"I"I"IIJJJ   ) )C->CCCS1W      a# . . . . ) ).)...a    C"D1B"D"DDEEEE%%i555 YY| $ $F 5=r#ct||dd\}}t||t|d|d|_|S)z% Add a hash method to *cls*. FrrrZ)rrbrrrrrTrVs r! _add_hashrGsc& U5UMFE 9#z J J$CL Jr#cR||}|turtS| S)z^ Check equality and either forward a NotImplemented or return the result negated. )rNotImplemented)r otherresults r!rrs. [[  F :r#rKc d|D}gd}i}|r|d|D]}|jrBd|jd}|j||<|d|d|jd|d |jd n%|d |jd |j||d ur|d d|d <|dn|dd|}||fS)z6 Create __eq__ method for *cls* with *attrs*. c g|] }|j | Sr)r?rs r!rz#_make_eq_script..s & & &1 &Q & & &r#)zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (rPr3r/r4z) == z(other.r0r5z == other.rfz andz )z return Truer)rr@rr)rrrVrr9rTs r!rrsY ' & & & &E   E E ( _%%% / /Ax I+qv+++#$(h VxVVqvVVHVVQVVVV GQVGGqvGGHHHb !!$Ry...b  W &''' YYu  F 5=r#c\dDfdfd}fd}fd}fd}||||fS)z9 Create ordering methods for *cls* with *attrs*. c g|] }|j | Sr)rArs r!rz_make_order..s ) ) )1 )Q ) ) )r#cPtdfdDDS)z& Save us some typing. c3:K|]\}}|r ||n|VdSr/r)rrrs r!rz6_make_order..attrs_to_tuple..sK  s (CCJJJ5      r#c3PK|] }t|j|jfV!dSr/)rrrB)rrobjs r!rz6_make_order..attrs_to_tuple..sG89af%%q{3r#)rL)rSrs`r!attrs_to_tuplez#_make_order..attrs_to_tuplesW  =B      r#c^|j|jur||kStSz1 Automatically created by attrs. rrIr rJrTs r!rz_make_order..__lt__9 ?dn , ,!>$''..*?*?? ?r#c^|j|jur||kStSrVrWrXs r!rz_make_order..__le__9 ?dn , ,!>$''>>%+@+@@ @r#c^|j|jur||kStSrVrWrXs r!rz_make_order..__gt__rYr#c^|j|jur||kStSrVrWrXs r!rz_make_order..__ge__r[r#r)rrrrrrrTs ` @r!rrs * ) ) ) )E       666 ))r#c||j}t|\}}t||t|d|d|_t |_|S)z5 Add equality methods to *cls* with *attrs*. NrrE)rrrbrrrrFs r!_add_eqr_ sd }##E**MFE 9#x H HxCJCJ Jr#ctd|D}d|D}t|d<t|d<t|d<g}|D]H\}}}|rd|znd|zdz}|tkr|d |d n |d |d |d } || Id |} |d} n|dz} ddddddddddddd| d| ddd g} d!| |fS)"zC Create the source and globs for a __repr__ and return it. c3pK|]1}|jdu |j|jdurtn|j|jfV2dS)FTN)r8rr;rs r!rz$_make_repr_script.."sV"" 6   !&D..$$afqv>    ""r#c8i|]\}}}|tk|dz|S)_repr)r8)rrrrPs r!rlz%_make_repr_script..'s0   (dAqQ$YYwYYYr#r rcrr@zgetattr(self, "z ", NOTHING)z={z!r}z_repr(z)}rNz1{self.__class__.__qualname__.rsplit(">.", 1)[-1]}z.{self.__class__.__name__}zdef __repr__(self):z try:z: already_repring = _compat.repr_context.already_repringz except AttributeError:z! already_repring = {id(self),}z: _compat.repr_context.already_repring = already_repringz else:z# if id(self) in already_repring:z return '...'z else:z# already_repring.add(id(self))z return f'(z)'z finally:z$ already_repring.remove(id(self))r)rLr rcrr8rr) rrattr_names_with_reprsrVattribute_fragmentsrrdryaccessorfragment repr_fragmentcls_name_fragmentrs r!rrs""""""   ,A   EE),E E)+ - - a MGdNN%6%= %M  Dyy 44 * *'+ttTTT888<  ""8,,,,II122M zO!== D"+D--=)==M===. E$ 99U  U ""r#c||j}t||\}}t||t|d|d|_|S)z% Add a repr method to *cls*. Nr"rE)rrrbrr")rrrrTrVs r! _add_reprrmTs` }#%eR00MFE 9#z J J$CL Jr#c\t|}|Ut|ts@t|}t|ddd}t |t |St|dd}|2|t|dd}| ||_|S|d}t||S)a Return the tuple of *attrs* attributes for a class or instance. The tuple also allows accessing the fields by their names (see below for examples). Args: cls (type): Class or instance to introspect. Raises: TypeError: If *cls* is neither a class nor an *attrs* instance. attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs* class. Returns: tuple (with name accessors) of `attrs.Attribute` .. versionchanged:: 16.2.0 Returned tuple allows accessing the fields by name. .. versionchanged:: 23.1.0 Add support for generic classes. .. versionchanged:: 26.1.0 Add support for instances. Nrz0Passed object must be a class or attrs instance.! is not an attrs-decorated class.)rrJr3rrFr rr)r generic_basetype_rQrs r!r r cs0$C((LJsD$9$9S  5+T 2 2 :DCC.. e}} C*D 1 1E }  #L*;TBBE ',# 999"3''' Lr#ct|tsd}t|t|dd}||d}t |d|DS)a Return an ordered dictionary of *attrs* attributes for a class, whose keys are the attribute names. Args: cls (type): Class to introspect. Raises: TypeError: If *cls* is not a class. attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs* class. Returns: dict[str, attrs.Attribute]: Dict of attribute name to definition .. versionadded:: 18.1.0 zPassed object must be a class.rNroci|] }|j| Srrrs r!rlzfields_dict..s % % %!AFA % % %r#)rJr3rFrr)rrQrs r! fields_dictrtsn& c4 .nn C*D 1 1E }999"3''' % %u % % %%r#c tjdurdSt|jD]+}|j}| |||t ||j,dS)z Validate all attributes on *inst* that have a validator. Leaves all exceptions through. Args: inst: Instance of a class with *attrs* attributes. FN)r _run_validatorsr rr7rr)r rrks r!r=r=sg%'' DN # #.. K = AdAwtQV,, - - -..r#cB||}|od|jvS)z> Check if the attribute name comes from a slot class. rp)rr)a_namerrs r! _is_slot_attrrys)   F # #C  .;#,..r#tuple[str, dict, dict]c | duo | tju} |r| rd} t| |p|}g}i}|D]}|js|jt ur|||||j<|j+|dur$|jtjurd} t| d}i| r|jtjurd}t||||||||| || | rdnd \}}}|j tj vr/| tj |j j| t |d|rtj|d<|||fS)Nz$Frozen classes can't use on_setattr.TrrI)r attr_dictr)r rrGr;r6rrrrC_attrs_to_init_scriptr'r|modulesrOrrr)rrpre_initpre_init_has_args post_initrr rrrcls_on_setattrrhas_cls_on_setattrrQneeds_cached_setattrfiltered_attrsr|rrTrVrs r!rrs d"J~W]'J$4oo%/NI ((v !)w.. a    !& < #~~!,gm"C"C< oo%#'  (AL $E$E#' !6 &6J " "FE; ~$$ S[09::: LLW9==>>><(4';#$ 5+ %%r#r value_varhas_on_setattrcd|d|dS)zJ Use the cached object.setattr to set *attr_name* to *value_var*. _setattr('r?r0r)rrrs r!_setattrrs 3 2 2i 2 2 22r#r< Converterc<d|d|||dS)zk Use the cached object.setattr to set *attr_name* to *value_var*, but run its converter first. rr?r0)_fmt_converter_callrrrr<s r!_setattr_with_converterrs. ] \ \i&C&CIy&Y&Y \ \ \\r#rc8|rt||dSd|d|S)zo Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. Tr@rA)r)rrrs r!_assignr#s4 0 5$/// (9 ( ( ( ((r#cb|rt||d|Sd|d|||S)z Unless *attr_name* has an on_setattr hook, use normal assignment after conversion. Otherwise relegate to _setattr_with_converter. Tr@rA)rrrs r!_assign_with_converterr.sGN&y)T9MMM V9 V V!>!>y)!T!T V VVr#r rrcr|dur$|durdttfSdfd }dfd }d ||fSdttfS)zg Determine the correct setter functions based on whether a class is frozen and/or slotted. TrrrUrrr$r[cVt|rt|||Sd|d|SN _inst_dict['z'] = )ryr)rrrrs r! fmt_setterz&_determine_setters..fmt_setterKs@Y 66 F 9nEEE=)==)== =r#r<rc|st|rt||||Sd|d|||Sr)ryrr)rrrr<rs r!fmt_setter_with_converterz5_determine_setters..fmt_setter_with_converterSsd  y-!H!H .y.)h)gg)2O2OPY[d2e2egg gr#)z_inst_dict = self.__dict__rrUrrUrr$r[rU rrUrrUrr$r<rr[rU)rrrr)rr rrrs ` r!_determine_settersr;s~~ D==x!88 8 > > > > > > h h h h h h ,  %   w. ..r#r2r0 call_pre_initrcall_post_initdoes_cache_hashrrr method_namec  |rdgng} | r| dt|||\} }}| | g}g}g}g}i}ddi}|D]}|jr|||j}|jdup|jt juo| }|j}t|j t}|r|j j rdnd}|j /t|j tst|j }n|j }|jdur|rt |jfz}|K| |||d|d z|||j |||j<n'| |||d|d z||j j||<n]|I| ||d |d |||j |||j<n| ||d |d |n|j t&ur|s|d |d }|jr||n*|||||E| ||||||j |||j<nF| ||||n$|rt|d }|jr||n*||||| d|dt |jfz}|| d|||||z| d| d|||dz|zd z||z|j |||j<nd| d||||z| d| d|||dz|zd z|z|j j||<n|jr||n*|||||D| ||||||j |||j<n | |||||jdur(|j| |j||<||jr |j||<|rkt.|d<| d|D]I}d|jz}d|jz}| d|d|d|jd |j||<|||<J|r| d|r<|r|r dt0d} ndt0d} n dt0d} | | |r8d d!|D}!| d"|!d d#|}d#|}|rX||rd#ndd$d#|z }d#d%d&|DD}"||rd#ndz }||"z }|r |r d'|d | d(<d)}#d*| d|d+| r|#| nd,d-||fS).z Return a script of an initializer for *attrs*, a dict of globals, and annotations for the initializer. The globals are required by the generated script. zself.__attrs_pre_init__()z$_setattr = _cached_setattr_get(self)r[Nr rSFrer0z attr_dict['z '].defaultz =attr_dict['z=NOTHINGzif z is not NOTHING:r6zelse:Tr z#if _config._run_validators is True:__attr_validator___attr_z(self, z, self.zself.__attrs_post_init__()rz', None)rz '] = Noner@z = Noner2c38K|]}|j d|jVdS)r@N)r;rrs r!rz(_attrs_to_init_script..P s4BBQ16B(((BBBBBBr#zBaseException.__init__(self, rz*, cg|] }|d| S)=r)r kw_arg_names r!rz)_attrs_to_init_script..Z s8    ....   r#c3LK|]}|ddV dS)rrN)split)rkwas r!rz(_attrs_to_init_script..] s1#N#N#CIIcNN1$5#N#N#N#N#N#Nr#zself.__attrs_pre_init__(rz zdef z): passr)rrrr7rrCr rrDrJr6rI takes_selfr<rr;_INIT_FACTORY_PAT_get_global_namerPrr>r3_first_param_typer rr)$rr2r0rrrrrrrrrr extra_linesrrr  pre_init_args kw_only_argsattrs_to_validatenames_for_globalsrrrrarg_name has_factory maybe_selfr<init_factory_nameargval_nameinit_hash_cachevalspre_init_kw_only_argsNLs$ r!r}r}jsX (.; B ( ) )E   3    :L:}::6K6 LL DMLT"K XDXD ; (  $ $Q ' ' 'F T1 L - D2D  7 G44 *Kqy/CKVV ; ":ak9+M+M "!!+..II I 6U??* $5 $A!(LL11%-0AJ0A0A0AA*% "+&i&@&@&H&HIILL" %-0AJ0A0A0AA*89y7H!"344& --!;i;;;&! '")"<">v!i&7() H%%&9+F&(1(C H%-'.)$ :;;;" - -A*QV3H!AF*I LLLLLLL16LLL M M M*++ h '+, i ( (3 1222&  A N"J/@"J"J"J"M1B"M"M"M@&7@@@O _%%%>xxBB%BBBBB m>>>a B   T  (RWWU^^^&      r#rc,|dS)z The default __init__ parameter name for a field. This performs private-name adjustment via leading-unscore stripping, and is the default value of Attribute.alias if not provided. rP)lstriprs r!rrr s ;;s  r#cneZdZdZdZ ddZdZe ddd ZdZ dZ dZ dZ dS)raz *Read-only* representation of an attribute. .. warning:: You should never instantiate this class yourself. The class has *all* arguments of `attr.ib` (except for ``factory`` which is only syntactic sugar for ``default=Factory(...)`` plus the following: - ``name`` (`str`): The name of the attribute. - ``alias`` (`str`): The __init__ parameter name of the attribute, after any explicit overrides and default private-attribute-name handling. - ``alias_is_default`` (`bool`): Whether the ``alias`` was automatically generated (``True``) or explicitly provided by the user (``False``). - ``inherited`` (`bool`): Whether or not that attribute has been inherited from a base class. - ``eq_key`` and ``order_key`` (`typing.Callable` or `None`): The callables that are used for comparing and ordering objects by this attribute, respectively. These are set by passing a callable to `attr.ib`'s ``eq``, ``order``, or ``cmp`` arguments. See also :ref:`comparison customization `. Instances of this class are frequently used for introspection purposes like: - `fields` returns a tuple of them. - Validators get them passed as the first argument. - The :ref:`field transformer ` hook receives a list of them. - The ``alias`` property exposes the __init__ parameter name of the field, with any overrides and default private-attribute handling applied. .. versionadded:: 20.1.0 *inherited* .. versionadded:: 20.1.0 *on_setattr* .. versionchanged:: 20.2.0 *inherited* is not taken into account for equality checks and hashing anymore. .. versionadded:: 21.1.0 *eq_key* and *order_key* .. versionadded:: 22.2.0 *alias* .. versionadded:: 26.1.0 *alias_is_default* For the full version history of the fields, see `attr.ib`. )rr6r7r8r?r@rArBr:r;r=r3r<r>rrCrDrNFc|t||p| |p|d\} }}}t|}|d||d||d||d||d| |d||d||d ||d ||d ||d | |d | r!tjt | nt |d| |d| |d||d||d||d||dun|dS)NTrr6r7r8r?r@rArBr:r;r<r=r3r>rrCrDr)rErrtypesMappingProxyTyper1_EMPTY_METADATA_SINGLETON)r rr6r7r8r9r:r;rr=r3r<r>r?r@rArBrCrDr bound_setattrs r!rIzAttribute.__init__ s,(B 2y1E4( ( $FE9 %,,T22   fd### i))) k9--- fd### dB h''' gu%%% k9--- fd### fd### k9--- /&tH~~666.      fd### i))) k9--- lJ/// gu%%% -5ETMM;K     r#ctr/)rrs r!rzAttribute.__setattr__ s!!r#rrUrrOr>r$c4||j}n|jd|d}t||||j|j|jd|j|jd|j||j|j |n|j |j |j |j |j |j|j|jduS)Nz>Type annotation and type argument cannot both be present for 'z'.F)r3rG_default _validatorr8r:r;r=r<r>r?r@rArBrCrD)rrrr>r3rQs r!rzAttribute.from_counting_attr s <7DD W [SW[[[CS// !s  K M G  G G  K  Lz)GGrz E I H L M H H '   r#c \tj|}||d|vr(d|vr$t|ddnDd|vr@d|vr<|jr5t|dt |j|S)a  Copy *self* and apply *changes*. This works similarly to `attrs.evolve` but that function does not work with :class:`attrs.Attribute`. It is mainly meant to be used for `transform-fields`. .. versionadded:: 20.3.0 rDrFr)copy _setattrsrrrrrr)r r news r!rzAttribute.evolve$ sioo gmmoo&&& g  "4G"C"C   % %&8% @ @ @ @ g  w&&%'   % %0::    r#cDtfdjDS)( Play nice with pickle. c3lK|].}|dkrt|ntjV/dS)r=N)rr1r=rs r!rz)Attribute.__getstate__..H sZ  $(:#5#5GD$   4 ;N;N      r#rLrprs`r!r-zAttribute.__getstate__D s?          r#cxt|t|jkrltt|j|}|ddup+|dt |dk}g||R}|t|j|dS)rrDNr)rirpr1rrrr)r r state_dictrs r!r.zAttribute.__setstate__M s u::DN++ + +c$.%8899J)~~    #004K6"55  /e.-..E s4>51122222r#c t|}|D]L\}}|dkr ||||||r!tjt |nt MdS)Nr=)rrrrr1r)r name_values_pairsrrrs r!rzAttribute._setattrs^ s$,,T22 ,  KD%z!! dE**** !7.tE{{;;;6   r#) NNNFNNNNNNNr/)rrUrrOr>r$) r&r'r(r)rprIrrrrr-r.rrr#r!rr} s++^I>  ): : : : x"""?C    [ D@   333"     r#rcvg|]6}t|td|dkddd|dkddt| 7S)NrTFr= rr6r7r8r9r?rAr:r;rrDrrrrrs r!rrn sm  ((  j %d++   r#)rc(g|]}|jdk |Srrrs r!rr s$666Q+ 5 5q 5 5 5r#c6g|]}|j |jdk|Sr)r:rrs r!rr s+ = = =AF =qv'<'<1'<'<'r=rCrArBr8r3c#vK|]4}t|t|tddddddddddddV5dS)NTFrrDr6r7r8r9r:r;r>r?r@rArBrrC)rrrrs r!rz_CountingAttr. s|  $# -d33         r#) rrr8r?rAr:r;rCrDr=NTFrrc$txjdz c_tj|_||_||_||_||_| |_| |_| |_ ||_ ||_ ||_ ||_ | |_| |_||_||_dSr)rO cls_counterrrrr<r8r?r@rArBr:r;r=r3r>rCrD)r r6r7r8r9r:r;r<r=r3r>r?r@rArBrCrDs r!rIz_CountingAttr.__init__ s& !!Q&!!$0  #"   "      $ r#cX|j||_nt|j||_|S)z Decorator that adds *meth* to the list of validators. Returns *meth* unchanged. .. versionadded:: 17.1.0 )rrNr rs r!r7z_CountingAttr.validator s- ? ""DOO"4?D99DO r#c\|jturtt|d|_|S)z Decorator that allows to set the default for an attribute. Returns *meth* unchanged. Raises: DefaultAlreadySetError: If default has been set before. .. versionadded:: 17.1.0 T)r)rrrrIrs r!r6z_CountingAttr.default s0 = ' '( (666  r#) r&r'r(r)rprLrrrrIr7r6rr#r!rOrO sI$0   $ %     0>     ?00ObK###J   r#rOc~eZdZdZGddejZGddejZdZdZ e dZ d S) ra Effective class properties as derived from parameters to `attr.s()` or `define()` decorators. This is the same data structure that *attrs* uses internally to decide how to construct the final class. Warning: This feature is currently **experimental** and is not covered by our strict backwards-compatibility guarantees. Attributes: is_exception (bool): Whether the class is treated as an exception class. is_slotted (bool): Whether the class is `slotted `. has_weakref_slot (bool): Whether the class has a slot for weak references. is_frozen (bool): Whether the class is frozen. kw_only (KeywordOnly): Whether / how the class enforces keyword-only arguments on the ``__init__`` method. collected_fields_by_mro (bool): Whether the class fields were collected by method resolution order. That is, correctly but unlike `dataclasses`. added_init (bool): Whether the class has an *attrs*-generated ``__init__`` method. added_repr (bool): Whether the class has an *attrs*-generated ``__repr__`` method. added_eq (bool): Whether the class has *attrs*-generated equality methods. added_ordering (bool): Whether the class has *attrs*-generated ordering methods. hashability (Hashability): How `hashable ` the class is. added_match_args (bool): Whether the class supports positional `match ` over its fields. added_str (bool): Whether the class has an *attrs*-generated ``__str__`` method. added_pickling (bool): Whether the class has *attrs*-generated ``__getstate__`` and ``__setstate__`` methods for `pickle`. on_setattr_hook (Callable[[Any, Attribute[Any], Any], Any] | None): The class's ``__setattr__`` hook. field_transformer (Callable[[Attribute[Any]], Attribute[Any]] | None): The class's `field transformers `. .. versionadded:: 25.4.0 c(eZdZdZdZ dZ dZ dZdS)ClassProps.HashabilityzO The hashability of a class. .. versionadded:: 25.4.0 hashablehashable_cache unhashable leave_aloneN)r&r'r(r)rr6rrrr#r!r5rd s9  #*6! +# ''r#r5c"eZdZdZdZ dZ dZdS)ClassProps.KeywordOnlyzw How attributes should be treated regarding keyword-only parameters. .. versionadded:: 25.4.0 ryesforceN)r&r'r(r)rrrrr#r!rrt s1  .Q..r#rr:r0r3r2r>r/rr r r r4r r r?r;rc||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ | |_ ||_ ||_||_dSr/r)r r:r0r3r2r>r/rr r r r4r r r?r;rs r!rIzClassProps.__init__ s&)$ 0" '>$$$  ,& 0",.!2r#cb|jtjjup|jtjjuSr/)r4rr5rr6rs r!rzClassProps.is_hashable s1   6 ? ? J:#9#II r#N) r&r'r(r)r*Enumr5rrprIr|rrr#r!rr sBBH(((((di((( / / / / /di / / /I&"3"3"3H  X   r#rcfg|].}t|tddddddddt| /S)NTFrrrs r!rr sb       %d++   r#c*eZdZdZdZddZdZdZdS) rIa Stores a factory callable. If passed as the default value to `attrs.field`, the factory is used to generate a new value. Args: factory (typing.Callable): A callable that takes either none or exactly one mandatory positional argument depending on *takes_self*. takes_self (bool): Pass the partially initialized instance that is being initialized as a positional argument. .. versionadded:: 17.1.0 *takes_self* rPrFc"||_||_dSr/r)r rPrs r!rIzFactory.__init__ s $r#cDtfdjDS)rc38K|]}t|VdSr/rors r!rz'Factory.__getstate__.. s-DDTWT4((DDDDDDr#rrs`r!r-zFactory.__getstate__ s*DDDDT^DDDDDDr#c^t|j|D]\}}t|||dS)rN)rrpre)r rrrs r!r.zFactory.__setstate__ sBt~u55 ' 'KD% D$ & & & & ' 'r#N)F)r&r'r(r)rprIr-r.rr#r!rIrI sZ$*I%%%%EEE '''''r#rIcJg|] }t|tdddddddd !SNTF) rr6r7r8r9r?rAr:r;rrrrs r!rr W          r#cPeZdZdZdZddddZedd Zdd Zd Z d Z dS)rae Stores a converter callable. Allows for the wrapped converter to take additional arguments. The arguments are passed in the order they are documented. Args: converter (Callable): A callable that converts the passed value. takes_self (bool): Pass the partially initialized instance that is being initialized as a positional argument. (default: `False`) takes_field (bool): Pass the field definition (an :class:`Attribute`) into the converter as a positional argument. (default: `False`) .. versionadded:: 24.1.0 )__call__r _global_namer< takes_fieldrFrrc~|_|_|_t|}|_jsjs fd_n>jrjs fd_n%jsjr fd_n j_|}||jjd<dSdS)Nc.|Sr/r<)rrP__r s r!rz$Converter.__init__..6 s1F1Fr#c0||Sr/r)rinstancerr s r!rz$Converter.__init__..8 sx99r#c0||Sr/r)rrrr s r!rz$Converter.__init__..< sT^^u66r#r[) r<rrrget_first_param_typerrget_return_typer)r r<rrexrts` r!rIzConverter.__init__- s"$& !) , ,!#!8!8!:!: +4#3 +FFFFDMM _ +T%5 +DMM +T%5 +DMM!NDM    ! ! >68DM )( 3 3 3 >r#rrUr[c d|S)zh Return the name that a converter for an attribute name *attr_name* would have. __attr_converter_r)rs r!rzConverter._get_global_nameF s /9...r#rc,|js"|js||d|dS|jr%|jr||d|d|dS|jr||d|dS||d|d|dS)z Return a string that calls the converter for an attribute name *attr_name* and the value in variable named *value_var* according to `self.takes_self` and `self.takes_field`. rer0z, self, attr_dict['z'])z, self)z , attr_dict[')rrr)r rrs r!rzConverter._fmt_converter_callN s  F4#3 F++I66EEEEE E ? ft/ f++I66eeeeW`eee e ? L++I66KKKKK K'' 22[[Y[[Y[[[[r#c,|j|j|jdS)zx Return a dict containing only converter and takes_self -- the rest gets computed when loading. r<rrrrs r!r-zConverter.__getstate___ s# /+   r#c |jdi|dS)z+ Load instance from state. Nrr)r rs r!r.zConverter.__setstate__j s"  r#N)rrUr[rU)rrUrrUr[rU) r&r'r(r)rprIrrrr-r.rr#r!rr s(I165999992///\/\\\\"    r#cJg|] }t|tdddddddd !Srrrs r!rrq rr#rc  tjd|}t|tr|}n:t|tt fr d|D}nd}t ||dd}|dd}|dd} i | ||| d<|| d<| | d<tj ||i fd} tj tt5tjd jd d | _dddn #1swxYwY|d d} t)| |d |dd\|d <|d<t+dd|i|| } d|D| _| S)a A quick way to create a new class called *name* with *attrs*. .. note:: ``make_class()`` is a thin wrapper around `attr.s`, not `attrs.define` which means that it doesn't come with some of the improved defaults. For example, if you want the same ``on_setattr`` behavior as in `attrs.define`, you have to pass the hooks yourself: ``make_class(..., on_setattr=setters.pipe(setters.convert, setters.validate)`` .. warning:: It is *your* duty to ensure that the class name and the attribute names are valid identifiers. ``make_class()`` will *not* validate them for you. Args: name (str): The name for the new class. attrs (list | dict): A list of names or a dictionary of mappings of names to `attr.ib`\ s / `attrs.field`\ s. The order is deduced from the order of the names or attributes inside *attrs*. Otherwise the order of the definition of the attributes is used. bases (tuple[type, ...]): Classes that the new class will subclass. class_body (dict): An optional dictionary of class attributes for the new class. attributes_arguments: Passed unmodified to `attr.s`. Returns: type: A new class with *attrs*. .. versionadded:: 17.1.0 *bases* .. versionchanged:: 18.1.0 If *attrs* is ordered, the order is retained. .. versionchanged:: 23.2.0 *class_body* .. versionchanged:: 25.2.0 Class names can now be unicode. NFKCc,i|]}|tSr)rRrs r!rlzmake_class.. s///AAvxx///r#z(attrs argument must be a dict or a list.r*Nr+rIc.|Sr/)rO)rr~s r!rzmake_class.. s $r#r r&__main__r9r?rATrc2i|]\}}|j ||jSr/)r3)rrjrks r!rlzmake_class.. s.a!&2D162D2D2Dr#r) unicodedata normalizerJr1rKrLrFpoprOr new_classrarbrcrGr| _getframe f_globalsrr'rrrr)rrbases class_bodyattributes_argumentsrrQrr user_initrqr9rr~s @r! make_classr' sd`   . .D% ED%= ) )/////8nn||0$77H 2D99I Z..I D J%- !"&/ "#$Z OD%-G-G-G-G H HE  ^Z 8 8  =++599                    " "5$ / /C "   &&  ))   T"W% 9& 8 8x 8#7 8 8 ? ?C&nn..C Js3EEE)r r'c,eZdZdZeZdZdS) _AndValidatorz2 Compose many validators to a single one. c4|jD]}||||dSr/) _validators)r r rrrks r!rz_AndValidator.__call__ s5! ! !A AdD%  ! !r#N)r&r'r(r)rRr+rrr#r!r)r) s:&((K!!!!!r#r)cg}|D]4}|t|tr|jn|g5tt |S)a A validator that composes multiple validators into one. When called on a value, it runs all wrapped validators. Args: validators (~collections.abc.Iterable[typing.Callable]): Arbitrary number of validators. .. versionadded:: 17.1.0 )rrJr)r+rL) validatorsrr7s r!rNrN sh D   )]33 I ! !    t % %%r#ctdD}|rfd}nfd}s-td}|j||dnt d}|r ||jd<d}t st|tr|j }t | }|r ||jd <|rt|d d S|S) a A converter that composes multiple converters into one. When called on a value, it runs all wrapped converters, returning the *last* value. Type annotations will be inferred from the wrapped converters', if they have any. converters (~collections.abc.Iterable[typing.Callable]): Arbitrary number of converters. .. versionadded:: 20.1.0 c3@K|]}t|tVdSr/rJr)rcs r!rzpipe..% s,GGq*Q 22GGGGGGr#clD]/}t|tr ||||n ||}0|Sr/r0)rr rr1 converterss r!pipe_converterzpipe..pipe_converter) sM  +5a+C+COAAc4'''3Jr#c(D] }||}|Sr/r)rr1r3s r!r4zpipe..pipe_converter3 s&  affJr#A)rr[rrrfr[Tr) rr rrOrr rrJrrr )r3return_instancer4r6tlastrs` r!rMrM sH GGJGGGGGO            : CLL&--a1.E.EFFFF !A / / D D F F  645N *5 1"~ ! 4 ; ; !=D"$ ' ' 7 7 9 9  :79N *8 4LDdKKKK r#)NrS) rTrUrVrWrXrYrZrUr[r\r/) rTrUrZrUrVrWrcrYr[rd)rsrUrtrur[r3)r[r)r[r)T)NNNNNNNFFTFFFFFNNFFNNNTNT)rr3r)rUr[rU) rr3rrrr$rr$r[r,)rr3rr)rrKr[r,)r[r,)NN)r[rzrr)rrUrrUrr$r[rU)rr$r r$rr)rrr2r$r0r$rr$rr$rr$rr$rrrr$rr$rr$rrUr[rz)rrUr[rU)l __future__rr[rarr*r7rrkr|rrrWcollections.abcrr functoolsrtypingrrr rSr r r rrrrrr exceptionsrrrrobjectrrrrrrrr`rMr>r=r<rrrintr-rRrbrrrrrrrrrrrrrrrrErrrrrrrGrrrr_rrmr rtryrrrrrrr}rrrp_arOr_casrI_frr'r)rNrr#r!rDs> #"""""   --------%%%%%%++++++++++('''''''''! ')2E2266 FHH "gl7?G4DEEty(   ( ( ( ( ( ( ( ("        kkkkb)-      $+/     F1111.$$$$$*$$$ 000"'''####B%%%8}E}E}E}E@111h"777tD D D D D D D D N8((((((X.26         3BBBBJ  ///EEEEP       """"J5*5*5*p"6#6#6#6#r    000f&&&:...$///B&B&B&B&J3333]]]])))) W W W W,/,/,/,/^EEEEPnnnnnnnnb#" I G )2&&&66"666 > =b = = =     QQQQQQQQh -0011 _ _ _ _ _ _ _ _ D$"WYYz666d C C C $'$'$'$'$'$'$'$'N! )GGIIgR888CCC2 N N N________D; I GIIir * * *"555R    yTddddVTt$$$ ! ! ! ! ! ! !%$ !&&&.99999r#