o 诪go@sddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZmZmZddlmZmZmZmZmZmZddlmZmZmZmZejZ dZ!d Z"d Z#e $iZ%eZ&e'ej(ej)Z*Gd d d ej+Z,e,j-Z- Gd dde.Z/e-ddddddddddddddfddZ0dddZ1dddZ2ddZ3e3dgdZ4ddZ5ddZ6d d!Z7d"d#Z8d$d%Z9d&d'Z:d(d)Z;d*d+Zd0d1Z?d2d3Z@ dd4d5ZA                        dd6d7ZBeBZC d8d9ZDd:d;ZEdd?ZGd@dAZHdBdCZIdDdEZJddFdGZKdHdIZLddJdKZMdLdMZNdNdOZOdPdQZ)dRdSZPdTdUZQdd\d]ZRdd`daZSddcddZTddedfZUddkdlZVddydzZWdd|d}ZXGd~ddZYddeYjZDZ[eGeKeMeYe[ddde[Dddde[DdZYGdddZ\eKeMe\Z\GdddZ]dde]jZDZ^eGeKeMe]e^de^de^dZ]Gdd_d_Z_dddDZ^eGeKeMe_e^de^de^dZ_efdfddZ`eBdddGdddZaddZbddZ'dS)) annotationsN) itemgetter)_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@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. cCdS)NNOTHINGselfrrF/var/www/html/chatdoc2/venv/lib/python3.10/site-packages/attr/_make.py__repr__Iz_Nothing.__repr__cCr)NFrrrrr__bool__Lrz_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)r_none_constructor_argsrrr __reduce__dz_CacheHashWrapper.__reduce__)rrr r!typer(rrrrr$Xs r$TFcCs4t|| | d\} }} }|dur|dur|durd}t|| dur9|tur+d}t|t| s5d}t|t| }|dur?i}t| ttfrKt j | } |rXt|ttfrXt |}|ret|ttfret |}t did|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* 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_setattraliasr) _determine_attrib_eq_order TypeErrorr ValueErrorcallableFactory isinstancelisttuplerpipeand_ _CountingAttr)r,r-r.r/r0r1r3r*r2factoryr4r5r7r9r:r6r8msgrrrattribhsp7       rHcCst||d}t|||dS)z[ Evaluate the script with the given global (globs) and local (locs) variables. execN)compileeval)scriptglobslocsfilenamebytecoderrr_compile_and_evals rRc Cs|durin|}d}|} t|d|d|f}tj||} | |kr$n|ddd|d}|d7}q t||||||S)zO Create the method with the script given and return the method object. NrT->)len splitlines linecachecache setdefaultrR) namerMrPrNlocalsrOcount base_filenamelinecache_tupleold_valrrr _make_methods"racCsv|d}d|ddg}|r%t|D]\}}|d|d|dqn|dttd }td ||||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)) Attributeszclass z(tuple):z __slots__ = () z% = _attrs_property(_attrs_itemgetter())z pass)_attrs_itemgetter_attrs_property ) enumerateappendrpropertyrRjoin)cls_name attr_namesattr_class_nameattr_class_templatei attr_namerNrrr_make_attr_tuple_classs   rr _Attributes)attrs base_attrsbase_attrs_mapcCs2t|}|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. )'"rrS)str startswithendswith_CLASSVAR_PREFIXES)annotrrr _is_class_var#s  r~cCs ||jvS)zR Check whether *cls* defines *attrib_name* (and doesn't just inherit it). )__dict__)cls attrib_namerrr_has_own_attribute4s rcCsg}i}t|jddD]$}t|dgD]}|js|j|vr q|jdd}|||||j<qq g}t}t|D]}|j|vrCq;|d|| |jq;||fS)zQ Collect attr.ibs from base classes of *cls*, except *taken_attr_names*. rrS__attrs_attrs__T inheritedr) reversed__mro__getattrrr[evolverisetinsertadd)rtaken_attr_namesru base_attr_mapbase_clsafilteredseenrrr_collect_base_attrs;s$       rcCsng}i}|jddD]'}t|dgD]}|j|vrq|jdd}||j|||||j<qq ||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. rrSrTr)rrr[rrri)rrrurrrrrr_collect_base_attrs_brokenZs       rc s|jt||durt|}np|dursddD}g}t}D],\} } t| r1q(|| | t} t | t sM| turHt nt | d} | | | fq(||} t | dkrrtddt| fd d d d ntd dDdd d }fdd|D} |rt|dd| D\}}n t|dd| D\}}|rdd| D} dd|D}|| }d}dd|DD]} |dur| jturd| }t||dur| jturd}q|dur|||}dd|D}dd|D}t|j|}t||||fS)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|] \}}t|tr|qSrr@rE.0r[attrrrr s z#_transform_attrs..r,rz1The following `attr.ib`s lack a type annotation: , cs |jSr%)getcounter)n)cdrrs z"_transform_attrs..)key.css&|]\}}t|tr||fVqdSr%rrrrr s z#_transform_attrs..cSs |djSNr)r)errrr cs&g|]\}}tj|||dqS))r[car*) Attributefrom_counting_attrr)rrqr)annsrr s  z$_transform_attrs..cSh|]}|jqSrr[rrrrrrcSrrrrrrrrrcSg|]}|jddqST)r4rrrrrrcSrrrrrrrrrFcss(|]}|jdur|jdur|VqdS)FN)r1r4rrrrrs&zlNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: cSs(g|]}|js|jt|jdn|qS))r:)r:r_default_init_alias_forr[rrrrrscSsg|]}|jqSrrrrrrrr)rr rAitemsrr~rrrr@rErHrirVrrksortedrrr,r=rrrrs)rthese auto_attribsr4collect_by_mrofield_transformerca_listca_names annot_namesrqr*r unannotated own_attrsrurrt had_defaultrGrm AttrsClassr)rrr_transform_attrsvs           rcCslgd}|dur|dn|gd|ddgt|d}|tj|d}tdd |||d |id 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 __getattr__rg_cls)r\)riextend_generate_unique_filename _OBJ_SETATTR__get__rark)rrrlinesunique_filenameglobrrr_make_cached_property_getattrs4   rcCs(t|tr|dvrt|||dSt)z4 Attached to frozen classes as __setattr__. ) __cause__ __context__ __traceback____suppress_context__ __notes__N)r@ BaseException __setattr__rrr[valuerrr_frozen_setattrssrcCs&t|tr|dvrt||dSt)z4 Attached to frozen classes as __delattr__. )rN)r@r __delattr__r)rr[rrr_frozen_delattrs.s rc Osz|\}Wntydt|d}t|dw|j}t|}|D]}|js)q#|j}|j}||vr:t||||<q#|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) r=rVr< __class__fieldsr1r[r:r) argschangesinstrGrrtrrq init_namerrrr9s$%   rc@seZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'S)( _ClassBuilderz( Iteratively build *one* class. ) _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_slots _weakref_slot_wrote_own_setattrcCst||||| |\}}}||_|rt|jni|_||_dd|D|_||_tdd|D|_ ||_ ||_ ||_ | |_ tt|dd|_d|_|jr\|j}t|}t|jdk|_tt|dd|_t| |_| |_| |_| |_d|_|j|jd <|rt|jd <t|jd <d |_n?| tt j!t j"fvrd}}|D]}|j#durd }|j$durd }|r|rnq| tkr|s|r| t j!kr|r| t j"kr|sd|_|r|%\|jd <|jd<dSdS)NcSrrrrrrrrrz)_ClassBuilder.__init__..css|]}|jVqdSr%rrrrrrsz)_ClassBuilder.__init__..__attrs_pre_init__Fr__attrs_post_init__rrrT __getstate__ __setstate__)&rrdictrrrrrrBrrrrrboolrrrrinspect signaturerV parametersrrrrrrrr_DEFAULT_ON_SETATTRrvalidateconvertr-r2_make_getstate_setstate)rrrslotsfrozen weakref_slotgetstate_setstaterr4 cache_hashis_excrr9has_custom_setattrrrtrubase_map pre_init_funcpre_init_signature has_validator has_converterrrrr__init__s~          z_ClassBuilder.__init__cCsd|jjdS)Nz<_ClassBuilder(cls=z)>)rrrrrrrsz_ClassBuilder.__repr__cCsL|jdur |}n |}trt|}t|ddr$d|jvr$||S)z Finalize class based on the accumulated configuration. Builder cannot be used after calling this method. T__attrs_init_subclass__N) r_create_slots_class_patch_original_classrabcupdate_abstractmethodsrrr)rrrrr build_classs     z_ClassBuilder.build_classc Cs|j}|j}|jr5|jD](}||vr4t||ttur4tt t ||Wdn1s/wYq |j D] \}}t |||q:|j sWt|ddrWd|_|jsWt|_|S)zA Apply accumulated methods and return the class. N__attrs_own_setattr__F)rrrrr _SENTINEL contextlibsuppressAttributeErrordelattrrrsetattrrrrrr)rr base_namesr[rrrrrs&   z#_ClassBuilder._patch_original_classc sfddjD}js*d|d<js*jjD]jddr)t|d<nqi}d}jj ddD]jdd d urCd }| fd dt d gDq6t j j}jrrdt jd d vrrd|vrr|sr|d7}dd|D}g}|rtj}|D]!\}} ||f7}||=|| t| j} | tjjur| ||<q|d} | d ur|| t|| j|d<fdd|Dfdd|DfddD| jrtt|d <jj|d<tjjjjj|} t| j |D]L} t!| t"t#frt | j$dd }nt!| t%r-t | j&dd }nt | dd }|s8q |D]}z|j'ju}Wn t(yOYq:w|rV| |_'q:q | S)zL Build and return a new class with a `__slots__` attribute. cs2i|]\}}|gtjddRvr||qS)r __weakref__)rBrrkvrrr +s z5_ClassBuilder._create_slots_class..FrrrrSrNTci|]}|t|qSrrrr[)rrrr Js  __slots__r)rcSs$i|]\}}t|tjr||jqSr)r@ functoolscached_propertyfunc)rr[r&rrrr [s  rcg|]}|vr|qSrrr#)rrrrzrz5_ClassBuilder._create_slots_class..csi|] \}}|vr||qSrr)rslotslot_descriptor) slot_namesrrr s cr(rrr#) reused_slotsrrrrr __closure__))rrrrr __bases__rrrrupdaterrrrrr rirrreturn_annotation Parameteremptyrr_HASH_CACHE_FIELDrBr r*r itertoolschainvaluesr@ classmethod staticmethod__func__rjfget cell_contentsr=)rrexisting_slotsweakref_inheritednamesr&additional_closure_functions_to_updateclass_annotationsr[r' annotationrritem closure_cellscellmatchr)rrr,rr+rr's                     z!_ClassBuilder._create_slots_classcCs |t|j||j|jd<|S)Nr)_add_method_dunders _make_reprrrr)rnsrrradd_reprs z_ClassBuilder.add_reprcCs<|jd}|durd}t|dd}|||jd<|S)Nrz3__str__ can only be generated if a __repr__ exists.cSs|Sr%rrrrr__str__r)z&_ClassBuilder.add_str..__str__rK)rrr=rF)rr.rGrKrrradd_strs z_ClassBuilder.add_strcs<tdd|jDfdd}|jfdd}||fS)zF Create custom __setstate__ and __getstate__ methods. css|] }|dkr|VqdS)rNr)ranrrrrsz8_ClassBuilder._make_getstate_setstate..csfddDS)9 Automatically created by attrs. cr!rr"r#rrrr rzQ_ClassBuilder._make_getstate_setstate..slots_getstate..rr)state_attr_namesrrslots_getstatez=_ClassBuilder._make_getstate_setstate..slots_getstatecsjt|}t|trt|D] \}}|||qnD] }||vr)||||qr3|tddSdS)rNN)rrr@rBzipr3)rstate_ClassBuilder__bound_setattrr[rhash_caching_enabledrOrrslots_setstates   z=_ClassBuilder._make_getstate_setstate..slots_setstate)rBrr)rrPrWrrUrrs z%_ClassBuilder._make_getstate_setstatecCsd|jd<|S)N__hash__)rrrrrmake_unhashables z_ClassBuilder.make_unhashablecCs(|t|j|j|j|jd|jd<|S)NrrrX)rF _make_hashrrrrrrrrradd_hashs  z_ClassBuilder.add_hashcCF|t|j|j|j|j|j|j|j|j |j |j |j dd |j d<|S)NF attrs_initr rF _make_initrrrrrrrrrrrrrrrradd_init" z_ClassBuilder.add_initcCs|dd|jd<|S)Nc[st|fi|Sr%r)rrrrrrsz+_ClassBuilder.add_replace.. __replace__)rFrrrrr add_replaces z_ClassBuilder.add_replacecCstdd|jD|jd<dS)Ncss"|] }|jr|js|jVqdSr%)r1r4r[)rfieldrrrrs z/_ClassBuilder.add_match_args..__match_args__)rBrrrrrradd_match_argssz_ClassBuilder.add_match_argscCr])NTr^__attrs_init__r`rrrradd_attrs_initrcz_ClassBuilder.add_attrs_initcCs2|j}|t|j|j|d<|t|d<|S)N__eq____ne__)rrF_make_eqrr_make_nerrrrradd_eq2s  z_ClassBuilder.add_eqcs>j}fddtjjD\|d<|d<|d<|d<S)Nc3s|]}|VqdSr%)rF)rmethrrrr?s  z*_ClassBuilder.add_order..__lt____le____gt____ge__)r _make_orderrrrorrr add_order<s   z_ClassBuilder.add_ordercs|jr|Si|jD]}|jp|j}|r |tjur ||f|j<q s%|S|jr.d}t|fdd}d|j d<| ||j d<d|_ |S)Nz7Can't combine custom __setattr__ with on_setattr hooks.csDz|\}}Wn ty|}Ynw||||}t|||dSr%)KeyErrorr)rr[valrhooknvalsa_attrsrrrYs  z._ClassBuilder.add_setattr..__setattr__Trr) rrr9rrNO_OPr[rr=rrFr)rrr9rGrrr|r add_setattrFs$    z_ClassBuilder.add_setattrcCstt |jj|_Wdn1swYtt|jjd|j|_Wdn1s5wYttd|jjd|_Wd|S1sTwY|S)zL Add __module__ and __qualname__ to a *method* if possible. Nrz$Method generated by attrs for class )rrrrrr rr!)rmethodrrrrFis     z!_ClassBuilder._add_method_dundersN)rrr r!r$r rrrrrIrLrrYr\rbrerhrjrprwrrFrrrrrss,\$  )   #rcCst|durt|du|dufrd}t||dur||fS|dur"|}|dur(|}|dur6|dur6d}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_order|src Cs|durt|du|dufrd}t|dd}|dur(||\}}||||fS|dur2|d}}n||\}}|durB||}}n||\}}|durV|durVd}t|||||fS)rNrcSs&t|r d|}}||fSd}||fS)z8 Decide whether a key function is used. TN)r>)rrrrrdecide_callable_or_booleans  z>_determine_attrib_eq_order..decide_callable_or_booleanFTrr) r/r5r7rrGrcmp_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)r)rflag auto_detectdundersr,dunderrrr_determine_whether_to_implements  rcsdurddl}|jtdddt|||d\|dur | t ttfr,tj  fdd}|durL|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*. NrzQThe `repr_ns` argument is deprecated and will be removed in or after August 2025.) stacklevelcspt|}duot|t}ot|d}|r |r d}t|t||t|dd | |}t|drD|durL|t|d}|s]|dur]| |sjt|drj| |  dur}dur}t|d r}d dur d ur durd }t | d us dur|d us|rrd }t |n! dus dur|dur|dur| n rd }t ||t| d r|n |rd}t |trt|ds|tr rt|ds||S)NTrz/Can't freeze a class with a custom __setattr__.)rrrrJ)rkrl)rrrsrtrurXFr+zlInvalid value for cache_hash. To use hash caching, hashing must be either explicitly or implicitly enabled.r zFInvalid value for cache_hash. To use hash caching, init must be True.rdrg)_has_frozen_base_class issubclassrrr=rrrIrLrprwrr<r\rYrbrjr rerrhr)r is_frozenrhas_own_setattrrGbuilderr5rrauto_excrreq_rrrr0r1r4 match_argsr9order_r.repr_nsrryrrrrwrapLs     zattrs..wrap) warningswarnDeprecationWarningrr@rArBrrC) maybe_clsrrr.r/r0r1rrrryrr4rrr5r7rrrr9rr unsafe_hashrrrrrrts"\ 4krtcCs |jtuS)zV Check whether *cls* has a frozen ancestor by looking at its __setattr__. )rr)rrrrrs rc Cs$d|d|jdt|d|jdS)zF Create a "filename" suitable for a function being generated. z. r0zdef __hash__(selfzhash((rdz):z, *zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper()c s|||ddgD]-}|jr4d|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,__key(self.z), self.rcN)rr6r[ri)prefixindentrcmp_namertclosing_bracesrN hash_func method_lines type_hashrrappend_hash_computation_liness  z1_make_hash..append_hash_computation_lineszif self.z is None:zobject.__setattr__(self, '', rself. = z return self.zreturn rgrX)rBrr0rir3rkra) rrtrrtabrhash_defrrMrrrr[s@    r[cCst||ddd|_|S)z% Add a hash method to *cls*. FrZ)r[rXrrtrrr _add_hashsrcCs dd}|S)z Create __ne__ method. cSs||}|tur tS| S)zj Check equality and either forward a NotImplemented or return the result negated. )rkNotImplemented)rotherresultrrrrl*s z_make_ne..__ne__r)rlrrrrn%s rnc Csdd|D}t|d}gd}i}|rd|d|D]B}|jrAd|jd}|j||<|d|d |jd |d |jd n |d |jd|j||dur]|dd|d<q|dn|dd|}td|||S)z6 Create __eq__ method for *cls* with *attrs*. cSg|]}|jr|qSr)r5rrrrr<z_make_eq..r5)zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (rrrrz) == z(other.rrz == other.rSz andz )z return Truergrk)rrir6r[rkra)rrtrrrNrrrMrrrrm8s*        rmcsVddDfddfdd}fdd}fd d }fd d }||||fS) z9 Create ordering methods for *cls* with *attrs*. cSrr)r7rrrrrbrz_make_order..cs tddfddDDS)z& Save us some typing. css$|] \}}|r ||n|VqdSr%r)rrrrrrrhs  z6_make_order..attrs_to_tuple..c3s"|] }t|j|jfVqdSr%)rr[r8robjrrrjs )rBrrtrrattrs_to_tupleds  z#_make_order..attrs_to_tuplecs |j|jur||kStSz1 Automatically created by attrs. rrrrrrrrro z_make_order..__lt__cs |j|jur||kStSrrrrrrrsxrz_make_order..__le__cs |j|jur||kStSrrrrrrrtrz_make_order..__gt__cs |j|jur||kStSrrrrrrrurz_make_order..__ge__r)rrtrrrsrtrur)rtrrrv^s  rvcCs&|dur|j}t|||_t|_|S)z5 Add equality methods to *cls* with *attrs*. N)rrmrkrnrlrrrr_add_eqs  rcCst|d}tdd|D}dd|D}t|d<t|d<t|d<g}|D]'\}}} | r0d |nd |d } |tkr@d || fnd ||| f} || q%d|} |durYd} n|d} ddddddddddddd| d| ddd g}td!d"|||d#S)$Nr.css8|]}|jdur|j|jdurtn|j|jfVqdS)FTN)r.r[r1rrrrrs z_make_repr..cSs$i|]\}}}|tkr|d|qS)_repr)r.)rr[rrrrrr sz_make_repr..rrrrzgetattr(self, "z ", NOTHING)z %s={%s!r}z%s={%s_repr(%s)}rz1{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))rrg)rN) rrBrrrr.rirkra)rtrHrrattr_names_with_reprsrNattribute_fragmentsr[rrpaccessorfragment repr_fragmentcls_name_fragmentrrrrrGsT    rGcCs |dur|j}t||||_|S)z% Add a repr method to *cls*. N)rrGr)rrHrtrrr _add_reprsrcCsvt|}|durt|tsd}t|t|dd}|dur9|dur0t|dd}|dur0||_|S|d}t||S)aG Return the tuple of *attrs* attributes for a class. The tuple also allows accessing the fields by their names (see below for examples). 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: 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. NPassed object must be a class.r! is not an attrs-decorated class.)r r@r*r<rrr)r generic_baserGrtrrrrs   rcCsJt|ts d}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 rrNrcSsi|]}|j|qSrrrrrrr /zfields_dict..)r@r*r<rr)rrGrtrrr fields_dicts   rcCsDtjdurdSt|jD]}|j}|dur|||t||jq 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_validatorsrrr-rr[)rrrrrrr2s rcCs||}|o d|jvS)z> Check if the attribute name comes from a slot class. r$)rr)a_namerrrrr _is_slot_attrDs rc  Cs2| duo| tju} |r| rd} t| |p|}g}i}|D]1}|js(|jtur(q|||||j<|jdurD|durAd} t| d}q| rN|jtjurNd}qt |d}t ||||||||| || | rddnd \}}}|j t j vrz|t j |j j|t|d|rtj|d<t| rdnd|||}||_|S)Nz$Frozen classes can't use on_setattr.Tr1rir )r attr_dictr)rr~r=r1r,rrir[r9r_attrs_to_init_scriptrsysmodulesr/rrrra__annotations__)rrtpre_initpre_init_has_args post_initrrrrrcls_on_setattrr_has_cls_on_setattrrGneeds_cached_setattrfiltered_attrsrrrrMrNrr1rrrraLsb        rarqry value_varhas_on_setattrrreturncCsd|d|dS)zJ Use the cached object.setattr to set *attr_name* to *value_var*. _setattr('rrrrqrrrrr_setattrrQrr2 ConvertercCsd|d|||dS)zk Use the cached object.setattr to set *attr_name* to *value_var*, but run its converter first. rrr)_fmt_converter_callrqrrr2rrr_setattr_with_convertersrrcCs |rt||dSd|d|S)zo Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. Trr)r)rqrrrrr_assigns rcCs*|r t||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_convertersrrrrdict[str, type]csJ|dur |dur dttfSdfd d }dfd d }d||fSdttfS)zg Determine the correct setter functions based on whether a class is frozen and/or slotted. Trrqryrrrrcs&t|r t|||Sd|d|SN _inst_dict['z'] = )rrrrrr fmt_setters  z&_determine_setters..fmt_setterr2rcs4|st|rt||||Sd|d|||Sr)rrrrrrrfmt_setter_with_converters z5_determine_setters..fmt_setter_with_converter)z_inst_dict = self.__dict__Nrqryrryrrrry rqryrryrrr2rrry)rrrr)rrrrrrrr_determine_setterss  rlist[Attribute]r is_slotted call_pre_initrcall_post_initdoes_cache_hashrrr method_nametuple[str, dict, dict]c $ Cs|rdgng} | r| dt|||\} }}| | g}g}g}i}ddi}|D]}|jr5|||j}|jdupD|jtjuoD| }|j}t |j t }|rV|j j rVdnd}|j durit |j tsit|j }n|j }|jdur|rt|jf}|dur| |||d|d |||j |||j<n| |||d|d ||j j||<n|dur| ||d |d |||j |||j<n| ||d |d |n|j tur|s|d |d }|jr||n|||dur| ||||||j |||j<n| ||||n|r|d }|jr-||n||| d|dt|jf}|durs| d|||||| d| d|||d|d |||j |||j<n!| d||||| d| d|||d|d ||j j||<n1|jr||n|||dur| ||||||j |||j<n | |||||jdur|jdur|dur|j||<q*|dur|jr|j||<q*|r't|d<| d|D]&}d|j}d|j}| d|d|d|jd |j||<|||<q|r/| d|rQ|rF|r?dtd}n dtd}ndtd}| ||rgd d!d"|D} | d#| d d$|}|}!|r||rwd$ndd%d$|7}d$d&d'd(d"|DD}"|!|!rd$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)rNrrIFrrz attr_dict['z '].defaultz =attr_dict['z=NOTHINGzif z is not NOTHING:rczelse:Trz#if _config._run_validators is True:__attr_validator___attr_z(self, z, self.zself.__attrs_post_init__()rz', None)rz '] = Nonerz = Nonercss"|] }|jrd|jVqdS)rN)r1r[rrrrrs z(_attrs_to_init_script..zBaseException.__init__(self, rz*, cSsg|] }|d|qS)=r)r kw_arg_namerrrrs z)_attrs_to_init_script..css|] }|ddVqdS)rrN)split)rkwarrrrszself.__attrs_pre_init__(rz zdef z): passrg)rirrr-r[r9rr~r:r@r,r? takes_selfr2rr1_INIT_FACTORY_PAT_get_global_namerFrr4r*_first_param_typerr3rk)$rtrrrrrrrrrrrr extra_linesrrr kw_only_argsattrs_to_validatenames_for_globalsrrrqrarg_name has_factory maybe_selfr2init_factory_nameargval_nameinit_hash_cachevals pre_init_argspre_init_kw_only_argsNLrrrrsl                                       "  rr[cCs |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)lstriprrrrrs rc@sheZdZdZdZ          dddZddZedd d Zd d Z d dZ ddZ ddZ dS)ra *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. - ``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* For the full version history of the fields, see `attr.ib`. )r[r,r-r.r5r6r7r8r0r1r3r*r2r4rr9r:NFcCst||p| |p|d\} }}}t|}|d||d||d||d||d| |d||d||d ||d ||d ||d | |d | rVtt| nt|d| |d| |d||d||d|dS)NTr[r,r-r.r5r6r7r8r0r1r2r3r*r4rr9r:)r;rrtypesMappingProxyTyper_EMPTY_METADATA_SINGLETON)rr[r,r-r.r/r0r1rr3r*r2r4r5r6r7r8r9r: bound_setattrrrrr C s4                zAttribute.__init__cCstr%)rrrrrrz rzAttribute.__setattr__c sZ|durj}n jdurd}t|fddtjD}|d|jj|ddd|S)Nz8Type annotation and type argument cannot both be presentcs i|] }|dvr|t|qS))r[r-r,r*rr")rrrrrr  s z0Attribute.from_counting_attr..F)r[r-r,r*r/rr)r*r=rr$ _validator_default)rr[rr*rG inst_dictrr$rr} s$   zAttribute.from_counting_attrcKst|}|||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 )copy _setattrsr)rrnewrrrr s zAttribute.evolvectfddjDS)( Play nice with pickle. c3s,|]}|dkr t|ntjVqdS)r3N)rrr3r#rrrr s  z)Attribute.__getstate__..rBr$rrrrr s zAttribute.__getstate__cCs|t|j|dSr,N)r)rRr$rrSrrrr szAttribute.__setstate__cCsLt|}|D]\}}|dkr|||q|||r tt|ntqdS)Nr3)rrr r!rr")rname_values_pairsr#r[rrrrr) s   zAttribute._setattrs) NNNFNNNNNNr%) rrr r!r$r rr7rrrrr)rrrrr s*, 7  rcCs2g|]}t|tddddd|dkddt|d qS)NTFr3) r[r,r-r.r/r5r7r0r1rr:)rrrr#rrrr s rrcCsg|] }|jdkr|qSrrrrrrr scCs g|] }|jr|jdkr|qSr)r0r[rrrrr s c@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. )r&r%r:r2rr5r6r0r1r4r3r9r7r8r.r*ccs:|]}t|t|tdddddddddddddVqdS)NTFr[r:r,r-r.r/r0r1r4r5r6r7r8rr9)rrrr#rrrr s* z_CountingAttr.) rr&r.r5r7r0r1r9r:r3NTFr1rcCsttjd7_tj|_||_||_||_||_| |_| |_| |_ ||_ ||_ ||_ ||_ | |_| |_||_||_dSr)rE cls_counterrr&r%r2r.r5r6r7r8r0r1r3r*r4r9r:)rr,r-r.r/r0r1r2r3r*r4r5r6r7r8r9r:rrrr 5 s" z_CountingAttr.__init__cCs&|jdur ||_|St|j||_|S)z Decorator that adds *meth* to the list of validators. Returns *meth* unchanged. .. versionadded:: 17.1.0 N)r%rDrrqrrrr-Z 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 )r&rrr?r3rrrr,h s z_CountingAttr.default) rrr r!r$rBrrr2r r-r,rrrrrE s<1% rEc@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* rFr FcCs||_||_dSr%r4)rrFr rrrr  s zFactory.__init__cr+)r,c3s|]}t|VqdSr%r"r#rrrr z'Factory.__getstate__..r-rrrrr szFactory.__getstate__cCs&t|j|D] \}}t|||qdSr.)rRr$r)rrSr[rrrrr szFactory.__setstate__N)F)rrr r!r$r rrrrrrr?~ s   r?cC(g|]}t|tddddddddd qSNTF) r[r,r-r.r/r5r7r0r1rrrr#rrrr  c@sLeZdZdZdZdddddZedd d Zdd dZddZ 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__r _global_namer2 takes_fieldr Fr r<cs|_|_|_t|}|_js js fdd_n#jr.js.fdd_njs<jr<fdd_nfdd_|}|durS|jjd<dSdS)Ncs |Sr%r2)rr__rrrr rz$Converter.__init__..cs ||Sr%r>)rinstancer?rrrr cs ||Sr%r>)rr?rfrrrr rAcs|||Sr%r>)rr@rfrrrr sr) r2r r<r get_first_param_typerr:get_return_typer)rr2r r<exrtrrrr  s     zConverter.__init__rqryrcCs d|S)zh Return the name that a converter for an attribute name *attr_name* would have. __attr_converter_r)rqrrrr s zConverter._get_global_namercCs|js|js||d|dS|jr%|jr%||d|d|dS|jr3||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[')r r<r)rrqrrrrr s  zConverter._fmt_converter_callcCs|j|j|jdS)zx Return a dict containing only converter and takes_self -- the rest gets computed when loading. r2r r<rGrrrrr szConverter.__getstate__cCs|jdi|dS)z+ Load instance from state. Nrrr/rrrr szConverter.__setstate__N)rqryrry)rqryrryrry) rrr r!r$r r8rrrrrrrrr s    cCr6r7r8r#rrrr r9rGc  s^t|tr|}nt|ttfrdd|D}nd}t||dd}|dd}|dd} i|dur:||durB|d<|durJ|d<| durR| d<t||ifdd } t t t t d jd d | _Wdn1szwY|d d} t| |d|dd\|d<|d<tdd|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)`` 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* cSsi|]}|tqSr)rHrrrrr \ rzmake_class..z(attrs argument must be a dict or a list.rNrr cs |Sr%)r/)rHbodyrrro rzmake_class..rr__main__r/r5r7TrcSs"i|] \}}|jdur||jqSr%)r*rrrrr  sr)r@rrArBr<popr/r  new_classrrrr=r _getframe f_globalsrrrrrr) r[rtbases class_bodyattributes_argumentscls_dictrGrr user_inittype_r/rrrHr make_class1 sN (      rU)rrc@seZdZdZeZddZdS) _AndValidatorz2 Compose many validators to a single one. cCs|jD]}||||qdSr%) _validators)rrrrrrrrr: s z_AndValidator.__call__N)rrr r!rHrWr:rrrrrV s rVcGs6g}|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@rVrWrB) validatorsrr-rrrrD s  rDcstddD}|rfdd}nfdd}s)td}|j||dn*td}|r8||jd <d }tsFt|t rF|j }t| }|rS||jd <|r\t |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 r5zpipe..cs,D]}t|tr||||n||}q|Sr%rY)ryrrfrZ convertersrrpipe_converter szpipe..pipe_convertercsD]}||}q|Sr%r)ryrZr[rrr] s A)ryrrryrSrTr=) rtypingTypeVarrr/r rBr r@rr:rC)r\return_instancer]r^tlastrErr[rrC s&     rC)NrIr%)T)NNNNNNNFFTFFFFFNNFFNNNTN)NNrr)rqryrryrrrry)rrrrrr)rtrrrrrrrrrrrrrrrrrrrrrrryrr)r[ryrry)c __future__rrrr(r"r%rr4rXrr r_operatorrrIrrrrr r r r r exceptionsrrrrobjectrrr r|r3r!r"rrCrrrEnumrrintr$rHrRrarrrsr~rrrrrrrrrrr;rrtrrrr[rrnrmrvrrGrrrrrarrrrrrrrr$_arEr?_frrUrVrDrrrrs2      k  m: : ,  a G& 8 9 . O  /  L     ' d  a