ó
9(Zc @` sw d d l m Z m Z m 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 d e f d „ ƒ YZ e ƒ Z e d e e d e d i d d
„ Z! d „ Z" e" d d d g ƒ Z# d „ Z$ d „ Z% d „ Z& d „ Z' d e f d „ ƒ YZ( d d d e e d e e) e) e) e) d „ Z* e* Z+ e r®d „ Z, n d „ Z, d „ Z- d „ Z. d „ Z/ d „ Z0 d d „ Z1 d „ Z2 d d d! „ Z3 d" „ Z4 d# „ Z5 d$ „ Z6 d% „ Z7 d& „ Z8 d' e f d( „ ƒ YZ9 g e9 j: D]? Z; e9 d) e; d* e d+ d d, e d- e d. e; d/ k d0 e ƒ ^ qLZ< e/ e1 e3 e9 d e< ƒd e< ƒd g e< D] Z= e= j> r¹e= ^ q¹ƒZ9 d1 e f d2 „ ƒ YZ? e1 e3 e? ƒ ƒ Z? e* d3 e d0 e) d. e ƒ d4 e f d5 „ ƒ Yƒ Z@ e f d6 „ ZA e* d3 e d. e ƒ d7 e f d8 „ ƒ Yƒ ZB d9 „ ZC d S(: i ( t absolute_importt divisiont print_functionN( t
itemgetteri ( t _config( t PY2t iteritemst isclasst metadata_proxyt set_closure_cell( t DefaultAlreadySetErrort FrozenInstanceErrort NotAnAttrsClassErrort UnannotatedAttributeErrors __attr_convert_{}s __attr_factory_{}s/ {attr_name} = property(itemgetter({index}))t _Nothingc B` sD e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z RS( s€
Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
All instances of `_Nothing` are equal.
c C` s | S( N( ( t self( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __copy__' s c C` s | S( N( ( R t _( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __deepcopy__* s c C` s
| j t k S( N( t __class__R ( R t other( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __eq__- s c C` s | | k S( N( ( R R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __ne__0 s c C` s d S( Nt NOTHING( ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __repr__3 s c C` s d S( NIï¾Þ ( ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __hash__6 s ( t __name__t
__module__t __doc__R R R R R R ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR ! s c C` sp | d k r3 | t k r3 | t k r3 t d ƒ ‚ n t d | d | d | d | d | d | d | d | d
| ƒ S( s9
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 convert: :func:`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 :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 `_).
This argument is provided for backward compatibility.
Regardless of the approach used, the type will be stored on
``Attribute.type``.
.. 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*
s6 Invalid value for hash. Must be True, False, or None.t defaultt validatort reprt cmpt hasht initt convertt metadatat typeN( t Nonet Truet Falset TypeErrort
_CountingAttr( R R R R R! R" R# R$ R% ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt attrib@ s M$ c C` s d j | ƒ } d j | ƒ d g } | ri xI t | ƒ D]+ \ } } | j t j d | d | ƒ ƒ q7 Wn
| j d ƒ i t d 6} t t d j | ƒ d d
ƒ | ƒ | | S( sé
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))
s {}Attributess class {}(tuple):s __slots__ = ()t indext attr_names passR s
t t exec( t formatt enumeratet appendt _tuple_property_patR t evalt compilet join( t cls_namet
attr_namest attr_class_namet attr_class_templatet iR- t globs( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _make_attr_tuple_classž s
"t _Attributest attrst super_attrsc C` s t | ƒ j d ƒ S( s½
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.
s typing.ClassVar( t strt
startswith( t annot( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt
_is_class_var s c ` s® | j ‰ t | d i ƒ } | d k r[ | t k r[ t d „ ˆ j ƒ Dƒ d d „ ƒ} nP| d k r†| t k r†d „ ˆ j ƒ Dƒ } g } t ƒ } x— | j ƒ D]‰ \ } } t | ƒ rà q¥ n | j | ƒ ˆ j
| t ƒ } t | t
ƒ s| t k r t ƒ } qt d | ƒ } n | j | | f ƒ q¥ W| | }
t |
ƒ d k r«t d d j t |
d ‡ f d
† ƒƒ d ƒ ‚ q«n% t d „ t | ƒ Dƒ d d
„ ƒ} g | D]3 \ } } t j d | d | d | j
| ƒ ƒ ^ q²} g }
t d „ | Dƒ ƒ } x | j d d !D]m } t | d d ƒ } | d k rxF t | ƒ D]5 } | j | k rI|
j | ƒ | j | j ƒ qIqIWqqW|
j ƒ g |
| D] } | j ^ qž} t | j | ƒ } | |
g | D]3 \ } } t j d | d | d | j
| ƒ ƒ ^ qÒƒ } t } x† | D]~ } | t k rg| j t k rg| j t k rgt d j d | ƒ ƒ ‚ q | t k r | j t k r | j t k r t } q q Wt | |
f ƒ S( s®
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`.
t __annotations__c s` s0 | ]& \ } } t | t ƒ r | | f Vq d S( N( t
isinstanceR* ( t .0t namet attr( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys Ù s t keyc S` s | d j S( Ni ( t counter( t e( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt Ý s c S` s+ h | ]! \ } } t | t ƒ r | ’ q S( ( RF R* ( RG RH RI ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys à s R i s1 The following `attr.ib`s lack a type annotation: s , c ` s ˆ j | ƒ j S( N( t getRK ( t n( t cd( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRM ù s t .c s` s! | ] \ } } | | f Vq d S( N( ( RG RH t ca( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys þ s c S` s | d j S( Ni ( RK ( RL ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRM s RH RR R% c s` s | ] } | j Vq d S( N( RH ( RG t a( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys s i iÿÿÿÿt __attrs_attrs__sq No mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: {a!r}RS N(! t __dict__t getattrR& R( t sortedt itemsR' t setRD t addRN R RF R* R+ R2 t lenR
R6 R t Attributet from_counting_attrt __mro__t reversedRH t reverseR= R R R" t
ValueErrorR0 R> ( t clst theset auto_attribst annst ca_listt ca_namest annot_namesR- R% RS t unannotatedRR t non_super_attrsR@ t taken_attr_namest super_clst sub_attrsR8 t
AttrsClassR? t had_default( ( RP s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _transform_attrsÌ sv
5 =
A
*
c C` s
t ƒ ‚ d S( s4
Attached to frozen classes as __setattr__.
N( R ( R RH t value( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _frozen_setattrsA s c C` s
t ƒ ‚ d S( s4
Attached to frozen classes as __delattr__.
N( R ( R RH ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _frozen_delattrsH s t
_ClassBuilderc B` sw e Z d Z d Z d „ Z d
„ Z d „ Z d „ Z d
„ Z d „ Z d „ Z
d „ Z d „ Z d „ Z
d „ Z RS( s(
Iteratively build *one* class.
t _clst _cls_dictt _attrst _super_namest _attr_namest _slotst _frozent _has_post_initc C` sê t | | | ƒ \ } } | | _ | r6 t | j ƒ n i | _ | | _ t d „ | Dƒ ƒ | _ t d „ | Dƒ ƒ | _ | | _
| p’ t | ƒ | _ t
t | d t ƒ ƒ | _ | j | j d <| ræ t | j d ^ s c s` s | ] } | j Vq d S( N( RH ( RG RS ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys _ s t __attrs_post_init__RT t __setattr__t __delattr__( Rp Ru t dictRU Rv Rw RY Rx t tupleRy Rz t _has_frozen_superclassR{ t boolRV R( R| Rr Rs ( R Rb Rc t slotst frozenRd R? R@ ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __init__X s
c C` s d j d | j j ƒ S( Ns <_ClassBuilder(cls={cls})>Rb ( R0 Ru R ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR j s c C` s' | j t k r | j ƒ S| j ƒ Sd S( s‹
Finalize class based on the accumulated configuration.
Builder cannot be used anymore after calling this method.
N( Rz R' t _create_slots_classt _patch_original_class( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt build_classm s
c C` sŽ | j } | j } xE | j D]: } | | k r t | | d ƒ d k r t | | ƒ q q Wx- | j j ƒ D] \ } } t | | | ƒ qj W| S( sA
Apply accumulated methods and return the class.
N( Ru Rx Ry RV R& t delattrRv RX t setattr( R Rb t super_namesRH Rq ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRˆ x s c ` s} ˆ j ‰ ‡ f d † t ˆ j ƒ Dƒ } t ‡ f d † ˆ j Dƒ ƒ | d ‘ s c 3` s! | ] } | ˆ k r | Vq d S( N( ( RG RH ( RŒ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys ™ s t __slots__t __qualname__c ` s t ‡ f d † ˆ Dƒ ƒ S( s9
Automatically created by attrs.
c 3` s | ] } t ˆ | ƒ Vq d S( N( RV ( RG RH ( R ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys ¨ s ( R ( R ( R8 ( R s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt slots_getstate¤ s c ` sC t j | t ƒ } x* t ˆ | ƒ D] \ } } | | | ƒ q" Wd S( s9
Automatically created by attrs.
N( t _obj_setattrt __get__R\ t zip( R t statet _ClassBuilder__bound_setattrRH Rq ( R8 ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt slots_setstateª s t __getstate__t __setstate__t __closure__N( Rx R Rv R Ry RV Ru R& R% R t __bases__RU t valuesRF t classmethodt staticmethodt __func__t
cell_contentsR ( R RP t qualnameR‘ R— Rb t itemt
closure_cellst cell( ( R8 R RŒ s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR‡ ‹ s8
c C` s t | j d | ƒ| j d <| S( Nt nsR ( t
_make_reprRw Rv ( R R¥ ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt add_reprÓ s c C` s> | j j d ƒ } | d k r- t d ƒ ‚ n | | j d <| S( NR s3 __str__ can only be generated if a __repr__ exists.t __str__( Rv RN R& Ra ( R t repr_( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt add_str× s
c C` s d | j d <| S( NR ( R& Rv ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt make_unhashableá s
c C` s t | j ƒ | j d <| S( NR ( t
_make_hashRw Rv ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt add_hashå s c C` s& t | j | j | j ƒ | j d <| S( NR† ( t
_make_initRw R| R{ Rv ( R ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt add_inité s
c C` sF | j } t | j ƒ \ | d <| d <| d <| d <| d <| d <| S( NR R t __lt__t __le__t __gt__t __ge__( Rv t _make_cmpRw ( R RP ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt add_cmpñ s 9( s _clss _cls_dicts _attrss _super_namess _attr_namess _slotss _frozens _has_post_init( R R R R R† R R‰ Rˆ R‡ R§ Rª R« R R¯ Rµ ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRt O s H
c
` sH ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ f
d † } | d k r: | S| | ƒ Sd S( sU
A class decorator that adds `dunder
`_\ -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 \
`_
and the `GitHub issue that led to the default behavior \
`_ 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
` 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 ` sQ t | d d ƒ d k r' t d ƒ ‚ n t | ˆ ˆ ˆ ˆ ƒ } ˆ t k r[ | j ˆ ƒ n ˆ t k rt | j ƒ n ˆ t k r | j ƒ n ˆ t k rÀ ˆ t k rÀ ˆ d k rÀ t d ƒ ‚ nn ˆ t k s.ˆ d k rç ˆ t k rç nG ˆ t k sˆ d k r$ˆ t k r$ˆ t k r$| j ƒ n
| j
ƒ ˆ t k rG| j ƒ n | j ƒ S( NR s( attrs only works with new-style classes.s6 Invalid value for hash. Must be True, False, or None.(
RV R& R) Rt R' R§ Rª Rµ R( R R« R¯ R‰ ( Rb t builder(
Rd R R… R! R" R t repr_nsR„ RA Rc ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt wrapa s(
$ $0
N( R& ( t maybe_clsRc R· R R R! R" R„ R… RA Rd R¸ ( (
Rd R R… R! R" R R· R„ RA Rc s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR? ú s g* c C` s1 t | j d d ƒ t j k o0 | j j t j k S( sb
Check whether *cls* has a frozen ancestor by looking at its
__setattr__.
R N( RV R~ R& Rr R R ( Rb ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR‚ s c C` s
| j t k S( sb
Check whether *cls* has a frozen ancestor by looking at its
__setattr__.
( R~ Rr ( Rb ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR‚ › s c ` s t ‡ f d † | Dƒ ƒ S( s:
Create a tuple of all values of *obj*'s *attrs*.
c 3` s! | ] } t ˆ | j ƒ Vq d S( N( RV RH ( RG RS ( t obj( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys § s ( R ( Rº R? ( ( Rº s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _attrs_to_tuple£ s c ` s) t d „ ˆ Dƒ ƒ ‰ ‡ f d † } | S( Nc s` sB | ]8 } | j t k s6 | j d k r | j t k r | Vq d S( N( R! R' R& R ( RG RS ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys ¬ s c ` s t t | ˆ ƒ ƒ S( s1
Automatically created by attrs.
( R! R» ( R ( R? ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt hash_± s ( R ( R? R¼ ( ( R? s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR¬ ª s
c C` s t | ƒ | _ | S( s%
Add a hash method to *cls*.
( R¬ R ( Rb R? ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _add_hashº s c ` s¡ g ˆ D] } | j r | ^ q ‰ ‡ f d † ‰ ‡ f d † ‰ ‡ f d † } ‡ f d † } ‡ f d † } ‡ f d † } ‡ f d † } ˆ | | | | | f S( Nc ` s
t | ˆ ƒ S( s&
Save us some typing.
( R» ( Rº ( R? ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt attrs_to_tupleÅ s c ` s0 | j | j k r( ˆ | ƒ ˆ | ƒ k St Sd S( s1
Automatically created by attrs.
N( R t NotImplemented( R R ( R¾ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt eqË s c ` s( ˆ | | ƒ } | t k r t S| Sd S( s1
Automatically created by attrs.
N( R¿ ( R R t result( RÀ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt neÔ s c ` s0 t | | j ƒ r( ˆ | ƒ ˆ | ƒ k St Sd S( s1
Automatically created by attrs.
N( RF R R¿ ( R R ( R¾ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt ltÞ s c ` s0 t | | j ƒ r( ˆ | ƒ ˆ | ƒ k St Sd S( s1
Automatically created by attrs.
N( RF R R¿ ( R R ( R¾ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt leç s c ` s0 t | | j ƒ r( ˆ | ƒ ˆ | ƒ k St Sd S( s1
Automatically created by attrs.
N( RF R R¿ ( R R ( R¾ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt gtð s c ` s0 t | | j ƒ r( ˆ | ƒ ˆ | ƒ k St Sd S( s1
Automatically created by attrs.
N( RF R R¿ ( R R ( R¾ ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt geù s ( R ( R? RS RÂ RÃ RÄ RÅ RÆ ( ( R? R¾ RÀ s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR´ Â s "
c C` sL | d k r | j } n t | ƒ \ | _ | _ | _ | _ | _ | _ | S( s*
Add comparison methods to *cls*.
N( R& RT R´ R R R° R± R² R³ ( Rb R? ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _add_cmp s 0c ` s, t d „ | Dƒ ƒ ‰ ‡ ‡ f d † } | S( sK
Make a repr method for *attr_names* adding *ns* to the full name.
c s` s! | ] } | j r | j Vq d S( N( R RH ( RG RS ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys s 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ƒ ƒ ƒ S(
s1
Automatically created by attrs.
R s >.i iÿÿÿÿRQ s {0}({1})s , c 3` s, | ]" } | d t t ˆ | ƒ ƒ Vq d S( t =N( R RV ( RG RH ( R ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys - s N( R R& RV t rsplitR R0 R6 ( R t real_clsR¡ t
class_name( R8 R¥ ( R s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR© s ( R ( R? R¥ R© ( ( R8 R¥ s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR¦ s
c C` s4 | d k r | j } n t | | ƒ } | | _ | S( s%
Add a repr method to *cls*.
N( R& RT R¦ R ( Rb R¥ R? R© ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _add_repr4 s
c C` s. g | D]$ } | j s% | j t k r | ^ q } t j ƒ } | j t | ƒ j d ƒ ƒ d j | j ƒ ƒ } t
| | | ƒ \ } } i } t | | d ƒ } t d „ | Dƒ ƒ }
| j i t d 6|
d 6ƒ | t
k rè t | d R/ c s` s | ] } | j | f Vq d S( N( RH ( RG RS ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys U s R t attr_dictt _cached_setattrR† ( R" R R t hashlibt sha1t updateR t encodeR0 t hexdigestt _attrs_to_scriptR5 R€ R' R’ R4 R[ R& t
splitlinest linecachet cache( R? t post_initR… RS RÐ t unique_filenamet scriptR< t locst bytecodeRÍ R" ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR® @ s4
$
c C` s( t | j t | d t ƒ | ƒ | _ | S( sR
Add a __init__ method to *cls*. If *frozen* is True, make it immutable.
R} ( R® RT RV R( R† ( Rb R… ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt _add_initm s
c C` sX t | ƒ s t d ƒ ‚ n t | d d ƒ } | d k rT t d j d | ƒ ƒ ‚ n | S( sö
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.
s Passed object must be a class.RT s( {cls!r} is not an attrs-decorated class.Rb N( R R) RV R& R R0 ( Rb R? ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt fieldsy s c C` se t j t k r d SxK t | j ƒ D]: } | j } | d k r# | | | t | | j ƒ ƒ q# q# Wd S( s§
Validate all attributes on *inst* that have a validator.
Leaves all exceptions through.
:param inst: Instance of a class with ``attrs`` attributes.
N( R t _run_validatorsR( RÞ R R R& RV RH ( t instRS RŽ ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt validate• s c C` së g } | t k r4 | j d ƒ d „ } d „ } n d „ } d „ } g } g } i } xµ| D]} | j r~ | j | ƒ n | j }
| j j d ƒ } t | j t ƒ } | rÆ | j j rÆ d }
n d }
| j t
k rõ| r}t j | j ƒ } | j
d k rG| j | |
| d j |
ƒ ƒ ƒ t j | j ƒ } | j
| | m s RH R R R% ( R& R% Ra R\ R t
_validatort _default( Rb RH RR R% t inst_dict( ( RR s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR] c s
c ` s t ‡ f d † ˆ j Dƒ ƒ S( s(
Play nice with pickle.
c 3` s9 | ]/ } | d k r$ t ˆ | ƒ n t ˆ j ƒ Vq d S( R$ N( RV R€ R$ ( RG RH ( R ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys | s ( R R ( R ( ( R s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR˜ x s c C` st t j | t ƒ } x[ t | j | ƒ D]G \ } } | d k rM | | | ƒ q% | | | re t | ƒ n t ƒ q% Wd S( s(
Play nice with pickle.
R$ N( R’ R“ R\ R” R R R÷ ( R R• Rø RH Rq ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR™ € s (
s names defaults validators reprs cmps hashs inits converts metadatas typeN( R R R R R& R† R~ R R] R˜ R™ ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR\ B s RH R R R R R! R$ R" R* c B` s e Z d Z d Z e d „ d Dƒ ƒ e d d d
d d d d e d e d e d e ƒ f Z d Z
d „ Z d „ Z d „ Z
RS( s
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.
RK Rú R R R! R" R$ Rù R# R% c c` sB | ]8 } t d | d t d d d t d t d t d t ƒ Vq d S( RH R R R R R! R" N( R\ R R& R' ( RG RH ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys ¢ s RH R R i c
C` s t j d 7_ t j | _ | | _ | rQ t | t t f ƒ rQ t | Œ | _ n | | _ | | _ | | _
| | _ | | _ | | _
| | _ | | _ d S( Ni ( R* t cls_counterRK Rú RF t listR t and_Rù R R R! R" R# R$ R% (
R R R R R R! R" R# R$ R% ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR† ¬ s c C` s4 | j d k r | | _ n t | j | ƒ | _ | S( sŒ
Decorator that adds *meth* to the list of validators.
Returns *meth* unchanged.
.. versionadded:: 17.1.0
N( Rù R& Rþ ( R t meth( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR ¾ s c C` s4 | j t k r t ƒ ‚ n t | d t ƒ| _ | S( sÚ
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î ( Rú R R
Rí R' ( R Rÿ ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR Ì s
(
s counters _defaults reprs cmps hashs inits metadatas
_validators converts type( s counters _defaults reprs cmps hashs initN( R R R R R R\ R& R' R( RT Rü R† R R ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR* — s
R„ Rí c B` s, e Z d Z e ƒ Z e ƒ Z e d „ Z RS( sÉ
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*
c C` s | | _ | | _ d S( s‹
`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î ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR† ó s ( R R R R+ Rð Rî R( R† ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRí á s c K` sä t | t ƒ r | } n: t | t t f ƒ rF t d „ | Dƒ ƒ } n t d ƒ ‚ | j d d ƒ } t | | | d k r i n
i | d 6ƒ } y% t j d ƒ j
j d d ƒ | _ Wn t
t f k
rÍ n Xt d | | | ƒ S( s
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( R+ ( RG RS ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pys s s( attrs argument must be a dict or a list.R} i R t __main__Rc N( RF R€ Rý R R) t popR& R% t syst _getframet f_globalsRN R t AttributeErrorRa Rw ( RH R? t basest attributes_argumentst cls_dictRØ t type_( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt
make_classü s "t
_AndValidatorc B` s e Z d Z e ƒ Z d „ Z RS( s2
Compose many validators to a single one.
c C` s( x! | j D] } | | | | ƒ q
Wd S( N( t _validators( R Rà RI Rq RŽ ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt __call__6 s ( R R R R+ R R
( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyR / s c G` sO g } x6 | D]. } | j t | t ƒ r1 | j n | g ƒ q
Wt t | ƒ ƒ S( sô
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
( t extendRF R R R ( t
validatorst valsR ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyRþ ; s
(D t
__future__R R R RÏ RÖ R t operatorR R. R t _compatR R R R R t
exceptionsR
R R R
t objectR~ R’ Rå Rï R3 R÷ R R R& R' R+ R= R> RD Rp Rr Rs Rt R( R? Rw R‚ R» R¬ R½ R´ RÇ R¦ RÌ R® RÝ RÞ Rá RÔ R\ R RH t _aRS R! R* Rí R
R Rþ ( ( ( s) /tmp/pip-build-wDUJoH/attrs/attr/_make.pyt sv (" \
u « ‹ C
" - œKL %G3