U
|
L ±dÓz ã @ s@ d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ ddlm Z m
|
Z
|
m Z ddl m Z m Z mZmZ ddlmZmZmZmZ ejZdZdZd Zd
|
Ze i ¡Z e Z e e j e j!¡Z"G d d d ej#Z$e$j%Z%G d d de&Z'e%ddddddddddddddfddZ(dyddZ)dd Z*dd Z+e+ddd d gZ,d d Z-d d! Z.d"d# Z/d$d% Z0d&d' Z1d(d) Z2d*d+ Z3d,d- Z4G d.d/ d/Z5d0d1 Z6d2d3 Z7dzd4d5Z8d{d6dZ9e9Z:d7d8 Z;d9d: Z<d;d< Z=d=d> Z>d?d@ Z?dAdB Z@dCdD ZAd|dEdFZBdGdH ZCd}dIdJZDdKdL ZEdMdN ZFdOdP Z!dQdR ZGdSdT ZHdUdV ZIdWdX ZJdYdZ ZKd[d\ ZLd]d^ ZMd_d` ZNeOeOdadbdcZPG ddde deZQdfdg eQjRD ZSe>eBeDeQeSdhdidg eSD dhdjdg eSD dhZQG dkdl dlZTeBeDeTZTG dmdn dnZUdodg eUjRD ZVe>eBeDeUeVdheVdheVdhZUeffdpdqZWe9dddrG dsdt dtZXdudv ZYdwdx Z dS )~é N)Ú
|
itemgetteré )Ú_compatÚ_configÚsetters)ÚPY310Ú_AnnotationExtractorÚget_generic_baseÚset_closure_cell)ÚDefaultAlreadySetErrorÚFrozenInstanceErrorÚNotAnAttrsClassErrorÚUnannotatedAttributeErrorz__attr_converter_%sz__attr_factory_%s)ztyping.ClassVarz
|
t.ClassVarÚClassVarztyping_extensions.ClassVarZ_attrs_cached_hashc @ s( e Zd ZdZe ¡ Zdd Zdd ZdS )Ú_NothingaH
|
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.
|
c C s dS )NÚNOTHING© ©Úselfr r úAd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\attr/_make.pyÚ__repr__A s z_Nothing.__repr__c C s dS )NFr r r r r Ú__bool__D s z_Nothing.__bool__N) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__ÚenumÚautor r r r r r r r 4 s
|
r c @ s" e Zd ZdZeddfddZdS )Ú_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.
|
Nr c C s ||fS ©Nr )r Z_none_constructorÚ_argsr r r Ú
|
__reduce__Z s z _CacheHashWrapper.__reduce__)r r r r Útyper! r r r r r N s r TFc C sæ t || | d\} }} }|dk r6|dk r6|dk r6td| dk rf| tk rNtdt| s^tdt| } |dkrri }t| ttfrt j
|
| } |r¤t|ttfr¤t | }|r¾t|ttfr¾t
|
| }t | ||d||||||
|
| || || |dS )aä
|
Create a new attribute on a class.
|
|
.. warning::
|
|
Does *not* do anything unless the class is also decorated with
|
`attr.s` / `attrs.define` / et cetera!
|
|
Please consider using `attrs.field` in new code (``attr.ib`` will *never*
|
go away, though).
|
|
:param default: A value that is used if an *attrs*-generated ``__init__``
|
is used and no value is passed while instantiating or the attribute is
|
excluded using ``init=False``.
|
|
If the value is an instance of `attrs.Factory`, its callable will be
|
used to construct a new value (useful for mutable data types like lists
|
or dicts).
|
|
If a default is not set (or set manually to `attrs.NOTHING`), a value
|
*must* be supplied when instantiating; otherwise a `TypeError`
|
will be raised.
|
|
The default can also be set using decorator notation as shown below.
|
|
:type default: Any value
|
|
:param callable factory: Syntactic sugar for
|
``default=attr.Factory(factory)``.
|
|
:param validator: `callable` that is called by *attrs*-generated
|
``__init__`` methods after the instance has been initialized. They
|
receive the initialized instance, the :func:`~attrs.Attribute`, and the
|
passed value.
|
|
The return value is *not* inspected so the validator has to throw an
|
exception itself.
|
|
If a `list` is passed, its items are treated as validators and must
|
all pass.
|
|
Validators can be globally disabled and re-enabled using
|
`attrs.validators.get_disabled` / `attrs.validators.set_disabled`.
|
|
The validator can also be set using decorator notation as shown below.
|
|
:type validator: `callable` or a `list` of `callable`\ s.
|
|
:param repr: Include this attribute in the generated ``__repr__``
|
method. If ``True``, include the attribute; if ``False``, omit it. By
|
default, the built-in ``repr()`` function is used. To override how the
|
attribute value is formatted, pass a ``callable`` that takes a single
|
value and returns a string. Note that the resulting string is used
|
as-is, i.e. it will be used directly *instead* of calling ``repr()``
|
(the default).
|
:type repr: a `bool` or a `callable` to use a custom function.
|
|
:param eq: If ``True`` (default), include this attribute in the
|
generated ``__eq__`` and ``__ne__`` methods that check two instances
|
for equality. To override how the attribute value is compared,
|
pass a ``callable`` that takes a single value and returns the value
|
to be compared.
|
:type eq: a `bool` or a `callable`.
|
|
:param order: If ``True`` (default), include this attributes in the
|
generated ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods.
|
To override how the attribute value is ordered,
|
pass a ``callable`` that takes a single value and returns the value
|
to be ordered.
|
:type order: a `bool` or a `callable`.
|
|
:param cmp: Setting *cmp* is equivalent to setting *eq* and *order* to the
|
same value. Must not be mixed with *eq* or *order*.
|
:type cmp: a `bool` or a `callable`.
|
|
:param Optional[bool] hash: Include this attribute in the generated
|
``__hash__`` method. If ``None`` (default), mirror *eq*'s value. This
|
is the correct behavior according the Python spec. Setting this value
|
to anything else than ``None`` is *discouraged*.
|
:param bool init: Include this attribute in the generated ``__init__``
|
method. It is possible to set this to ``False`` and set a default
|
value. In that case this attributed is unconditionally initialized
|
with the specified default value or factory.
|
:param callable converter: `callable` that is called by
|
*attrs*-generated ``__init__`` methods to convert attribute's value
|
to the desired format. It is given the passed-in value, and the
|
returned value will be used as the new value of the attribute. The
|
value is converted before being passed to the validator, if any.
|
:param metadata: An arbitrary mapping, to be used by third-party
|
components. See `extending-metadata`.
|
|
:param type: The type of the attribute. Nowadays, the preferred method to
|
specify the type is using a variable annotation (see :pep:`526`).
|
This argument is provided for backward compatibility.
|
Regardless of the approach used, the type will be stored on
|
``Attribute.type``.
|
|
Please note that *attrs* doesn't do anything with this metadata by
|
itself. You can use it as part of your own code or for
|
`static type checking <types>`.
|
:param kw_only: Make this attribute keyword-only in the generated
|
``__init__`` (if ``init`` is ``False``, this parameter is ignored).
|
:param on_setattr: Allows to overwrite the *on_setattr* setting from
|
`attr.s`. If left `None`, the *on_setattr* value from `attr.s` is used.
|
Set to `attrs.setters.NO_OP` to run **no** `setattr` hooks for this
|
attribute -- regardless of the setting in `attr.s`.
|
:type on_setattr: `callable`, or a list of callables, or `None`, or
|
`attrs.setters.NO_OP`
|
:param Optional[str] alias: Override this attribute's parameter name in the
|
generated ``__init__`` method. If left `None`, default to ``name``
|
stripped of leading underscores. See `private-attributes`.
|
|
.. 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*
|
TNFú6Invalid 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Ú validatorÚreprÚcmpÚhashÚinitÚ converterÚmetadatar" Úkw_onlyÚeqÚeq_keyÚorderÚ order_keyÚ
|
on_setattrÚalias) Ú_determine_attrib_eq_orderÚ TypeErrorr Ú
|
ValueErrorÚcallableÚFactoryÚ
|
isinstanceÚlistÚtupler ÚpipeÚand_Ú _CountingAttr)r$ r% r& r' r( r) r+ r" r* Úfactoryr, r- r/ r1 r2 r. r0 r r r Úattrib^ sZ ÿ ÿÿ
|
ðr? Ú c C s t | |d}t||| dS )zU
|
"Exec" the script with the given global (globs) and local (locs) variables.
|
ÚexecN)ÚcompileÚeval)ÚscriptÚglobsÚlocsÚfilenameÚbytecoder r r Ú_compile_and_eval* s rI c C st i }d}|}t |d| d¡|f}tj ||¡}||kr<q^q |dd
d| d}|d7 }q t|||| || S )zO
|
Create the method with the script given and return the method object.
|
r NTéÿÿÿÿú-ú>)ÚlenÚ
|
splitlinesÚ linecacheÚcacheÚ
|
setdefaultrI ) ÚnamerD rG rE rF ÚcountÚ base_filenameZlinecache_tupleZold_valr r r Ú _make_method2 s ü
|
rU c C sv | d}d| ddg}|rJt |D ] \}}| d| d| d¡ q&n
|
| d¡ ttd }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))
|
Z
|
Attributeszclass z(tuple):z __slots__ = ()ú z% = _attrs_property(_attrs_itemgetter(ú))z pass)Z_attrs_itemgetterZ_attrs_propertyÚ
|
)Ú enumerateÚappendr ÚpropertyrI Újoin)Zcls_nameÚ
|
attr_namesZattr_class_nameZattr_class_templateÚiÚ attr_namerE r r r Ú_make_attr_tuple_classO s
|
|
|
þÿ
|
|
r` Ú _AttributesÚattrsÚ
|
base_attrsZbase_attrs_mapc C s2 t | } | d¡r(| d¡r(| dd
} | t¡S )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 rJ )ÚstrÚ
|
startswithÚendswithÚ_classvar_prefixes)Zannotr r r Ú _is_class_vary s rj c C sJ t | |t}|tkrdS | jdd
D ] }t ||d}||kr& dS q&dS )zR
|
Check whether *cls* defines *attrib_name* (and doesn't just inherit it).
|
Fr NT)ÚgetattrÚ _sentinelÚ__mro__)ÚclsZ attrib_nameÚattrÚbase_clsÚar r r Ú_has_own_attribute s rr c C s t | dr| jS i S )z$
|
Get annotations for *cls*.
|
Ú__annotations__)rr rs ©rn r r r Ú_get_annotations s
|
ru c C s¨ g }i }t | jdd
D ]H}t|dg D ]6}|js*|j|kr@q*|jdd}| |¡ |||j< q*qg }t }t |D ](}|j|krqv| d|¡ | |j¡ qv||fS )zQ
|
Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
|
r rJ Ú__attrs_attrs__T©Ú inheritedr )
|
Úreversedrm rk rx rR ÚevolverZ ÚsetÚinsertÚadd)rn Útaken_attr_namesrc Ú base_attr_maprp rq ÚfilteredÚseenr r r Ú_collect_base_attrs¤ s"
|
|
r c C sn g }i }| j dd
D ]N}t|dg D ]<}|j|kr6q&|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 rJ rv Trw )rm rk rR rz r} rZ )rn r~ rc r rp rq r r r Ú_collect_base_attrs_brokenà s
|
|
r c s& | j t| |dk r*dd | ¡ D }nâ|dkrîdd ¡ D }g }t } ¡ D ]Z\} }
|
t|
|
rhqV| | ¡ | t¡} t| t s¢| tkrt
|
} n
|
t
|
| d} | | | f¡ qV|| } t | dkrìt d d
|
t| fd d d ¡ d n tdd ¡ D dd d } fdd|D } |r>t| dd | D \}}nt| dd | D \}}|rxdd | D } dd |D }|| }d}dd |D D ]D} |dkrº| jtkrºtd| |dkr| jtk rd}q|dk rì|| |}dd |D }dd |D }t| j|}t||||fS ) a0
|
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.
|
|
*collect_by_mro* is True, collect them in the correct MRO order, otherwise
|
use the old -- incorrect -- order. See #428.
|
|
Return an `_Attributes`.
|
Nc S s g | ]\}}||fqS r r )Ú.0rR Úcar r r Ú
|
<listcomp>ð s z$_transform_attrs.<locals>.<listcomp>Tc S s h | ]\}}t |tr|qS r ©r8 r= ©r rR ro r r r Ú <setcomp>ò s
|
þz#_transform_attrs.<locals>.<setcomp>©r$ r z1The following `attr.ib`s lack a type annotation: ú, c s | ¡jS r )ÚgetÚcounter)Ún)Úcdr r Ú<lambda> ó z"_transform_attrs.<locals>.<lambda>)ÚkeyÚ.c s s$ | ] \}}t |tr||fV qd S r r r r r r Ú <genexpr> s
|
þz#_transform_attrs.<locals>.<genexpr>c S s
|
| d j S ©Nr )r )Úer r r r r c s& g | ] \}}t j|| |¡d qS ))rR r
r" )Ú AttributeÚfrom_counting_attrr )r r_ r
)Úannsr r r s ý ÿc S s h | ]
|
}|j qS r ©rR ©r rq r r r r " s c S s h | ]
|
}|j qS r r r r r r r & s c S s g | ]}|j d dqS ©T)r, ©rz r r r r r * s c S s g | ]}|j d dqS r r r r r r r + s Fc s s& | ] }|j d k r|jd kr|V qdS )FN)r) r, r r r r r 4 s
|
|
zlNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: c S s( g | ] }|j s |jt|jd n|qS ))r2 )r2 rz Ú_default_init_alias_forrR r r r r r D s ÿc S s g | ]
|
}|j qS r r r r r r r K s )Ú__dict__ru Úitemsr{ rj r} r r r8 r= r? rZ rM r r\ Úsortedr r r$ r5 r` r ra )rn ÚtheseÚ auto_attribsr, Úcollect_by_mroÚfield_transformerZca_listZca_namesZ annot_namesr_ r" rq Z unannotatedZ own_attrsrc r rb Z had_defaultr] Z
|
AttrsClassr )r r r Ú_transform_attrsß s þ
|
|
|
ÿÿüÿþú
|
ü ÿ
|
ÿÿ
|
|
þ r¦ c C s. t | tr$|dkr$t | ||¡ dS t dS )z4
|
Attached to frozen classes as __setattr__.
|
)Ú __cause__Ú __context__Ú __traceback__N)r8 Ú BaseExceptionÚ __setattr__r ©r rR Úvaluer r r Ú_frozen_setattrsQ s r® c C s
|
t dS )z4
|
Attached to frozen classes as __delattr__.
|
N©r )r rR r r r Ú_frozen_delattrs` s r° c @ s² e Zd ZdZdZdd Zdd Zer6ddlZd d
|
Z nd d
|
Z d d Z
|
dd Z dd Z dd Z dd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' ZdS )(Ú _ClassBuilderz(
|
Iteratively build *one* class.
|
)Ú _attr_namesÚ_attrsÚ_base_attr_mapÚ _base_namesÚ _cache_hashÚ_clsÚ _cls_dictÚ_delete_attribsÚ_frozenÚ _has_pre_initÚ_has_post_initÚ_is_excÚ _on_setattrÚ_slotsÚ _weakref_slotÚ_wrote_own_setattrÚ_has_custom_setattrc C sª t ||||| |\}}}|| _|r,t|jni | _|| _dd |D | _|| _tdd |D | _ || _
|
|| _ || _ | | _ tt|dd| _tt|dd| _t| | _|
|
| _| | _| | _d| _| j| jd< |rît| jd < t| jd
|
< d | _n| ttjtj fkrd }}|D ]8}|j d k r"d }|j d k r2d }|r|r qHq| tkr^|s^|r| tjkrp|r| tj kr|sd | _|r¦| ¡ \| jd < | jd < d S )Nc S s h | ]
|
}|j qS r r r r r r r s z)_ClassBuilder.__init__.<locals>.<setcomp>c s s | ] }|j V qd S r r r r r r r s z)_ClassBuilder.__init__.<locals>.<genexpr>Ú__attrs_pre_init__FÚ__attrs_post_init__rv r« Ú __delattr__TÚ __getstate__Ú __setstate__) r¦ r· Údictr r¸ r³ rµ r´ r: r² r¿ rº rÀ r¶ Úboolrk r» r¼ r¹ r½ r¾ r rÁ r® r° Ú_ng_default_on_setattrr ÚvalidateÚconvertr% r* Ú_make_getstate_setstate)r rn r¢ ÚslotsÚfrozenÚ weakref_slotÚgetstate_setstater£ r, Ú
|
cache_hashÚis_excr¤ r1 Zhas_custom_setattrr¥ rb rc Zbase_mapZ has_validatorZ has_converterrq r r r Ú__init__ s ú
|
|
|
ý
|
þýýûûúú ýþz_ClassBuilder.__init__c C s d| j j dS )Nz<_ClassBuilder(cls=z)>)r· r r r r r r Õ s z_ClassBuilder.__repr__r Nc C s" | j dkr| ¡ S | j | ¡ ¡S ©z
|
Finalize class based on the accumulated configuration.
|
|
Builder cannot be used after calling this method.
|
T)r¿ Ú_create_slots_classÚabcZupdate_abstractmethodsÚ_patch_original_classr r r r Ú build_classÛ s
|
|
ÿz_ClassBuilder.build_classc C s | j dkr| ¡ S | ¡ S rÕ )r¿ rÖ rØ r r r r rÙ ê s
|
c C s¢ | j }| j}| jrZ| jD ]@}||krt||ttk rzt|| W q tk
|
rV Y qX q| j ¡ D ]\}}t
|
||| qd| j st|ddrd|_ | j st|_|S )zA
|
Apply accumulated methods and return the class.
|
Ú__attrs_own_setattr__F)r· rµ r¹ r² rk rl ÚdelattrÚAttributeErrorr¸ r ÚsetattrrÁ rÚ rÂ Ú _obj_setattrr« )r rn Ú
|
base_namesrR r r r r rØ õ s.
|
ÿþ ÿz#_ClassBuilder._patch_original_classc
|
|
s fddj ¡ D }jsTd|d< jsTjjD ] j dd¡r4t|d< qTq4t }d}jj
|
dd
D ]: j dd ¡d k rd
|
}| fd dt d g D ¡ qnt jj}jrædt jd d kræd|kræ|sæ|d7 }fdd|D fdd| ¡ D fddD | ¡ jr< t¡ t|d < jj|d< tjjjjj|}|j ¡ D ]}t|ttfrt |j dd }n(t|t r¸t |j dd }n t |dd }|sÎqx|D ]>}z|j jk} W n t k
|
rü Y nX | rÒt!|| qÒqx|S )zL
|
Build and return a new class with a `__slots__` attribute.
|
c s( i | ] \}}|t jd kr||qS ))r Ú __weakref__)r: r² )r ÚkÚvr r r Ú
|
<dictcomp> s þ z5_ClassBuilder._create_slots_class.<locals>.<dictcomp>FrÚ r« r rJ rà NTc s i | ]}|t |qS r ©rk ©r rR )rp r r rã > s ÿ Ú __slots__r )rà c s g | ]}| kr|qS r r rå )rß r r r Q s z5_ClassBuilder._create_slots_class.<locals>.<listcomp>c s i | ]\}}| kr||qS r r )r ZslotZslot_descriptor)Ú
|
slot_namesr r rã V s þ c s g | ]}| kr|qS r r rå )Ú reused_slotsr r r [ s r Ú __closure__)"r¸ r rÁ r r· Ú __bases__r r rÞ rÈ rm Úupdaterk r{ rµ r² rÀ r¶ rZ Ú_hash_cache_fieldr: r r" r Úvaluesr8 Ú classmethodÚ staticmethodÚ__func__r[ ÚfgetÚ cell_contentsr5 r
|
)
|
r r Zexisting_slotsZweakref_inheritedÚnamesrn ÚitemZ closure_cellsÚcellÚmatchr )rp rß rè r rç r rÖ st
|
þ
|
|
þÿ
|
ÿþýü
|
þ
|
|
z!_ClassBuilder._create_slots_classc C s | t| j|| j¡| jd< | S )Nr )Ú_add_method_dundersÚ
|
_make_reprr³ r· r¸ )r Únsr r r Úadd_repr
s ÿ
|
z_ClassBuilder.add_reprc C s8 | j d¡}|d kr tddd }| |¡| j d< | S )Nr z3__str__ can only be generated if a __repr__ exists.c S s | ¡ S r ©r r r r r Ú__str__ s z&_ClassBuilder.add_str.<locals>.__str__rü )r¸ r r5 r÷ )r r& rü r r r Úadd_str s ÿz_ClassBuilder.add_strc s< t dd | jD fdd}| j fdd}||fS )zF
|
Create custom __setstate__ and __getstate__ methods.
|
c s s | ]}|d kr|V qdS )rà Nr )r Zanr r r r s z8_ClassBuilder._make_getstate_setstate.<locals>.<genexpr>c s fddD S )ú9
|
Automatically created by attrs.
|
c s i | ]}|t |qS r rä rå r r r rã ¥ s zQ_ClassBuilder._make_getstate_setstate.<locals>.slots_getstate.<locals>.<dictcomp>r r )Ústate_attr_namesr r Úslots_getstate¡ s z=_ClassBuilder._make_getstate_setstate.<locals>.slots_getstatec sf t | ¡}t|tr4t|D ]\}}||| q n D ]}||kr8|||| q8 rb|td dS )rþ N)rÞ Ú__get__r8 r: Úziprì )r ÚstateZ _ClassBuilder__bound_setattrrR r ©Zhash_caching_enabledrÿ r r Úslots_setstate© s
|
|
z=_ClassBuilder._make_getstate_setstate.<locals>.slots_setstate)r: r² r¶ )r r r r r r rÍ s ÿ z%_ClassBuilder._make_getstate_setstatec C s d | j d< | S )NÚ__hash__)r¸ r r r r Úmake_unhashableÁ s
|
z _ClassBuilder.make_unhashablec C s( | t| j| j| j| jd¡| jd< | S )N©rÏ rÒ r )r÷ Ú
|
_make_hashr· r³ rº r¶ r¸ r r r r Úadd_hashÅ s üÿ
|
z_ClassBuilder.add_hashc C sB | t| j| j| j| j| j| j| j| j | j
|
| j dd ¡| j d< | S )NF©Ú
|
attrs_initrÔ © r÷ Ú
|
_make_initr· r³ r» r¼ rº r¿ r¶ r´ r½ r¾ r¸ r r r r Úadd_initÑ s õÿ
|
z_ClassBuilder.add_initc C s t dd | jD | jd< d S )Nc s s | ]}|j r|js|jV qd S r )r) r, rR )r Úfieldr r r r å s þz/_ClassBuilder.add_match_args.<locals>.<genexpr>Ú__match_args__)r: r³ r¸ r r r r Úadd_match_argsä s þz _ClassBuilder.add_match_argsc C sB | t| j| j| j| j| j| j| j| j | j
|
| j dd ¡| j d< | S )NTr Ú__attrs_init__r r r r r Úadd_attrs_initë s õÿ
|
z _ClassBuilder.add_attrs_initc C s2 | j }| t| j| j¡|d< | t ¡|d< | S )NÚ__eq__Ú__ne__)r¸ r÷ Ú_make_eqr· r³ Ú_make_ne©r r r r r Úadd_eqþ s ÿz_ClassBuilder.add_eqc s> j } fddt j jD \|d< |d< |d< |d< S )Nc 3 s | ]} |¡V qd S r )r÷ )r Úmethr r r r s ÿz*_ClassBuilder.add_order.<locals>.<genexpr>Ú__lt__Ú__le__Ú__gt__Ú__ge__)r¸ Ú _make_orderr· r³ r r r r Ú add_order s
|
|
þ z_ClassBuilder.add_orderc s | j r
|
| S i | jD ],}|jp"| j}|r|tjk r||f |j< q sJ| S | jrXtd fdd}d| j d< |
|
|¡| j d< d| _ | S )Nz7Can't combine custom __setattr__ with on_setattr hooks.c sF z | \}}W n t k
|
r( |}Y nX || ||}t| || d S r )ÚKeyErrorrÞ )r rR Úvalrq ÚhookÚnval©Zsa_attrsr r r« & s
|
z._ClassBuilder.add_setattr.<locals>.__setattr__TrÚ r« ) rº r³ r1 r¾ r ÚNO_OPrR r r5 r¸ r÷ rÁ )r rq r1 r« r r& r Ú add_setattr s$
|
ÿ
|
|
z_ClassBuilder.add_setattrc C s z| j j|_W n tk
|
r" Y nX zd | j j|jf¡|_W n tk
|
rR Y nX zd| j j d|_W n tk
|
r~ Y nX |S )zL
|
Add __module__ and __qualname__ to a *method* if possible.
|
r z$Method generated by attrs for class )r· r rÜ r\ r r r )r Úmethodr r r r÷ 6 s ÿ
|
ÿz!_ClassBuilder._add_method_dunders)r r r r ræ rÔ r r r× rÙ rØ rÖ rú rý rÍ r r
|
r r r r r! r( r÷ r r r r r± g s, U
|
&j )
|
|
$r± c C sl | dk r$t |dk |dk fr$td| dk r4| | fS |dkr@|}|dkrL|}|dkrd|dkrdtd||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.©Úanyr5 )r' r- r/ Ú
|
default_eqr r r Ú_determine_attrs_eq_orderQ s r0 c C s° | dk r$t |dk |dk fr$tddd }| dk rL|| \} }| || |fS |dkr`|d }}n ||\}}|dkr|| }}n ||\}}|dkr¤|dkr¤td||||fS )r* Nr+ c S s t | rd| } }nd}| |fS )z8
|
Decide whether a key function is used.
|
TN)r6 )r r r r r Údecide_callable_or_booleans s z>_determine_attrib_eq_order.<locals>.decide_callable_or_booleanFTr, r- )r' r- r/ r/ r1 Zcmp_keyr. r0 r r r r3 k s r3 c C sF |dks|dkr|S |dkr(|dkr(|S |D ]}t | |r, dS q,|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)rr )rn ÚflagÚ auto_detectZdundersr$ Zdunderr r r Ú _determine_whether_to_implement s
|
r4 c s t |||d\|dk r | t ttfr6tj
|
fdd}| dkrv|S || S dS )a4
|
A class decorator that adds :term:`dunder methods` according to the
|
specified attributes using `attr.ib` or the *these* argument.
|
|
Please consider using `attrs.define` / `attrs.frozen` in new code
|
(``attr.s`` will *never* go away, though).
|
|
:param these: A dictionary of name to `attr.ib` mappings. This is
|
useful to avoid the definition of your attributes within the class body
|
because you can't (e.g. if you want to add ``__repr__`` methods to
|
Django models) or don't want to.
|
|
If *these* is not ``None``, *attrs* will *not* search the class body
|
for attributes and will *not* remove any attributes from it.
|
|
The order is deduced from the order of the attributes inside *these*.
|
|
:type these: `dict` of `str` to `attr.ib`
|
|
:param str repr_ns: When using nested classes, there's no way in Python 2
|
to automatically detect that. Therefore it's possible to set the
|
namespace explicitly for a more meaningful ``repr`` output.
|
:param bool auto_detect: Instead of setting the *init*, *repr*, *eq*,
|
*order*, and *hash* arguments explicitly, assume they are set to
|
``True`` **unless any** of the involved methods for one of the
|
arguments is implemented in the *current* class (i.e. it is *not*
|
inherited from some base class).
|
|
So for example by implementing ``__eq__`` on a class yourself,
|
*attrs* will deduce ``eq=False`` and will create *neither*
|
``__eq__`` *nor* ``__ne__`` (but Python classes come with a sensible
|
``__ne__`` by default, so it *should* be enough to only implement
|
``__eq__`` in most cases).
|
|
.. warning::
|
|
If you prevent *attrs* from creating the ordering methods for you
|
(``order=False``, e.g. by implementing ``__le__``), it becomes
|
*your* responsibility to make sure its ordering is sound. The best
|
way is to use the `functools.total_ordering` decorator.
|
|
|
Passing ``True`` or ``False`` to *init*, *repr*, *eq*, *order*,
|
*cmp*, or *hash* overrides whatever *auto_detect* would determine.
|
|
:param bool repr: Create a ``__repr__`` method with a human readable
|
representation of *attrs* attributes..
|
:param bool str: Create a ``__str__`` method that is identical to
|
``__repr__``. This is usually not necessary except for
|
`Exception`\ s.
|
:param Optional[bool] eq: If ``True`` or ``None`` (default), add ``__eq__``
|
and ``__ne__`` methods that check two instances for equality.
|
|
They compare the instances as if they were tuples of their *attrs*
|
attributes if and only if the types of both classes are *identical*!
|
:param Optional[bool] order: If ``True``, add ``__lt__``, ``__le__``,
|
``__gt__``, and ``__ge__`` methods that behave like *eq* above and
|
allow instances to be ordered. If ``None`` (default) mirror value of
|
*eq*.
|
:param Optional[bool] cmp: Setting *cmp* is equivalent to setting *eq*
|
and *order* to the same value. Must not be mixed with *eq* or *order*.
|
:param Optional[bool] unsafe_hash: If ``None`` (default), the ``__hash__``
|
method is generated according how *eq* and *frozen* are set.
|
|
1. If *both* are True, *attrs* will generate a ``__hash__`` for you.
|
2. If *eq* is True and *frozen* is False, ``__hash__`` will be set to
|
None, marking it unhashable (which it is).
|
3. If *eq* is False, ``__hash__`` will be left untouched meaning the
|
``__hash__`` method of the base class will be used (if base class is
|
``object``, this means it will fall back to id-based hashing.).
|
|
Although not recommended, you can decide for yourself and force
|
*attrs* to create one (e.g. if the class is immutable even though you
|
didn't freeze it programmatically) by passing ``True`` or not. Both of
|
these cases are rather special and should be used carefully.
|
|
See our documentation on `hashing`, Python's documentation on
|
`object.__hash__`, and the `GitHub issue that led to the default \
|
behavior <https://github.com/python-attrs/attrs/issues/136>`_ for more
|
details.
|
:param Optional[bool] hash: Alias for *unsafe_hash*. *unsafe_hash* takes
|
precedence.
|
:param bool init: Create a ``__init__`` method that initializes the
|
*attrs* attributes. Leading underscores are stripped for the argument
|
name. If a ``__attrs_pre_init__`` method exists on the class, it will
|
be called before the class is initialized. If a ``__attrs_post_init__``
|
method exists on the class, it will be called after the class is fully
|
initialized.
|
|
If ``init`` is ``False``, an ``__attrs_init__`` method will be
|
injected instead. This allows you to define a custom ``__init__``
|
method that can do pre-init work such as ``super().__init__()``,
|
and then call ``__attrs_init__()`` and ``__attrs_post_init__()``.
|
:param bool slots: Create a :term:`slotted class <slotted classes>` that's
|
more memory-efficient. Slotted classes are generally superior to the
|
default dict classes, but have some gotchas you should know about, so
|
we encourage you to read the :term:`glossary entry <slotted classes>`.
|
:param bool frozen: Make instances immutable after initialization. If
|
someone attempts to modify a frozen instance,
|
`attrs.exceptions.FrozenInstanceError` is raised.
|
|
.. note::
|
|
1. This is achieved by installing a custom ``__setattr__`` method
|
on your class, so you can't implement your own.
|
|
2. True immutability is impossible in Python.
|
|
3. This *does* have a minor a runtime performance `impact
|
<how-frozen>` when initializing new instances. In other words:
|
``__init__`` is slightly slower with ``frozen=True``.
|
|
4. If a class is frozen, you cannot modify ``self`` in
|
``__attrs_post_init__`` or a self-written ``__init__``. You can
|
circumvent that limitation by using
|
``object.__setattr__(self, "attribute_name", value)``.
|
|
5. Subclasses of a frozen class are frozen too.
|
|
:param bool weakref_slot: Make instances weak-referenceable. This has no
|
effect unless ``slots`` is also enabled.
|
:param bool auto_attribs: If ``True``, collect :pep:`526`-annotated
|
attributes from the class body.
|
|
In this case, you **must** annotate every field. If *attrs*
|
encounters a field that is set to an `attr.ib` but lacks a type
|
annotation, an `attr.exceptions.UnannotatedAttributeError` is
|
raised. Use ``field_name: typing.Any = attr.ib(...)`` if you don't
|
want to set a type.
|
|
If you assign a value to those attributes (e.g. ``x: int = 42``), that
|
value becomes the default value like if it were passed using
|
``attr.ib(default=42)``. Passing an instance of `attrs.Factory` also
|
works as expected in most cases (see warning below).
|
|
Attributes annotated as `typing.ClassVar`, and attributes that are
|
neither annotated nor set to an `attr.ib` are **ignored**.
|
|
.. warning::
|
For features that use the attribute name to create decorators (e.g.
|
:ref:`validators <validators>`), you still *must* assign `attr.ib`
|
to them. Otherwise Python will either not find the name or try to
|
use the default value to call e.g. ``validator`` on it.
|
|
These errors can be quite confusing and probably the most common bug
|
report on our bug tracker.
|
|
:param bool kw_only: Make all attributes keyword-only
|
in the generated ``__init__`` (if ``init`` is ``False``, this
|
parameter is ignored).
|
:param bool cache_hash: Ensure that the object's hash code is computed
|
only once and stored on the object. If this is set to ``True``,
|
hashing must be either explicitly or implicitly enabled for this
|
class. If the hash code is cached, avoid any reassignments of
|
fields involved in hash code computation or mutations of the objects
|
those fields point to after object creation. If such changes occur,
|
the behavior of the object's hash code is undefined.
|
:param bool auto_exc: If the class subclasses `BaseException`
|
(which implicitly includes any subclass of any exception), the
|
following happens to behave like a well-behaved Python exceptions
|
class:
|
|
- the values for *eq*, *order*, and *hash* are ignored and the
|
instances compare and hash by the instance's ids (N.B. *attrs* will
|
*not* remove existing implementations of ``__hash__`` or the equality
|
methods. It just won't add own ones.),
|
- all attributes that are either passed into ``__init__`` or have a
|
default value are additionally available as a tuple in the ``args``
|
attribute,
|
- the value of *str* is ignored leaving ``__str__`` to base classes.
|
:param bool collect_by_mro: Setting this to `True` fixes the way *attrs*
|
collects attributes from base classes. The default behavior is
|
incorrect in certain cases of multiple inheritance. It should be on by
|
default but is kept off for backward-compatibility.
|
|
See issue `#428 <https://github.com/python-attrs/attrs/issues/428>`_ for
|
more details.
|
|
:param Optional[bool] getstate_setstate:
|
.. note::
|
This is usually only interesting for slotted classes and you should
|
probably just set *auto_detect* to `True`.
|
|
If `True`, ``__getstate__`` and
|
``__setstate__`` are generated and attached to the class. This is
|
necessary for slotted classes to be pickleable. If left `None`, it's
|
`True` by default for slotted classes and ``False`` for dict classes.
|
|
If *auto_detect* is `True`, and *getstate_setstate* is left `None`,
|
and **either** ``__getstate__`` or ``__setstate__`` is detected directly
|
on the class (i.e. not inherited), it is set to `False` (this is usually
|
what you want).
|
|
:param on_setattr: A callable that is run whenever the user attempts to set
|
an attribute (either by assignment like ``i.x = 42`` or by using
|
`setattr` like ``setattr(i, "x", 42)``). It receives the same arguments
|
as validators: the instance, the attribute that is being modified, and
|
the new value.
|
|
If no exception is raised, the attribute is set to the return value of
|
the callable.
|
|
If a list of callables is passed, they're automatically wrapped in an
|
`attrs.setters.pipe`.
|
:type on_setattr: `callable`, or a list of callables, or `None`, or
|
`attrs.setters.NO_OP`
|
|
:param Optional[callable] field_transformer:
|
A function that is called with the original class object and all
|
fields right before *attrs* finalizes the class. You can use
|
this, e.g., to automatically add converters or validators to
|
fields based on their types. See `transform-fields` for more details.
|
|
:param bool match_args:
|
If `True` (default), set ``__match_args__`` on the class to support
|
:pep:`634` (Structural Pattern Matching). It is a tuple of all
|
non-keyword-only ``__init__`` parameter names on Python 3.10 and later.
|
Ignored on older Python versions.
|
|
.. 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).
|
Nc sò p
|
t | }dko t| t}o*t| d}|r<|r<tdt| |t| dd | |}t| dr| ¡ dkr| ¡ t| d}|s¶|dkr¶| ¡ |sÐt| drÐ|
|
¡ | ¡ d krödkröt| d röd
|
dk r d
|
k r d k r t d n| d
|
ksB d kr<|d
|
ksB|rRrt d nH dksz d kr|dkr|dkr| ¡ nrt d | ¡ t|
|
d r´| ¡ n| ¡ rÊt dtrê rêt| dsê| ¡ | ¡ S )NTr« z/Can't freeze a class with a custom __setattr__.)rÆ rÇ r rû )r r )r r r r r Fr# 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.r )Ú_has_frozen_base_classÚ
|
issubclassrª rr r5 r± r4 rú rý r r! r( r4 r
|
r r r r r rÙ )rn Ú is_frozenrÓ Zhas_own_setattrZbuilderr- ©r£ r3 Úauto_excrÒ r¤ Zeq_r¥ rÏ rÑ r( r) r, Ú
|
match_argsr1 Zorder_r& Úrepr_nsrÎ rf r¢ rÐ r r ÚwrapÑ sÐ ÿûì ÿ
|
ÿ ÿÿþý ÿ$ÿ
|
ÿÿÿ
|
ÿ ÿ
|
ÿÿþýzattrs.<locals>.wrap)r0 r8 r9 r: r r; )Z maybe_clsr¢ r; r& r' r( r) rÎ rÏ rÐ rf r£ r, rÒ r9 r- r/ r3 r¤ rÑ r1 r¥ r: Z unsafe_hashr< r r8 r rb ® s
|
4oc C s
|
| j tkS )zV
|
Check whether *cls* has a frozen ancestor by looking at its
|
__setattr__.
|
)r« r® rt r r r r5 M s r5 c C s$ d| d| j dt| d| j dS )zF
|
Create a "filename" suitable for a function being generated.
|
z<attrs generated ú r r rL )r rk r )rn Ú func_namer r r Ú_generate_unique_filenameU s "ÿr? c s t dd D d}t| d}t|i d}dd|sF|d7 }n |d 7 }|d
|
7 }d d 7 |g fd d}|rö |dt d ¡ |rÊ|dt d|d |d d ¡ n|dt d|d |dt ¡ n
|
|d| d ¡}td||S )Nc s s0 | ](}|j d ks$|j dkr|jd kr|V qdS )TN)r( r- r r r r r ` s
|
|
|
|
z _make_hash.<locals>.<genexpr>ú r( zdef __hash__(selfzhash((rW z):z, *zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper(ú)c s || |d d g¡ D ]Z}|jrhd|j d}|j|< |d| d|j d ¡ q& |d|j d ¡ q& |d ¡ d 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.ú),ú self.rV N)Úextendr. rR rZ )ÚprefixÚindentrq Úcmp_name©rb Zclosing_bracesrE Z hash_funcZ method_linesZ type_hashr r Ú append_hash_computation_lines| s
|
þÿ
|
ÿz1_make_hash.<locals>.append_hash_computation_lineszif self.z is None:zobject.__setattr__(self, 'ú', é úself.ú = z return self.zreturn rX r )r: r? r( rZ rì r\ rU ) rn rb rÏ rÒ ÚtabÚunique_filenameZhash_defrM rD r rL r r _ sH ÿ
|
|
ÿ
|
ÿ
|
ÿ
|
|
r c C s t | |ddd| _| S )z%
|
Add a hash method to *cls*.
|
Fr )r r ©rn rb r r r Ú _add_hash© s rU c C s dd } | S )z
|
Create __ne__ method.
|
c S s | |¡}|tkrtS | S )zj
|
Check equality and either forward a NotImplemented or
|
return the result negated.
|
)r ÚNotImplemented)r ÚotherÚresultr r r r ¶ s
|
z_make_ne.<locals>.__ne__r )r r r r r ± s r c C sò dd |D }t | d}dddg}i }|rÐ| d¡ dg}|D ]}|jrd |j d
|
}|j||< | d | d |j d ¡ | d | d|j d ¡ q>| d|j d¡ | d|j d¡ q>||dg 7 }n
|
| d¡ d |¡}td|||S )z6
|
Create __eq__ method for *cls* with *attrs*.
|
c S s g | ]}|j r|qS r )r- r r r r r È s z _make_eq.<locals>.<listcomp>r- zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (z
|
) == (rC rD r@ rE rF z(other.rG rB z other.z )z return TruerX r )r? rZ r. rR r\ rU ) rn rb rS ÚlinesrE Zothersrq rK rD r r r r Ä s,
|
ý
|
|
|
|
r c sV dd D fddfdd}fdd}fd d
|
}fd d }||||fS ) z9
|
Create ordering methods for *cls* with *attrs*.
|
c S s g | ]}|j r|qS r )r/ r r r r r ð s z _make_order.<locals>.<listcomp>c s t dd fddD D S )z&
|
Save us some typing.
|
c s s" | ]\}}|r||n|V qd S r r )r r r r r r r ö s ÿz6_make_order.<locals>.attrs_to_tuple.<locals>.<genexpr>c 3 s | ]}t |j|jfV qd S r )rk rR r0 r ©Úobjr r r ø s )r: rZ ©rb rZ r Úattrs_to_tupleò s
|
|
ÿþz#_make_order.<locals>.attrs_to_tuplec s |j | j kr | |k S tS ©z1
|
Automatically created by attrs.
|
©Ú __class__rV ©r rW ©r] r r r ý s z_make_order.<locals>.__lt__c s |j | j kr | |kS tS r^ r_ ra rb r r r s z_make_order.<locals>.__le__c s |j | j kr | |kS tS r^ r_ ra rb r r r s z_make_order.<locals>.__gt__c s |j | j kr | |kS tS r^ r_ ra rb r r r s z_make_order.<locals>.__ge__r )rn rb r r r r r )rb r] r r ì s r c C s& |dkr| j }t| || _t | _| S )z5
|
Add equality methods to *cls* with *attrs*.
|
N)rv r r r r rT r r r Ú_add_eq$ s
|
rc c C s t |d}tdd | D }dd |D }t|d< t|d< t|d< g }|D ]N\}}} | r`d | n
|
d
|
| d }
|
|tkrd ||
|
f n d |||
|
f } | | ¡ qJd |¡} |d kr²d} n|d } ddddddddddddd | d | d d d g}td!d" |¡||d#S )$Nr& c s s6 | ].}|j d k r|j|j dkr"t n|j |jfV qdS )FTN)r& rR r) r r r r r 6 s
|
þz _make_repr.<locals>.<genexpr>c S s$ i | ] \}}}|t kr|d |qS )Ú_repr)r& )r rR ÚrrC r r r rã ; s z _make_repr.<locals>.<dictcomp>r rÜ r rP zgetattr(self, "z ", NOTHING)z %s={%s!r}z%s={%s_repr(%s)}r z1{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 rX )rE ) r? r: r rÜ r r& rZ r\ rU )rb rù rn rS Zattr_names_with_reprsrE Zattribute_fragmentsrR re r^ ÚaccessorÚfragmentZ repr_fragmentZcls_name_fragmentrY r r r rø 1 sZ
|
þÿÿÿ ý
|
ñ ÿrø c C s |dkr| j }t||| | _| S )z%
|
Add a repr method to *cls*.
|
N)rv rø r )rn rù rb r r r Ú _add_reprj s ri c C sn t | }|dkr"t| ts"tdt| dd}|dkrj|dk r\t|dd}|dk r\|| _|S t| d|S )a*
|
Return the tuple of *attrs* attributes for a class.
|
|
The tuple also allows accessing the fields by their names (see below for
|
examples).
|
|
:param type cls: Class to introspect.
|
|
:raise TypeError: If *cls* is not a class.
|
:raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
|
class.
|
|
:rtype: 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.
|
Nú Passed object must be a class.rv ú! is not an attrs-decorated class.)r r8 r" r4 rk rv r )rn Z generic_baserb r r r Úfieldsu s rl c C sB t | tstdt| dd}|dkr4t| ddd |D S )aX
|
Return an ordered dictionary of *attrs* attributes for a class, whose
|
keys are the attribute names.
|
|
:param type cls: Class to introspect.
|
|
:raise TypeError: If *cls* is not a class.
|
:raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
|
class.
|
|
:rtype: dict
|
|
.. versionadded:: 18.1.0
|
rj rv Nrk c S s i | ] }|j |qS r r r r r r rã ± s z fields_dict.<locals>.<dictcomp>)r8 r" r4 rk r rT r r r Ú fields_dict s
|
rm c C sD t jdkrdS t| jD ]&}|j}|dk r|| |t| |j qdS )z¥
|
Validate all attributes on *inst* that have a validator.
|
|
Leaves all exceptions through.
|
|
:param inst: Instance of a class with *attrs* attributes.
|
FN)r Z_run_validatorsrl r` r% rk rR )Úinstrq râ r r r rË ´ s
|
rË c C s
|
d| j kS )Nræ )r rt r r r Ú _is_slot_clsÅ s ro c C s | |kot || S )z>
|
Check if the attribute name comes from a slot class.
|
)ro )Za_namer r r r Ú _is_slot_attrÉ s rp c C s$ | d k o| t jk } |r"| r"td|p(|} g } i }|D ]^}|jsL|jtkrLq6| |¡ |||j< |jd k r|dkrztdd} q6| r6|jt jk r6d} q6t | d}t
|
| |||||||| | |
|
\}}}| j t j krâ| t j | j j¡ | t|d¡ | rtj|d< t|
|
rdnd|||}||_|S )Nz$Frozen classes can't use on_setattr.Tr) )r Ú attr_dictZ_cached_setattr_getr rÔ )r r' r5 r) r$ r rZ rR r1 r? Ú_attrs_to_init_scriptr ÚsysÚmodulesrë r rÞ r rU rs )rn rb Úpre_initÚ post_initrÏ rÎ rÒ r rÓ Zcls_on_setattrr Úhas_cls_on_setattrÚneeds_cached_setattrZfiltered_attrsrq rq rS rD rE Ú annotationsr) r r r r Ð sZ ÿ
|
|
|
|
õ
|
|
ür c C s d| d| dS )zJ
|
Use the cached object.setattr to set *attr_name* to *value_var*.
|
z
|
_setattr('rN rA r ©r_ Z value_varÚhas_on_setattrr r r Ú_setattr s r| c C s d| t | f |f S )zk
|
Use the cached object.setattr to set *attr_name* to *value_var*, but run
|
its converter first.
|
z_setattr('%s', %s(%s)))Ú_init_converter_patrz r r r Ú_setattr_with_converter" s
|
ýr~ c C s |rt | |dS d| d| S )zo
|
Unless *attr_name* has an on_setattr hook, use normal assignment. Otherwise
|
relegate to _setattr.
|
TrP rQ )r| )r_ r r{ r r r Ú_assign. s r c C s$ |rt | |dS d| t| f |f S )z
|
Unless *attr_name* has an on_setattr hook, use normal assignment after
|
conversion. Otherwise relegate to _setattr_with_converter.
|
Tzself.%s = %s(%s))r~ r} rz r r r Ú_assign_with_converter9 s ýr c
|
s< g } |r| d¡ |r | d¡ |dkr^|dkr:t} t} qf| d¡ fdd} fdd} nt} t} g }g }g }i }d d
|
i}| D ]~}|jr| |¡ |j}|jd
|
k p¶|jtj k o¶| }|j
|
}t |j t }|rÜ|j jrÜd }nd }|jd krÈ|rlt|jf }|jd
|
k r@| | ||d| d |¡ t|jf }|j||< n | | ||d| d |¡ |j j||< nX|jd
|
k rª| | |d| d|¡ t|jf }|j||< n| | |d| d|¡ nè|j tk rP|sP| d| d}|jrþ| |¡ n
|
| |¡ |jd
|
k r:| | |||¡ |j|t|jf < n| | |||¡ n`|rN| d}|jrt| |¡ n
|
| |¡ | d| d¡ t|jf }|jd
|
k rþ| d| ||| ¡ | d¡ | d| ||d | d | ¡ |j|t|jf < nB| d| ||| ¡ | d¡ | d| ||d | d | ¡ |j j||< nb|jrb| |¡ n
|
| |¡ |jd
|
k r| | |||¡ |j|t|jf < n| | |||¡ |jdkr|jd
|
k rÞ|jd
|
krÞ|j||< q|jd
|
k rt|j ¡ } | r| ||< q|rnt|d< | d¡ |D ]L}d|j } d|j }| d| d | d |j d¡ |j|| < |||< q |r~| d ¡ |r²|r|rd } nd } nd!} | | td"f ¡ |rÞd# d$d% | D ¡} | d&| d¡ d' |¡}|r|d(|rüd'nd d' |¡f 7 }d)|
|
rd*nd+|| r.d, | ¡nd-f ||fS ).zô
|
Return a script of an initializer for *attrs* and a dict of globals.
|
|
The globals are expected by the generated script.
|
|
If *frozen* is True, we cannot set the attributes directly so we use
|
a cached ``object.__setattr__``.
|
zself.__attrs_pre_init__()z$_setattr = _cached_setattr_get(self)Tz_inst_dict = self.__dict__c s& t | rt| ||S d| d| S )Nz _inst_dict['z'] = )rp r| rz ©r r r Ú
|
fmt_settert s
|
z)_attrs_to_init_script.<locals>.fmt_setterc s. |st | rt| ||S d| t| f |f S )Nz_inst_dict['%s'] = %s(%s))rp r~ r} rz r r r Úfmt_setter_with_converterz s ÿýz8_attrs_to_init_script.<locals>.fmt_setter_with_converterÚreturnNr r@ Frf rA z attr_dict['z
|
'].defaultz =attr_dict['z=NOTHINGzif z is not NOTHING:rV zelse:r z#if _config._run_validators is True:Z__attr_validator_Z__attr_z(self, z, self.zself.__attrs_post_init__()z_setattr('%s', %s)z_inst_dict['%s'] = %sz self.%s = %sÚNonerB c s s | ]}|j rd |j V qdS )rP N)r) rR r r r r r J s z(_attrs_to_init_script.<locals>.<genexpr>z BaseException.__init__(self, r z%s*, %szdef %s(self, %s):
|
%s
|
r rÔ z
|
Úpass) rZ r| r~ r r r% rR r1 r r' r2 r8 r$ r7 Ú
|
takes_selfr) Ú_init_factory_patr* r} r> r r, r" r Úget_first_param_typer rì r\ ) rb rÏ rÎ ru rv rÒ r rÓ rx rw r rY r r ÚargsZ kw_only_argsZattrs_to_validateZnames_for_globalsry rq r_ r{ Zarg_nameZ has_factoryZ
|
maybe_selfZinit_factory_nameZ conv_nameÚargÚtZval_nameZinit_hash_cacheÚvalsr r r rr H s
|
ü
|
|
|
|
ÿ ýÿ ýÿ
|
ýÿ
|
ýÿ
|
ÿÿþ
|
ÿ
|
|
ÿÿÿ
|
ýÿÿ
|
þ
|
ÿÿ
|
ýÿÿ
|
ÿÿþ
|
ÿ
|
|
|
|
|
|
|
|
|
þ ýÿørr )rR r c C s
|
| d¡S )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.
|
rC )Úlstripr r r r r a s r c
|
@ sT e Zd ZdZdZdddZdd Zedd d
|
Zd d Z d d Z
|
dd Z dd Z dS )r a¶
|
*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
|
<custom-comparison>`.
|
|
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 <transform-fields>` 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`.
|
)rR r$ r% r& r- r. r/ r0 r( r) r+ r" r* r, rx r1 r2 NFc C sè t ||p
|
| |p|d\} }}}t | ¡}|d| |d| |d| |d| |d| |d| |d| |d | |d
|
| |d | |d | |d | r¬t t| ¡nt |d|
|
|d| |d| |d| |d| d S )NTrR r$ r% r& r- r. r/ r0 r( r) r* r+ r" r, rx r1 r2 )r3 rÞ r ÚtypesÚMappingProxyTyperÈ Ú_empty_metadata_singleton)r rR r$ r% r& r' r( r) rx r+ r" r* r, r- r. r/ r0 r1 r2 Ú bound_setattrr r r rÔ ¬ s: ÿ
|
|
|
|
|
|
|
|
|
|
|
|
ÿû
|
|
|
|
zAttribute.__init__c C s
|
t d S r r¯ r¬ r r r r« ã s zAttribute.__setattr__c sV |d kr j }n j d k r"td fddtjD }| f | j j|d dd|S )Nz8Type annotation and type argument cannot both be presentc s i | ]}|d kr|t |qS ))rR r% r$ r" rx rä )r rá ©r
r r rã ï s ÿþ z0Attribute.from_counting_attr.<locals>.<dictcomp>F)rR r% r$ r" r' rx )r" r5 r ræ Ú
|
_validatorÚ_default)rn rR r
r" Ú inst_dictr r r r æ s&
|
ÿ
|
þ úùz Attribute.from_counting_attrc K s t | ¡}| | ¡ ¡ |S )zý
|
Copy *self* and apply *changes*.
|
|
This works similarly to `attrs.evolve` but that function does not work
|
with `Attribute`.
|
|
It is mainly meant to be used for `transform-fields`.
|
|
.. versionadded:: 20.3.0
|
)ÚcopyÚ _setattrsr )r ÚchangesÚnewr r r rz
|
s
|
zAttribute.evolvec s t fdd jD S )ú(
|
Play nice with pickle.
|
c 3 s* | ]"}|d krt |nt jV qdS )r+ N)rk rÈ r+ rå r r r r
|
s ÿz)Attribute.__getstate__.<locals>.<genexpr>©r: ræ r r r r rÆ
|
s þzAttribute.__getstate__c C s | t| j|¡ dS ©r N)r r ræ )r r r r r rÇ !
|
s zAttribute.__setstate__c C sL t | ¡}|D ]8\}}|dkr*||| q|||r@t t|¡nt qd S )Nr+ )rÞ r r r rÈ r )r Zname_values_pairsr rR r r r r r '
|
s
|
ÿüzAttribute._setattrs)
|
NNNFNNNNNN)N) r r r r ræ rÔ r« rî r rz rÆ rÇ r r r r r r l s( + í
|
7 r c C s2 g | ]*}t |td dd dd|dkddt|d qS )NTFr+ ) rR r$ r% r& r' r- r/ r( r) rx r2 )r r r rå r r r r 5
|
s óõr r\ c C s g | ]}|j d kr|qS rw r r r r r r I
|
s
|
c C s g | ]}|j r|jd kr|qS rw )r( rR r r r r r K
|
s
|
c @ sj e Zd ZdZdZedd dD eddddddd dd ddd dd dd
|
f Zd Zd d Z dd Z
|
dd Z dS )r= a
|
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& r- r. r/ r0 r( r) r+ r r* r" r, r1 r2 c c s8 | ]0}t |t|td dd ddddd dd dd dV qd S )NTF©rR r2 r$ r% r& r' r( r) r, r- r. r/ r0 rx r1 )r r r rå r r r r j
|
s$ ïñz_CountingAttr.<genexpr>) r r r& r- r/ r( r) r1 r2 r+ NTFr r c C st t jd7 _t j| _|| _|| _|| _|| _| | _| | _| | _ || _
|
|| _ || _ || _ | | _|
|
| _|| _|| _d S r )r= Ú cls_counterr r r r* r& r- r. r/ r0 r( r) r+ r" r, r1 r2 )r r$ r% r& r' r( r) r* r+ r" r, r- r. r/ r0 r1 r2 r r r rÔ
|
s" z_CountingAttr.__init__c C s$ | j dkr|| _ nt| j || _ |S )z
|
Decorator that adds *meth* to the list of validators.
|
|
Returns *meth* unchanged.
|
|
.. versionadded:: 17.1.0
|
N)r r< ©r r r r r r% Á
|
s
|
z_CountingAttr.validatorc C s" | j tk rt t|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 r r r7 r r r r r$ Ï
|
s
|
|
z_CountingAttr.default) r r r r ræ r: r rv r rÔ r% r$ r r r r r= O
|
s8 î ñÿã0%r= c @ s. e Zd ZdZdZd ddZdd Zdd Zd
|
S ) r7 aÇ
|
Stores a factory callable.
|
|
If passed as the default value to `attrs.field`, the factory is used to
|
generate a new value.
|
|
:param callable factory: A callable that takes either none or exactly one
|
mandatory positional argument depending on *takes_self*.
|
:param bool takes_self: Pass the partially initialized instance that is
|
being initialized as a positional argument.
|
|
.. versionadded:: 17.1.0 *takes_self*
|
©r> r Fc C s || _ || _d S r r¡ )r r> r r r r rÔ õ
|
s zFactory.__init__c s t fdd jD S )r c 3 s | ]}t |V qd S r rä rå r r r r ý
|
s z'Factory.__getstate__.<locals>.<genexpr>r r r r r rÆ ù
|
s zFactory.__getstate__c C s& t | j|D ]\}}t| || q dS r )r ræ rÝ )r r rR r r r r rÇ ÿ
|
s zFactory.__setstate__N)F)r r r r ræ rÔ rÆ rÇ r r r r r7 ä
|
s
|
|
r7 c C s( g | ] }t |td dd dddddd
|
qS )NTF)
|
rR r$ r% r& r' r- r/ r( r) rx )r r rå r r r r s ôöc
|
s" t |tr|}n&t |ttfr.dd |D }ntd| dd¡}| dd¡}| dd¡}i |dk rn| d< |dk r~| d< |dk r| d< t | |i fdd ¡}zt d
|
¡j
|
d d ¡|_ W n t tfk
|
rØ Y nX | d d¡} t| | d¡| d¡d\|d< |d< tf d|i||S )aé
|
A quick way to create a new class called *name* with *attrs*.
|
|
:param str name: The name for the new class.
|
|
:param attrs: 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.
|
:type attrs: `list` or `dict`
|
|
:param tuple bases: Classes that the new class will subclass.
|
|
:param attributes_arguments: Passed unmodified to `attr.s`.
|
|
:return: A new class with *attrs*.
|
:rtype: type
|
|
.. versionadded:: 17.1.0 *bases*
|
.. versionchanged:: 18.1.0 If *attrs* is ordered, the order is retained.
|
c S s i | ] }|t qS r )r? r r r r rã 5 s z make_class.<locals>.<dictcomp>z(attrs argument must be a dict or a list.rà NrÄ rÔ c s
|
| ¡S r )rë )rù ©Úbodyr r r E r z make_class.<locals>.<lambda>r r Ú__main__r' r- r/ Tr¢ )r8 rÈ r9 r: r4 Úpopr Ú new_classrs Ú _getframeÚ f_globalsr r rÜ r5 r0 r³ )
|
rR rb ÚbasesZattributes_argumentsZcls_dictru rv Z user_initÚtype_r' r r¢ r Ú
|
make_class sD
|
ÿ
|
üýr« )rÎ r( c @ s e Zd ZdZe Zdd ZdS )Ú _AndValidatorz2
|
Compose many validators to a single one.
|
c C s | j D ]}|||| qd S r )Ú _validators)r rn ro r râ r r r Ú__call__m s
|
z_AndValidator.__call__N)r r r r r? r r® r r r r r¬ e s r¬ c G s6 g }| D ] }| t|tr |jn|g¡ qtt|S )zÞ
|
A validator that composes multiple validators into one.
|
|
When called on a value, it runs all wrapped validators.
|
|
:param callables validators: Arbitrary number of validators.
|
|
.. versionadded:: 17.1.0
|
)rH r8 r¬ r r: )Z
|
validatorsr r% r r r r< r s
|
ÿýr< c sh fdd} s(t d¡}||d|_n<t d ¡ }|rF||jd< t d ¡ }|rd||jd< |S ) aY
|
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.
|
|
:param callables converters: Arbitrary number of converters.
|
|
.. versionadded:: 20.1.0
|
c s D ] }|| } q| S r r )r# r* ©Ú
|
convertersr r Úpipe_converter s
|
z pipe.<locals>.pipe_converterÚA)r# r r r# rJ r )ÚtypingÚTypeVarrs r r Zget_return_type)r° r± r² r Úrtr r¯ r r; s
|
|
|
r; )Nr@ )T)NNNNNNNFFTFFFFFNNFFNNNTN)N)NN)Zr r rO rs r r³ Úoperatorr r@ r r r r r r r
|
Ú
|
exceptionsr r r r Úobjectr« rÞ r} r ri rì r r rl r; rÌ rË rÊ ÚEnumr r Úintr r? rI rU r` ra rj rr ru r r r¦ r® r° r± r0 r3 r4 rb r³ r5 r? r rU r r r rc rø ri rl rm ro rp r r| r~ r r rr rf r r ræ Z_ar= r7 Z_fr« r¬ r< r r r r Ú<module> s
|
ñ
|
M
|
úþ
|
r m* ÿ
|
è
|
|
J(8
|
9
|
(K Jò
|
þ û # ó K
|
|
