a &j@sddlmZddlZddlZddlZddlZddlZddlZddlZddl 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 +iZ,e%Z-e.ej/ej0Z1Gd ddej2Z3e3j4Z4Gddde5Z6e4ddddddddddddddfddZ7dddddddddZ8dddddddddZ9dd d!d"d#d$Z:Gd%d&d&eZ;d'd(Zd/d0Z?d&d,d1d2Z@d3d4ZAd5d6ZBd7d8ZCd9d:ZDGd;d<d<ZEd=d>ZFd?d@ZGddAdBZHddDdEZIeIZJdFdGZKd!dddHdIdJZLd!dKdLdLdMdNdOdPZMd!dKdQdRdSZNdTdUZOdVdMdWdXdYZPdZd[ZQdd\d]ZRdMd,d^d_ZSdd`daZTdbdcZUdddeZVdfdgZ0dhdiZWdjd,dkdlZXdddLddmdndoZYdddLdpddqdrdsZZdddLddtdudvZ[dddLdpddqdwdxZ\dLdLdydzd{d|Z]dKdLdLdLdLdLdLdydLdLdLddjd} d~dZ^dddddZ_GdddZ`dde`jaDZbeNeReTe`ebdddebDdddebDdZ`GdddZceReTecZcGdddZdddedjaDZeeReTedeedeedZdGdddZfddefjaDZgeNeReTefegdegdegdZfGddpdpZhdddDZgeNeReTehegdegdegdZhe%fdfddZieIdddGdddZjddZkddZ.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.ClassVarZ_attrs_cached_hashc@s(eZdZdZeZddZddZdS)_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. cCsdS)NNOTHINGselfrr0E:\soccer\ml_env\Lib\site-packages\attr/_make.py__repr__Ksz_Nothing.__repr__cCsdS)NFrrrrr__bool__Nsz_Nothing.__bool__N) __name__ __module__ __qualname____doc__enumautorrrrrrrr>s rc@s"eZdZdZeddfddZdS)_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. NrcCs||fSNr)rZ_none_constructor_argsrrr __reduce__fsz_CacheHashWrapper.__reduce__)r r!r"r#typer)rrrrr&Zs r&TcCst|| | d\} }} }|dur:|dur:|dur:d}t|| durr|turVd}t|t| sjd}t|t| }|dur~i}t| ttfrt j | } |rt|ttfrt |}|rt|ttfrt |}t |||d|||||| | || || |dS)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 convertermetadatar*kw_onlyeqeq_keyorder order_key on_setattralias) _determine_attrib_eq_order TypeErrorr ValueErrorcallableFactory isinstancelisttupler pipeand_ _CountingAttr)r,r-r.r/r0r1r3r*r2factoryr4r5r7r9r:r6r8msgrrrattribjsR:  rHstrzdict[str, Any] | NonezMapping[str, object] | NoneNone)scriptglobslocsfilenamereturncCst||d}t|||dS)z[ Evaluate the script with the given global (globs) and local (locs) variables. execN)compileeval)rLrMrNrObytecoderrr_compile_and_evals rUzdict[str, Any])rLrOrMlocalsrPc Csz|dur in|}d}|}t|d|d|f}tj||}||krFqh|ddd|d}|d7}qt|||||S)zP Cache the script with _linecache_, compile it and return the _locals_. Nr T->)len splitlines linecachecache setdefaultrU) rLrOrMrVrNcount base_filenameZlinecache_tupleZold_valrrr_linecache_and_compiles  raz list[str]r*)cls_name attr_namesrPcCsF|d}i}t|D] \}}|fdd}t|||<qt|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)) Z AttributescSs||Sr'r)rirrrgettersz&_make_attr_tuple_class..getter) enumeratepropertyr*rB)rbrcZattr_class_namebodyrd attr_namererrr_make_attr_tuple_class s  rjc@s&eZdZUded<ded<ded<dS) _Attributesr*attrslist[Attribute] base_attrsdict[str, type]Zbase_attrs_mapN)r r!r"__annotations__rrrrrk s rkcCs2t|}|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 rW)rJ startswithendswith_CLASSVAR_PREFIXES)Zannotrrr _is_class_var&s rvcCs ||jvS)zR Check whether *cls* defines *attrib_name* (and doesn't just inherit it). )__dict__)clsZ attrib_namerrr_has_own_attribute7sryz'tuple[list[Attribute], dict[str, type]]rPcCsg}i}t|jddD]H}t|dgD]6}|js*|j|vr@q*|jdd}|||||j<q*qg}t}t|D](}|j|vrqv|d|| |jqv||fS)zQ Collect attr.ibs from base classes of *cls*, except *taken_attr_names*. r rW__attrs_attrs__T inheritedr) reversed__mro__getattrr}nameevolveappendsetinsertadd)rxtaken_attr_namesrn base_attr_mapbase_clsafilteredseenrrr_collect_base_attrs>s"     rcCsng}i}|jddD]N}t|dgD]<}|j|vr6q&|jdd}||j|||||j<q&q||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 rWr{Tr|)rrrrrr)rxrrnrrrrrr_collect_base_attrs_broken_s     rc s|jt||dur$t|}n|durddD}g}t}D]H\} } t| rbqP|| | t} | j t urt | } | | | fqP||} | rt ddt| fddd d ntd d Dd dd }tjtjjfdd|D} |r2t|dd| D\}}nt|dd| D\}}tjjurtdd| D} dd|D}|| }|D]4} | jst| dt| jt| ddq|durt|||}d}dd |DD]H} |dur | jtur d| }t||dur| jturd}q|D]4} | js.t| dt| jt| ddq.dd|D}t |j!|}t"||||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`. NTcSsh|]\}}|jtur|qSr __class__rE.0rattrrrr s z#_transform_attrs..z1The following `attr.ib`s lack a type annotation: , cs |jSr')getcounter)n)cdrrz"_transform_attrs..)key.css$|]\}}|jtur||fVqdSr'rrrrr s z#_transform_attrs..cSs |djSNr )r)errrrrc s(g|] \}}||u|qSr)r)rrica)annsfcar4norr sz$_transform_attrs..cSsh|] }|jqSrrrrrrrrrcSsh|] }|jqSrrrrrrrrcSsg|]}|jddqST)r4rrrrrrrcSsg|]}|jddqSrrrrrrrrr:alias_is_defaultFcss&|]}|jdur|jdur|VqdS)FN)r1r4rrrrrrzlNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: cSsg|] }|jqSrrrrrrrr)#rwrrAitemsrrvrrrrrErHrrjoinsorted Attributefrom_counting_attr ClassProps KeywordOnlyNOrrFORCEr: _OBJ_SETATTR__get___default_init_alias_forrrBr,r=rjr rk)rxthese auto_attribsr4collect_by_mrofield_transformerZca_listZca_namesZ annot_namesrir*rZ unannotatedZ own_attrsrnrrlZ had_defaultrGrcZ AttrsClassr)rrrr4rr_transform_attrs{s         rcCsngd}|dur|dn|gd|ddgt|d}|tj|d}td|||d |id 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)rV __getattr__)rextend_generate_unique_filenamerrrar)rrrxlinesZunique_filenameglobrrr_make_cached_property_getattrs.   rcCs,t|tr$|dvr$t|||dStdS)z4 Attached to frozen classes as __setattr__. ) __cause__ __context__ __traceback____suppress_context__ __notes__N)r@ BaseException __setattr__rrrvaluerrr_frozen_setattrs/srcCs*t|tr"|dkr"t||dStdS)z4 Attached to frozen classes as __delattr__. rN)r@r __delattr__r)rrrrr_frozen_delattrs@s rc Osz |\}Wn,ty6dt|d}t|dYn0|j}t|}|D].}|jsVqJ|j}|j}||vrJt||||<qJ|fi|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 givenN) r=rZr<rfieldsr1rr:r) argschangesinstrGrxrlrriZ init_namerrrrKs %  rc@seZdZdZdZdddddddZd d Zd d d dZddZddZ ddZ ddZ ddZ ddZ ddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d-d.d/d0Zd-d-d.d1d2Zd3S)4 _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_setattrr*boolr)rxrpropshas_custom_setattrcCsDt||||j|j|j\}}}||_|jr4t|jni|_||_ dd|D|_ ||_ t dd|D|_ |j|_|j|_|j|_|jtjju|_tt|dd|_d|_|jr|j} t| } t| j dk|_tt|dd|_!t| |_"|j#|_$|j%|_&||_'d|_(|j |jd <||jd <|jrDt)|jd <t*|jd <d |_(n|j&t+t,j-t,j.fvrd} } |D]8} | j/durzd } | j0durd } | rf| rfqqf|j&t+kr| s| r|j&t,j-kr| r|j&t,j.kr| sd|_&|j1r|2\|jd<|jd<g|_3d|_4t5|jdr.t5|jds8|j6|_7n|j8|_7dS)NcSsh|] }|jqSrrrrrrrrz)_ClassBuilder.__init__..css|] }|jVqdSr'rrrrrrrz)_ClassBuilder.__init__..__attrs_pre_init__Fr __attrs_post_init__r{Z__attrs_props__rrT __getstate__ __setstate__r!r")9rr4collected_fields_by_mrorr is_slotteddictrwrrrrrBrr is_frozenrhas_weakref_slotr hashabilityr HashabilityHASHABLE_CACHEDrrrrrrinspect signaturerZ parametersrr is_exceptionron_setattr_hookrrrrr_DEFAULT_ON_SETATTRr validateconvertr-r2added_pickling_make_getstate_setstaterrhasattr_add_method_dunders_safer_add_method_dunders_unsafe)rrxrrrrrlrnZbase_mapZ pre_init_funcZpre_init_signatureZ has_validatorZ has_converterrrrr__init__s                z_ClassBuilder.__init__cCsd|jjdS)Nz<_ClassBuilder(cls=z)>)rr rrrrrsz_ClassBuilder.__repr__rKrzcCslddd|jD}i}|jD]\}}}||q t|t|jd|}|jD]\}}}||j|qPdS)z= Evaluate any registered snippets in one go. rcSsg|] }|dqS)rr)rZsnippetrrrrrz0_ClassBuilder._eval_snippets..methodsN)rrupdaterarrr)rrLrM_Z snippet_globsrNhookrrr_eval_snippets s  z_ClassBuilder._eval_snippetscCsb||jdur*|}t||j_n|}tr@t |}t |ddr^d|j vr^| |S)z Finalize class based on the accumulated configuration. Builder cannot be used after calling this method. T__attrs_init_subclass__N)r r_create_slots_classweakrefrefrZ__attrs_base_of_slotted___patch_original_classr abcZupdate_abstractmethodsrrwr)rrxrrr build_classs   z_ClassBuilder.build_classc Cs|j}|j}|jrj|jD]P}||vrt||tturttt ||Wdq1s^0Yq|j D]\}}t |||qt|j st|ddrd|_|jst|_|S)zA Apply accumulated methods and return the class. N__attrs_own_setattr__F)rrrrr _SENTINEL contextlibsuppressAttributeErrordelattrrrsetattrrrrrr)rrx base_namesrrrrrr5s&  *z#_ClassBuilder._patch_original_classc sfddjD}ttdr.tjjsjd|d<jsjjjD]j ddrJt |d<qjqJi}d}jj ddD]:j d d d urd }| fd dtd gDqtjj}jrd tjd dvrd |vr|s|d7}dd|D}g}|rtj}|D]F\}} ||f7}||=|| t| j} | tjjur(| ||<q(| d} | d ur|| t|| j|d<fdd|Dfdd|DfddD| jrtt|d <jj|d<tjjj jj|} t!"| j #|D]} t$| t%t&fr^t| j'dd }n(t$| t(rzt| j)dd }n t| dd }|sq:|D]8}z|j*ju}Wnt+yYn0|r| |_*qq:| S)zL Build and return a new class with a `__slots__` attribute. cs2i|]*\}}|gtjddRvr||qS)rw __weakref__)rBrrkvrrr ]sz5_ClassBuilder._create_slots_class.._clear_type_descriptorsFrrr rWrNTcsi|]}|t|qSrrrr)rrrr!s __slots__r)rcSs"i|]\}}t|tr||jqSr)r@rfunc)rrZ cached_proprrrr!s rcsg|]}|vr|qSrrr$)rrrrrz5_ClassBuilder._create_slots_class..csi|]\}}|vr||qSrr)rZslotZslot_descriptor) slot_namesrrr!scsg|]}|vr|qSrrr$) reused_slotsrrrrr" __closure__),rrrsysr"rrr __bases__rwrrrr rrrrrrrrrreturn_annotation Parameteremptyrr_HASH_CACHE_FIELDrBr"r*r itertoolschainvaluesr@ classmethod staticmethod__func__rgfget cell_contentsr=)rrZexisting_slotsZweakref_inheritednamesrZ&additional_closure_functions_to_updateZclass_annotationsrr& annotationrrxitemZ closure_cellscellmatchr)rrr(rr'rrYs                       z!_ClassBuilder._create_slots_classcs8tj|\}}fdd}j|||fd_S)Ncs|d|d<dS)Nrrcls_dictrMrrr _attach_reprsz,_ClassBuilder.add_repr.._attach_reprT)_make_repr_scriptrrrr)rnsrLrMr@rrradd_reprs  z_ClassBuilder.add_reprcCs.|jsd}t|dd}|||jd<|S)Nz3__str__ can only be generated if a __repr__ exists.cSs|Sr'rrrrr__str__sz&_ClassBuilder.add_str..__str__rE)rr=rr)rrGrErrradd_strs z_ClassBuilder.add_strcs<tdd|jDfdd}|jfdd}||fS)zF Create custom __setstate__ and __getstate__ methods. css|]}|dkr|VqdS)rNr)rZanrrrrsz8_ClassBuilder._make_getstate_setstate..csfddDS)9 Automatically created by attrs. csi|]}|t|qSrr#r$rrrr! rzQ_ClassBuilder._make_getstate_setstate..slots_getstate..rr)state_attr_namesrrslots_getstatesz=_ClassBuilder._make_getstate_setstate..slots_getstatecsft|}t|tr4t|D]\}}|||qn D]}||vr8||||q8rb|tddS)rGN)rrr@rBzipr/)rstateZ_ClassBuilder__bound_setattrrrZhash_caching_enabledrHrrslots_setstates  z=_ClassBuilder._make_getstate_setstate..slots_setstate)rBrr)rrIrMrrLrrs z%_ClassBuilder._make_getstate_setstatecCsd|jd<|SN__hash__)rrrrrmake_unhashable&s z_ClassBuilder.make_unhashablecsHtjjjjd\}}ddddfdd }j|||fS)Nfrozen cache_hashrrK)r?rNrPcs|d|d<dSrNr=)r?rNrrr attach_hash2sz+_ClassBuilder.add_hash..attach_hash)_make_hash_scriptrrrrrr)rrLrMrTrrradd_hash*s z_ClassBuilder.add_hashcs`tjjjjjjjjj j j dd \}}fdd}j |||fS)NF attrs_initcs |d}|_||d<dS)Nrrprr?rMr1rrrr _attach_initIsz,_ClassBuilder.add_init.._attach_init_make_init_scriptrrrrrrrrrrrrr)rrLrMr\rr[radd_init9s" z_ClassBuilder.add_initcCs|t|jd<|S)N __replace__)rrrrrrr add_replaceRsz_ClassBuilder.add_replacecCstdd|jD|jd<dS)Ncss |]}|jr|js|jVqdSr')r1r4r)rfieldrrrrWs z/_ClassBuilder.add_match_args..__match_args__)rBrrrrrradd_match_argsVsz_ClassBuilder.add_match_argscs`tjjjjjjjjj j j dd \}}fdd}j |||fS)NTrWcs |d}|_||d<dS)N__attrs_init__rYrZr[rr_attach_attrs_initmsz8_ClassBuilder.add_attrs_init.._attach_attrs_initr])rrLrMrfrr[radd_attrs_init]s" z_ClassBuilder.add_attrs_initcs>j}tj\}}fdd}j|||ft|d<S)Ncs|d|d<dS)N__eq__r=r>rrr _attach_eq{sz(_ClassBuilder.add_eq.._attach_eq__ne__)r_make_eq_scriptrrrrj)rrrLrMrirrradd_eqvs  z_ClassBuilder.add_eqcs>j}fddtjjD\|d<|d<|d<|d<S)Nc3s|]}|VqdSr'r=)rmethrrrrsz*_ClassBuilder.add_order..__lt____le____gt____ge__)r _make_orderrr)rrrrr add_orders   z_ClassBuilder.add_ordercsi|jD],}|jp|j}|r |tjur ||f|j<q s@|S|jrRd}t|fdd}d|jd<| ||jd<d|_ |S)Nz7Can't combine custom __setattr__ with on_setattr hooks.csDz|\}}Wnty&|}Yn0||||}t|||dSr')KeyErrorr)rrvalrr ZnvalZsa_attrsrrrs    z._ClassBuilder.add_setattr..__setattr__Trr) rr9rr NO_OPrrr=rrr)rrr9rGrrrvr add_setattrs   z_ClassBuilder.add_setattrr)methodrPcCs6|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#rryrrrrs  z(_ClassBuilder._add_method_dunders_unsafecCstt|jj|_Wdn1s*0Ytt&|jjd|j|_Wdn1sj0Ytt"d|jjd|_Wdn1s0Y|S)zL Add __module__ and __qualname__ to a *method* if possible. Nrrz)rrrrr!r"r r#r{rrrrs ( 4 0z&_ClassBuilder._add_method_dunders_safeN)r r!r"r#r%rrr rrrrCrFrrPrVr_rardrgrlrsrxrrrrrrrs.e$  )  rcCst|dur(t|du|dufr(d}t||dur8||fS|durD|}|durP|}|durl|durld}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.anyr=)r/r5r7 default_eqrGrrr_determine_attrs_eq_ordersrc Cs|dur(t|du|dufr(d}t|dd}|durP||\}}||||fS|durd|d}}n ||\}}|dur||}}n ||\}}|dur|durd}t|||||fS)r|Nr}cSs t|rd|}}nd}||fS)z8 Decide whether a key function is used. TN)r>)rrrrrdecide_callable_or_booleans z>_determine_attrib_eq_order..decide_callable_or_booleanFTr~r) r/r5r7rrGrZcmp_keyr6r8rrrr;s"       r;cCsF|dus|dur|S|dur(|dur(|S|D]}t||r,dSq,|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. TFN)ry)rxflag auto_detectZdundersr,dunderrrr_determine_whether_to_implements  rFcsdur"ddl}|jtdddt|||d\|dur@| tttfrXtj fdd}|dur|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 sp t|}duot|t}o*t|d}|r@|r@d}t|| oRt|d}tj}|rf|j}n durrx|j n|j }nx dur|j}nh durdurt|dr|j}q|dur|durԈr|j n|j }q|dur|j}q|j }n d}t |tj } rr|jn|j} n|j} t||t| dt|d || oVt|d | | t| d d d } | jsrd}t |t|| |d} | jr| | jr| | jr| | jr| s| | jr| n| j|j ur| | jr0| n| !rJd}t |t"rdt|dsd| #t$r rt|ds| %| &S)NTrz/Can't freeze a class with a custom __setattr__.)rhrjFrOr+rrD)rnrorprq)rr)r,)rrrr added_init added_repradded_eqadded_orderingradded_match_argsr4r added_strrrrzlInvalid value for cache_hash. To use hash caching, hashing must be either explicitly or implicitly enabled.)rrrzFInvalid value for cache_hash. To use hash caching, init must be True.r`rc)'_has_frozen_base_class issubclassrryr=rrr LEAVE_ALONErHASHABLE UNHASHABLEr<rrYESr is_hashablerrrCrrFrrlrrsrxrVrrPrr_rgrrar rdr) rxris_excZhas_own_setattrrGr5rrrZkworbuilderrrauto_excrSrZeq_r force_kw_onlyrRgetstate_setstater0r1r4 match_argsr9Zorder_r.repr_nsslotsrJr weakref_slotrrwraps #   zattrs..wrap) warningswarnDeprecationWarningrr@rArBr rC)Z maybe_clsrrr.r/r0r1rrRrrJrr4rSrr5r7rrrr9rr unsafe_hashrrrrrrrl-s$a 6 rlcCs |jtuS)zV Check whether *cls* has a frozen ancestor by looking at its __setattr__. )rr)rxrrrr9sr)rx func_namerPc Cs$d|d|jdt|d|jdS)zF Create a "filename" suitable for a function being generated. z. r0zdef __hash__(selfzhash((z))z):z, *zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper()c s|||ddgD]Z}|jrhd|jd}|j|<|d|d|jdq&|d|jdq&|dd 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,r _key(self.z), self. N)rr6rr)prefixindentrcmp_namerlZclosing_bracesrMZ hash_funcZ method_linesZ type_hashrrappend_hash_computation_linesfs  z8_make_hash_script..append_hash_computation_lineszif self.z is None:zobject.__setattr__(self, '', rself. = z return self.zreturn r)rBr0rrr/r)rxrlrRrStabZhash_defrrLrrrrUKs>   rU)rxrlcCs6t||ddd\}}t||t|dd|d|_|S)z% Add a hash method to *cls*. FrQrOrO)rUrUrrOrxrlrLrMrrr _add_hashs   rcCs||}|turtS| S)z^ Check equality and either forward a NotImplemented or return the result negated. )rhNotImplemented)rotherresultrrrrjs rjrA)rlrPc Csdd|D}gd}i}|r|d|D]}|jrxd|jd}|j||<|d|d|jd |d |jd n|d |jd |j||dur,|dd|d<q,|dn |dd|}||fS)z6 Create __eq__ method for *cls* with *attrs*. cSsg|]}|jr|qSr)r5rrrrrrz#_make_eq_script..)zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (r rrrz) == z(other.rrz == other.rWz andz )z return Truer)rr6rr)rlrrMrrrLrrrrks&       rkcsVddDfddfdd}fdd}fd d }fd d }||||fS) z9 Create ordering methods for *cls* with *attrs*. cSsg|]}|jr|qSr)r7rrrrrrz_make_order..cs tddfddDDS)z& Save us some typing. css"|]\}}|r||n|VqdSr'r)rrrrrrrsz6_make_order..attrs_to_tuple..c3s |]}t|j|jfVqdSr')rrr8robjrrrs)rBrrlrrattrs_to_tuples  z#_make_order..attrs_to_tuplecs |j|jur||kStSz1 Automatically created by attrs. rrrrrrrrns z_make_order..__lt__cs |j|jur||kStSrrrrrrros z_make_order..__le__cs |j|jur||kStSrrrrrrrps z_make_order..__gt__cs |j|jur||kStSrrrrrrrqs z_make_order..__ge__r)rxrlrnrorprqr)rlrrrrs rrcCsB|dur|j}t|\}}t||t|dd|d|_t|_|S)z5 Add equality methods to *cls* with *attrs*. Nrhr)r{rkrUrrhrjrrrr_add_eq s   rc Cstdd|D}dd|D}t|d<t|d<t|d<g}|D]N\}}}|rVd|n d |d }|tkrvd ||fn d |||f} || q@d |} |durd} n|d} ddddddddddddd| d| ddd g} d!| |fS)"zC Create the source and globs for a __repr__ and return it. css6|].}|jdur|j|jdur"tn|j|jfVqdS)FTN)r.rr1rrrrr"s z$_make_repr_script..cSs$i|]\}}}|tkr|d|qS)_repr)r.)rrrr rrrr!'sz%_make_repr_script..r rrrzgetattr(self, "z ", NOTHING)z %s={%s!r}z%s={%s_repr(%s)}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)rBr rrr.rr) rlrBZattr_names_with_reprsrMZattribute_fragmentsrrrdaccessorfragmentZ repr_fragmentZcls_name_fragmentrrrrrAsN   rAcCs>|dur|j}t||\}}t||t|dd|d|_|S)z% Add a repr method to *cls*. Nrr)r{rArUrr)rxrBrlrLrMrrr _add_reprTs  rcCst|}|durFt|tsFt|}t|dddur>d}t|t|St|dd}|dur|durt|dd}|dur||_|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. Nr{z0Passed object must be a class or attrs instance.! is not an attrs-decorated class.)rr@r*rr<rr{r)rxZ generic_basetype_rGrlrrrrcs"   rcCsJt|tsd}t|t|dd}|dur<|d}t|dd|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.r{NrcSsi|] }|j|qSrrrrrrr!rzfields_dict..)r@r*r<rr)rxrGrlrrr fields_dicts   rcCsDtjdurdSt|jD]&}|j}|dur|||t||jqdS)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 Z_run_validatorsrrr-rr)rrr rrrrs rcCs||}|od|jvS)z> Check if the attribute name comes from a slot class. r%)rrw)a_namerrxrrr _is_slot_attrs rztuple[str, dict, dict]c  Cs | duo| tju} |r&| r&d} t| |p,|}g}i}|D]n}|jsP|jturPq:|||||j<|jdur|dur|jtjurd} t| d}q:| r:|jtjur:d}q:t ||||||||| || | rdnd \}}}|j t j vr| t j |j j| t|d|rtj|d<|||fS)Nz$Frozen classes can't use on_setattr.Trer)r attr_dictr)r rwr=r1r,rrrr9_attrs_to_init_scriptr!r*modulesr rwrr)rxrlpre_initpre_init_has_args post_initrRrrSrrZcls_on_setattrrXhas_cls_on_setattrrGneeds_cached_setattrZfiltered_attrsrrrLrMrrrrr^sP      r^ri value_varhas_on_setattrrPcCsd|d|dS)zJ Use the cached object.setattr to set *attr_name* to *value_var*. _setattr('rrrrirrrrr_setattrsr Converterrirrr2rPcCsd|d|||dS)zk Use the cached object.setattr to set *attr_name* to *value_var*, but run its converter first. rrr)_fmt_converter_callrirrr2rrr_setattr_with_convertersr)rirrrPcCs |rt||dSd|d|S)zo Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. Trr)r)rirrrrr_assign#s rcCs*|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. Trr)rrrrrr_assign_with_converter.srro)rRrrcs`|durV|durdttfSdddddfdd }dddddd fd d }d ||fSdttfS) zg Determine the correct setter functions based on whether a class is frozen and/or slotted. TrrJrrcs&t|rt|||Sd|d|SN _inst_dict['z'] = )rrrrrr fmt_setterKs  z&_determine_setters..fmt_setterrrcs4|st|rt||||Sd|d|||Sr)rrrrrrrfmt_setter_with_converterSs z5_determine_setters..fmt_setter_with_converter)z_inst_dict = self.__dict__)rrrr)rRrrrrrrr_determine_setters;s r) rlrr call_pre_initrcall_post_initdoes_cache_hashrrrr method_namerPc $ Cs|r dgng} | r| dt|||\} }}| | g}g}g}g}i}ddi}|D]}|jrn|||j}|jdup|jtjuo| }|j}t |j t }|r|j j rdnd}|j durt |j tst|j }n|j }|jdur|rdt|jf}|dur8| |||d|d |||j |||j<n| |||d|d ||j j||<nT|dur| ||d |d |||j |||j<n| ||d |d |n|j turN|sN|d |d }|jr||n|||||dur8| ||||||j |||j<n| ||||nv|rX|d }|jrr||n||||| d|dt|jf}|dur| d|||||| d| d|||d|d |||j |||j<nB| d||||| d| d|||d|d ||j j||<nl|jrl||n|||||dur| ||||||j |||j<n| |||||jdurX|jdur|dur|j||<qX|durX|jrX|j||<qX|rtt|d<| d|D]L}d|j}d|j}| d|d|d|jd |j||<|||<q&|r| d|r|r|rdtd} n dtd} n dtd} | | |rd d!d"|D}!| d#|!d d$|}d$|}|rh||rd$ndd%d$|7}d$d&d'd(d"|DD}"||rZd$nd7}||"7}|r|rd)|d | d*<d+}#d,| d|d-| r|#| nd.d/||fS)0z 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)rPNrrIFrrz attr_dict['z '].defaultz =attr_dict['z=NOTHINGzif z is not NOTHING:rzelse:Tr z#if _config._run_validators is True:Z__attr_validator_Z__attr_z(self, z, self.zself.__attrs_post_init__()rz', None)rz '] = Nonerz = Nonercss |]}|jrd|jVqdS)rN)r1rrrrrrP rz(_attrs_to_init_script..zBaseException.__init__(self, rz*, cSsg|]}|d|qS)=r)rZ kw_arg_namerrrrZ sz)_attrs_to_init_script..css|]}|ddVqdS)rrN)split)rZkwarrrr] rzself.__attrs_pre_init__(rz zdef z): passr)rrrr-rr9r rwr:r@r,r? takes_selfr2rr1_INIT_FACTORY_PAT_get_global_namerFrr4r*_first_param_typer r/r)$rlrrrrrrrrrrrr extra_linesrrrZ pre_init_argsZ kw_only_argsZattrs_to_validateZnames_for_globalsrrrirZarg_nameZ has_factoryZ maybe_selfr2Zinit_factory_nameargZval_nameZinit_hash_cachevalsZpre_init_kw_only_argsNLrrrrjsr                                              "  r)rrPcCs |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. r )lstriprrrrrr src @s^eZdZdZdZdddZddZedd d d d d dZddZ ddZ ddZ ddZ 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`. )rr,r-r.r5r6r7r8r0r1r3r*r2r4r}r9r:rNFcCst||p | |p|d\} }}}t|}|d||d||d||d||d| |d||d||d ||d ||d ||d | |d | rtt| nt|d| |d| |d||d||d||d|dur|dun|dS)NTrr,r-r.r5r6r7r8r0r1r2r3r*r4r}r9r:r)r;rrtypesMappingProxyTyper_EMPTY_METADATA_SINGLETON)rrr,r-r.r/r0r1r}r3r*r2r4r5r6r7r8r9r:r bound_setattrrrrr s<                  zAttribute.__init__cCstdSr')rrrrrr szAttribute.__setattr__rJrEr)rrr4cCs|dur|j}n|jdur.d|d}t||||j|j|jd|j|jd|j||j|j durb|n|j |j |j |j |j |j|j|jduS)Nz>Type annotation and type argument cannot both be present for 'z'.F)r*r=_default _validatorr.r0r1r3r2r4r5r6r7r8r9r:)rxrrr4r*rGrrrr s4  zAttribute.from_counting_attrcKsjt|}||d|vr:d|vr:t|ddn,d|vrfd|vrf|jrft|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 r:rFr)copy _setattrsrrrrrr)rrnewrrrr$ s  zAttribute.evolvecstfddjDS)( Play nice with pickle. c3s*|]"}|dkrt|ntjVqdS)r3N)rrr3r$rrrrH sz)Attribute.__getstate__..rBr%rrrrrD s zAttribute.__getstate__cCsjt|t|jkrTtt|j|}|ddupD|dt|dk}g||R}|t|j|dS)rr:Nr)rZr%rrJrrr)rrKZ state_dictrrrrrM s zAttribute.__setstate__cCsLt|}|D]8\}}|dkr*|||q|||r@tt|ntqdS)Nr3)rrrrrr)rZname_values_pairsrrrrrrr^ s   zAttribute._setattrs) NNNFNNNNNNN)N) r r!r"r#r%rrr3rrrrrrrrrr} s,/ <"  rcCs6g|].}t|td|dkddd|dkddt|d qS)NrTFr3 rr,r-r.r/r5r7r0r1r}r:rrrr$rrrrn srrcCsg|]}|jdkr|qSr|rrrrrr rcCs g|]}|jr|jdkr|qSr|)r0rrrrrr rc@sneZdZdZdZgedddDeddddddd dd ddd dd dd RZd Zd d Z ddZ ddZ dS)rEa Intermediate representation of attributes that uses a counter to preserve the order in which the attributes have been defined. *Internal* data structure of the attrs library. Running into is most likely the result of a bug like a forgotten `@attr.s` decorator. )rrr:r2rr5r6r0r1r4r3r9r7r8r.r*ccs8|]0}t|t|tdddddddddddddVqdS)NTFrr:r,r-r.r/r0r1r4r5r6r7r8r}r9)rrrr$rrrr s$z_CountingAttr.) rrr.r5r7r0r1r9r:r3NTFr rcCsttjd7_tj|_||_||_||_||_| |_| |_| |_ ||_ ||_ ||_ ||_ | |_| |_||_||_dSr)rE cls_counterrrrr2r.r5r6r7r8r0r1r3r*r4r9r:)rr,r-r.r/r0r1r2r3r*r4r5r6r7r8r9r:rrrr s"z_CountingAttr.__init__cCs$|jdur||_nt|j||_|S)z Decorator that adds *meth* to the list of validators. Returns *meth* unchanged. .. versionadded:: 17.1.0 N)rrDrrmrrrr- s z_CountingAttr.validatorcCs |jturtt|dd|_|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)rrrr?r rrrr, s z_CountingAttr.default) r r!r"r#r%rBrr{r rr-r,rrrrrE s:1%rEc@sLeZdZdZGdddejZGdddejZdZddZ e d d Z 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@s eZdZdZdZdZdZdZdS)zClassProps.HashabilityzO The hashability of a class. .. versionadded:: 25.4.0 ZhashableZhashable_cacheZ unhashableZ leave_aloneN)r r!r"r#rrrrrrrrrd s rc@seZdZdZdZdZdZdS)zClassProps.KeywordOnlyzw How attributes should be treated regarding keyword-only parameters. .. versionadded:: 25.4.0 ryesforceN)r r!r"r#rrrrrrrrt s rrrrrr4rrrrrrrrrrrcCsd||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ | |_ ||_ ||_||_dSr'r)rrrrrr4rrrrrrrrrrrrrrr s zClassProps.__init__cCs|jtjjup|jtjjuSr')rrrrrrrrrr s zClassProps.is_hashableN) r r!r"r#r$Enumrrr%rrgrrrrrr sD$rcCs.g|]&}t|tddddddddt|d qS)NTFr r r$rrrr sc@s.eZdZdZdZd ddZddZdd Zd S) r?a 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* rFrFcCs||_||_dSr'r)rrFrrrrr szFactory.__init__cstfddjDS)rc3s|]}t|VqdSr'r#r$rrrr rz'Factory.__getstate__..rrrrrr szFactory.__getstate__cCs&t|j|D]\}}t|||q dS)rN)rJr%r)rrKrrrrrr szFactory.__setstate__N)F)r r!r"r#r%rrrrrrrr? s  r?cCs(g|] }t|tddddddddd qSNTF) rr,r-r.r/r5r7r0r1r}rrr$rrrr s c@sZeZdZdZdZdddddZedddd d Zdddd d d ZddZ ddZ 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__rZ _global_namer2 takes_fieldrFrrcs|_|_|_t|}|_js@js@fdd_n@jr\js\fdd_n$jsxjrxfdd_nj_|}|dur|jjd<dS)Ncs |Sr'r2)rr __rrrr6 rz$Converter.__init__..cs ||Sr'r)rinstancerrrrr8 scs ||Sr'r)rrrbrrrr< srP) r2rrrget_first_param_typerrget_return_typerp)rr2rrexrtrrrr- s    zConverter.__init__rJ)rirPcCs d|S)zh Return the name that a converter for an attribute name *attr_name* would have. Z__attr_converter_r)rirrrrF szConverter._get_global_name)rirrPcCs|js"|js"||d|dS|jrJ|jrJ||d|d|dS|jrf||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`. rrz, self, attr_dict['z'])z, self)z , attr_dict[')rrr)rrirrrrrN s  zConverter._fmt_converter_callcCs|j|j|jdS)zx Return a dict containing only converter and takes_self -- the rest gets computed when loading. r2rrrrrrrr_ szConverter.__getstate__cCs|jfi|dS)z+ Load instance from state. Nr)rrKrrrrj szConverter.__setstate__N) r r!r"r#r%rr4rrrrrrrrr s  cCs(g|] }t|tddddddddd qSrrr$rrrrq s rc  sltd|}t|tr|}n*t|ttfr:dd|D}n d}t||dd}|dd}|dd} i|dur||dur|d<|dur|d<| dur| d<t ||ifd d } t t t&td jd d | _Wdn1s0Y|dd} t| |d|dd\|d<|d<tfd|i|| } dd|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. NFKCcSsi|] }|tqSr)rHrrrrr! rzmake_class..z(attrs argument must be a dict or a list.rNrrcs |Sr')r )rBrhrrr rzmake_class..r r __main__r/r5r7TrcSs"i|]\}}|jdur||jqSr')r*rrrrr! s) unicodedata normalizer@rrArBr<popr r new_classrrrr=r* _getframe f_globalsrr!rrrrp) rrlbasesZ class_bodyZattributes_argumentsr?rGrrZ user_initrr/rxrr!r make_class sN0       & r*)rrc@seZdZdZeZddZdS) _AndValidatorz2 Compose many validators to a single one. cCs|jD]}||||qdSr') _validators)rrrrr rrrr s z_AndValidator.__call__N)r r!r"r#rHr,rrrrrr+ sr+cGs6g}|D] }|t|tr |jn|gqtt|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 )rr@r+r,rB)Z validatorsrr-rrrrD s rDcstddD}|r$fdd}n fdd}sPtd}|j||dnTtd}|rn||jd <d }tst|tr|j }t| }|r||jd <|rt|d 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 css|]}t|tVqdSr'r@r)rcrrrr% rzpipe..cs,D]"}t|tr||||n||}q|Sr'r-)rurrbr. convertersrrpipe_converter) szpipe..pipe_convertercsD] }||}q|Sr'r)rur.r/rrr13 s A)rurPrrurWrPTr) rrrpr rrrr@rrr)r0Zreturn_instancer1r2tlastrrr/rrC s&    rC)NrI)N)T)NNNNNNNFFTFFFFFNNFFNNNTNT)N)NN)l __future__rrrrr$rr0r\r*rr#rcollections.abcrr functoolsrtypingrrrrIr r r r rrrrr exceptionsrrrrobjectrrrrur/rrrrCrrrrrrintr&rHrUrarjrkrvryrrrrrrrrrr;rrlrrrrUrrjrkrrrrArrrrr^rrrrrrrrr%Z_arErZ_casr?_frr*r+rDrrrrsB       q#!4 :K,   H %8 9 3E   /&  r     #' b  k