3goddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZmZmZddlmZmZmZmZmZmZddlmZmZmZmZej>Z dZ!d Z"d Z#e jHiZ%eZ&ejNejPejRZ*Gd d ejVZ,e,jZZ- Gd de.Z/e-ddddddddddddddfdZ0dPdZ1dQdZ2dZ3e3dgdZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZd"Z?d#Z@ dRd$ZA dSd%ZBeBZC d&ZDd'ZEd(ZFd)ZGd*ZHd+ZId,ZJdQd-ZKd.ZLdTd/ZMd0ZNd1ZOd2Z)d3ZPd4ZQdUd5ZR dVd7ZSdWd8ZT dVd9ZU dXd:ZV dYd;ZWdZd<ZXGd=d>ZYeYjDcgc]}eY|e-ddddd|d?k7ddeX|@  c}Z[eGeKeMeYe[Ae[Dcgc]}|jdBk7s|c}Ae[Dcgc]!}|js|jdBk7s |#c}AZYGdCdDZ^eKeMe^Z^GdEdFZ_e_jDcgc]}eY|e-ddddddddG c}Z`eGeKeMe_e`Ae`Ae`AZ_GdHd6ZadIDcgc]}eY|e-ddddddddG c}Z`eGeKeMeae`Ae`Ae`AZaefdfdJZbeBddKGdLdMZcdNZddOZ'ycc}wcc}wcc}wcc}wcc}w)[) 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>eZdZdZej ZdZdZy)_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. cy)NNOTHINGselfs `/var/www/python.lazyprojects.co.uk/rdoDiscordBot/venv/lib/python3.12/site-packages/attr/_make.py__repr__z_Nothing.__repr__Iscy)NFrrs r__bool__z_Nothing.__bool__LsrN) __name__ __module__ __qualname____doc__enumautorrr rrrrr<s diikGrrc(eZdZdZeddfdZy)_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__ds  %''r)r!r"r#r$typer-rrrr(r(Xs ,0:R(rr(TFct|| | d\} }} }||dur|dur d}t|| 8|tur d}t|t | s d}t|t | }|i}t | ttfrtj| } |rt |ttfrt|}|rt |ttfrt|}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* 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)r1r2r3r4r5r6r8r.r7factoryr9r:r<r>r?r;r=msgs rattribrMhsn$> R$ By D,U1BFn ' !O S/ ! >CS/ !'"*tUm,\\:. Z D%=9)$ Z D%=9)$                         ! rc8t||d}t|||y)z[ Evaluate the script with the given global (globs) and local (locs) variables. execN)compileeval)scriptglobslocsfilenamebytecodes r_compile_and_evalrWs vx0H5$rc|in|}d}|} t|d|jd|f}tjj ||} | |k(rn|ddd|d}|dz }Ut ||||||S)zO Create the method with the script given and return the method object. NrT->)len splitlines linecachecache setdefaultrW) namerRrUrSlocalsrTcount base_filenamelinecache_tupleold_vals r _make_methodrgs2VD EM  K    d #    //,,XG o % #CR()5'3   feT84 :rc|d}d|ddg}|r,t|D]\}}|jd|d|dn|jdttd }t d j ||||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 ) enumerateappendrpropertyrWjoin)cls_name attr_namesattr_class_nameattr_class_templatei attr_namerSs r_make_attr_tuple_classrys" *-O !*%j1LAy  & &yk!FqcL 2 "":.", JEdii 34e<  !!r _Attributes)attrs base_attrsbase_attrs_mapct|}|jdr|jdr|dd}|jtS)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. )'"rrY)str startswithendswith_CLASSVAR_PREFIXES)annots r _is_class_varr#sE JE  #z(Ba    . //rc||jvS)zR Check whether *cls* defines *attrib_name* (and doesn't just inherit it). )__dict__)cls attrib_names r_has_own_attributer4s #,, &&rcg}i}t|jddD]a}t|dgD]O}|js|j|vr|j d}|j ||||j<Qcg}t}t|D]>}|j|vr|jd||j|j@||fS)zQ Collect attr.ibs from base classes of *cls*, except *taken_attr_names*. rrY__attrs_attrs__T inheritedr) reversed__mro__getattrrraevolverpsetinsertadd)rtaken_attr_namesr| base_attr_mapbase_clsafilteredseens r_collect_base_attrsr;sJMS[[2./#4b9A{{aff(884(A   a $,M!&& ! :0H 5D j ! 66T> 1  " ] ""rcg}i}|jddD]p}t|dgD]^}|j|vr|jd}|j |j|j ||||j<`r||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. rrYrTr)rrrarrrp)rrr|rrrs r_collect_base_attrs_brokenrZsJMKK"%#4b9Avv))4(A   (   a $,M!&& !:& } $$rc |jt|}|t|j}n3|dur jD chc]\}} t | t r|} }} g}t } |jD]y\} } t| r| j| j| t}t |t s|tur tn t|}|j| |f{| | z }t|dkDrQtddjt!|fdzdzt!d jDd }|D cgc],\} }t"j%| ||j|  .}} }|r(t'||Dchc]}|j(c}\}}n't+||Dchc]}|j(c}\}}|r>|Dcgc]}|j-d }}|Dcgc]}|j-d }}||z}d }d|DD]B}|dur"|j.turd|}t1||d us.|j.tusAd}D| |||}|Dcgc]5}|j2s%|j-t5|j(n|7}}|Dcgc]}|j(}}t7|j8|}t;||||fScc} }wcc}} wcc}wcc}wcc}wcc}wcc}wcc}w)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`. Tr1rz1The following `attr.ib`s lack a type annotation: , c:j|jSr*)getcounter)ncds rz"_transform_attrs..sbffQi6G6Gr)key.c3JK|]\}}t|tr||fywr*)rErJ).0raattrs r z#_transform_attrs..s* ",JD$dM2t ",s!#c |djSNr)r)es rrz"_transform_attrs..s !A$,,r)racar.)r9Fc3\K|]$}|jdus|jdus!|&yw)FN)r6r9rrs rrz#_transform_attrs..s' MA!&&"5!))u:Las ,,,zlNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: )r?)rr rFitemsrErJrrrrrrMrpr\rrrsorted Attributefrom_counting_attrrrarrr1rBr?_default_init_alias_forryr!rz)rthese auto_attribsr9collect_by_mrofield_transformerannsca_listrarca_names annot_namesrxr.r unannotatedr own_attrsr|rr{ had_defaultrLrt AttrsClassrs @r_transform_attrsrvsl B C D u{{}%  !hhj ( d$ . (  e #zz|OItT" OOI &y'*Aa/ !W FH&2C NNIq> * ,, { a +C));,GH   "$((*  '  % %MIr $$r(; % % $7 ),)Q!&&),% ! M%? ),)Q!&&),% ! M5>?YQXXdX+Y ?6@Ajahhth,j A  "E K M M $ 199#7ABCAFGCS/ ! % AIIW$<K N$!#u- A@Aww.qvv67AM  #((%Q!&&%J(' jAJ  5):}E FFo H--@A. )s0L.1L.L" L' 9L,L1:L6L;cgd}||jdn|jgd|jddgt|d}|tj|d}t dd j |||d |i 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__rn_cls)rb)rpextend_generate_unique_filename _OBJ_SETATTR__get__rgrr)rrrlinesunique_filenameglobs r_make_cached_property_getattrrs E# :      LL $ ) 0Y?O/+33, D  % C  rcft|tr|dvrtj|||yt)z4 Attached to frozen classes as __setattr__. ) __cause__ __context__ __traceback____suppress_context__ __notes__N)rE BaseException __setattr__rrravalues r_frozen_setattrsrs7$ &44, !!$e4 rcdt|tr|dvrtj||yt)z4 Attached to frozen classes as __delattr__. )rN)rEr __delattr__r)rras r_frozen_delattrsr.s.$ &4>+A!!$- rc |\}|j}t |}|D];}|j s|j }|j}||vs-t||||<=|di|S#t$rdt|d}t|dwxYw)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) rBr\rA __class__fieldsr6rar?r) argschangesinstrLrr{rrx init_names rrr9sJ' ..C 3KE vv FF GG G #!(y!9GI   >>! '8T ; O n$& 's A%%%B ceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZy) _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_setattrct||||| |\}}}||_|rt|jni|_||_|Dchc]}|j c}|_||_td|D|_ ||_ ||_ ||_ | |_tt!|dd|_d|_|j"r>|j&}t)j*|}t-|j.dkD|_tt!|dd|_t| |_| |_| |_| |_d|_|j |jd<|r.t<|jd<t>|jd<d |_n| t@tBjDtBjFfvrldx}}|D]%}|jHd }|jJd }|s"|s%n| t@k(r|s|r*| tBjDk(r|r| tBjFk(r |sd|_|r.|jM\|jd <|jd <yycc}w) Nc34K|]}|jywr*rars rrz)_ClassBuilder.__init__..s 7As__attrs_pre_init__Fr__attrs_post_init__rrrT __getstate__ __setstate__)'rrdictrrrrarrrGrrrrrboolrrrrinspect signaturer\ parametersrrrrrrrr_DEFAULT_ON_SETATTRrvalidateconvertr2r7_make_getstate_setstate)rrrslotsfrozen weakref_slotgetstate_setstaterr9 cache_hashis_excrr>has_custom_setattrrr{r|base_mapr pre_init_funcpre_init_signature has_validator has_converters r__init__z_ClassBuilder.__init__sI"'7       ' #z8 /4cll+" ,67JqAFFJ7& 7 77  )%!'#/CU"KL"'    22M!(!2!2=!A &)*<*G*G&H1&LD #"730Eu#MN#'; %#5 "',0KK() ,)rr!rs rrz_ClassBuilder.__repr__s$TYY%7%7$8;;rc|jdur|j}n+|j}trt j |}t |ddrd|jvr|j|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_classr abcupdate_abstractmethodsrrr)rrs r build_classz_ClassBuilder.build_classsk ;;$ **,C,,.C005 C2D 9)=  ' ' ) rc|j}|j}|jr\|jD]M}||vst ||t t us t jt5t||dddO|jjD]\}}t||||js+t |ddrd|_|js t |_|S#1swYxYw)zA Apply accumulated methods and return the class. N__attrs_own_setattr__F)rrrrr _SENTINEL contextlibsuppressAttributeErrordelattrrrsetattrrr#rrr)rr base_namesrars rrz#_ClassBuilder._patch_original_classsii%%    (( *T95YF $,,^<T*=<) >>//1KD% Cu %2 &&7 (%, ).C %++". #=|d<tA|j |j jB|j j|}tEjF|jjI| D]}t#|tJtLfrt|jNdd}n5t#|tPrt|jRdd}n t|dd}|si|D]%} |jT|j u}|s||_*'|Scc}}wcc}wcc} }wcc}wcc}}wcc}w#tV$rYXwxYw)zL Build and return a new class with a `__slots__` attribute. r __weakref__Fr#rrrYNT __slots__r)r,rr# __closure__),rrrGrrrr __bases__rrrrupdaterrrrrE functoolscached_propertyfuncr rprrreturn_annotation Parameteremptyrr_HASH_CACHE_FIELDr#r.r! itertoolschainvalues classmethod staticmethod__func__rqfget cell_contentsrB)rkvrrexisting_slotsweakref_inheritedrar*namesr2r&additional_closure_functions_to_updateclass_annotationsr3 annotationr slot_namesslotslot_descriptor reused_slotsritem closure_cellscellmatchs rrz!_ClassBuilder._create_slots_class'sr ,,. .1M% 0 01M:M}MM qD.  &&*/B& '++ $ 3 3H((,,-DeL,8=)!4! ))!B/H  $$]D9E$(!  ! !!(+r B B'(D11 B 0))*      WTYY R%HHU*% % %E*, )3%o/9+D+DE /&& &)3  24.  0 ; /557 d$ tH6==dC$..t4FF W%6%6%<%<<.8%d+8 "vvm4 +6==>NO =!#3TYY!B}  (-GutJ0Fdu G*8)=)=)? )?%oz! / !)?  (2NztT5Mdz N ,      / 0 +;!YY33>d499odii00$))2E2ErJOO LL   !#I D$l ;<!( }d K D(+!( =$ G 'mT B  %1 ..$));E -0*&! 2 K >" >H  OJ"sA+P4P: 1P? QQ)Q  Q Q Q Q! Q!c|jt|j||j|jd<|S)Nr)_add_method_dunders _make_reprrrr)rnss radd_reprz_ClassBuilder.add_reprs6%)%=%= t{{B 2& z" rc|jjd}| d}t|d}|j||jd<|S)Nrz3__str__ can only be generated if a __repr__ exists.c"|jSr*rrs r__str__z&_ClassBuilder.add_str..__str__s==? "rrX)rrrBrQ)rr3rLrXs radd_strz_ClassBuilder.add_strsO~~!!*- <GCS/ ! #%)$<$.s! )2R=-@B)s cDDcic]}|t||c}Scc}w)9 Automatically created by attrs. r)rrastate_attr_namess rslots_getstatez=_ClassBuilder._make_getstate_setstate..slots_getstates,;KK:J$D'$--:JK KKsctj|}t|trt |D]\}}|||nD]}||vs||||r|t dyy)r^N)rrrErGzipr7)rstate_ClassBuilder__bound_setattrrarhash_caching_enabledr`s rslots_setstatez=_ClassBuilder._make_getstate_setstate..slots_setstatesx+2248O%'$''7#?KD%#D%0$@-Du}'eDk:-$ 148$r)rGrr)rrargrfr`s @@rr z%_ClassBuilder._make_getstate_setstatesI !! ))!   L $// 9,~--rc$d|jd<|S)N__hash__)rrs rmake_unhashablez_ClassBuilder.make_unhashables%)z" rc|jt|j|j|j|j |j d<|S)Nrrri)rQ _make_hashrrrrrrs radd_hashz_ClassBuilder.add_hashsH%)%=%=   ||++  & z" rcH|jt|j|j|j|j |j |j|j|j|j|j|jd |jd<|S)NF attrs_initrrQ _make_initrrrrrrrrrrrrrs radd_initz_ClassBuilder.add_inits%)%=%=   ""''##    ##     & z"" rcD|jd|jd<|S)Nct|fi|Sr*)r)rrs rrz+_ClassBuilder.add_replace..sF4$;7$;r __replace__)rQrrs r add_replacez_ClassBuilder.add_replaces%(,(@(@ ;) }% rcVtd|jD|jd<y)Nc3dK|](}|jr|js|j*ywr*)r6r9ra)rfields rrz/_ClassBuilder.add_match_args..s)1 $zz%-- JJ$s.0__match_args__)rGrrrs radd_match_argsz_ClassBuilder.add_match_argss'+01 1 , '(rcH|jt|j|j|j|j |j |j|j|j|j|j|jd |jd<|S)NTrp__attrs_init__rrrs radd_attrs_initz_ClassBuilder.add_attrs_inits+/+C+C   ""''##    ##    , '(" rc|j}|jt|j|j|d<|jt |d<|S)N__eq____ne__)rrQ_make_eqrr_make_nerrs radd_eqz_ClassBuilder.add_eq2sN ^^// TYY , 8 // ;8  rcj}fdtjjD\|d<|d<|d<|d<S)Nc3@K|]}j|ywr*)rQ)rmethrs rrz*_ClassBuilder.add_order..?s%B ;  $ $T *;s__lt____le____gt____ge__)r _make_orderrrrs` r add_orderz_ClassBuilder.add_order<sL ^^B #DIIt{{;B >8 blBxL"X,  rcx|jr|Si|jD]C}|jxs |j}|s |tj us3||f|j <Es|S|jr d}t|fd}d|jd<|j||jd<d|_ |S)Nz7Can't combine custom __setattr__ with on_setattr hooks.ch |\}}||||}t|||y#t$r|}YwxYwr*)KeyErrorr)rravalrhooknvalsa_attrss rrz._ClassBuilder.add_setattr..__setattr__YsG *"4.4D!S) tT *   s # 11Tr#r) rrr>rrNO_OPrarrBrrQr)rrr>rLrrs @r add_setattrz_ClassBuilder.add_setattrFs <<KA9)9)9Jj =#$j=  K  # #KCS/ ! +37./(,(@(@(M}%"& rctjt5|jj|_dddtjt5|jj d|j |_dddtjt5d|jj d|_ddd|S#1swYxYw#1swYXxYw#1swY|SxYw)zL Add __module__ and __qualname__ to a *method* if possible. Nrz$Method generated by attrs for class )r%r&r'rr"r#r!r$)rmethods rrQz!_ClassBuilder._add_method_dundersis  0 $ 4 4F 1  0%)YY%;%;$_determine_attrib_eq_order..decide_callable_or_booleans1 E?u3EczCczrFTrr) r4r:r<rrLrcmp_keyr;r=s rr@r@s  3$T0ABC6o 1#6 WGS')) zF/3 F }vy5e<y U{u}=o vui ''rcT|dus|dur|S||dur|S|D]}t||sy|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_detectdundersr1dunders r_determine_whether_to_implementrsG t|tu}  | u, c6 * Nrc4  ddl}|jtddt|||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*. NrzQThe `repr_ns` argument is deprecated and will be removed in or after August 2025.) stacklevelcxs t|} duxrt|t}xr t|d}|r|r d}t |t ||t |d | | }t |dr|jdur|jt | d}|s|dur|j|st |dr|j|jdurt|d rd durd ur d }t|d us|d us|r rKd }t|dus |dur|dur|jn r d }t||jt |d r|jn|j! r d}t|t"rt|ds|j%t&rrt|ds|j)|j+S)NTrz/Can't freeze a class with a custom __setattr__.)rrrrW)rr)rrrrriFr0zlInvalid value for cache_hash. To use hash caching, hashing must be either explicitly or implicitly enabled.rzFInvalid value for cache_hash. To use hash caching, init must be True.rwr|)_has_frozen_base_class issubclassrrrBrrrTrYrrrrArnrjrtrr rxr r}r!)r is_frozenrhas_own_setattrrLbuilderr:rrauto_excrreq_rrrr5r6r9 match_argsr>order_r3repr_nsr rrrs rwrapzattrs..wrapLse94S9 T!Djm&D% *< +  yCCS/ !      +!0          ) , + {M    W % $; OO  , k#7 "* NN 9 &N      Lt#"3 3D t E 1d6FJCC. 5=T\bEkfEn$ T\ LR4ZI,=    En$  # # % * {M       " " $^n$  23 F    ! &s,<=  " " $""$$r) warningswarnDeprecationWarningrrErFrGrrH) maybe_clsrrr3r4r5r6r rrrrr9rrr:r<rrrr>rr unsafe_hashrrrrs ``` `````````` `````` @@rr{r{sx c   ,CUDAKC*tUm,\\:. g%g%g%g%V  ?rc&|jtuS)zV Check whether *cls* has a frozen ancestor by looking at its __setattr__. )rr)rs rrrs ??. ..rc Xd|d|jdt|d|jdS)zF Create a "filename" suitable for a function being generated. z.s0aAFFdNqvv~!$$$,5s 888 r5zdef __hash__(selfzhash((rkz):z, *zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper()c hj||zz|d dzgD]u}|jrEd|jd}|j|<j|d|d|jdzTj|d|jdzwj|dzzy ) 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.rjN)rr;rarp) prefixindentrcmp_namer{closing_bracesrS hash_func method_lines type_hashs rappend_hash_computation_linesz1_make_hash..append_hash_computation_liness )+8I;a00  Axxqvvhd+"#((h##xzxrBB##F}QVVHA-F$FG FVOn<=rzif self.z is None:zobject.__setattr__(self, '', rself. = z return self.zreturn rnri)rGrr5rpr7rrrg)rr{rrtabrhash_defrrRrrSrrrs ` @@@@@rrmrmsO  E C/V>4CH->,?y"IIJ  ),->,?sCS1W    a# . ))*#.a  CL1B0C"DDE%i5 YY| $F  FOU CCrc.t||dd|_|S)z% Add a hash method to *cls*. Frl)rmrirr{s r _add_hashrsc55ICL Jrc d}|S)z Create __ne__ method. cF|j|}|turtS| S)zj Check equality and either forward a NotImplemented or return the result negated. )rNotImplemented)rotherresults rrz_make_ne..__ne__*s( U# ^ #! !zrr)rs rrr%s  Mrc X|Dcgc]}|js|}}t|d}gd}i}|r|jd|D]}|jrRd|jd}|j||<|jd|d|jd|d |jd n+|jd |jd |j||d us|d d|d <|jdn|jddj |}t d|||Scc}w)z6 Create __eq__ method for *cls* with *attrs*. r:)zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (rrrrz) == z(other.rrz == other.rYz andz )z return Truernr)r:rrpr;rarrrg)rr{rrrrSrrRs rrr8s. &1QE &/T:O E E  _%Axxqvvhd+#$((h xjqvvheH:WQVVHTUV }QVVHJqvvhGHb !$Ryk.b   W &' YYu F &/5 AA? 's D'D'cDcgc]}|js|c}fdfd}fd}fd}fd}||||fScc}w)z9 Create ordering methods for *cls* with *attrs*. c<tdfdDDS)z& Save us some typing. c3:K|]\}}|r||n|ywr*r)rrrs rrz6_make_order..attrs_to_tuple..hs+  sCJ5 (sc3bK|]&}t|j|jf(ywr*)rrar=)rrobjs rrz6_make_order..attrs_to_tuple..js)=Baff%q{{3Us,/)rG)rr{s`rattrs_to_tuplez#_make_order..attrs_to_tupleds) =B   rcb|j|jur||kStSz1 Automatically created by attrs. rrrrrs rrz_make_order..__lt__o0 ??dnn ,!$'.*?? ?rcb|j|jur||kStSrrrs rrz_make_order..__le__x0 ??dnn ,!$'>%+@@ @rcb|j|jur||kDStSrrrs rrz_make_order..__gt__rrcb|j|jur||k\StSrrrs rrz_make_order..__ge__rr)r<)rr{rrrrrrs ` @rrr^sO )1Q )E   666 ))c *s??cb| |j}t|||_t|_|S)z5 Add equality methods to *cls* with *attrs*. )rrrrrrs r_add_eqrs0 }###u%CJCJ Jrct|d}td|D}|Dcic]\}}}|tk7s|dz|}}}}t|d<t|d<t |d<g} |D]B\}}} | rd|znd|zd z} |tk(r|d | d n |d |d | d } | j | Ddj| } |d}n|dz}ddddddddddddd|d| ddd g}td!d"j|||#Scc}}}w)$Nr3c3K|]I}|jdur9|j|jdurtn |j|jfKyw)FTN)r3rar6rs rrz_make_repr..sC"A 66  !&&D.$affqvv>sAA_reprrr'rrzgetattr(self, "z ", NOTHING)z={z!r}z_repr(z)}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))rrn)rS) rrGr3rr'rrprrrg)r{rSrrattr_names_with_reprsrarrrSattribute_fragmentsrwaccessorfragment repr_fragmentcls_name_fragmentrs rrRrRsw/V Check if the attribute name comes from a slot class. r-)rr)a_namerrs r _is_slot_attrrDs(   F #C  .;#,,..rc | duxr| tju} |r| r d} t| |xs|}g}i}|D]}|js|jt ur"|j ||||j<|j|dur d} t| d}b| se|jtjusd}t|d}t||||||||| || | rdnd \}}}|jtjvr6|jtj|jj|jt |d|rt j"|d<t%| rdnd|||}||_|S)Nz$Frozen classes can't use on_setattr.Tr6rr)r attr_dictr)rrrBr6r1rrprar>r_attrs_to_init_scriptr"sysmodulesr0rrrrg__annotations__)rr{pre_initpre_init_has_args post_initrr rrrcls_on_setattrrqhas_cls_on_setattrrLneeds_cached_setattrfiltered_attrsrrrrRrSrr6s rrsrsLs d"J~W]]'J$4o%/NI vv!))w. a  !&& << #~< o%#' ALL $E#'  0V(4';';#$ &J  D 'D Krcd|d|dS)zJ Use the cached object.setattr to set *attr_name* to *value_var*. _setattr('rrr)rx value_varhas_on_setattrs r_setattrr!s {#i[ 22r Converterc4d|d|j||dS)zk Use the cached object.setattr to set *attr_name* to *value_var*, but run its converter first. rrr)_fmt_converter_callrxrr r7s r_setattr_with_converterr&s( {#i&C&CIy&Y%ZZ[ \\rc0|r t||dSd|d|S)zo Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. Trr)r!)rxrr s r_assignr(s)  5$// 9+S ((rcR|rt||d|Sd|d|j||S)z Unless *attr_name* has an on_setattr hook, use normal assignment after conversion. Otherwise relegate to _setattr_with_converter. Trr)r&r$r%s r_assign_with_converterr*s9&y)T9MM 9+S!>!>y)!T U VVrc|dur4|dur dttfS dfd } dfd }d||fSdttfS)zg Determine the correct setter functions based on whether a class is frozen and/or slotted. TrcFt|r t|||Sd|d|SN _inst_dict['z'] = )rr!)rxrr rs r fmt_setterz&_determine_setters..fmt_setters1Y 6 9nEE!)E)= =rcl|s t|rt||||Sd|d|j||Sr-)rr&r$)rxrr r7rs rfmt_setter_with_converterz5_determine_setters..fmt_setter_with_convertersL y-!H.y.)")E)2O2OPY[d2e1fg gr)z_inst_dict = self.__dict__rxrrrr rreturnr rxrrrr rr7r"r3r)r!r&r(r*)rr rr/r1s ` r_determine_settersr5s~ D=x!88 8 > >'* ><@ >  > h h h! h! h  h ,  %   w. ..rc d |rdgng} | r| jdt|||\} }}| j| g}g}g}i}ddi}|D]}|jr|j||j}|j duxs |j t juxr| }|j}t|jt}|r|jjrdnd}|j0t|jtst|j}n |j}|jdur|rt |jfz}|J| j|||d|d z|||j||j#|j<n | j|||d|d z||jj$||<n|H| j||d |d |||j||j#|j<n| j||d |d |n|jt&ur|s|d |d }|j(r|j|n|j||D| j||||||j||j#|j<n| j||||n|rH|d }|j(r|j|n|j|| jd|dt |jfz}|}| jd|||||z| jd| jd|||dz|zd z||z|j||j#|j<nR| jd||||z| jd| jd|||dz|zd z|z|jj$||<n|j(r|j|n|j||C| j||||||j||j#|j<n| j|||||jdus|j*||j*||<||j,s|j,||<|rxt.|d<| jd|D]Y}d|jz}d|jz}| jd|d|d|jd |j||<|||<[|r| jd|r5|r|r dt0d}ndt0d}n dt0d}| j||r-d j3d!|D} | jd"| d d#j3|}|}!|rV||rd#ndd$d#j3|z }d#j3d%|DD"cgc] }"|"d&|" c}"}#|!|!rd#ndz }!|!|#z }!|r |r d'|!d | d(<d)}$d*| d|d+| r|$j3| nd,d-||fScc}"w).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)r3NrFrrz attr_dict['z '].defaultz =attr_dict['z=NOTHINGzif z is not NOTHING:rjzelse:Trz#if _config._run_validators is True:__attr_validator___attr_z(self, z, self.zself.__attrs_post_init__()rz', None)r.z '] = Nonerz = Nonerc3TK|] }|jsd|j"yw)rN)r6rars rrz(_attrs_to_init_script..s"B%Q166%x(%s((zBaseException.__init__(self, rz*, c3DK|]}|jddyw)=rN)split)rkwas rrz(_attrs_to_init_script..s#N#CIIcN1$5s r<zself.__attrs_pre_init__(rz zdef z): passrn)rpr5rr2rar>rrr?rEr1rD takes_selfr7r"r6_INIT_FACTORY_PAT_get_global_namerKrr9r._first_param_typerr7rr)%r{r is_slotted call_pre_initrcall_post_initdoes_cache_hashrrrr method_namer extra_linesr/r1r kw_only_argsattrs_to_validatenames_for_globalsrrrxr arg_name has_factory maybe_selfr7init_factory_nameargval_nameinit_hash_cachevals pre_init_args kw_arg_namepre_init_kw_only_argsNLs% rrrs((.; ( )E  3  :L:}:6K6 LL DLT"K  ;;  $ $Q 'FF T1 LL - D2D  77 G4 *qyy/C/CV ;; ":akk9+M!!++.I I 66U?$5 $A!(LL1%-!Jvv!i&7() H%&9+F+F(1(C(C H%kn'.)$ :;"A*QVV3H!AFF*I LL4z 7166(!L M*+++ h '+, i ( # 12 $./@.A"J$01B0C9"M %&7%8@O _%xxB%BB 4TF!<= 99T?DM 44R(DIIl,C+DEE $ $O#N $OK-q .#N !  B6 .. *-m_A>a B  WTF+RWWU^&)*     sZ-c$|jdS)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)lstriprs rrrs ;;s rc`eZdZdZdZ d dZdZed dZdZ dZ d Z d Z y) 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`. )rar1r2r3r:r;r<r=r5r6r8r.r7r9rr>r?Nct||xs| |xs|d\} }}}tj|}|d||d||d||d||d| |d||d||d ||d ||d ||d | |d | rtjt | nt |d| |d| |d||d||d|y)NTrar1r2r3r:r;r<r=r5r6r7r8r.r9rr>r?)r@rrtypesMappingProxyTyper_EMPTY_METADATA_SINGLETON)rrar1r2r3r4r5r6rr8r.r7r9r:r;r<r=r>r? bound_setattrs rrzAttribute.__init__C s*(B 2y1E4( $FE9 %,,T2  fd#i)k9-fd#dBh'gu%k9-fd#fd#k9- &&tH~6.   fd#i)k9-lJ/gu%rctr*)rrs rrzAttribute.__setattr__z s!!rc | |j}n|j d}t|tjDcic]}|dvr |t ||}}|d||j |j |ddd|Scc}w)Nz8Type annotation and type argument cannot both be present)rar2r1r.rF)rar2r1r.r4rr)r.rBrr-r _validator_default)rrarr.rLr@ inst_dicts rrzAttribute.from_counting_attr} s <77D WW LCS/ !((  ( wr1~ (    mmKK      sA8c ntj|}|j|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 )copy _setattrsr)rrnews rrzAttribute.evolve s(iio gmmo& rc@tfdjDS)( Play nice with pickle. c3jK|]*}|dk7r t|ntj,yw)r8N)rrr8rrars rrz)Attribute.__getstate__.. s5 &$(:#5GD$ 4 ;N N&s03rGr-rs`rrzAttribute.__getstate__ s#    rcN|jt|j|yrkN)rhrcr-rrds rrzAttribute.__setstate__ s s4>>512rc tj|}|D]A\}}|dk7r ||||||rtjt |nt Cy)Nr8)rrr]r^rr_)rname_values_pairsr`rars rrhzAttribute._setattrs sY$,,T2 ,KD%z!dE*!..tE{;6  -r) NNNFNNNNNNr*) r!r"r#r$r-rrr;rrrrrhrrrrr sb(XI<  '5&n"  <$ 3 rrr8) rar1r2r3r4r:r<r5r6rr?)r{rc|eZdZdZdZgeddDeddddddddddddddd Zd Zd Z d Z d Z y)rJa 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. )rdrcr?r7rr:r;r5r6r9r8r>r<r=r3r.c#jK|]+}t|t|tdddddddddddd-yw)NTFrar?r1r2r3r4r5r6r9r:r;r<r=rr>)rrr)rras rrz_CountingAttr. sX $ # -d3  " s13) rrdr3r:r<r5r6r>r?r8NTFrvrc2txjdz c_tj|_||_||_||_||_| |_| |_| |_ ||_ ||_ ||_ ||_ | |_| |_||_||_yr)rJ cls_counterrrdrcr7r3r:r;r<r=r5r6r8r.r9r>r?)rr1r2r3r4r5r6r7r8r.r9r:r;r<r=r>r?s rrz_CountingAttr.__init__5 s& !!Q&!$00  #"   "      $ rcf|j ||_|St|j||_|S)z Decorator that adds *meth* to the list of validators. Returns *meth* unchanged. .. versionadded:: 17.1.0 )rcrIrrs rr2z_CountingAttr.validatorZ s5 ?? ""DO #4??D9DO rcZ|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@)rdrrrDrzs rr1z_CountingAttr.defaulth s) == '( (6  r) r!r"r#r$r-rGrrrxrr2r1rrrrJrJ sI$0  $ %  0>  ?0ObK#J rrJc(eZdZdZdZddZdZdZy)rDa 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* rKr@c ||_||_yr*r})rrKr@s rrzFactory.__init__ s $rc@tfdjDS)rkc36K|]}t|ywr*r_rms rrz'Factory.__getstate__.. sD^TWT4(^srnrs`rrzFactory.__getstate__ sDT^^DDDrcZt|j|D]\}}t|||yrp)rcr-r))rrdrars rrzFactory.__setstate__ s)t~~u5KD% D$ &6rN)F)r!r"r#r$r-rrrrrrrDrD~ s$*I%E 'rrD) rar1r2r3r4r:r<r5r6rcHeZdZdZdZddddZed dZd dZdZ d Z y ) r"ae 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__rC _global_namer7 takes_fieldr@Fr@rc|_|_|_t|}|j _jsjs fd_nPjrjs fd_n-jsjr fd_n fd_|j}||j jd<yy)Nc&j|Sr*r7)rr__rs rrz$Converter.__init__.. s1Frc(j||Sr*r)rinstancerrs rrz$Converter.__init__.. sx9rc(j||Sr*r)rrr{rs rrz$Converter.__init__.. sT^^u6rc*j|||Sr*r)rrr{rs rrz$Converter.__init__.. s4>>x<rr3) r7r@rr get_first_param_typerCrget_return_typer)rr7r@rexrts` rrzConverter.__init__ s"$& !) ,!#!8!8!:4#3#3FDM __T%5%5DMT%5%5DMDM   ! >68DMM ) )( 3 rc d|S)zh Return the name that a converter for an attribute name *attr_name* would have. __attr_converter_r)rxs rrBzConverter._get_global_name s #9+..rc>|js#|js|j|d|dS|jr&|jr|j|d|d|dS|jr|j|d|dS|j|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@rrB)rrxrs rr$zConverter._fmt_converter_call s 4#3#3++I67q 1E E ??t//++I67q CVW`Vaade e ??++I67q 7K K'' 231YK}YKWZ[[rcJ|j|j|jdS)zx Return a dict containing only converter and takes_self -- the rest gets computed when loading. r7r@rrrs rrzConverter.__getstate__ s% //++  rc(|jdi|y)z+ Load instance from state. Nrrrqs rrzConverter.__setstate__ s  rN)rxrr3r)rxrrrr3r) r!r"r#r$r-rr<rBr$rrrrrr"r" s>(I16596//\"  rrc t|tr|}n.o s  $rrr!__main__r4r:r<Trr)rErrFrGrMrApopr0r] new_classr%r&r'rBr _getframe f_globalsrr"rrrr.r)rar{bases class_bodyattributes_argumentscls_dictrrLrr user_inittype_r4rr@rArs @r make_classr1 sP% ED%= ))./AAvxK/8n||0$7H 2D9I Z.I D J%- !"&/ "#$Z OOD%-G HE   ^Z 8==+5599    9  " "5$ /C "   &  )  T"W% 9& 8x 8#7 8 ?C'nn..da!&&2D166 .C J_02 9 8&sG*5GG)GG)r rc$eZdZdZeZdZy) _AndValidatorz2 Compose many validators to a single one. c:|jD] }||||yr*) _validators)rrrrrAs rrz_AndValidator.__call__ s!!A dD% "rN)r!r"r#r$rMrrrrrrr s(K!rrcg}|D]0}|jt|tr |jn|g2tt |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 )rrErrrG) validatorsrTr2s rrIrI sJ D  )]3  ! !   t %%rctdD}|rfd}nfd}s4tjd}|jj ||dn~t dj }|r||jd<d}tst|tr |j}t |j}|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|tywr*rEr")rcs rrzpipe.. sGJq*Q 2JscZD]$}t|tr ||||n||}&|Sr*r)rrr{r converterss rpipe_converterzpipe..pipe_converter s4+5a+CAc4'3 Jrc&D] }||} |Sr*r)rrrs rrzpipe..pipe_converter sf JrA)rr3rrrYr3Tr) rtypingTypeVarrr0r rr rEr"rr)rreturn_instancerrtlastrs` rrHrH s GJGGO    NN3 &&--a1.EF !A / D D F 45N * *5 1"~ 4 ;==D"$ ' 7 7 9 79N * *8 4DdKK r)Nr7r*)T)NNNNNNNFFTFFFFFNNFFNNNTN)NNr2r4)rxrrrr rr3r)rrr rrdict[str, type])r{zlist[Attribute]rrrDrrErrrrFrrGrrrrrrrrrrHrr3ztuple[str, dict, dict])rarr3r)e __future__rrr%rgr%r1rr8r^rr]roperatorrr7rrrr r r r r r exceptionsrrrrobjectrrrArr7r^r_r$rHr r r Enumrrintr(rMrWrgryrzrrrrrrrrrrrr@rr{rrrrmrrrrrrRrrr rrsr!r&r(r*r5rrrr-_arar5rJrD_fr"rrrI)rars00rrsu#   ('!! ')2E2226 H "gll7??G4D4DEtyy(    ( ("        hV :":%  0"'#>%8jGZ7t"7tFFR8((X.26         1]@  /DDN&#BL5*p 6r+\&:.$/L^3]]"]48]EN]]) W W" W48 WEN W W,/ ,/,/.=,/^A AAA A  A  AA#A AAAAAHHHr##$    j %d+ $"  )2&6"Q+ 5q"6 =bAFFqvv'<1b =   QQh -01 $'$'h!!"       " GIgR8C2 Naab;;       ;  Iir *"5R  yTZBTt$ ! !% !&.9S(7 =Dns0-#M$M 9M M M *M &M*M