#IGZ�� �
@ s� d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l
m Z d d l m
Z
m Z m Z m Z m Z d d l m Z m Z m Z m Z e j Z d Z d Z d
Z e i � Z Gd d � d e � Z e � Z e d d
d
d d
d d d d d d �
Z d d � Z! e! d d d g � Z" d d � Z# d d � Z$ d d � Z% d d � Z& d d � Z' Gd d � d e � Z( d d d d
d
d d
d! d! d! d! d" d � Z) e) Z* e
r�d# d$ � Z+ n d% d$ � Z+ d& d' � Z, d( d) � Z- d* d+ � Z. d, d- � Z/ d. d/ � Z0 d d0 d1 � Z1 d2 d3 � Z2 d d d4 d5 � Z3 d6 d7 � Z4 d8 d9 � Z5 d: d; � Z6 d< d= � Z7 d> d? � Z8 Gd@ dA � dA e � Z9 dB dC � e9 j: D� Z; e. e1 e3 e9 d e; �d e; �d dD dC � e; D� �Z9 GdE dF � dF e � Z< e1 e3 e< � � Z< e) dG d
dH d! dI d
� GdJ dK � dK e � � Z= e f dL dM � Z> e) dG d
dI d
� GdN dO � dO e � � Z? dP dQ � Z@ d S)R� )�absolute_import�division�print_functionN)�
itemgetter� )�_config)�PY2�isclass� iteritems�metadata_proxy�set_closure_cell)�DefaultAlreadySetError�FrozenInstanceError�NotAnAttrsClassError�UnannotatedAttributeErrorz__attr_converter_{}z__attr_factory_{}z/ {attr_name} = property(itemgetter({index}))c @ s^ e Z d Z d Z d d � Z d d � Z d d � Z d d � Z d
d � Z d d
� Z d S)�_Nothingz�
Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
All instances of `_Nothing` are equal.
c C s | S)N� )�selfr r � /_make.py�__copy__ s z_Nothing.__copy__c C s | S)Nr )r �_r r r � __deepcopy__# s z_Nothing.__deepcopy__c C s
| j t k S)N)� __class__r )r �otherr r r �__eq__& s z_Nothing.__eq__c C s | | k S)Nr )r r r r r �__ne__) s z_Nothing.__ne__c C s d S)N�NOTHINGr )r r r r �__repr__, s z_Nothing.__repr__c C s d S)Nl �>[= r )r r r r �__hash__/ s z_Nothing.__hash__N)
�__name__�
__module__� __qualname__�__doc__r r r r r r r r r r r s r Tc
C s� | d k r0 | d k r0 | d k r0 t d � � | d k rp | d k rT t d � � t j d t d d �| } | d k r� i } t d | d
| d | d | d
| d | d | d | d | � S)aJ
Create a new attribute on a class.
.. warning::
Does *not* do anything unless the class is also decorated with
:func:`attr.s`!
: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 :class:`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 ``attr.NOTHING``), a value
*must* be supplied when instantiating; otherwise a :exc:`TypeError`
will be raised.
The default can also be set using decorator notation as shown below.
:type default: Any value.
:param validator: :func:`callable` that is called by ``attrs``-generated
``__init__`` methods after the instance has been initialized. They
receive the initialized instance, the :class:`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
:func:`get_run_validators`.
The validator can also be set using decorator notation as shown below.
:type validator: ``callable`` or a ``list`` of ``callable``\ s.
:param bool repr: Include this attribute in the generated ``__repr__``
method.
:param bool cmp: Include this attribute in the generated comparison methods
(``__eq__`` et al).
:param hash: Include this attribute in the generated ``__hash__``
method. If ``None`` (default), mirror *cmp*'s value. This is the
correct behavior according the Python spec. Setting this value to
anything else than ``None`` is *discouraged*.
:type hash: ``bool`` or ``None``
: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: :func:`callable` that is called by
``attrs``-generated ``__init__`` methods to converter 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 :ref:`extending_metadata`.
:param type: The type of the attribute. In Python 3.6 or greater, the
preferred method to specify the type is using a variable annotation
(see `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_).
This argument is provided for backward compatibility.
Regardless of the approach used, the type will be stored on
``Attribute.type``.
.. 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 *cmp* 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.
NTFz6Invalid value for hash. Must be True, False, or None.zHCan't pass both `convert` and `converter`. Please use `converter` only.z`The `convert` argument is deprecated in favor of `converter`. It will be removed after 2019/01.�
stacklevel� �default� validator�repr�cmp�hash�init� converter�metadata�type)� TypeError� RuntimeError�warnings�warn�DeprecationWarning�
_CountingAttr)
r% r& r' r( r) r* �convertr, r- r+ r r r �attrib9 s. R$
r5 c C s� d j | � } d j | � d g } | ri xI t | � D]+ \ } } | j t j d | d | � � q7 Wn
| j d � d t i } t t d j | � d d
� | � | | 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 {}(tuple):z __slots__ = ()�index� attr_namez passr �
� �exec)�format� enumerate�append�_tuple_property_patr �eval�compile�join)Zcls_name�
attr_namesZattr_class_nameZattr_class_template�ir7 �globsr r r �_make_attr_tuple_class� s
"rE � _Attributes�attrs� super_attrsc C s t | � j d � S)z�
Check whether *annot* is a typing.ClassVar.
The implementation is gross but importing `typing` is slow and there are
discussions to remove it from the stdlib alltogether.
ztyping.ClassVar)�str�
startswith)Zannotr r r �
_is_class_var� s rK c C s` t | d d � } | d k r" i Sx7 | j d d � D]" } | t | d d � k r6 i Sq6 W| S)z$
Get annotations for *cls*.
�__annotations__Nr )�getattr�__mro__)�cls�anns� super_clsr r r �_get_annotations� s rR c s5 | j � t | � � | d k rO t d d � t | � D� d d d � �} nG| d k rkd d � � j � D� } g } t � } x� � j � D]� \ } } t | � r� q� | j | � � j | t � } t
| t � s | t k r� t � } n t d
| � } | j
| | f � q� W| | } t | � d k r�t d d
j t | d � f d d � �� d � � n+ t d d � � j � D� d d d � �} � f d d � | D� }
g } d d � |
D� } x� | j d d � D]m }
t |
d d � } | d k r�xF | D]> } | j | j � } | d k r| j
| � | | | j <qWq�Wd d � | |
D� } t | j | � } | | � f d d � | D� � } d } x� | D]{ } | d k r�| j t k r�| j d k r�t d j d | � � � q�| d k r�| j t k r�| j d k r�d } q�Wt | | f � S) z�
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.
Return an `_Attributes`.
Nc s s! | ] \ } } | | f Vq d S)Nr )�.0�name�car r r � <genexpr>� s z#_transform_attrs.<locals>.<genexpr>�keyc S s | d j S)Nr )�counter)�er r r �<lambda>� s z"_transform_attrs.<locals>.<lambda>Tc S s+ h | ]! \ } } t | t � r | � q Sr )�
isinstancer3 )rS rT �attrr r r � <setcomp>� s z#_transform_attrs.<locals>.<setcomp>r% r z1The following `attr.ib`s lack a type annotation: z, c s � j | � j S)N)�getrX )�n)�cdr r rZ s �.c s s0 | ]& \ } } t | t � r | | f Vq d S)N)r[ r3 )rS rT r\ r r r rV s c S s | d j S)Nr )rX )rY r r r rZ s c
s= g | ]3 \ } } t j d | d | d � j | � � � q S)rT rU r- )� Attribute�from_counting_attrr^ )rS r7 rU )rP r r �
<listcomp># s z$_transform_attrs.<locals>.<listcomp>c S s i | ] } | | j � q Sr )rT )rS �ar r r �
<dictcomp>- s z$_transform_attrs.<locals>.<dictcomp>r �__attrs_attrs__c S s g | ] } | j � q Sr )rT )rS re r r r rd ; s c
s= g | ]3 \ } } t j d | d | d � j | � � � q S)rT rU r- )rb rc r^ )rS r7 rU )rP r r rd A s FzqNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: {a!r}re ���)�__dict__rR �sortedr
�items�setrK �addr^ r r[ r3 r5 r= �lenr rA rN rM rT rE r r% r* �
ValueErrorr; rF )rO �these� auto_attribsZca_listZca_namesZ annot_namesr7 r- re Z unannotatedZ own_attrsrH Ztaken_attr_namesrQ Z sub_attrsZprev_arB Z
AttrsClassrG Z had_defaultr )rP r` r �_transform_attrs� sv
5
*
rr c C s
t � � d S)z4
Attached to frozen classes as __setattr__.
N)r )r rT �valuer r r �_frozen_setattrs[ s rt c C s
t � � d S)z4
Attached to frozen classes as __delattr__.
N)r )r rT r r r �_frozen_delattrsb s ru c @ s� e Z d Z d Z d# Z d
d � Z d d
� Z d d � Z d d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d d! � Z d" S)$�
_ClassBuilderz(
Iteratively build *one* class.
�_cls� _cls_dict�_attrs� _super_names� _attr_names�_slots�_frozen�_has_post_initc C s� t | | | � \ } } | | _ | r6 t | j � n i | _ | | _ t d d � | D� � | _ t d d � | D� � | _ | | _
| p� t | � | _ t
t | d d � � | _ | j | j d <| r� t | j d <t | j d <d S) Nc s s | ] } | j Vq d S)N)rT )rS re r r r rV x s z)_ClassBuilder.__init__.<locals>.<genexpr>c s s | ] } | j Vq d S)N)rT )rS re r r r rV y s �__attrs_post_init__Frg � __setattr__� __delattr__)rr rw �dictri rx ry rl rz �tupler{ r| �_has_frozen_superclassr} �boolrM r~ rt ru )r rO rp �slots�frozenrq rG rH r r r �__init__r s
z_ClassBuilder.__init__c C s d j d | j j � S)Nz<_ClassBuilder(cls={cls})>rO )r; rw r )r r r r r � s z_ClassBuilder.__repr__c C s' | j d k r | j � S| j � Sd S)z�
Finalize class based on the accumulated configuration.
Builder cannot be used anymore after calling this method.
TN)r| �_create_slots_class�_patch_original_class)r r r r � build_class� s
z_ClassBuilder.build_classc C s� | j } | j } xB | j D]7 } | | k r t | | d � d k r t | | � q Wx- | j j � D] \ } } t | | | � qg W| S)zA
Apply accumulated methods and return the class.
N)rw rz r{ rM �delattrrx rk �setattr)r rO � super_namesrT rs r r r r� � s z#_ClassBuilder._patch_original_classc s� � j � � f d d � t � j � D� } t � f d d � � j D� � | d <t � j d d � } | d k r| | | d <t � j � � � f d d � } � f d
d � } | | d <| | d
<t � j � � j j � j j | � } x� | j
j � D]~ } t | t
t f � r-t | j d d � } n t | d d � } | sHq� x- | D]% } | j � j k rOt | | � qOWq� W| S)zL
Build and return a new class with a `__slots__` attribute.
c s8 i | ]. \ } } | t � j � d k r | | � q S)ri )ri )r� r{ )rS �k�v)r r r rf � s z5_ClassBuilder._create_slots_class.<locals>.<dictcomp>c 3 s! | ] } | � k r | Vq d S)Nr )rS rT )r� r r rV � s z4_ClassBuilder._create_slots_class.<locals>.<genexpr>� __slots__r! Nc s t � f d d � � D� � S)z9
Automatically created by attrs.
c 3 s | ] } t � | � Vq d S)N)rM )rS rT )r r r rV � s zL_ClassBuilder._create_slots_class.<locals>.slots_getstate.<locals>.<genexpr>)r� )r )rB )r r �slots_getstate� s z9_ClassBuilder._create_slots_class.<locals>.slots_getstatec sC t j | t � } x* t � | � D] \ } } | | | � q" Wd S)z9
Automatically created by attrs.
N)� _obj_setattr�__get__rb �zip)r �stateZ _ClassBuilder__bound_setattrrT rs )rB r r �slots_setstate� s z9_ClassBuilder._create_slots_class.<locals>.slots_setstate� __getstate__� __setstate__� __closure__)rz r
rx r� r{ rM rw r- r � __bases__ri �valuesr[ � classmethod� staticmethod�__func__�
cell_contentsr ) r r` �qualnamer� r� rO �itemZ
closure_cellsZcellr )rB r r� r r� � s8
z!_ClassBuilder._create_slots_classc C s) | j t | j d | �� | j d <| S)N�nsr )�_add_method_dunders�
_make_reprry rx )r r� r r r �add_repr� s z_ClassBuilder.add_reprc C sP | j j d � } | d k r* t d � � d d � } | j | � | j d <| S)Nr z3__str__ can only be generated if a __repr__ exists.c S s
| j � S)N)r )r r r r �__str__� s z&_ClassBuilder.add_str.<locals>.__str__r� )rx r^ ro r� )r r' r� r r r �add_str� s z_ClassBuilder.add_strc C s d | j d <| S)Nr )rx )r r r r �make_unhashable s
z _ClassBuilder.make_unhashablec C s# | j t | j � � | j d <| S)Nr )r� �
_make_hashry rx )r r r r �add_hash s z_ClassBuilder.add_hashc C s/ | j t | j | j | j � � | j d <| S)Nr� )r� �
_make_initry r~ r} rx )r r r r �add_init s z_ClassBuilder.add_initc sY � j } � f d d � t � j � D� \ | d <| d <| d <| d <| d <| d <� S) Nc 3 s | ] } � j | � Vq d S)N)r� )rS �meth)r r r rV s z(_ClassBuilder.add_cmp.<locals>.<genexpr>r r �__lt__�__le__�__gt__�__ge__)rx � _make_cmpry )r r` r )r r �add_cmp s =z_ClassBuilder.add_cmpc C sf y | j j | _ Wn t k
r' Yn Xy% d j | j j | j f � | _ Wn t k
ra Yn X| S)zL
Add __module__ and __qualname__ to a *method* if possible.
ra )rw r �AttributeErrorrA r! r )r �methodr r r r� ! s
z!_ClassBuilder._add_method_dundersN)rw rx ry rz 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 rv i s H
rv Fc
sK � � � � � � � � � � f
d d � } | d k r= | S| | � Sd S)aU
A class decorator that adds `dunder
<https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the
specified attributes using :func:`attr.ib` or the *these* argument.
:param these: A dictionary of name to :func:`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.
:type these: :class:`dict` of :class:`str` to :func:`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 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
:class:`Exception`\ s.
:param bool cmp: Create ``__eq__``, ``__ne__``, ``__lt__``, ``__le__``,
``__gt__``, and ``__ge__`` methods that compare the class as if it were
a tuple of its ``attrs`` attributes. But the attributes are *only*
compared, if the type of both classes is *identical*!
:param hash: If ``None`` (default), the ``__hash__`` method is generated
according how *cmp* and *frozen* are set.
1. If *both* are True, ``attrs`` will generate a ``__hash__`` for you.
2. If *cmp* is True and *frozen* is False, ``__hash__`` will be set to
None, marking it unhashable (which it is).
3. If *cmp* is False, ``__hash__`` will be left untouched meaning the
``__hash__`` method of the superclass will be used (if superclass 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 the `Python documentation \
<https://docs.python.org/3/reference/datamodel.html#object.__hash__>`_
and the `GitHub issue that led to the default behavior \
<https://github.com/python-attrs/attrs/issues/136>`_ for more details.
:type hash: ``bool`` or ``None``
:param bool init: Create a ``__init__`` method that initializes the
``attrs`` attributes. Leading underscores are stripped for the
argument name. If a ``__attrs_post_init__`` method exists on the
class, it will be called after the class is fully initialized.
:param bool slots: Create a slots_-style class that's more
memory-efficient. See :ref:`slots` for further ramifications.
:param bool frozen: Make instances immutable after initialization. If
someone attempts to modify a frozen instance,
:exc:`attr.exceptions.FrozenInstanceError` is raised.
Please note:
1. This is achieved by installing a custom ``__setattr__`` method
on your class so you can't implement an own one.
2. True immutability is impossible in Python.
3. This *does* have a minor a runtime performance :ref:`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)``.
.. _slots: https://docs.python.org/3/reference/datamodel.html#slots
:param bool auto_attribs: If True, collect `PEP 526`_-annotated attributes
(Python 3.6 and later only) from the class body.
In this case, you **must** annotate every field. If ``attrs``
encounters a field that is set to an :func:`attr.ib` but lacks a type
annotation, an :exc:`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 :class:`Factory` also
works as expected.
Attributes annotated as :data:`typing.ClassVar` are **ignored**.
.. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/
.. versionadded:: 16.0.0 *slots*
.. versionadded:: 16.1.0 *frozen*
.. versionadded:: 16.3.0 *str*, and 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*
c sB t | d d � d k r$ t d � � t | � � � � � } � d k rU | j � � � d k rk | j � � d k r� | j � � d k r� � d k r� � d k r� t d � � nn � d k s"� d k r� � d k r� nG � d k s � d k r� d k r� d k r| j � n
| j � � d k r8| j � | j � S)Nr z(attrs only works with new-style classes.TFz6Invalid value for hash. Must be True, False, or None.)
rM r. rv r� r� r� r� r� r� r� )rO Zbuilder)
rq r( r� r) r* r' �repr_nsr� rI rp r r �wrap� s(
$ $0
zattrs.<locals>.wrapNr ) Z maybe_clsrp r� r' r( r) r* r� r� rI rq r� r )
rq r( r� r) r* r' r� r� rI rp r rG 4 s g- c C s1 t | j d d � t j k o0 | j j t j k S)zb
Check whether *cls* has a frozen ancestor by looking at its
__setattr__.
r N)rM r� rt r r )rO r r r r� � s r� c C s
| j t k S)zb
Check whether *cls* has a frozen ancestor by looking at its
__setattr__.
)r� rt )rO r r r r� � s c s t � f d d � | D� � S)z:
Create a tuple of all values of *obj*'s *attrs*.
c 3 s! | ] } t � | j � Vq d S)N)rM rT )rS re )�objr r rV � s z"_attrs_to_tuple.<locals>.<genexpr>)r� )r� rG r )r� r �_attrs_to_tuple� s r� c
C s t d d � | D� � } t j � } | j t | � j d � � d | j � f } t | � } d d d | f g } x" | D] } | j d | j � q} W| j d � d
j
| � } i } i } t | | d � } t | | | � t
| � d | j d � | f t j | <| d
S)Nc s sB | ]8 } | j d k s6 | j d k r | j d k r | Vq d S)TN)r) r( )rS re r r r rV � s z _make_hash.<locals>.<genexpr>zutf-8z<attrs generated hash %s>zdef __hash__(self):z return hash((z %d,z self.%s,z ))r8 r: Tr )r� �hashlib�sha1�updater' �encode� hexdigestr) r= rT rA r@ r? rn �
splitlines� linecache�cache)
rG r� �unique_filenameZ type_hash�linesre �scriptrD �locs�bytecoder r r r� � s.
r� c C s t | � | _ | S)z%
Add a hash method to *cls*.
)r� r )rO rG r r r � _add_hash s r� c C s$ | j | � } | t k r t S| S)z^
Check equality and either forward a NotImplemented or return the result
negated.
)r �NotImplemented)r r �resultr r r r s r c s� d d � � D� � t j � } | j t � � j d � � d | j � f } d d d g } � r� | j d � d g } x< � D]4 } | j d
| j f � | j d | j f � q� W| | d g 7} n
| j d
� d j | � } i } i } t | | d � } t
| | | � t | � d | j d � | f t
j | <| d }
t } � f d d � � � f d d � } � f d d � }
� f d d � } � f d d � } |
| | |
| | f S) Nc S s g | ] } | j r | � q Sr )r( )rS re r r r rd ! s z _make_cmp.<locals>.<listcomp>zutf-8z<attrs generated eq %s>zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz
return (z
) == (z self.%s,z other.%s,z )z return Truer8 r: Tr c s
t | � � S)z&
Save us some typing.
)r� )r� )rG r r �attrs_to_tupleL s z!_make_cmp.<locals>.attrs_to_tuplec s0 t | | j � r( � | � � | � k St Sd S)z1
Automatically created by attrs.
N)r[ r r� )r r )r� r r r� R s z_make_cmp.<locals>.__lt__c s0 t | | j � r( � | � � | � k St Sd S)z1
Automatically created by attrs.
N)r[ r r� )r r )r� r r r� [ s z_make_cmp.<locals>.__le__c s0 t | | j � r( � | � � | � k St Sd S)z1
Automatically created by attrs.
N)r[ r r� )r r )r� r r r� d s z_make_cmp.<locals>.__gt__c s0 t | | j � r( � | � � | � k St Sd S)z1
Automatically created by attrs.
N)r[ r r� )r r )r� r r r� m s z_make_cmp.<locals>.__ge__)r� r� r� r' r� r� r= rT rA r@ r? rn r� r� r� r )rG r� r� r� Zothersre r� rD r� r� �eq�ner� r� r� r� r )rG r� r r� s@
r� c C sI | d k r | j } t | � \ | _ | _ | _ | _ | _ | _ | S)z*
Add comparison methods to *cls*.
N)rg r� r r r� r� r� r� )rO rG r r r �_add_cmpy s 0r� c s2 t d d � | D� � � � � f d d � } | S)zK
Make a repr method for *attr_names* adding *ns* to the full name.
c s s! | ] } | j r | j Vq d S)N)r' rT )rS re r r r rV � s z _make_repr.<locals>.<genexpr>c s� � j } � d k rX t | d d � } | d k rL | j d d � d
} qi | j } n � d | j } d j | d j � f d d � � D� � � S) z1
Automatically created by attrs.
Nr! z>.r ra z{0}({1})z, c 3 s/ | ]% } | d t t � | t � � Vq d S)�=N)r' rM r )rS rT )r r r rV � s z/_make_repr.<locals>.__repr__.<locals>.<genexpr>rh )r rM �rsplitr r; rA )r Zreal_clsr� �
class_name)rB r� )r r r � s z _make_repr.<locals>.__repr__)r� )rG r� r r )rB r� r r� � s
r� c C s+ | d k r | j } t | | � | _ | S)z%
Add a repr method to *cls*.
N)rg r� r )rO r� rG r r r � _add_repr� s r� c
C s d d � | D� } t j � } | j t | � j d � � d j | j � � } t | | | � \ } } i } t | | d � } t d d � | D� � } | j d t
d | i � | d
k r� t | d <t | | | � t
| � d | j d
� | f t j | <| d S)
Nc S s. g | ]$ } | j s$ | j t k r | � q Sr )r* r% r )rS re r r r rd � s z _make_init.<locals>.<listcomp>zutf-8z<attrs generated init {0}>r: c s s | ] } | j | f Vq d S)N)rT )rS re r r r rV � s z _make_init.<locals>.<genexpr>r � attr_dictTZ_cached_setattrr� )r� r� r� r' r� r; r� �_attrs_to_init_scriptr@ r� r r� r? rn r� r� r� )
rG � post_initr� r� r� r� rD r� r� r� r r r r� � s0
r� c C s( t | j t | d d � | � | _ | S)zR
Add a __init__ method to *cls*. If *frozen* is True, make it immutable.
r F)r� rg rM r� )rO r� r r r � _add_init� s
r� c C sR t | � s t d � � t | d d � } | d k rN t d j d | � � � | S)a�
Returns 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 attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
class.
:rtype: tuple (with name accessors) of :class:`attr.Attribute`
.. versionchanged:: 16.2.0 Returned tuple allows accessing the fields
by name.
z Passed object must be a class.rg Nz({cls!r} is not an attrs-decorated class.rO )r r. rM r r; )rO rG r r r �fields� s r� c C sb t j d k r d SxH t | j � D]7 } | j } | d k r# | | | t | | j � � q# Wd S)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_validatorsr� r r& rM rT )�instre r� r r r �validate s r� c C s� g } | d k r: | j d � d d � } d d � } n d d � } d d � } g } g } i } x�| D]�} | j r� | j | � | j }
| j j d � } t | j t � } | r� | j j r� d
}
n d }
| j d k r�| r�t j
| j � } | j d
k rP| j | |
| d j
|
� � � t j
| j � } | j | | <n# | j | |
| d j
|
� � � | j j
| | <q| j d
k r�| j | |
d j
d |
� � � t j
| j � } | j | | <q| j | |
d j
d |
� � � qk | j t k r�| r�| j d j
d | d |
� � | j d
k rt| j | |
| � � | j | t j
| j � <q| j | |
| � � qk | r�| j d j
d | � � | j d j
d | � � t j
| j � } | j d
k rP| j d | |
| � � | j d � | j d | |
| d j
|
� � � | j | t j
| j � <nN | j d | |
| � � | j d � | j d | |
| d j
|
� � � | j j
| | <qk | j | � | j d
k r�| j | |
| � � | j | t j
| j � <qk | j | |
| � � qk W| r�t | d <| j d � xh | D]` } d j
| j � } d j
| j � }
| j d j
| |
| j � � | j | | <| | |
<q=W| r�| j d � d j
d d j | � d | r�d! j | � n d" � | f S)#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__``.
Tz8_setattr = _cached_setattr.__get__(self, self.__class__)c S s d d | d | i S)Nz(_setattr('%(attr_name)s', %(value_var)s)r7 � value_varr )r7 r� r r r �
fmt_setter) s z)_attrs_to_init_script.<locals>.fmt_setterc S s) t j | � } d d | d | d | i S)Nz2_setattr('%(attr_name)s', %(conv)s(%(value_var)s))r7 r� �conv)�_init_converter_patr; )r7 r� � conv_namer r r �fmt_setter_with_converter/ s
z8_attrs_to_init_script.<locals>.fmt_setter_with_converterc S s d d | d | i S)Nz self.%(attr_name)s = %(value)sr7 rs r )r7 rs r r r r� 7 s c S s) t j | � } d d | d | d | i S)Nz,self.%(attr_name)s = %(conv)s(%(value_var)s)r7 r� r� )r� r; )r7 r� r� r r r r� = s
r r r9 FNz({0})z attr_dict['{attr_name}'].defaultr7 z+{arg_name}=attr_dict['{attr_name}'].default�arg_namez{arg_name}=NOTHINGz if {arg_name} is not NOTHING:z zelse:r z#if _config._run_validators is True:z__attr_validator_{}z __attr_{}z {}(self, {}, self.{})zself.__attrs_post_init__()z(def __init__(self, {args}):
{lines}
�argsz, r� z
�pass)r= r& rT �lstripr[ r% �Factory�
takes_selfr* �_init_factory_patr; r+ r� �factoryr r rA )rG r� r� r� r� r� r� Zattrs_to_validateZnames_for_globalsre r7 r� Z has_factoryZ
maybe_selfZinit_factory_namer� Zval_namer r r r� s�
r� c
@ s e Z d Z d Z d Z d d d d d
d � Z d d � Z e d d � � Z e d d d � � Z
d d � Z d d � Z d S)rb z�
*Read-only* representation of an attribute.
:attribute name: The name of the attribute.
Plus *all* arguments of :func:`attr.ib`.
For the version history of the fields, see :func:`attr.ib`.
rT r% r& r' r( r) r* r, r- r+ Nc
C s� t j | t � } | d k rR | d k r6 t d � � t j d t d d �| } | d | � | d | � | d | � | d | � | d | � | d
| � | d | � | d | � | d
| r� t | � n t � | d |
� d S)NzHCan't pass both `convert` and `converter`. Please use `converter` only.z`The `convert` argument is deprecated in favor of `converter`. It will be removed after 2019/01.r# r$ rT r% r& r' r( r) r* r+ r, r- ) r� r� rb r/ r0 r1 r2 r �_empty_metadata_singleton)
r rT r% r& r' r( r) r* r4 r, r- r+ �
bound_setattrr r r r� � s*
zAttribute.__init__c C s
t � � d S)N)r )r rT rs r r r r� � s zAttribute.__setattr__c C s t j d t d d �| j S)NzaThe `convert` attribute is deprecated in favor of `converter`. It will be removed after 2019/01.r# r$ )r0 r1 r2 r+ )r r r r r4 � s
zAttribute.convertc
sw | d k r � j } n � j d k r3 t d � � � f d d � t j D� } | d | d � j d � j d | | � S)Nz8Type annotation and type argument cannot both be presentc s. i | ]$ } | d k r t � | � | � q S)rT r& r% r- r4 )rT r& r% r- r4 )rM )rS r� )rU r r rf s z0Attribute.from_counting_attr.<locals>.<dictcomp>rT r& r% r- )r- ro rb r� �
_validator�_default)rO rT rU r- � inst_dictr )rU r rc � s
z Attribute.from_counting_attrc s t � f d d � � j D� � S)z(
Play nice with pickle.
c 3 s9 | ]/ } | d k r$ t � | � n t � j � Vq d S)r, N)rM r� r, )rS rT )r r r rV s z)Attribute.__getstate__.<locals>.<genexpr>)r� r� )r r )r r r� s zAttribute.__getstate__c C st t j | t � } x[ t | j | � D]G \ } } | d k rM | | | � q% | | | re t | � n t � q% Wd S)z(
Play nice with pickle.
r, N)r� r� rb r� r� r r� )r r� r� rT rs r r r r� s zAttribute.__setstate__)
rT r% r& r' r( r) r* r, r- r+ )
r r r! r" r� r� r� �propertyr4 r� rc r� r� r r r r rb � s ! rb c C sU g | ]K } | d k r t d | d t d d d d d d d | d k d
d � � q S) r4 rT r% r& Nr' Tr( r) r, r* )rb r )rS rT r r r rd % s rd c C s g | ] } | j r | � q Sr )r) )rS re r r r rd - s c @ s� e Z d Z d Z d Z e d d
� d D� � e d d d d d d d d d d d d d d � f Z d Z d d � Z d d � Z
d d � Z d S) r3 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.
rX r� r' r( r) r* r, r� r+ r- c c sB | ]8 } t d | d t d d d d d d d d d d � Vq d S) rT r% r& Nr' Tr( r) r* )rb r )rS rT r r r rV < s z_CountingAttr.<genexpr>rT r% Nr& TFr c
C s� t j d 7_ t j | _ | | _ | rQ t | t t f � rQ t | � | _ n | | _ | | _ | | _
| | _ | | _ | | _
| | _ | | _ d S)Nr )r3 � cls_counterrX r� r[ �listr� �and_r� r' r( r) r* r+ r, r- )
r r% r& r' r( r) r* r+ r, r- r r r r� F s z_CountingAttr.__init__c C s4 | j d k r | | _ n t | 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& X s z_CountingAttr.validatorc C s1 | j t k r t � � t | d 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
r� T)r� r r
r� )r r� r r r r% f s
z_CountingAttr.default)
rX r� r' r( r) r* r, r� r+ r- )rX r� r' r( r) r* ) r r r! r" r� r� rb rg r� r� r& r% r r r r r3 1 s
r3 r� r* r) c @ s7 e Z d Z d Z e � Z e � Z d d d � Z d S)r� a�
Stores a factory callable.
If passed as the default value to :func:`attr.ib`, 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*
Fc C s | | _ | | _ d S)z�
`Factory` is part of the default machinery so if we want a default
value here, we have to implement it ourselves.
N)r� r� )r r� r� r r r r� � s zFactory.__init__N)r r r! r" r5 r� r� r� r r r r r� { s r� c K s� t | t � r | } n= t | t t f � rI t d d � | D� � } n t d � � | j d d � } t | | | d k r� i n d | i � } y% t j d � j j
d d � | _ Wn t t
f k
r� Yn Xt d | | � | � S)
a
A quick way to create a new class called *name* with *attrs*.
:param name: The name for the new class.
:type name: str
:param attrs: A list of names or a dictionary of mappings of names to
attributes.
:type attrs: :class:`list` or :class:`dict`
:param tuple bases: Classes that the new class will subclass.
:param attributes_arguments: Passed unmodified to :func:`attr.s`.
:return: A new class with *attrs*.
:rtype: type
.. versionadded:: 17.1.0 *bases*
c s s | ] } | t � f Vq d S)N)r5 )rS re r r r rV � s z make_class.<locals>.<genexpr>z(attrs argument must be a dict or a list.r Nr r �__main__rp )r[ r� r� r� r. �popr- �sys� _getframe� f_globalsr^ r r� ro ry )rT rG �basesZattributes_argumentsZcls_dictr� Ztype_r r r �
make_class� s !r� c @ s+ e Z d Z d Z e � Z d d � Z d S)�
_AndValidatorz2
Compose many validators to a single one.
c C s( x! | j D] } | | | | � q
Wd S)N)� _validators)r r� r\ rs r� r r r �__call__� s z_AndValidator.__call__N)r r r! r" r5 r� r� r r r r r� � s r� c G sO g } x6 | D]. } | j t | t � r1 | j n | g � q
Wt t | � � S)z�
A validator that composes multiple validators into one.
When called on a value, it runs all wrapped validators.
:param validators: Arbitrary number of validators.
:type validators: callables
.. versionadded:: 17.1.0
)�extendr[ r� r� r� )Z
validators�valsr& r r r r� � s
r� )AZ
__future__r r r r� r� r� r0 �operatorr r9 r Z_compatr r r
r r �
exceptionsr
r r r �objectr� r� r� r� r> r� r r r5 rE rF rK rR rr rt ru rv rG ry r� r� r� r� r r� r� r� r� r� r� r� r� r� rb r� Z_ar3 r� r� r� r� r r r r �<module> s| (" r
p � � ( Y
" , �j
G% 3