FileXXXXXXXXXXX

File manager - Edit - /var/www/payraty/helpdesk/public/storage/branding_media/images/attr.zip

Back
PK��!�mt^��currentnu�W+A��unconfined PK��!��prevnu��6�$��PK��!��execnu�W+A��PK��!��fscreatenu�W+A��PK��!�� keycreatenu�W+A��PK��!�� sockcreatenu�W+A��PK��!�� smack/currentnu�W+A��PK��!�mt^��apparmor/currentnu�W+A��unconfined PK��!�� apparmor/prevnu��6�$��PK��!�� apparmor/execnu�W+A��PK��!��b��}��}��_make.pynu��[��from __future__ import absolute_import, division, print_function import copy import inspect import linecache import sys import threading import uuid import warnings from operator import itemgetter from . import _config, setters from ._compat import ( PY2, PYPY, isclass, iteritems, metadata_proxy, new_class, ordered_dict, set_closure_cell, ) from .exceptions import ( DefaultAlreadySetError, FrozenInstanceError, NotAnAttrsClassError, PythonTooOldError, UnannotatedAttributeError, ) if not PY2: import typing # This is used at least twice, so cache it here. _obj_setattr = object.__setattr__ _init_converter_pat = "__attr_converter_%s" _init_factory_pat = "__attr_factory_{}" _tuple_property_pat = ( " {attr_name} = _attrs_property(_attrs_itemgetter({index}))" ) _classvar_prefixes = ( "typing.ClassVar", "t.ClassVar", "ClassVar", "typing_extensions.ClassVar", ) # we don't use a double-underscore prefix because that triggers # name mangling when trying to create a slot for the field # (when slots=True) _hash_cache_field = "_attrs_cached_hash" _empty_metadata_singleton = metadata_proxy({}) # Unique object for unequivocal getattr() defaults. _sentinel = object() class _Nothing(object): """ Sentinel class to indicate the lack of a value when ``None`` is ambiguous. ``_Nothing`` is a singleton. There is only ever one of it. .. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False. """ _singleton = None def __new__(cls): if _Nothing._singleton is None: _Nothing._singleton = super(_Nothing, cls).__new__(cls) return _Nothing._singleton def __repr__(self): return "NOTHING" def __bool__(self): return False def __len__(self): return 0 # __bool__ for Python 2 NOTHING = _Nothing() """ Sentinel to indicate the lack of a value when ``None`` is ambiguous. """ class _CacheHashWrapper(int): """ 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. """ if PY2: # For some reason `type(None)` isn't callable in Python 2, but we don't # actually need a constructor for None objects, we just need any # available function that returns None. def __reduce__(self, _none_constructor=getattr, _args=(0, "", None)): return _none_constructor, _args else: def __reduce__(self, _none_constructor=type(None), _args=()): return _none_constructor, _args def attrib( default=NOTHING, validator=None, repr=True, cmp=None, hash=None, init=True, metadata=None, type=None, converter=None, factory=None, kw_only=False, eq=None, order=None, on_setattr=None, ): """ Create a new attribute on a class. .. warning:: Does not do anything unless the class is also decorated with `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 `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 `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 `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 `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 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. 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``. 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 (Python 3+) 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 `attr.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 `attr.setters.NO_OP` .. 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 """ eq, eq_key, order, order_key = _determine_attrib_eq_order( cmp, eq, order, True ) if hash is not None and hash is not True and hash is not False: raise TypeError( "Invalid value for hash. Must be True, False, or None." ) if factory is not None: if default is not NOTHING: raise ValueError( "The `default` and `factory` arguments are mutually " "exclusive." ) if not callable(factory): raise ValueError("The `factory` argument must be a callable.") default = Factory(factory) if metadata is None: metadata = {} # Apply syntactic sugar by auto-wrapping. if isinstance(on_setattr, (list, tuple)): on_setattr = setters.pipe(on_setattr) if validator and isinstance(validator, (list, tuple)): validator = and_(validator) if converter and isinstance(converter, (list, tuple)): converter = pipe(converter) return _CountingAttr( default=default, validator=validator, repr=repr, cmp=None, hash=hash, init=init, converter=converter, metadata=metadata, type=type, kw_only=kw_only, eq=eq, eq_key=eq_key, order=order, order_key=order_key, on_setattr=on_setattr, ) def _compile_and_eval(script, globs, locs=None, filename=""): """ "Exec" the script with the given global (globs) and local (locs) variables. """ bytecode = compile(script, filename, "exec") eval(bytecode, globs, locs) def _make_method(name, script, filename, globs=None): """ Create the method with the script given and return the method object. """ locs = {} if globs is None: globs = {} _compile_and_eval(script, globs, locs, filename) # In order of debuggers like PDB being able to step through the code, # we add a fake linecache entry. linecache.cache[filename] = ( len(script), None, script.splitlines(True), filename, ) return locs[name] def _make_attr_tuple_class(cls_name, attr_names): """ 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)) """ attr_class_name = "{}Attributes".format(cls_name) attr_class_template = [ "class {}(tuple):".format(attr_class_name), " __slots__ = ()", ] if attr_names: for i, attr_name in enumerate(attr_names): attr_class_template.append( _tuple_property_pat.format(index=i, attr_name=attr_name) ) else: attr_class_template.append(" pass") globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property} _compile_and_eval("\n".join(attr_class_template), globs) return globs[attr_class_name] # Tuple class for extracted attributes from a class definition. # `base_attrs` is a subset of `attrs`. _Attributes = _make_attr_tuple_class( "_Attributes", [ # all attributes to build dunder methods for "attrs", # attributes that have been inherited "base_attrs", # map inherited attributes to their originating classes "base_attrs_map", ], ) def _is_class_var(annot): """ 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. """ annot = str(annot) # Annotation can be quoted. if annot.startswith(("'", '"')) and annot.endswith(("'", '"')): annot = annot[1:-1] return annot.startswith(_classvar_prefixes) def _has_own_attribute(cls, attrib_name): """ Check whether cls defines attrib_name (and doesn't just inherit it). Requires Python 3. """ attr = getattr(cls, attrib_name, _sentinel) if attr is _sentinel: return False for base_cls in cls.__mro__[1:]: a = getattr(base_cls, attrib_name, None) if attr is a: return False return True def _get_annotations(cls): """ Get annotations for cls. """ if _has_own_attribute(cls, "__annotations__"): return cls.__annotations__ return {} def _counter_getter(e): """ Key function for sorting to avoid re-creating a lambda for every class. """ return e[1].counter def _collect_base_attrs(cls, taken_attr_names): """ Collect attr.ibs from base classes of cls, except taken_attr_names. """ base_attrs = [] base_attr_map = {} # A dictionary of base attrs to their classes. # Traverse the MRO and collect attributes. for base_cls in reversed(cls.__mro__[1:-1]): for a in getattr(base_cls, "__attrs_attrs__", []): if a.inherited or a.name in taken_attr_names: continue a = a.evolve(inherited=True) base_attrs.append(a) base_attr_map[a.name] = base_cls # For each name, only keep the freshest definition i.e. the furthest at the # back. base_attr_map is fine because it gets overwritten with every new # instance. filtered = [] seen = set() for a in reversed(base_attrs): if a.name in seen: continue filtered.insert(0, a) seen.add(a.name) return filtered, base_attr_map def _collect_base_attrs_broken(cls, taken_attr_names): """ 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. """ base_attrs = [] base_attr_map = {} # A dictionary of base attrs to their classes. # Traverse the MRO and collect attributes. for base_cls in cls.__mro__[1:-1]: for a in getattr(base_cls, "__attrs_attrs__", []): if a.name in taken_attr_names: continue a = a.evolve(inherited=True) taken_attr_names.add(a.name) base_attrs.append(a) base_attr_map[a.name] = base_cls return base_attrs, base_attr_map def _transform_attrs( cls, these, auto_attribs, kw_only, collect_by_mro, field_transformer ): """ 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`. """ cd = cls.__dict__ anns = _get_annotations(cls) if these is not None: ca_list = [(name, ca) for name, ca in iteritems(these)] if not isinstance(these, ordered_dict): ca_list.sort(key=_counter_getter) elif auto_attribs is True: ca_names = { name for name, attr in cd.items() if isinstance(attr, _CountingAttr) } ca_list = [] annot_names = set() for attr_name, type in anns.items(): if _is_class_var(type): continue annot_names.add(attr_name) a = cd.get(attr_name, NOTHING) if not isinstance(a, _CountingAttr): if a is NOTHING: a = attrib() else: a = attrib(default=a) ca_list.append((attr_name, a)) unannotated = ca_names - annot_names if len(unannotated) > 0: raise UnannotatedAttributeError( "The following `attr.ib`s lack a type annotation: " + ", ".join( sorted(unannotated, key=lambda n: cd.get(n).counter) ) + "." ) else: ca_list = sorted( ( (name, attr) for name, attr in cd.items() if isinstance(attr, _CountingAttr) ), key=lambda e: e[1].counter, ) own_attrs = [ Attribute.from_counting_attr( name=attr_name, ca=ca, type=anns.get(attr_name) ) for attr_name, ca in ca_list ] if collect_by_mro: base_attrs, base_attr_map = _collect_base_attrs( cls, {a.name for a in own_attrs} ) else: base_attrs, base_attr_map = _collect_base_attrs_broken( cls, {a.name for a in own_attrs} ) attr_names = [a.name for a in base_attrs + own_attrs] AttrsClass = _make_attr_tuple_class(cls.__name__, attr_names) if kw_only: own_attrs = [a.evolve(kw_only=True) for a in own_attrs] base_attrs = [a.evolve(kw_only=True) for a in base_attrs] attrs = AttrsClass(base_attrs + own_attrs) # Mandatory vs non-mandatory attr order only matters when they are part of # the __init__ signature and when they aren't kw_only (which are moved to # the end and can be mandatory or non-mandatory in any order, as they will # be specified as keyword args anyway). Check the order of those attrs: had_default = False for a in (a for a in attrs if a.init is not False and a.kw_only is False): if had_default is True and a.default is NOTHING: raise ValueError( "No mandatory attributes allowed after an attribute with a " "default value or factory. Attribute in question: %r" % (a,) ) if had_default is False and a.default is not NOTHING: had_default = True if field_transformer is not None: attrs = field_transformer(cls, attrs) return _Attributes((attrs, base_attrs, base_attr_map)) if PYPY: def _frozen_setattrs(self, name, value): """ Attached to frozen classes as __setattr__. """ if isinstance(self, BaseException) and name in ( "__cause__", "__context__", ): BaseException.__setattr__(self, name, value) return raise FrozenInstanceError() else: def _frozen_setattrs(self, name, value): """ Attached to frozen classes as __setattr__. """ raise FrozenInstanceError() def _frozen_delattrs(self, name): """ Attached to frozen classes as __delattr__. """ raise FrozenInstanceError() class _ClassBuilder(object): """ Iteratively build one class. """ __slots__ = ( "_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", "_has_own_setattr", "_has_custom_setattr", ) def __init__( self, cls, these, slots, frozen, weakref_slot, getstate_setstate, auto_attribs, kw_only, cache_hash, is_exc, collect_by_mro, on_setattr, has_custom_setattr, field_transformer, ): attrs, base_attrs, base_map = _transform_attrs( cls, these, auto_attribs, kw_only, collect_by_mro, field_transformer, ) self._cls = cls self._cls_dict = dict(cls.__dict__) if slots else {} self._attrs = attrs self._base_names = set(a.name for a in base_attrs) self._base_attr_map = base_map self._attr_names = tuple(a.name for a in attrs) self._slots = slots self._frozen = frozen self._weakref_slot = weakref_slot self._cache_hash = cache_hash self._has_pre_init = bool(getattr(cls, "__attrs_pre_init__", False)) self._has_post_init = bool(getattr(cls, "__attrs_post_init__", False)) self._delete_attribs = not bool(these) self._is_exc = is_exc self._on_setattr = on_setattr self._has_custom_setattr = has_custom_setattr self._has_own_setattr = False self._cls_dict["__attrs_attrs__"] = self._attrs if frozen: self._cls_dict["__setattr__"] = _frozen_setattrs self._cls_dict["__delattr__"] = _frozen_delattrs self._has_own_setattr = True if getstate_setstate: ( self._cls_dict["__getstate__"], self._cls_dict["__setstate__"], ) = self._make_getstate_setstate() def __repr__(self): return "<_ClassBuilder(cls={cls})>".format(cls=self._cls.__name__) def build_class(self): """ Finalize class based on the accumulated configuration. Builder cannot be used after calling this method. """ if self._slots is True: return self._create_slots_class() else: return self._patch_original_class() def _patch_original_class(self): """ Apply accumulated methods and return the class. """ cls = self._cls base_names = self._base_names # Clean class of attribute definitions (`attr.ib()`s). if self._delete_attribs: for name in self._attr_names: if ( name not in base_names and getattr(cls, name, _sentinel) is not _sentinel ): try: delattr(cls, name) except AttributeError: # This can happen if a base class defines a class # variable and we want to set an attribute with the # same name by using only a type annotation. pass # Attach our dunder methods. for name, value in self._cls_dict.items(): setattr(cls, name, value) # If we've inherited an attrs __setattr__ and don't write our own, # reset it to object's. if not self._has_own_setattr and getattr( cls, "__attrs_own_setattr__", False ): cls.__attrs_own_setattr__ = False if not self._has_custom_setattr: cls.__setattr__ = object.__setattr__ return cls def _create_slots_class(self): """ Build and return a new class with a `__slots__` attribute. """ cd = { k: v for k, v in iteritems(self._cls_dict) if k not in tuple(self._attr_names) + ("__dict__", "__weakref__") } # If our class doesn't have its own implementation of __setattr__ # (either from the user or by us), check the bases, if one of them has # an attrs-made __setattr__, that needs to be reset. We don't walk the # MRO because we only care about our immediate base classes. # XXX: This can be confused by subclassing a slotted attrs class with # XXX: a non-attrs class and subclass the resulting class with an attrs # XXX: class. See `test_slotted_confused` for details. For now that's # XXX: OK with us. if not self._has_own_setattr: cd["__attrs_own_setattr__"] = False if not self._has_custom_setattr: for base_cls in self._cls.__bases__: if base_cls.__dict__.get("__attrs_own_setattr__", False): cd["__setattr__"] = object.__setattr__ break # Traverse the MRO to collect existing slots # and check for an existing __weakref__. existing_slots = dict() weakref_inherited = False for base_cls in self._cls.__mro__[1:-1]: if base_cls.__dict__.get("__weakref__", None) is not None: weakref_inherited = True existing_slots.update( { name: getattr(base_cls, name) for name in getattr(base_cls, "__slots__", []) } ) base_names = set(self._base_names) names = self._attr_names if ( self._weakref_slot and "__weakref__" not in getattr(self._cls, "__slots__", ()) and "__weakref__" not in names and not weakref_inherited ): names += ("__weakref__",) # We only add the names of attributes that aren't inherited. # Setting __slots__ to inherited attributes wastes memory. slot_names = [name for name in names if name not in base_names] # There are slots for attributes from current class # that are defined in parent classes. # As their descriptors may be overriden by a child class, # we collect them here and update the class dict reused_slots = { slot: slot_descriptor for slot, slot_descriptor in iteritems(existing_slots) if slot in slot_names } slot_names = [name for name in slot_names if name not in reused_slots] cd.update(reused_slots) if self._cache_hash: slot_names.append(_hash_cache_field) cd["__slots__"] = tuple(slot_names) qualname = getattr(self._cls, "__qualname__", None) if qualname is not None: cd["__qualname__"] = qualname # Create new class based on old class and our methods. cls = type(self._cls)(self._cls.__name__, self._cls.__bases__, cd) # The following is a fix for # https://github.com/python-attrs/attrs/issues/102. On Python 3, # if a method mentions `__class__` or uses the no-arg super(), the # compiler will bake a reference to the class in the method itself # as `method.__closure__`. Since we replace the class with a # clone, we rewrite these references so it keeps working. for item in cls.__dict__.values(): if isinstance(item, (classmethod, staticmethod)): # Class- and staticmethods hide their functions inside. # These might need to be rewritten as well. closure_cells = getattr(item.__func__, "__closure__", None) elif isinstance(item, property): # Workaround for property `super()` shortcut (PY3-only). # There is no universal way for other descriptors. closure_cells = getattr(item.fget, "__closure__", None) else: closure_cells = getattr(item, "__closure__", None) if not closure_cells: # Catch None or the empty list. continue for cell in closure_cells: try: match = cell.cell_contents is self._cls except ValueError: # ValueError: Cell is empty pass else: if match: set_closure_cell(cell, cls) return cls def add_repr(self, ns): self._cls_dict["__repr__"] = self._add_method_dunders( _make_repr(self._attrs, ns=ns) ) return self def add_str(self): repr = self._cls_dict.get("__repr__") if repr is None: raise ValueError( "__str__ can only be generated if a __repr__ exists." ) def __str__(self): return self.__repr__() self._cls_dict["__str__"] = self._add_method_dunders(__str__) return self def _make_getstate_setstate(self): """ Create custom __setstate__ and __getstate__ methods. """ # __weakref__ is not writable. state_attr_names = tuple( an for an in self._attr_names if an != "__weakref__" ) def slots_getstate(self): """ Automatically created by attrs. """ return tuple(getattr(self, name) for name in state_attr_names) hash_caching_enabled = self._cache_hash def slots_setstate(self, state): """ Automatically created by attrs. """ __bound_setattr = _obj_setattr.__get__(self, Attribute) for name, value in zip(state_attr_names, state): __bound_setattr(name, value) # The hash code cache is not included when the object is # serialized, but it still needs to be initialized to None to # indicate that the first call to __hash__ should be a cache # miss. if hash_caching_enabled: __bound_setattr(_hash_cache_field, None) return slots_getstate, slots_setstate def make_unhashable(self): self._cls_dict["__hash__"] = None return self def add_hash(self): self._cls_dict["__hash__"] = self._add_method_dunders( _make_hash( self._cls, self._attrs, frozen=self._frozen, cache_hash=self._cache_hash, ) ) return self def add_init(self): self._cls_dict["__init__"] = self._add_method_dunders( _make_init( self._cls, self._attrs, self._has_pre_init, self._has_post_init, self._frozen, self._slots, self._cache_hash, self._base_attr_map, self._is_exc, self._on_setattr is not None and self._on_setattr is not setters.NO_OP, attrs_init=False, ) ) return self def add_attrs_init(self): self._cls_dict["__attrs_init__"] = self._add_method_dunders( _make_init( self._cls, self._attrs, self._has_pre_init, self._has_post_init, self._frozen, self._slots, self._cache_hash, self._base_attr_map, self._is_exc, self._on_setattr is not None and self._on_setattr is not setters.NO_OP, attrs_init=True, ) ) return self def add_eq(self): cd = self._cls_dict cd["__eq__"] = self._add_method_dunders( _make_eq(self._cls, self._attrs) ) cd["__ne__"] = self._add_method_dunders(_make_ne()) return self def add_order(self): cd = self._cls_dict cd["__lt__"], cd["__le__"], cd["__gt__"], cd["__ge__"] = ( self._add_method_dunders(meth) for meth in _make_order(self._cls, self._attrs) ) return self def add_setattr(self): if self._frozen: return self sa_attrs = {} for a in self._attrs: on_setattr = a.on_setattr or self._on_setattr if on_setattr and on_setattr is not setters.NO_OP: sa_attrs[a.name] = a, on_setattr if not sa_attrs: return self if self._has_custom_setattr: # We need to write a __setattr__ but there already is one! raise ValueError( "Can't combine custom __setattr__ with on_setattr hooks." ) # docstring comes from _add_method_dunders def __setattr__(self, name, val): try: a, hook = sa_attrs[name] except KeyError: nval = val else: nval = hook(self, a, val) _obj_setattr(self, name, nval) self._cls_dict["__attrs_own_setattr__"] = True self._cls_dict["__setattr__"] = self._add_method_dunders(__setattr__) self._has_own_setattr = True return self def _add_method_dunders(self, method): """ Add __module__ and __qualname__ to a method if possible. """ try: method.__module__ = self._cls.__module__ except AttributeError: pass try: method.__qualname__ = ".".join( (self._cls.__qualname__, method.__name__) ) except AttributeError: pass try: method.__doc__ = "Method generated by attrs for class %s." % ( self._cls.__qualname__, ) except AttributeError: pass return method _CMP_DEPRECATION = ( "The usage of `cmp` is deprecated and will be removed on or after " "2021-06-01. Please use `eq` and `order` instead." ) def _determine_attrs_eq_order(cmp, eq, order, default_eq): """ 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. """ if cmp is not None and any((eq is not None, order is not None)): raise ValueError("Don't mix `cmp` with `eq' and `order`.") # cmp takes precedence due to bw-compatibility. if cmp is not None: return cmp, cmp # If left None, equality is set to the specified default and ordering # mirrors equality. if eq is None: eq = default_eq if order is None: order = eq if eq is False and order is True: raise ValueError("`order` can only be True if `eq` is True too.") return eq, order def _determine_attrib_eq_order(cmp, eq, order, default_eq): """ 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. """ if cmp is not None and any((eq is not None, order is not None)): raise ValueError("Don't mix `cmp` with `eq' and `order`.") def decide_callable_or_boolean(value): """ Decide whether a key function is used. """ if callable(value): value, key = True, value else: key = None return value, key # cmp takes precedence due to bw-compatibility. if cmp is not None: cmp, cmp_key = decide_callable_or_boolean(cmp) return cmp, cmp_key, cmp, cmp_key # If left None, equality is set to the specified default and ordering # mirrors equality. if eq is None: eq, eq_key = default_eq, None else: eq, eq_key = decide_callable_or_boolean(eq) if order is None: order, order_key = eq, eq_key else: order, order_key = decide_callable_or_boolean(order) if eq is False and order is True: raise ValueError("`order` can only be True if `eq` is True too.") return eq, eq_key, order, order_key def _determine_whether_to_implement( cls, flag, auto_detect, dunders, default=True ): """ 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. auto_detect must be False on Python 2. """ if flag is True or flag is False: return flag if flag is None and auto_detect is False: return default # Logically, flag is None and auto_detect is True here. for dunder in dunders: if _has_own_attribute(cls, dunder): return False return default def attrs( maybe_cls=None, these=None, repr_ns=None, repr=None, cmp=None, hash=None, init=None, slots=False, frozen=False, weakref_slot=True, str=False, auto_attribs=False, kw_only=False, cache_hash=False, auto_exc=False, eq=None, order=None, auto_detect=False, collect_by_mro=False, getstate_setstate=None, on_setattr=None, field_transformer=None, ): r""" A class decorator that adds `dunder <https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the specified attributes using `attr.ib` or the these argument. :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. If these is an ordered dict (`dict` on Python 3.6+, `collections.OrderedDict` otherwise), the order is deduced from the order of the attributes inside these. Otherwise the order of the definition of the attributes is used. :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. auto_detect requires Python 3. Setting it ``True`` on Python 2 raises a `PythonTooOldError`. :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] 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 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 `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 `glossary entry <slotted classes>`. :param bool frozen: Make instances immutable after initialization. If someone attempts to modify a frozen instance, `attr.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 (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 `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 `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. `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. .. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/ :param bool kw_only: Make all attributes keyword-only (Python 3+) 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-compatability. 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 `attr.setters.pipe`. :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. .. 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 """ if auto_detect and PY2: raise PythonTooOldError( "auto_detect only works on Python 3 and later." ) eq_, order_ = _determine_attrs_eq_order(cmp, eq, order, None) hash_ = hash # work around the lack of nonlocal if isinstance(on_setattr, (list, tuple)): on_setattr = setters.pipe(on_setattr) def wrap(cls): if getattr(cls, "__class__", None) is None: raise TypeError("attrs only works with new-style classes.") is_frozen = frozen or _has_frozen_base_class(cls) is_exc = auto_exc is True and issubclass(cls, BaseException) has_own_setattr = auto_detect and _has_own_attribute( cls, "__setattr__" ) if has_own_setattr and is_frozen: raise ValueError("Can't freeze a class with a custom __setattr__.") builder = _ClassBuilder( cls, these, slots, is_frozen, weakref_slot, _determine_whether_to_implement( cls, getstate_setstate, auto_detect, ("__getstate__", "__setstate__"), default=slots, ), auto_attribs, kw_only, cache_hash, is_exc, collect_by_mro, on_setattr, has_own_setattr, field_transformer, ) if _determine_whether_to_implement( cls, repr, auto_detect, ("__repr__",) ): builder.add_repr(repr_ns) if str is True: builder.add_str() eq = _determine_whether_to_implement( cls, eq_, auto_detect, ("__eq__", "__ne__") ) if not is_exc and eq is True: builder.add_eq() if not is_exc and _determine_whether_to_implement( cls, order_, auto_detect, ("__lt__", "__le__", "__gt__", "__ge__") ): builder.add_order() builder.add_setattr() if ( hash_ is None and auto_detect is True and _has_own_attribute(cls, "__hash__") ): hash = False else: hash = hash_ if hash is not True and hash is not False and hash is not None: # Can't use `hash in` because 1 == True for example. raise TypeError( "Invalid value for hash. Must be True, False, or None." ) elif hash is False or (hash is None and eq is False) or is_exc: # Don't do anything. Should fall back to __object__'s __hash__ # which is by id. if cache_hash: raise TypeError( "Invalid value for cache_hash. To use hash caching," " hashing must be either explicitly or implicitly " "enabled." ) elif hash is True or ( hash is None and eq is True and is_frozen is True ): # Build a __hash__ if told so, or if it's safe. builder.add_hash() else: # Raise TypeError on attempts to hash. if cache_hash: raise TypeError( "Invalid value for cache_hash. To use hash caching," " hashing must be either explicitly or implicitly " "enabled." ) builder.make_unhashable() if _determine_whether_to_implement( cls, init, auto_detect, ("__init__",) ): builder.add_init() else: builder.add_attrs_init() if cache_hash: raise TypeError( "Invalid value for cache_hash. To use hash caching," " init must be True." ) return builder.build_class() # maybe_cls's type depends on the usage of the decorator. It's a class # if it's used as `@attrs` but ``None`` if used as `@attrs()`. if maybe_cls is None: return wrap else: return wrap(maybe_cls) _attrs = attrs """ Internal alias so we can use it in functions that take an argument called attrs. """ if PY2: def _has_frozen_base_class(cls): """ Check whether cls* has a frozen ancestor by looking at its __setattr__. """ return ( getattr(cls.__setattr__, "__module__", None) == _frozen_setattrs.__module__ and cls.__setattr__.__name__ == _frozen_setattrs.__name__ ) else: def _has_frozen_base_class(cls): """ Check whether cls has a frozen ancestor by looking at its __setattr__. """ return cls.__setattr__ == _frozen_setattrs def _generate_unique_filename(cls, func_name): """ Create a "filename" suitable for a function being generated. """ unique_id = uuid.uuid4() extra = "" count = 1 while True: unique_filename = "<attrs generated {0} {1}.{2}{3}>".format( func_name, cls.__module__, getattr(cls, "__qualname__", cls.__name__), extra, ) # To handle concurrency we essentially "reserve" our spot in # the linecache with a dummy line. The caller can then # set this value correctly. cache_line = (1, None, (str(unique_id),), unique_filename) if ( linecache.cache.setdefault(unique_filename, cache_line) == cache_line ): return unique_filename # Looks like this spot is taken. Try again. count += 1 extra = "-{0}".format(count) def _make_hash(cls, attrs, frozen, cache_hash): attrs = tuple( a for a in attrs if a.hash is True or (a.hash is None and a.eq is True) ) tab = " " unique_filename = _generate_unique_filename(cls, "hash") type_hash = hash(unique_filename) hash_def = "def __hash__(self" hash_func = "hash((" closing_braces = "))" if not cache_hash: hash_def += "):" else: if not PY2: hash_def += ", " hash_def += ( ", _cache_wrapper=" + "__import__('attr._make')._make._CacheHashWrapper):" ) hash_func = "_cache_wrapper(" + hash_func closing_braces += ")" method_lines = [hash_def] def append_hash_computation_lines(prefix, indent): """ 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 """ method_lines.extend( [ indent + prefix + hash_func, indent + " %d," % (type_hash,), ] ) for a in attrs: method_lines.append(indent + " self.%s," % a.name) method_lines.append(indent + " " + closing_braces) if cache_hash: method_lines.append(tab + "if self.%s is None:" % _hash_cache_field) if frozen: append_hash_computation_lines( "object.__setattr__(self, '%s', " % _hash_cache_field, tab 2 ) method_lines.append(tab * 2 + ")") # close __setattr__ else: append_hash_computation_lines( "self.%s = " % _hash_cache_field, tab * 2 ) method_lines.append(tab + "return self.%s" % _hash_cache_field) else: append_hash_computation_lines("return ", tab) script = "\n".join(method_lines) return _make_method("__hash__", script, unique_filename) def _add_hash(cls, attrs): """ Add a hash method to cls. """ cls.__hash__ = _make_hash(cls, attrs, frozen=False, cache_hash=False) return cls def _make_ne(): """ Create __ne__ method. """ def __ne__(self, other): """ Check equality and either forward a NotImplemented or return the result negated. """ result = self.__eq__(other) if result is NotImplemented: return NotImplemented return not result return __ne__ def _make_eq(cls, attrs): """ Create __eq__ method for cls with attrs. """ attrs = [a for a in attrs if a.eq] unique_filename = _generate_unique_filename(cls, "eq") lines = [ "def __eq__(self, other):", " if other.__class__ is not self.__class__:", " return NotImplemented", ] # We can't just do a big self.x = other.x and... clause due to # irregularities like nan == nan is false but (nan,) == (nan,) is true. globs = {} if attrs: lines.append(" return (") others = [" ) == ("] for a in attrs: if a.eq_key: cmp_name = "_%s_key" % (a.name,) # Add the key function to the global namespace # of the evaluated function. globs[cmp_name] = a.eq_key lines.append( " %s(self.%s)," % ( cmp_name, a.name, ) ) others.append( " %s(other.%s)," % ( cmp_name, a.name, ) ) else: lines.append(" self.%s," % (a.name,)) others.append(" other.%s," % (a.name,)) lines += others + [" )"] else: lines.append(" return True") script = "\n".join(lines) return _make_method("__eq__", script, unique_filename, globs) def _make_order(cls, attrs): """ Create ordering methods for cls with attrs. """ attrs = [a for a in attrs if a.order] def attrs_to_tuple(obj): """ Save us some typing. """ return tuple( key(value) if key else value for value, key in ( (getattr(obj, a.name), a.order_key) for a in attrs ) ) def __lt__(self, other): """ Automatically created by attrs. """ if other.__class__ is self.__class__: return attrs_to_tuple(self) < attrs_to_tuple(other) return NotImplemented def __le__(self, other): """ Automatically created by attrs. """ if other.__class__ is self.__class__: return attrs_to_tuple(self) <= attrs_to_tuple(other) return NotImplemented def __gt__(self, other): """ Automatically created by attrs. """ if other.__class__ is self.__class__: return attrs_to_tuple(self) > attrs_to_tuple(other) return NotImplemented def __ge__(self, other): """ Automatically created by attrs. """ if other.__class__ is self.__class__: return attrs_to_tuple(self) >= attrs_to_tuple(other) return NotImplemented return __lt__, __le__, __gt__, __ge__ def _add_eq(cls, attrs=None): """ Add equality methods to cls with attrs. """ if attrs is None: attrs = cls.__attrs_attrs__ cls.__eq__ = _make_eq(cls, attrs) cls.__ne__ = _make_ne() return cls _already_repring = threading.local() def _make_repr(attrs, ns): """ Make a repr method that includes relevant attrs, adding ns to the full name. """ # Figure out which attributes to include, and which function to use to # format them. The a.repr value can be either bool or a custom callable. attr_names_with_reprs = tuple( (a.name, repr if a.repr is True else a.repr) for a in attrs if a.repr is not False ) def __repr__(self): """ Automatically created by attrs. """ try: working_set = _already_repring.working_set except AttributeError: working_set = set() _already_repring.working_set = working_set if id(self) in working_set: return "..." real_cls = self.__class__ if ns is None: qualname = getattr(real_cls, "__qualname__", None) if qualname is not None: class_name = qualname.rsplit(">.", 1)[-1] else: class_name = real_cls.__name__ else: class_name = ns + "." + real_cls.__name__ # Since 'self' remains on the stack (i.e.: strongly referenced) for the # duration of this call, it's safe to depend on id(...) stability, and # not need to track the instance and therefore worry about properties # like weakref- or hash-ability. working_set.add(id(self)) try: result = [class_name, "("] first = True for name, attr_repr in attr_names_with_reprs: if first: first = False else: result.append(", ") result.extend( (name, "=", attr_repr(getattr(self, name, NOTHING))) ) return "".join(result) + ")" finally: working_set.remove(id(self)) return __repr__ def _add_repr(cls, ns=None, attrs=None): """ Add a repr method to cls. """ if attrs is None: attrs = cls.__attrs_attrs__ cls.__repr__ = _make_repr(attrs, ns) return cls def fields(cls): """ 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 attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. :rtype: tuple (with name accessors) of `attr.Attribute` .. versionchanged:: 16.2.0 Returned tuple allows accessing the fields by name. """ if not isclass(cls): raise TypeError("Passed object must be a class.") attrs = getattr(cls, "__attrs_attrs__", None) if attrs is None: raise NotAnAttrsClassError( "{cls!r} is not an attrs-decorated class.".format(cls=cls) ) return attrs def fields_dict(cls): """ 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 attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. :rtype: an ordered dict where keys are attribute names and values are `attr.Attribute`\\ s. This will be a `dict` if it's naturally ordered like on Python 3.6+ or an :class:`~collections.OrderedDict` otherwise. .. versionadded:: 18.1.0 """ if not isclass(cls): raise TypeError("Passed object must be a class.") attrs = getattr(cls, "__attrs_attrs__", None) if attrs is None: raise NotAnAttrsClassError( "{cls!r} is not an attrs-decorated class.".format(cls=cls) ) return ordered_dict(((a.name, a) for a in attrs)) def validate(inst): """ Validate all attributes on inst that have a validator. Leaves all exceptions through. :param inst: Instance of a class with ``attrs`` attributes. """ if _config._run_validators is False: return for a in fields(inst.__class__): v = a.validator if v is not None: v(inst, a, getattr(inst, a.name)) def _is_slot_cls(cls): return "__slots__" in cls.__dict__ def _is_slot_attr(a_name, base_attr_map): """ Check if the attribute name comes from a slot class. """ return a_name in base_attr_map and _is_slot_cls(base_attr_map[a_name]) def _make_init( cls, attrs, pre_init, post_init, frozen, slots, cache_hash, base_attr_map, is_exc, has_global_on_setattr, attrs_init, ): if frozen and has_global_on_setattr: raise ValueError("Frozen classes can't use on_setattr.") needs_cached_setattr = cache_hash or frozen filtered_attrs = [] attr_dict = {} for a in attrs: if not a.init and a.default is NOTHING: continue filtered_attrs.append(a) attr_dict[a.name] = a if a.on_setattr is not None: if frozen is True: raise ValueError("Frozen classes can't use on_setattr.") needs_cached_setattr = True elif ( has_global_on_setattr and a.on_setattr is not setters.NO_OP ) or _is_slot_attr(a.name, base_attr_map): needs_cached_setattr = True unique_filename = _generate_unique_filename(cls, "init") script, globs, annotations = _attrs_to_init_script( filtered_attrs, frozen, slots, pre_init, post_init, cache_hash, base_attr_map, is_exc, needs_cached_setattr, has_global_on_setattr, attrs_init, ) if cls.__module__ in sys.modules: # This makes typing.get_type_hints(CLS.__init__) resolve string types. globs.update(sys.modules[cls.__module__].__dict__) globs.update({"NOTHING": NOTHING, "attr_dict": attr_dict}) if needs_cached_setattr: # Save the lookup overhead in __init__ if we need to circumvent # setattr hooks. globs["_cached_setattr"] = _obj_setattr init = _make_method( "__attrs_init__" if attrs_init else "__init__", script, unique_filename, globs, ) init.__annotations__ = annotations return init def _setattr(attr_name, value_var, has_on_setattr): """ Use the cached object.setattr to set attr_name to value_var. """ return "_setattr('%s', %s)" % (attr_name, value_var) def _setattr_with_converter(attr_name, value_var, has_on_setattr): """ Use the cached object.setattr to set attr_name to value_var, but run its converter first. """ return "_setattr('%s', %s(%s))" % ( attr_name, _init_converter_pat % (attr_name,), value_var, ) def _assign(attr_name, value, has_on_setattr): """ Unless attr_name has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. """ if has_on_setattr: return _setattr(attr_name, value, True) return "self.%s = %s" % (attr_name, value) def _assign_with_converter(attr_name, value_var, has_on_setattr): """ Unless attr_name has an on_setattr hook, use normal assignment after conversion. Otherwise relegate to _setattr_with_converter. """ if has_on_setattr: return _setattr_with_converter(attr_name, value_var, True) return "self.%s = %s(%s)" % ( attr_name, _init_converter_pat % (attr_name,), value_var, ) if PY2: def _unpack_kw_only_py2(attr_name, default=None): """ Unpack attr_name from _kw_only dict. """ if default is not None: arg_default = ", %s" % default else: arg_default = "" return "%s = _kw_only.pop('%s'%s)" % ( attr_name, attr_name, arg_default, ) def _unpack_kw_only_lines_py2(kw_only_args): """ Unpack all kw_only_args from _kw_only dict and handle errors. Given a list of strings "{attr_name}" and "{attr_name}={default}" generates list of lines of code that pop attrs from _kw_only dict and raise TypeError similar to builtin if required attr is missing or extra key is passed. >>> print("\n".join(_unpack_kw_only_lines_py2(["a", "b=42"]))) try: a = _kw_only.pop('a') b = _kw_only.pop('b', 42) except KeyError as _key_error: raise TypeError( ... if _kw_only: raise TypeError( ... """ lines = ["try:"] lines.extend( " " + _unpack_kw_only_py2(arg.split("=")) for arg in kw_only_args ) lines += """\ except KeyError as _key_error: raise TypeError( '__init__() missing required keyword-only argument: %s' % _key_error ) if _kw_only: raise TypeError( '__init__() got an unexpected keyword argument %r' % next(iter(_kw_only)) ) """.split( "\n" ) return lines def _attrs_to_init_script( attrs, frozen, slots, pre_init, post_init, cache_hash, base_attr_map, is_exc, needs_cached_setattr, has_global_on_setattr, attrs_init, ): """ 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__``. """ lines = [] if pre_init: lines.append("self.__attrs_pre_init__()") if needs_cached_setattr: lines.append( # Circumvent the __setattr__ descriptor to save one lookup per # assignment. # Note _setattr will be used again below if cache_hash is True "_setattr = _cached_setattr.__get__(self, self.__class__)" ) if frozen is True: if slots is True: fmt_setter = _setattr fmt_setter_with_converter = _setattr_with_converter else: # Dict frozen classes assign directly to __dict__. # But only if the attribute doesn't come from an ancestor slot # class. # Note _inst_dict will be used again below if cache_hash is True lines.append("_inst_dict = self.__dict__") def fmt_setter(attr_name, value_var, has_on_setattr): if _is_slot_attr(attr_name, base_attr_map): return _setattr(attr_name, value_var, has_on_setattr) return "_inst_dict['%s'] = %s" % (attr_name, value_var) def fmt_setter_with_converter( attr_name, value_var, has_on_setattr ): if has_on_setattr or _is_slot_attr(attr_name, base_attr_map): return _setattr_with_converter( attr_name, value_var, has_on_setattr ) return "_inst_dict['%s'] = %s(%s)" % ( attr_name, _init_converter_pat % (attr_name,), value_var, ) else: # Not frozen. fmt_setter = _assign fmt_setter_with_converter = _assign_with_converter args = [] kw_only_args = [] attrs_to_validate = [] # This is a dictionary of names to validator and converter callables. # Injecting this into __init__ globals lets us avoid lookups. names_for_globals = {} annotations = {"return": None} for a in attrs: if a.validator: attrs_to_validate.append(a) attr_name = a.name has_on_setattr = a.on_setattr is not None or ( a.on_setattr is not setters.NO_OP and has_global_on_setattr ) arg_name = a.name.lstrip("_") has_factory = isinstance(a.default, Factory) if has_factory and a.default.takes_self: maybe_self = "self" else: maybe_self = "" if a.init is False: if has_factory: init_factory_name = _init_factory_pat.format(a.name) if a.converter is not None: lines.append( fmt_setter_with_converter( attr_name, init_factory_name + "(%s)" % (maybe_self,), has_on_setattr, ) ) conv_name = _init_converter_pat % (a.name,) names_for_globals[conv_name] = a.converter else: lines.append( fmt_setter( attr_name, init_factory_name + "(%s)" % (maybe_self,), has_on_setattr, ) ) names_for_globals[init_factory_name] = a.default.factory else: if a.converter is not None: lines.append( fmt_setter_with_converter( attr_name, "attr_dict['%s'].default" % (attr_name,), has_on_setattr, ) ) conv_name = _init_converter_pat % (a.name,) names_for_globals[conv_name] = a.converter else: lines.append( fmt_setter( attr_name, "attr_dict['%s'].default" % (attr_name,), has_on_setattr, ) ) elif a.default is not NOTHING and not has_factory: arg = "%s=attr_dict['%s'].default" % (arg_name, attr_name) if a.kw_only: kw_only_args.append(arg) else: args.append(arg) if a.converter is not None: lines.append( fmt_setter_with_converter( attr_name, arg_name, has_on_setattr ) ) names_for_globals[ _init_converter_pat % (a.name,) ] = a.converter else: lines.append(fmt_setter(attr_name, arg_name, has_on_setattr)) elif has_factory: arg = "%s=NOTHING" % (arg_name,) if a.kw_only: kw_only_args.append(arg) else: args.append(arg) lines.append("if %s is not NOTHING:" % (arg_name,)) init_factory_name = _init_factory_pat.format(a.name) if a.converter is not None: lines.append( " " + fmt_setter_with_converter( attr_name, arg_name, has_on_setattr ) ) lines.append("else:") lines.append( " " + fmt_setter_with_converter( attr_name, init_factory_name + "(" + maybe_self + ")", has_on_setattr, ) ) names_for_globals[ _init_converter_pat % (a.name,) ] = a.converter else: lines.append( " " + fmt_setter(attr_name, arg_name, has_on_setattr) ) lines.append("else:") lines.append( " " + fmt_setter( attr_name, init_factory_name + "(" + maybe_self + ")", has_on_setattr, ) ) names_for_globals[init_factory_name] = a.default.factory else: if a.kw_only: kw_only_args.append(arg_name) else: args.append(arg_name) if a.converter is not None: lines.append( fmt_setter_with_converter( attr_name, arg_name, has_on_setattr ) ) names_for_globals[ _init_converter_pat % (a.name,) ] = a.converter else: lines.append(fmt_setter(attr_name, arg_name, has_on_setattr)) if a.init is True: if a.type is not None and a.converter is None: annotations[arg_name] = a.type elif a.converter is not None and not PY2: # Try to get the type from the converter. sig = None try: sig = inspect.signature(a.converter) except (ValueError, TypeError): # inspect failed pass if sig: sig_params = list(sig.parameters.values()) if ( sig_params and sig_params[0].annotation is not inspect.Parameter.empty ): annotations[arg_name] = sig_params[0].annotation if attrs_to_validate: # we can skip this if there are no validators. names_for_globals["_config"] = _config lines.append("if _config._run_validators is True:") for a in attrs_to_validate: val_name = "__attr_validator_" + a.name attr_name = "__attr_" + a.name lines.append( " %s(self, %s, self.%s)" % (val_name, attr_name, a.name) ) names_for_globals[val_name] = a.validator names_for_globals[attr_name] = a if post_init: lines.append("self.__attrs_post_init__()") # because this is set only after __attrs_post_init is called, a crash # will result if post-init tries to access the hash code. This seemed # preferable to setting this beforehand, in which case alteration to # field values during post-init combined with post-init accessing the # hash code would result in silent bugs. if cache_hash: if frozen: if slots: # if frozen and slots, then _setattr defined above init_hash_cache = "_setattr('%s', %s)" else: # if frozen and not slots, then _inst_dict defined above init_hash_cache = "_inst_dict['%s'] = %s" else: init_hash_cache = "self.%s = %s" lines.append(init_hash_cache % (_hash_cache_field, "None")) # For exceptions we rely on BaseException.__init__ for proper # initialization. if is_exc: vals = ",".join("self." + a.name for a in attrs if a.init) lines.append("BaseException.__init__(self, %s)" % (vals,)) args = ", ".join(args) if kw_only_args: if PY2: lines = _unpack_kw_only_lines_py2(kw_only_args) + lines args += "%s*_kw_only" % (", " if args else "",) # leading comma else: args += "%s, %s" % ( ", " if args else "", # leading comma ", ".join(kw_only_args), # kw_only args ) return ( """\ def {init_name}(self, {args}): {lines} """.format( init_name=("__attrs_init__" if attrs_init else "__init__"), args=args, lines="\n ".join(lines) if lines else "pass", ), names_for_globals, annotations, ) class Attribute(object): """ Read-only representation of an attribute. 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 field transformer hook receives a list of them. :attribute name: The name of the attribute. :attribute inherited: Whether or not that attribute has been inherited from a base class. Plus all arguments of `attr.ib` (except for ``factory`` which is only syntactic sugar for ``default=Factory(...)``. .. 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 For the full version history of the fields, see `attr.ib`. """ __slots__ = ( "name", "default", "validator", "repr", "eq", "eq_key", "order", "order_key", "hash", "init", "metadata", "type", "converter", "kw_only", "inherited", "on_setattr", ) def __init__( self, name, default, validator, repr, cmp, # XXX: unused, remove along with other cmp code. hash, init, inherited, metadata=None, type=None, converter=None, kw_only=False, eq=None, eq_key=None, order=None, order_key=None, on_setattr=None, ): eq, eq_key, order, order_key = _determine_attrib_eq_order( cmp, eq_key or eq, order_key or order, True ) # Cache this descriptor here to speed things up later. bound_setattr = _obj_setattr.__get__(self, Attribute) # Despite the big red warning, people do instantiate `Attribute` # themselves. bound_setattr("name", name) bound_setattr("default", default) bound_setattr("validator", validator) bound_setattr("repr", repr) bound_setattr("eq", eq) bound_setattr("eq_key", eq_key) bound_setattr("order", order) bound_setattr("order_key", order_key) bound_setattr("hash", hash) bound_setattr("init", init) bound_setattr("converter", converter) bound_setattr( "metadata", ( metadata_proxy(metadata) if metadata else _empty_metadata_singleton ), ) bound_setattr("type", type) bound_setattr("kw_only", kw_only) bound_setattr("inherited", inherited) bound_setattr("on_setattr", on_setattr) def __setattr__(self, name, value): raise FrozenInstanceError() @classmethod def from_counting_attr(cls, name, ca, type=None): # type holds the annotated value. deal with conflicts: if type is None: type = ca.type elif ca.type is not None: raise ValueError( "Type annotation and type argument cannot both be present" ) inst_dict = { k: getattr(ca, k) for k in Attribute.__slots__ if k not in ( "name", "validator", "default", "type", "inherited", ) # exclude methods and deprecated alias } return cls( name=name, validator=ca._validator, default=ca._default, type=type, cmp=None, inherited=False, inst_dict ) @property def cmp(self): """ Simulate the presence of a cmp attribute and warn. """ warnings.warn(_CMP_DEPRECATION, DeprecationWarning, stacklevel=2) return self.eq and self.order # Don't use attr.evolve since fields(Attribute) doesn't work def evolve(self, changes): """ Copy self and apply changes. This works similarly to `attr.evolve` but that function does not work with ``Attribute``. It is mainly meant to be used for `transform-fields`. .. versionadded:: 20.3.0 """ new = copy.copy(self) new._setattrs(changes.items()) return new # Don't use _add_pickle since fields(Attribute) doesn't work def __getstate__(self): """ Play nice with pickle. """ return tuple( getattr(self, name) if name != "metadata" else dict(self.metadata) for name in self.__slots__ ) def __setstate__(self, state): """ Play nice with pickle. """ self._setattrs(zip(self.__slots__, state)) def _setattrs(self, name_values_pairs): bound_setattr = _obj_setattr.__get__(self, Attribute) for name, value in name_values_pairs: if name != "metadata": bound_setattr(name, value) else: bound_setattr( name, metadata_proxy(value) if value else _empty_metadata_singleton, ) _a = [ Attribute( name=name, default=NOTHING, validator=None, repr=True, cmp=None, eq=True, order=False, hash=(name != "metadata"), init=True, inherited=False, ) for name in Attribute.__slots__ ] Attribute = _add_hash( _add_eq( _add_repr(Attribute, attrs=_a), attrs=[a for a in _a if a.name != "inherited"], ), attrs=[a for a in _a if a.hash and a.name != "inherited"], ) class _CountingAttr(object): """ 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. """ __slots__ = ( "counter", "_default", "repr", "eq", "eq_key", "order", "order_key", "hash", "init", "metadata", "_validator", "converter", "type", "kw_only", "on_setattr", ) __attrs_attrs__ = tuple( Attribute( name=name, default=NOTHING, validator=None, repr=True, cmp=None, hash=True, init=True, kw_only=False, eq=True, eq_key=None, order=False, order_key=None, inherited=False, on_setattr=None, ) for name in ( "counter", "_default", "repr", "eq", "order", "hash", "init", "on_setattr", ) ) + ( Attribute( name="metadata", default=None, validator=None, repr=True, cmp=None, hash=False, init=True, kw_only=False, eq=True, eq_key=None, order=False, order_key=None, inherited=False, on_setattr=None, ), ) cls_counter = 0 def __init__( self, default, validator, repr, cmp, hash, init, converter, metadata, type, kw_only, eq, eq_key, order, order_key, on_setattr, ): _CountingAttr.cls_counter += 1 self.counter = _CountingAttr.cls_counter self._default = default self._validator = validator self.converter = converter self.repr = repr self.eq = eq self.eq_key = eq_key self.order = order self.order_key = order_key self.hash = hash self.init = init self.metadata = metadata self.type = type self.kw_only = kw_only self.on_setattr = on_setattr def validator(self, meth): """ Decorator that adds meth to the list of validators. Returns meth unchanged. .. versionadded:: 17.1.0 """ if self._validator is None: self._validator = meth else: self._validator = and_(self._validator, meth) return meth def default(self, meth): """ 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 """ if self._default is not NOTHING: raise DefaultAlreadySetError() self._default = Factory(meth, takes_self=True) return meth _CountingAttr = _add_eq(_add_repr(_CountingAttr)) class Factory(object): """ Stores a factory callable. If passed as the default value to `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 """ __slots__ = ("factory", "takes_self") def __init__(self, factory, takes_self=False): """ `Factory` is part of the default machinery so if we want a default value here, we have to implement it ourselves. """ self.factory = factory self.takes_self = takes_self def __getstate__(self): """ Play nice with pickle. """ return tuple(getattr(self, name) for name in self.__slots__) def __setstate__(self, state): """ Play nice with pickle. """ for name, value in zip(self.__slots__, state): setattr(self, name, value) _f = [ Attribute( name=name, default=NOTHING, validator=None, repr=True, cmp=None, eq=True, order=False, hash=True, init=True, inherited=False, ) for name in Factory.__slots__ ] Factory = _add_hash(_add_eq(_add_repr(Factory, attrs=_f), attrs=_f), attrs=_f) def make_class(name, attrs, bases=(object,), *attributes_arguments): """ 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 attributes. If attrs is a list or an ordered dict (`dict` on Python 3.6+, `collections.OrderedDict` otherwise), 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. """ if isinstance(attrs, dict): cls_dict = attrs elif isinstance(attrs, (list, tuple)): cls_dict = dict((a, attrib()) for a in attrs) else: raise TypeError("attrs argument must be a dict or a list.") pre_init = cls_dict.pop("__attrs_pre_init__", None) post_init = cls_dict.pop("__attrs_post_init__", None) user_init = cls_dict.pop("__init__", None) body = {} if pre_init is not None: body["__attrs_pre_init__"] = pre_init if post_init is not None: body["__attrs_post_init__"] = post_init if user_init is not None: body["__init__"] = user_init type_ = new_class(name, bases, {}, lambda ns: ns.update(body)) # For pickling to work, the __module__ variable needs to be set to the # frame where the class is created. Bypass this step in environments where # sys._getframe is not defined (Jython for example) or sys._getframe is not # defined for arguments greater than 0 (IronPython). try: type_.__module__ = sys._getframe(1).f_globals.get( "__name__", "__main__" ) except (AttributeError, ValueError): pass # We do it here for proper warnings with meaningful stacklevel. cmp = attributes_arguments.pop("cmp", None) ( attributes_arguments["eq"], attributes_arguments["order"], ) = _determine_attrs_eq_order( cmp, attributes_arguments.get("eq"), attributes_arguments.get("order"), True, ) return _attrs(these=cls_dict, *attributes_arguments)(type_) # These are required by within this module so we define them here and merely # import into .validators / .converters. @attrs(slots=True, hash=True) class _AndValidator(object): """ Compose many validators to a single one. """ _validators = attrib() def __call__(self, inst, attr, value): for v in self._validators: v(inst, attr, value) def and_(validators): """ 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 """ vals = [] for validator in validators: vals.extend( validator._validators if isinstance(validator, _AndValidator) else [validator] ) return _AndValidator(tuple(vals)) def pipe(converters): """ 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 """ def pipe_converter(val): for converter in converters: val = converter(val) return val if not PY2: if not converters: # If the converter list is empty, pipe_converter is the identity. A = typing.TypeVar("A") pipe_converter.__annotations__ = {"val": A, "return": A} else: # Get parameter type. sig = None try: sig = inspect.signature(converters[0]) except (ValueError, TypeError): # inspect failed pass if sig: params = list(sig.parameters.values()) if ( params and params[0].annotation is not inspect.Parameter.empty ): pipe_converter.__annotations__["val"] = params[ 0 ].annotation # Get return type. sig = None try: sig = inspect.signature(converters[-1]) except (ValueError, TypeError): # inspect failed pass if sig and sig.return_annotation is not inspect.Signature().empty: pipe_converter.__annotations__[ "return" ] = sig.return_annotation return pipe_converter PK��!�8�4�V4��V4�� _funcs.pynu��[��from __future__ import absolute_import, division, print_function import copy from ._compat import iteritems from ._make import NOTHING, _obj_setattr, fields from .exceptions import AttrsAttributeNotFoundError def asdict( inst, recurse=True, filter=None, dict_factory=dict, retain_collection_types=False, value_serializer=None, ): """ Return the ``attrs`` attribute values of inst as a dict. Optionally recurse into other ``attrs``-decorated classes. :param inst: Instance of an ``attrs``-decorated class. :param bool recurse: Recurse into classes that are also ``attrs``-decorated. :param callable filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the `attr.Attribute` as the first argument and the value as the second argument. :param callable dict_factory: A callable to produce dictionaries from. For example, to produce ordered dictionaries instead of normal Python dictionaries, pass in ``collections.OrderedDict``. :param bool retain_collection_types: Do not convert to ``list`` when encountering an attribute whose type is ``tuple`` or ``set``. Only meaningful if ``recurse`` is ``True``. :param Optional[callable] value_serializer: A hook that is called for every attribute or dict key/value. It receives the current instance, field and value and must return the (updated) value. The hook is run after the optional filter has been applied. :rtype: return type of dict_factory :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 16.0.0 dict_factory .. versionadded:: 16.1.0 retain_collection_types .. versionadded:: 20.3.0 value_serializer """ attrs = fields(inst.__class__) rv = dict_factory() for a in attrs: v = getattr(inst, a.name) if filter is not None and not filter(a, v): continue if value_serializer is not None: v = value_serializer(inst, a, v) if recurse is True: if has(v.__class__): rv[a.name] = asdict( v, True, filter, dict_factory, retain_collection_types, value_serializer, ) elif isinstance(v, (tuple, list, set, frozenset)): cf = v.__class__ if retain_collection_types is True else list rv[a.name] = cf( [ _asdict_anything( i, filter, dict_factory, retain_collection_types, value_serializer, ) for i in v ] ) elif isinstance(v, dict): df = dict_factory rv[a.name] = df( ( _asdict_anything( kk, filter, df, retain_collection_types, value_serializer, ), _asdict_anything( vv, filter, df, retain_collection_types, value_serializer, ), ) for kk, vv in iteritems(v) ) else: rv[a.name] = v else: rv[a.name] = v return rv def _asdict_anything( val, filter, dict_factory, retain_collection_types, value_serializer, ): """ ``asdict`` only works on attrs instances, this works on anything. """ if getattr(val.__class__, "__attrs_attrs__", None) is not None: # Attrs class. rv = asdict( val, True, filter, dict_factory, retain_collection_types, value_serializer, ) elif isinstance(val, (tuple, list, set, frozenset)): cf = val.__class__ if retain_collection_types is True else list rv = cf( [ _asdict_anything( i, filter, dict_factory, retain_collection_types, value_serializer, ) for i in val ] ) elif isinstance(val, dict): df = dict_factory rv = df( ( _asdict_anything( kk, filter, df, retain_collection_types, value_serializer ), _asdict_anything( vv, filter, df, retain_collection_types, value_serializer ), ) for kk, vv in iteritems(val) ) else: rv = val if value_serializer is not None: rv = value_serializer(None, None, rv) return rv def astuple( inst, recurse=True, filter=None, tuple_factory=tuple, retain_collection_types=False, ): """ Return the ``attrs`` attribute values of inst as a tuple. Optionally recurse into other ``attrs``-decorated classes. :param inst: Instance of an ``attrs``-decorated class. :param bool recurse: Recurse into classes that are also ``attrs``-decorated. :param callable filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the `attr.Attribute` as the first argument and the value as the second argument. :param callable tuple_factory: A callable to produce tuples from. For example, to produce lists instead of tuples. :param bool retain_collection_types: Do not convert to ``list`` or ``dict`` when encountering an attribute which type is ``tuple``, ``dict`` or ``set``. Only meaningful if ``recurse`` is ``True``. :rtype: return type of tuple_factory :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 16.2.0 """ attrs = fields(inst.__class__) rv = [] retain = retain_collection_types # Very long. :/ for a in attrs: v = getattr(inst, a.name) if filter is not None and not filter(a, v): continue if recurse is True: if has(v.__class__): rv.append( astuple( v, recurse=True, filter=filter, tuple_factory=tuple_factory, retain_collection_types=retain, ) ) elif isinstance(v, (tuple, list, set, frozenset)): cf = v.__class__ if retain is True else list rv.append( cf( [ astuple( j, recurse=True, filter=filter, tuple_factory=tuple_factory, retain_collection_types=retain, ) if has(j.__class__) else j for j in v ] ) ) elif isinstance(v, dict): df = v.__class__ if retain is True else dict rv.append( df( ( astuple( kk, tuple_factory=tuple_factory, retain_collection_types=retain, ) if has(kk.__class__) else kk, astuple( vv, tuple_factory=tuple_factory, retain_collection_types=retain, ) if has(vv.__class__) else vv, ) for kk, vv in iteritems(v) ) ) else: rv.append(v) else: rv.append(v) return rv if tuple_factory is list else tuple_factory(rv) def has(cls): """ Check whether cls is a class with ``attrs`` attributes. :param type cls: Class to introspect. :raise TypeError: If cls is not a class. :rtype: bool """ return getattr(cls, "__attrs_attrs__", None) is not None def assoc(inst, *changes): """ Copy inst* and apply changes. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. :return: A copy of inst with changes incorporated. :raise attr.exceptions.AttrsAttributeNotFoundError: If attr_name couldn't be found on cls. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. deprecated:: 17.1.0 Use `evolve` instead. """ import warnings warnings.warn( "assoc is deprecated and will be removed after 2018/01.", DeprecationWarning, stacklevel=2, ) new = copy.copy(inst) attrs = fields(inst.__class__) for k, v in iteritems(changes): a = getattr(attrs, k, NOTHING) if a is NOTHING: raise AttrsAttributeNotFoundError( "{k} is not an attrs attribute on {cl}.".format( k=k, cl=new.__class__ ) ) _obj_setattr(new, k, v) return new def evolve(inst, *changes): """ Create a new instance, based on inst* with changes applied. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. :return: A copy of inst with changes incorporated. :raise TypeError: If attr_name couldn't be found in the class ``__init__``. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 17.1.0 """ cls = inst.__class__ attrs = fields(cls) for a in attrs: if not a.init: continue attr_name = a.name # To deal with private attributes. init_name = attr_name if attr_name[0] != "_" else attr_name[1:] if init_name not in changes: changes[init_name] = getattr(inst, attr_name) return cls(*changes) def resolve_types(cls, globalns=None, localns=None, attribs=None): """ Resolve any strings and forward annotations in type annotations. This is only required if you need concrete types in `Attribute`'s type* field. In other words, you don't need to resolve your types if you only use them for static type checking. With no arguments, names will be looked up in the module in which the class was created. If this is not what you want, e.g. if the name only exists inside a method, you may pass globalns or localns to specify other dictionaries in which to look up these names. See the docs of `typing.get_type_hints` for more details. :param type cls: Class to resolve. :param Optional[dict] globalns: Dictionary containing global variables. :param Optional[dict] localns: Dictionary containing local variables. :param Optional[list] attribs: List of attribs for the given class. This is necessary when calling from inside a ``field_transformer`` since cls is not an ``attrs`` class yet. :raise TypeError: If cls is not a class. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class and you didn't pass any attribs. :raise NameError: If types cannot be resolved because of missing variables. :returns: cls so you can use this function also as a class decorator. Please note that you have to apply it after `attr.s`. That means the decorator has to come in the line before `attr.s`. .. versionadded:: 20.1.0 .. versionadded:: 21.1.0 attribs """ try: # Since calling get_type_hints is expensive we cache whether we've # done it already. cls.__attrs_types_resolved__ except AttributeError: import typing hints = typing.get_type_hints(cls, globalns=globalns, localns=localns) for field in fields(cls) if attribs is None else attribs: if field.name in hints: # Since fields have been frozen we must work around it. _obj_setattr(field, "type", hints[field.name]) cls.__attrs_types_resolved__ = True # Return the class so you can use it as a decorator too. return cls PK��!��^�� exceptions.pynu��[��from __future__ import absolute_import, division, print_function class FrozenError(AttributeError): """ A frozen/immutable instance or attribute have been attempted to be modified. It mirrors the behavior of ``namedtuples`` by using the same error message and subclassing `AttributeError`. .. versionadded:: 20.1.0 """ msg = "can't set attribute" args = [msg] class FrozenInstanceError(FrozenError): """ A frozen instance has been attempted to be modified. .. versionadded:: 16.1.0 """ class FrozenAttributeError(FrozenError): """ A frozen attribute has been attempted to be modified. .. versionadded:: 20.1.0 """ class AttrsAttributeNotFoundError(ValueError): """ An ``attrs`` function couldn't find an attribute that the user asked for. .. versionadded:: 16.2.0 """ class NotAnAttrsClassError(ValueError): """ A non-``attrs`` class has been passed into an ``attrs`` function. .. versionadded:: 16.2.0 """ class DefaultAlreadySetError(RuntimeError): """ A default has been set using ``attr.ib()`` and is attempted to be reset using the decorator. .. versionadded:: 17.1.0 """ class UnannotatedAttributeError(RuntimeError): """ A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type annotation. .. versionadded:: 17.3.0 """ class PythonTooOldError(RuntimeError): """ It was attempted to use an ``attrs`` feature that requires a newer Python version. .. versionadded:: 18.2.0 """ class NotCallableError(TypeError): """ A ``attr.ib()`` requiring a callable has been set with a value that is not callable. .. versionadded:: 19.2.0 """ def __init__(self, msg, value): super(TypeError, self).__init__(msg, value) self.msg = msg self.value = value def __str__(self): return str(self.msg) PK��!��V~��~��converters.pyinu��[��from typing import Callable, Optional, TypeVar, overload from . import _ConverterType _T = TypeVar("_T") def pipe(validators: _ConverterType) -> _ConverterType: ... def optional(converter: _ConverterType) -> _ConverterType: ... @overload def default_if_none(default: _T) -> _ConverterType: ... @overload def default_if_none(, factory: Callable[[], _T]) -> _ConverterType: ... PK��!�� >��>��_cmp.pyinu��[��from typing import Type from . import _CompareWithType def cmp_using( eq: Optional[_CompareWithType], lt: Optional[_CompareWithType], le: Optional[_CompareWithType], gt: Optional[_CompareWithType], ge: Optional[_CompareWithType], require_same_type: bool, class_name: str, ) -> Type: ... PK��!��Y�r��r��_version_info.pynu��[��from __future__ import absolute_import, division, print_function from functools import total_ordering from ._funcs import astuple from ._make import attrib, attrs @total_ordering @attrs(eq=False, order=False, slots=True, frozen=True) class VersionInfo(object): """ A version object that can be compared to tuple of length 1--4: >>> attr.VersionInfo(19, 1, 0, "final") <= (19, 2) True >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1) True >>> vi = attr.VersionInfo(19, 2, 0, "final") >>> vi < (19, 1, 1) False >>> vi < (19,) False >>> vi == (19, 2,) True >>> vi == (19, 2, 1) False .. versionadded:: 19.2 """ year = attrib(type=int) minor = attrib(type=int) micro = attrib(type=int) releaselevel = attrib(type=str) @classmethod def _from_version_string(cls, s): """ Parse s and return a _VersionInfo. """ v = s.split(".") if len(v) == 3: v.append("final") return cls( year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3] ) def _ensure_tuple(self, other): """ Ensure other is a tuple of a valid length. Returns a possibly transformed other and ourselves as a tuple of the same length as other. """ if self.__class__ is other.__class__: other = astuple(other) if not isinstance(other, tuple): raise NotImplementedError if not (1 <= len(other) <= 4): raise NotImplementedError return astuple(self)[: len(other)], other def __eq__(self, other): try: us, them = self._ensure_tuple(other) except NotImplementedError: return NotImplemented return us == them def __lt__(self, other): try: us, them = self._ensure_tuple(other) except NotImplementedError: return NotImplemented # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't # have to do anything special with releaselevel for now. return us < them PK��!�:dc�J��J�� filters.pynu��[��""" Commonly useful filters for `attr.asdict`. """ from __future__ import absolute_import, division, print_function from ._compat import isclass from ._make import Attribute def _split_what(what): """ Returns a tuple of `frozenset`s of classes and attributes. """ return ( frozenset(cls for cls in what if isclass(cls)), frozenset(cls for cls in what if isinstance(cls, Attribute)), ) def include(what): """ Whitelist what. :param what: What to whitelist. :type what: `list` of `type` or `attr.Attribute`\\ s :rtype: `callable` """ cls, attrs = _split_what(what) def include_(attribute, value): return value.__class__ in cls or attribute in attrs return include_ def exclude(what): """ Blacklist what. :param what: What to blacklist. :type what: `list` of classes or `attr.Attribute`\\ s. :rtype: `callable` """ cls, attrs = _split_what(what) def exclude_(attribute, value): return value.__class__ not in cls and attribute not in attrs return exclude_ PK��!�� setters.pynu��[��""" Commonly used hooks for on_setattr. """ from __future__ import absolute_import, division, print_function from . import _config from .exceptions import FrozenAttributeError def pipe(setters): """ Run all setters* and return the return value of the last one. .. versionadded:: 20.1.0 """ def wrapped_pipe(instance, attrib, new_value): rv = new_value for setter in setters: rv = setter(instance, attrib, rv) return rv return wrapped_pipe def frozen(_, __, ___): """ Prevent an attribute to be modified. .. versionadded:: 20.1.0 """ raise FrozenAttributeError() def validate(instance, attrib, new_value): """ Run attrib's validator on new_value if it has one. .. versionadded:: 20.1.0 """ if _config._run_validators is False: return new_value v = attrib.validator if not v: return new_value v(instance, attrib, new_value) return new_value def convert(instance, attrib, new_value): """ Run attrib's converter -- if it has one -- on new_value and return the result. .. versionadded:: 20.1.0 """ c = attrib.converter if c: return c(new_value) return new_value NO_OP = object() """ Sentinel for disabling class-wide on_setattr hooks for certain attributes. Does not work in `pipe` or within lists. .. versionadded:: 20.1.0 """ PK��!��>��>��setters.pyinu��[��from typing import Any, NewType, NoReturn, TypeVar, cast from . import Attribute, _OnSetAttrType _T = TypeVar("_T") def frozen( instance: Any, attribute: Attribute[Any], new_value: Any ) -> NoReturn: ... def pipe(setters: _OnSetAttrType) -> _OnSetAttrType: ... def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ... # convert is allowed to return Any, because they can be chained using pipe. def convert( instance: Any, attribute: Attribute[Any], new_value: Any ) -> Any: ... _NoOpType = NewType("_NoOpType", object) NO_OP: _NoOpType PK��!��M�%��%��_cmp.pynu��[��from __future__ import absolute_import, division, print_function import functools from ._compat import new_class from ._make import _make_ne _operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="} def cmp_using( eq=None, lt=None, le=None, gt=None, ge=None, require_same_type=True, class_name="Comparable", ): """ Create a class that can be passed into `attr.ib`'s ``eq``, ``order``, and ``cmp`` arguments to customize field comparison. The resulting class will have a full set of ordering methods if at least one of ``{lt, le, gt, ge}`` and ``eq`` are provided. :param Optional[callable] eq: `callable` used to evaluate equality of two objects. :param Optional[callable] lt: `callable` used to evaluate whether one object is less than another object. :param Optional[callable] le: `callable` used to evaluate whether one object is less than or equal to another object. :param Optional[callable] gt: `callable` used to evaluate whether one object is greater than another object. :param Optional[callable] ge: `callable` used to evaluate whether one object is greater than or equal to another object. :param bool require_same_type: When `True`, equality and ordering methods will return `NotImplemented` if objects are not of the same type. :param Optional[str] class_name: Name of class. Defaults to 'Comparable'. See `comparison` for more details. .. versionadded:: 21.1.0 """ body = { "__slots__": ["value"], "__init__": _make_init(), "_requirements": [], "_is_comparable_to": _is_comparable_to, } # Add operations. num_order_functions = 0 has_eq_function = False if eq is not None: has_eq_function = True body["__eq__"] = _make_operator("eq", eq) body["__ne__"] = _make_ne() if lt is not None: num_order_functions += 1 body["__lt__"] = _make_operator("lt", lt) if le is not None: num_order_functions += 1 body["__le__"] = _make_operator("le", le) if gt is not None: num_order_functions += 1 body["__gt__"] = _make_operator("gt", gt) if ge is not None: num_order_functions += 1 body["__ge__"] = _make_operator("ge", ge) type_ = new_class(class_name, (object,), {}, lambda ns: ns.update(body)) # Add same type requirement. if require_same_type: type_._requirements.append(_check_same_type) # Add total ordering if at least one operation was defined. if 0 < num_order_functions < 4: if not has_eq_function: # functools.total_ordering requires __eq__ to be defined, # so raise early error here to keep a nice stack. raise ValueError( "eq must be define is order to complete ordering from " "lt, le, gt, ge." ) type_ = functools.total_ordering(type_) return type_ def _make_init(): """ Create __init__ method. """ def __init__(self, value): """ Initialize object with value. """ self.value = value return __init__ def _make_operator(name, func): """ Create operator method. """ def method(self, other): if not self._is_comparable_to(other): return NotImplemented result = func(self.value, other.value) if result is NotImplemented: return NotImplemented return result method.__name__ = "__%s__" % (name,) method.__doc__ = "Return a %s b. Computed by attrs." % ( _operation_names[name], ) return method def _is_comparable_to(self, other): """ Check whether `other` is comparable to `self`. """ for func in self._requirements: if not func(self, other): return False return True def _check_same_type(self, other): """ Return True if self* and other are of the same type, False otherwise. """ return other.value.__class__ is self.value.__class__ PK��!�J&LN��N��validators.pyinu��[��from typing import ( Any, AnyStr, Callable, Container, Iterable, List, Mapping, Match, Optional, Tuple, Type, TypeVar, Union, overload, ) from . import _ValidatorType _T = TypeVar("_T") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _I = TypeVar("_I", bound=Iterable) _K = TypeVar("_K") _V = TypeVar("_V") _M = TypeVar("_M", bound=Mapping) # To be more precise on instance_of use some overloads. # If there are more than 3 items in the tuple then we fall back to Any @overload def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ... @overload def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ... @overload def instance_of( type: Tuple[Type[_T1], Type[_T2]] ) -> _ValidatorType[Union[_T1, _T2]]: ... @overload def instance_of( type: Tuple[Type[_T1], Type[_T2], Type[_T3]] ) -> _ValidatorType[Union[_T1, _T2, _T3]]: ... @overload def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ... def provides(interface: Any) -> _ValidatorType[Any]: ... def optional( validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]] ) -> _ValidatorType[Optional[_T]]: ... def in_(options: Container[_T]) -> _ValidatorType[_T]: ... def and_(validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... def matches_re( regex: AnyStr, flags: int = ..., func: Optional[ Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]] ] = ..., ) -> _ValidatorType[AnyStr]: ... def deep_iterable( member_validator: _ValidatorType[_T], iterable_validator: Optional[_ValidatorType[_I]] = ..., ) -> _ValidatorType[_I]: ... def deep_mapping( key_validator: _ValidatorType[_K], value_validator: _ValidatorType[_V], mapping_validator: Optional[_ValidatorType[_M]] = ..., ) -> _ValidatorType[_M]: ... def is_callable() -> _ValidatorType[_T]: ... PK��!�F�'�,��,�� validators.pynu��[��""" Commonly useful validators. """ from __future__ import absolute_import, division, print_function import re from ._make import _AndValidator, and_, attrib, attrs from .exceptions import NotCallableError __all__ = [ "and_", "deep_iterable", "deep_mapping", "in_", "instance_of", "is_callable", "matches_re", "optional", "provides", ] @attrs(repr=False, slots=True, hash=True) class _InstanceOfValidator(object): type = attrib() def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not isinstance(value, self.type): raise TypeError( "'{name}' must be {type!r} (got {value!r} that is a " "{actual!r}).".format( name=attr.name, type=self.type, actual=value.__class__, value=value, ), attr, self.type, value, ) def __repr__(self): return "<instance_of validator for type {type!r}>".format( type=self.type ) def instance_of(type): """ A validator that raises a `TypeError` if the initializer is called with a wrong type for this particular attribute (checks are performed using `isinstance` therefore it's also valid to pass a tuple of types). :param type: The type to check for. :type type: type or tuple of types :raises TypeError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected type, and the value it got. """ return _InstanceOfValidator(type) @attrs(repr=False, frozen=True, slots=True) class _MatchesReValidator(object): regex = attrib() flags = attrib() match_func = attrib() def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not self.match_func(value): raise ValueError( "'{name}' must match regex {regex!r}" " ({value!r} doesn't)".format( name=attr.name, regex=self.regex.pattern, value=value ), attr, self.regex, value, ) def __repr__(self): return "<matches_re validator for pattern {regex!r}>".format( regex=self.regex ) def matches_re(regex, flags=0, func=None): r""" A validator that raises `ValueError` if the initializer is called with a string that doesn't match regex. :param str regex: a regex string to match against :param int flags: flags that will be passed to the underlying re function (default 0) :param callable func: which underlying `re` function to call (options are `re.fullmatch`, `re.search`, `re.match`, default is ``None`` which means either `re.fullmatch` or an emulation of it on Python 2). For performance reasons, they won't be used directly but on a pre-`re.compile`\ ed pattern. .. versionadded:: 19.2.0 """ fullmatch = getattr(re, "fullmatch", None) valid_funcs = (fullmatch, None, re.search, re.match) if func not in valid_funcs: raise ValueError( "'func' must be one of %s." % ( ", ".join( sorted( e and e.__name__ or "None" for e in set(valid_funcs) ) ), ) ) pattern = re.compile(regex, flags) if func is re.match: match_func = pattern.match elif func is re.search: match_func = pattern.search else: if fullmatch: match_func = pattern.fullmatch else: pattern = re.compile(r"(?:{})\Z".format(regex), flags) match_func = pattern.match return _MatchesReValidator(pattern, flags, match_func) @attrs(repr=False, slots=True, hash=True) class _ProvidesValidator(object): interface = attrib() def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not self.interface.providedBy(value): raise TypeError( "'{name}' must provide {interface!r} which {value!r} " "doesn't.".format( name=attr.name, interface=self.interface, value=value ), attr, self.interface, value, ) def __repr__(self): return "<provides validator for interface {interface!r}>".format( interface=self.interface ) def provides(interface): """ A validator that raises a `TypeError` if the initializer is called with an object that does not provide the requested interface* (checks are performed using ``interface.providedBy(value)`` (see `zope.interface <https://zopeinterface.readthedocs.io/en/latest/>`_). :param interface: The interface to check for. :type interface: ``zope.interface.Interface`` :raises TypeError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected interface, and the value it got. """ return _ProvidesValidator(interface) @attrs(repr=False, slots=True, hash=True) class _OptionalValidator(object): validator = attrib() def __call__(self, inst, attr, value): if value is None: return self.validator(inst, attr, value) def __repr__(self): return "<optional validator for {what} or None>".format( what=repr(self.validator) ) def optional(validator): """ A validator that makes an attribute optional. An optional attribute is one which can be set to ``None`` in addition to satisfying the requirements of the sub-validator. :param validator: A validator (or a list of validators) that is used for non-``None`` values. :type validator: callable or `list` of callables. .. versionadded:: 15.1.0 .. versionchanged:: 17.1.0 validator can be a list of validators. """ if isinstance(validator, list): return _OptionalValidator(_AndValidator(validator)) return _OptionalValidator(validator) @attrs(repr=False, slots=True, hash=True) class _InValidator(object): options = attrib() def __call__(self, inst, attr, value): try: in_options = value in self.options except TypeError: # e.g. `1 in "abc"` in_options = False if not in_options: raise ValueError( "'{name}' must be in {options!r} (got {value!r})".format( name=attr.name, options=self.options, value=value ) ) def __repr__(self): return "<in_ validator with options {options!r}>".format( options=self.options ) def in_(options): """ A validator that raises a `ValueError` if the initializer is called with a value that does not belong in the options provided. The check is performed using ``value in options``. :param options: Allowed options. :type options: list, tuple, `enum.Enum`, ... :raises ValueError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected options, and the value it got. .. versionadded:: 17.1.0 """ return _InValidator(options) @attrs(repr=False, slots=False, hash=True) class _IsCallableValidator(object): def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if not callable(value): message = ( "'{name}' must be callable " "(got {value!r} that is a {actual!r})." ) raise NotCallableError( msg=message.format( name=attr.name, value=value, actual=value.__class__ ), value=value, ) def __repr__(self): return "<is_callable validator>" def is_callable(): """ A validator that raises a `attr.exceptions.NotCallableError` if the initializer is called with a value for this particular attribute that is not callable. .. versionadded:: 19.1.0 :raises `attr.exceptions.NotCallableError`: With a human readable error message containing the attribute (`attr.Attribute`) name, and the value it got. """ return _IsCallableValidator() @attrs(repr=False, slots=True, hash=True) class _DeepIterable(object): member_validator = attrib(validator=is_callable()) iterable_validator = attrib( default=None, validator=optional(is_callable()) ) def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if self.iterable_validator is not None: self.iterable_validator(inst, attr, value) for member in value: self.member_validator(inst, attr, member) def __repr__(self): iterable_identifier = ( "" if self.iterable_validator is None else " {iterable!r}".format(iterable=self.iterable_validator) ) return ( "<deep_iterable validator for{iterable_identifier}" " iterables of {member!r}>" ).format( iterable_identifier=iterable_identifier, member=self.member_validator, ) def deep_iterable(member_validator, iterable_validator=None): """ A validator that performs deep validation of an iterable. :param member_validator: Validator to apply to iterable members :param iterable_validator: Validator to apply to iterable itself (optional) .. versionadded:: 19.1.0 :raises TypeError: if any sub-validators fail """ return _DeepIterable(member_validator, iterable_validator) @attrs(repr=False, slots=True, hash=True) class _DeepMapping(object): key_validator = attrib(validator=is_callable()) value_validator = attrib(validator=is_callable()) mapping_validator = attrib(default=None, validator=optional(is_callable())) def __call__(self, inst, attr, value): """ We use a callable class to be able to change the ``__repr__``. """ if self.mapping_validator is not None: self.mapping_validator(inst, attr, value) for key in value: self.key_validator(inst, attr, key) self.value_validator(inst, attr, value[key]) def __repr__(self): return ( "<deep_mapping validator for objects mapping {key!r} to {value!r}>" ).format(key=self.key_validator, value=self.value_validator) def deep_mapping(key_validator, value_validator, mapping_validator=None): """ A validator that performs deep validation of a dictionary. :param key_validator: Validator to apply to dictionary keys :param value_validator: Validator to apply to dictionary values :param mapping_validator: Validator to apply to top-level mapping attribute (optional) .. versionadded:: 19.1.0 :raises TypeError: if any sub-validators fail """ return _DeepMapping(key_validator, value_validator, mapping_validator) PK��!��t;�� _compat.pynu��[��from __future__ import absolute_import, division, print_function import platform import sys import types import warnings PY2 = sys.version_info[0] == 2 PYPY = platform.python_implementation() == "PyPy" if PYPY or sys.version_info[:2] >= (3, 6): ordered_dict = dict else: from collections import OrderedDict ordered_dict = OrderedDict if PY2: from collections import Mapping, Sequence from UserDict import IterableUserDict # We 'bundle' isclass instead of using inspect as importing inspect is # fairly expensive (order of 10-15 ms for a modern machine in 2016) def isclass(klass): return isinstance(klass, (type, types.ClassType)) def new_class(name, bases, kwds, exec_body): """ A minimal stub of types.new_class that we need for make_class. """ ns = {} exec_body(ns) return type(name, bases, ns) # TYPE is used in exceptions, repr(int) is different on Python 2 and 3. TYPE = "type" def iteritems(d): return d.iteritems() # Python 2 is bereft of a read-only dict proxy, so we make one! class ReadOnlyDict(IterableUserDict): """ Best-effort read-only dict wrapper. """ def __setitem__(self, key, val): # We gently pretend we're a Python 3 mappingproxy. raise TypeError( "'mappingproxy' object does not support item assignment" ) def update(self, _): # We gently pretend we're a Python 3 mappingproxy. raise AttributeError( "'mappingproxy' object has no attribute 'update'" ) def __delitem__(self, _): # We gently pretend we're a Python 3 mappingproxy. raise TypeError( "'mappingproxy' object does not support item deletion" ) def clear(self): # We gently pretend we're a Python 3 mappingproxy. raise AttributeError( "'mappingproxy' object has no attribute 'clear'" ) def pop(self, key, default=None): # We gently pretend we're a Python 3 mappingproxy. raise AttributeError( "'mappingproxy' object has no attribute 'pop'" ) def popitem(self): # We gently pretend we're a Python 3 mappingproxy. raise AttributeError( "'mappingproxy' object has no attribute 'popitem'" ) def setdefault(self, key, default=None): # We gently pretend we're a Python 3 mappingproxy. raise AttributeError( "'mappingproxy' object has no attribute 'setdefault'" ) def __repr__(self): # Override to be identical to the Python 3 version. return "mappingproxy(" + repr(self.data) + ")" def metadata_proxy(d): res = ReadOnlyDict() res.data.update(d) # We blocked update, so we have to do it like this. return res def just_warn(args, kw): # pragma: no cover """ We only warn on Python 3 because we are not aware of any concrete consequences of not setting the cell on Python 2. """ else: # Python 3 and later. from collections.abc import Mapping, Sequence # noqa def just_warn(args, *kw): """ We only warn on Python 3 because we are not aware of any concrete consequences of not setting the cell on Python 2. """ warnings.warn( "Running interpreter doesn't sufficiently support code object " "introspection. Some features like bare super() or accessing " "__class__ will not work with slotted classes.", RuntimeWarning, stacklevel=2, ) def isclass(klass): return isinstance(klass, type) TYPE = "class" def iteritems(d): return d.items() new_class = types.new_class def metadata_proxy(d): return types.MappingProxyType(dict(d)) def make_set_closure_cell(): """Return a function of two arguments (cell, value) which sets the value stored in the closure cell `cell` to `value`. """ # pypy makes this easy. (It also supports the logic below, but # why not do the easy/fast thing?) if PYPY: def set_closure_cell(cell, value): cell.__setstate__((value,)) return set_closure_cell # Otherwise gotta do it the hard way. # Create a function that will set its first cellvar to `value`. def set_first_cellvar_to(value): x = value return # This function will be eliminated as dead code, but # not before its reference to `x` forces `x` to be # represented as a closure cell rather than a local. def force_x_to_be_a_cell(): # pragma: no cover return x try: # Extract the code object and make sure our assumptions about # the closure behavior are correct. if PY2: co = set_first_cellvar_to.func_code else: co = set_first_cellvar_to.__code__ if co.co_cellvars != ("x",) or co.co_freevars != (): raise AssertionError # pragma: no cover # Convert this code object to a code object that sets the # function's first _freevar_ (not cellvar) to the argument. if sys.version_info >= (3, 8): # CPython 3.8+ has an incompatible CodeType signature # (added a posonlyargcount argument) but also added # CodeType.replace() to do this without counting parameters. set_first_freevar_code = co.replace( co_cellvars=co.co_freevars, co_freevars=co.co_cellvars ) else: args = [co.co_argcount] if not PY2: args.append(co.co_kwonlyargcount) args.extend( [ co.co_nlocals, co.co_stacksize, co.co_flags, co.co_code, co.co_consts, co.co_names, co.co_varnames, co.co_filename, co.co_name, co.co_firstlineno, co.co_lnotab, # These two arguments are reversed: co.co_cellvars, co.co_freevars, ] ) set_first_freevar_code = types.CodeType(args) def set_closure_cell(cell, value): # Create a function using the set_first_freevar_code, # whose first closure cell is `cell`. Calling it will # change the value of that cell. setter = types.FunctionType( set_first_freevar_code, {}, "setter", (), (cell,) ) # And call it to set the cell. setter(value) # Make sure it works on this interpreter: def make_func_with_cell(): x = None def func(): return x # pragma: no cover return func if PY2: cell = make_func_with_cell().func_closure[0] else: cell = make_func_with_cell().__closure__[0] set_closure_cell(cell, 100) if cell.cell_contents != 100: raise AssertionError # pragma: no cover except Exception: return just_warn else: return set_closure_cell set_closure_cell = make_set_closure_cell() PK��!��py.typednu��[��PK��!��`ͮM��M��__init__.pynu��[��from __future__ import absolute_import, division, print_function import sys from functools import partial from . import converters, exceptions, filters, setters, validators from ._cmp import cmp_using from ._config import get_run_validators, set_run_validators from ._funcs import asdict, assoc, astuple, evolve, has, resolve_types from ._make import ( NOTHING, Attribute, Factory, attrib, attrs, fields, fields_dict, make_class, validate, ) from ._version_info import VersionInfo __version__ = "21.2.0" __version_info__ = VersionInfo._from_version_string(__version__) __title__ = "attrs" __description__ = "Classes Without Boilerplate" __url__ = "https://www.attrs.org/" __uri__ = __url__ __doc__ = __description__ + " <" + __uri__ + ">" __author__ = "Hynek Schlawack" __email__ = "hs@ox.cx" __license__ = "MIT" __copyright__ = "Copyright (c) 2015 Hynek Schlawack" s = attributes = attrs ib = attr = attrib dataclass = partial(attrs, auto_attribs=True) # happy Easter ;) __all__ = [ "Attribute", "Factory", "NOTHING", "asdict", "assoc", "astuple", "attr", "attrib", "attributes", "attrs", "cmp_using", "converters", "evolve", "exceptions", "fields", "fields_dict", "filters", "get_run_validators", "has", "ib", "make_class", "resolve_types", "s", "set_run_validators", "setters", "validate", "validators", ] if sys.version_info[:2] >= (3, 6): from ._next_gen import define, field, frozen, mutable __all__.extend((define, field, frozen, mutable)) PK��!��d�� converters.pynu��[��""" Commonly useful converters. """ from __future__ import absolute_import, division, print_function from ._compat import PY2 from ._make import NOTHING, Factory, pipe if not PY2: import inspect import typing __all__ = [ "pipe", "optional", "default_if_none", ] def optional(converter): """ A converter that allows an attribute to be optional. An optional attribute is one which can be set to ``None``. Type annotations will be inferred from the wrapped converter's, if it has any. :param callable converter: the converter that is used for non-``None`` values. .. versionadded:: 17.1.0 """ def optional_converter(val): if val is None: return None return converter(val) if not PY2: sig = None try: sig = inspect.signature(converter) except (ValueError, TypeError): # inspect failed pass if sig: params = list(sig.parameters.values()) if params and params[0].annotation is not inspect.Parameter.empty: optional_converter.__annotations__["val"] = typing.Optional[ params[0].annotation ] if sig.return_annotation is not inspect.Signature.empty: optional_converter.__annotations__["return"] = typing.Optional[ sig.return_annotation ] return optional_converter def default_if_none(default=NOTHING, factory=None): """ A converter that allows to replace ``None`` values by default or the result of factory. :param default: Value to be used if ``None`` is passed. Passing an instance of `attr.Factory` is supported, however the ``takes_self`` option is not. :param callable factory: A callable that takes no parameters whose result is used if ``None`` is passed. :raises TypeError: If neither default or factory is passed. :raises TypeError: If both default and factory are passed. :raises ValueError: If an instance of `attr.Factory` is passed with ``takes_self=True``. .. versionadded:: 18.2.0 """ if default is NOTHING and factory is None: raise TypeError("Must pass either `default` or `factory`.") if default is not NOTHING and factory is not None: raise TypeError( "Must pass either `default` or `factory` but not both." ) if factory is not None: default = Factory(factory) if isinstance(default, Factory): if default.takes_self: raise ValueError( "`takes_self` is not supported by default_if_none." ) def default_if_none_converter(val): if val is not None: return val return default.factory() else: def default_if_none_converter(val): if val is not None: return val return default return default_if_none_converter PK��!�괎�9��9��__init__.pyinu��[��import sys from typing import ( Any, Callable, Dict, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload, ) # `import X as X` is required to make these public from . import converters as converters from . import exceptions as exceptions from . import filters as filters from . import setters as setters from . import validators as validators from ._version_info import VersionInfo __version__: str __version_info__: VersionInfo __title__: str __description__: str __url__: str __uri__: str __author__: str __email__: str __license__: str __copyright__: str _T = TypeVar("_T") _C = TypeVar("_C", bound=type) _EqOrderType = Union[bool, Callable[[Any], Any]] _ValidatorType = Callable[[Any, Attribute[_T], _T], Any] _ConverterType = Callable[[Any], Any] _FilterType = Callable[[Attribute[_T], _T], bool] _ReprType = Callable[[Any], str] _ReprArgType = Union[bool, _ReprType] _OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any] _OnSetAttrArgType = Union[ _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType ] _FieldTransformer = Callable[[type, List[Attribute[Any]]], List[Attribute[Any]]] # FIXME: in reality, if multiple validators are passed they must be in a list # or tuple, but those are invariant and so would prevent subtypes of # _ValidatorType from working when passed in a list or tuple. _ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]] # _make -- NOTHING: object # NOTE: Factory lies about its return type to make this possible: # `x: List[int] # = Factory(list)` # Work around mypy issue #4554 in the common case by using an overload. if sys.version_info >= (3, 8): from typing import Literal @overload def Factory(factory: Callable[[], _T]) -> _T: ... @overload def Factory( factory: Callable[[Any], _T], takes_self: Literal[True], ) -> _T: ... @overload def Factory( factory: Callable[[], _T], takes_self: Literal[False], ) -> _T: ... else: @overload def Factory(factory: Callable[[], _T]) -> _T: ... @overload def Factory( factory: Union[Callable[[Any], _T], Callable[[], _T]], takes_self: bool = ..., ) -> _T: ... # Static type inference support via __dataclass_transform__ implemented as per: # https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md # This annotation must be applied to all overloads of "define" and "attrs" # # NOTE: This is a typing construct and does not exist at runtime. Extensions # wrapping attrs decorators should declare a separate __dataclass_transform__ # signature in the extension module using the specification linked above to # provide pyright support. def __dataclass_transform__( , eq_default: bool = True, order_default: bool = False, kw_only_default: bool = False, field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()), ) -> Callable[[_T], _T]: ... class Attribute(Generic[_T]): name: str default: Optional[_T] validator: Optional[_ValidatorType[_T]] repr: _ReprArgType cmp: _EqOrderType eq: _EqOrderType order: _EqOrderType hash: Optional[bool] init: bool converter: Optional[_ConverterType] metadata: Dict[Any, Any] type: Optional[Type[_T]] kw_only: bool on_setattr: _OnSetAttrType def evolve(self, changes: Any) -> "Attribute[Any]": ... # NOTE: We had several choices for the annotation to use for type arg: # 1) Type[_T] # - Pros: Handles simple cases correctly # - Cons: Might produce less informative errors in the case of conflicting # TypeVars e.g. `attr.ib(default='bad', type=int)` # 2) Callable[..., _T] # - Pros: Better error messages than #1 for conflicting TypeVars # - Cons: Terrible error messages for validator checks. # e.g. attr.ib(type=int, validator=validate_str) # -> error: Cannot infer function type argument # 3) type (and do all of the work in the mypy plugin) # - Pros: Simple here, and we could customize the plugin with our own errors. # - Cons: Would need to write mypy plugin code to handle all the cases. # We chose option #1. # `attr` lies about its return type to make the following possible: # attr() -> Any # attr(8) -> int # attr(validator=<some callable>) -> Whatever the callable expects. # This makes this type of assignments possible: # x: int = attr(8) # # This form catches explicit None or no default but with no other arguments # returns Any. @overload def attrib( default: None = ..., validator: None = ..., repr: _ReprArgType = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: None = ..., converter: None = ..., factory: None = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> Any: ... # This form catches an explicit None or no default and infers the type from the # other arguments. @overload def attrib( default: None = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: Optional[Type[_T]] = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> _T: ... # This form catches an explicit default argument. @overload def attrib( default: _T, validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: Optional[Type[_T]] = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> _T: ... # This form covers type=non-Type: e.g. forward references (str), Any @overload def attrib( default: Optional[_T] = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: object = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> Any: ... @overload def field( , default: None = ..., validator: None = ..., repr: _ReprArgType = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., converter: None = ..., factory: None = ..., kw_only: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> Any: ... # This form catches an explicit None or no default and infers the type from the # other arguments. @overload def field( , default: None = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> _T: ... # This form catches an explicit default argument. @overload def field( , default: _T, validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> _T: ... # This form covers type=non-Type: e.g. forward references (str), Any @overload def field( , default: Optional[_T] = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., converter: Optional[_ConverterType] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., ) -> Any: ... @overload @__dataclass_transform__(order_default=True, field_descriptors=(attrib, field)) def attrs( maybe_cls: _C, these: Optional[Dict[str, Any]] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., auto_detect: bool = ..., collect_by_mro: bool = ..., getstate_setstate: Optional[bool] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., field_transformer: Optional[_FieldTransformer] = ..., ) -> _C: ... @overload @__dataclass_transform__(order_default=True, field_descriptors=(attrib, field)) def attrs( maybe_cls: None = ..., these: Optional[Dict[str, Any]] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., auto_detect: bool = ..., collect_by_mro: bool = ..., getstate_setstate: Optional[bool] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., field_transformer: Optional[_FieldTransformer] = ..., ) -> Callable[[_C], _C]: ... @overload @__dataclass_transform__(field_descriptors=(attrib, field)) def define( maybe_cls: _C, , these: Optional[Dict[str, Any]] = ..., repr: bool = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., auto_detect: bool = ..., getstate_setstate: Optional[bool] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., field_transformer: Optional[_FieldTransformer] = ..., ) -> _C: ... @overload @__dataclass_transform__(field_descriptors=(attrib, field)) def define( maybe_cls: None = ..., , these: Optional[Dict[str, Any]] = ..., repr: bool = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., auto_detect: bool = ..., getstate_setstate: Optional[bool] = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., field_transformer: Optional[_FieldTransformer] = ..., ) -> Callable[[_C], _C]: ... mutable = define frozen = define # they differ only in their defaults # TODO: add support for returning NamedTuple from the mypy plugin class _Fields(Tuple[Attribute[Any], ...]): def __getattr__(self, name: str) -> Attribute[Any]: ... def fields(cls: type) -> _Fields: ... def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ... def validate(inst: Any) -> None: ... def resolve_types( cls: _C, globalns: Optional[Dict[str, Any]] = ..., localns: Optional[Dict[str, Any]] = ..., attribs: Optional[List[Attribute[Any]]] = ..., ) -> _C: ... # TODO: add support for returning a proper attrs class from the mypy plugin # we use Any instead of _CountingAttr so that e.g. `make_class('Foo', # [attr.ib()])` is valid def make_class( name: str, attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]], bases: Tuple[type, ...] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[_EqOrderType] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[_EqOrderType] = ..., order: Optional[_EqOrderType] = ..., collect_by_mro: bool = ..., on_setattr: Optional[_OnSetAttrArgType] = ..., field_transformer: Optional[_FieldTransformer] = ..., ) -> type: ... # _funcs -- # TODO: add support for returning TypedDict from the mypy plugin # FIXME: asdict/astuple do not honor their factory args. Waiting on one of # these: # https://github.com/python/mypy/issues/4236 # https://github.com/python/typing/issues/253 def asdict( inst: Any, recurse: bool = ..., filter: Optional[_FilterType[Any]] = ..., dict_factory: Type[Mapping[Any, Any]] = ..., retain_collection_types: bool = ..., value_serializer: Optional[Callable[[type, Attribute[Any], Any], Any]] = ..., ) -> Dict[str, Any]: ... # TODO: add support for returning NamedTuple from the mypy plugin def astuple( inst: Any, recurse: bool = ..., filter: Optional[_FilterType[Any]] = ..., tuple_factory: Type[Sequence[Any]] = ..., retain_collection_types: bool = ..., ) -> Tuple[Any, ...]: ... def has(cls: type) -> bool: ... def assoc(inst: _T, changes: Any) -> _T: ... def evolve(inst: _T, changes: Any) -> _T: ... # _config -- def set_run_validators(run: bool) -> None: ... def get_run_validators() -> bool: ... # aliases -- s = attributes = attrs ib = attr = attrib dataclass = attrs # Technically, partial(attrs, auto_attribs=True) ;) PK��!�X}��exceptions.pyinu��[��from typing import Any class FrozenError(AttributeError): msg: str = ... class FrozenInstanceError(FrozenError): ... class FrozenAttributeError(FrozenError): ... class AttrsAttributeNotFoundError(ValueError): ... class NotAnAttrsClassError(ValueError): ... class DefaultAlreadySetError(RuntimeError): ... class UnannotatedAttributeError(RuntimeError): ... class PythonTooOldError(RuntimeError): ... class NotCallableError(TypeError): msg: str = ... value: Any = ... def __init__(self, msg: str, value: Any) -> None: ... PK��!�Q";��_next_gen.pynu��[��""" These are Python 3.6+-only and keyword-only APIs that call `attr.s` and `attr.ib` with different default values. """ from functools import partial from attr.exceptions import UnannotatedAttributeError from . import setters from ._make import NOTHING, _frozen_setattrs, attrib, attrs def define( maybe_cls=None, , these=None, repr=None, hash=None, init=None, slots=True, frozen=False, weakref_slot=True, str=False, auto_attribs=None, kw_only=False, cache_hash=False, auto_exc=True, eq=None, order=False, auto_detect=True, getstate_setstate=None, on_setattr=None, field_transformer=None, ): r""" The only behavioral differences are the handling of the auto_attribs option: :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves exactly like `attr.s`. If left `None`, `attr.s` will try to guess: 1. If any attributes are annotated and no unannotated `attr.ib`\ s are found, it assumes auto_attribs=True. 2. Otherwise it assumes auto_attribs=False and tries to collect `attr.ib`\ s. and that mutable classes (``frozen=False``) validate on ``__setattr__``. .. versionadded:: 20.1.0 """ def do_it(cls, auto_attribs): return attrs( maybe_cls=cls, these=these, repr=repr, hash=hash, init=init, slots=slots, frozen=frozen, weakref_slot=weakref_slot, str=str, auto_attribs=auto_attribs, kw_only=kw_only, cache_hash=cache_hash, auto_exc=auto_exc, eq=eq, order=order, auto_detect=auto_detect, collect_by_mro=True, getstate_setstate=getstate_setstate, on_setattr=on_setattr, field_transformer=field_transformer, ) def wrap(cls): """ Making this a wrapper ensures this code runs during class creation. We also ensure that frozen-ness of classes is inherited. """ nonlocal frozen, on_setattr had_on_setattr = on_setattr not in (None, setters.NO_OP) # By default, mutable classes validate on setattr. if frozen is False and on_setattr is None: on_setattr = setters.validate # However, if we subclass a frozen class, we inherit the immutability # and disable on_setattr. for base_cls in cls.__bases__: if base_cls.__setattr__ is _frozen_setattrs: if had_on_setattr: raise ValueError( "Frozen classes can't use on_setattr " "(frozen-ness was inherited)." ) on_setattr = setters.NO_OP break if auto_attribs is not None: return do_it(cls, auto_attribs) try: return do_it(cls, True) except UnannotatedAttributeError: return do_it(cls, False) # maybe_cls's type depends on the usage of the decorator. It's a class # if it's used as `@attrs` but ``None`` if used as `@attrs()`. if maybe_cls is None: return wrap else: return wrap(maybe_cls) mutable = define frozen = partial(define, frozen=True, on_setattr=None) def field( , default=NOTHING, validator=None, repr=True, hash=None, init=True, metadata=None, converter=None, factory=None, kw_only=False, eq=None, order=None, on_setattr=None, ): """ Identical to `attr.ib`, except keyword-only and with some arguments removed. .. versionadded:: 20.1.0 """ return attrib( default=default, validator=validator, repr=repr, hash=hash, init=init, metadata=metadata, converter=converter, factory=factory, kw_only=kw_only, eq=eq, order=order, on_setattr=on_setattr, ) PK��!�њ%��!��__pycache__/_make.cpython-310.pycnu��[��o ��`�}��@��s��d�dl�mZmZmZ�d�dlZd�dlZd�dlZd�dlZd�dlZd�dl Z d�dl Z d�dlmZ�ddl mZmZ�ddlmZmZmZmZmZmZmZmZ�ddlmZmZmZmZmZ�es\d�dlZe j!Z"dZ#d Z$d Z%dZ&dZ'ei��Z(e ��Z)G�d d��de �Ze��Z+ �G�dd��de,�Z-e+dddddddddddddfdd�Z.d�dd�Z/d�dd�Z0dd��Z1e1dg�d��Z2dd��Z3d d!��Z4d"d#��Z5d$d%��Z6d&d'��Z7d(d)��Z8dd+��Z9er�d,d-��Z:nd.d-��Z:d/d0��Z;G�d1d2��d2e �Z<d3Z=d4d5��Z>d6d7��Z? d�d8d9�Z@ d�d:d;�ZAeAZB �e�rd<d=��ZCnd>d=��ZCd?d@��ZDdAdB��ZEdCdD��ZFdEdF��ZGdGdH��ZHdIdJ��ZId�dKdL�ZJe�K��ZLdMdN��ZMd�dOdP�ZNdQdR��ZOdSdT��ZPdUdV��ZQdWdX��ZRdYdZ��ZSd[d\��ZTd]d^��ZUd_d`��ZVdadb��ZWdcdd��ZXe�rwd�dedf�ZYdgdh��ZZdidj��Z[G�dkdl��dle �Z\dmdn��e\j]D��Z^eFeJeNe\e^do�dpdn��e^D��do�dqdn��e^D��do�Z\G�drds��dse �Z_eJeNe_��Z_G�dtdu��due �Z`dvdn��e`j]D��ZaeFeJeNe`eado�eado�eado�Z`e ffdwdx�ZbeAdddy�G�dzd{��d{e ��Zcd\|d}��Zdd~d��ZedS�)��)�absolute_import�division�print_functionN)� itemgetter��)�_config�setters)�PY2�PYPY�isclass� iteritems�metadata_proxy� new_class�ordered_dict�set_closure_cell)�DefaultAlreadySetError�FrozenInstanceError�NotAnAttrsClassError�PythonTooOldError�UnannotatedAttributeErrorz__attr_converter_%sz__attr_factory_{}z= {attr_name} = _attrs_property(_attrs_itemgetter({index})))ztyping.ClassVarz t.ClassVar�ClassVarztyping_extensions.ClassVar�_attrs_cached_hashc��s<��e�Zd�ZdZdZ��fdd�Zdd��Zdd��Zd d ��Z��Z S�)�_Nothingz� Sentinel class to indicate the lack of a value when ``None`` is ambiguous. ``_Nothing`` is a singleton. There is only ever one of it. .. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False. Nc��s"��t�jd�u�rtt�\|��\|��t�_t�jS��N)r�� _singleton�super�__new__��cls�� __class__��,/usr/lib/python3/dist-packages/attr/_make.pyr��H��s�� z_Nothing.__new__c��C��dS�)N�NOTHINGr!��selfr!��r!��r"��__repr__M��z_Nothing.__repr__c��C��r#��)NFr!��r%��r!��r!��r"��__bool__P��r(��z_Nothing.__bool__c��C��r#��)Nr��r!��r%��r!��r!��r"��__len__S��r(��z_Nothing.__len__) �__name__� __module__�__qualname__�__doc__r��r��r'��r)��r�� __classcell__r!��r!��r��r"��r��=��s��r��c��@��s8��e�Zd�ZdZeredfdd�ZdS�ed�dfdd�ZdS�)�_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. )r��Nc��C��\|\|fS�r��r!��r&��_none_constructor�_argsr!��r!��r"�� __reduce__m��z_CacheHashWrapper.__reduce__Nr!��c��C��r2��r��r!��r3��r!��r!��r"��r6��r��r7��)r+��r,��r-��r.��r ��getattrr6��typer!��r!��r!��r"��r0��]��s ��r0��TFc��C��s��t�\|\|\|d�\}}}}\|dur\|dur\|durtd��\| dur3\|�tur'td��t\| �s/td��t\| �}�\|du�r9i�}t\| ttf�rEt j \| ��} \|rRt\|ttf�rRt\|��}\|r_t\|ttf�r_t \|��}t\|�\|\|d\|\|\|\|\|\| \|\|\|\|\| d�S�)a\|�� Create a new attribute on a class. .. warning:: Does not* do anything unless the class is also decorated with `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 `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 `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 `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 `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 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. 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``. 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 (Python 3+) 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 `attr.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 `attr.setters.NO_OP` .. 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 TNF�6Invalid value for hash. Must be True, False, or None.z=The `default` and `factory` arguments are mutually exclusive.zThe `factory` argument must be a callable.)�default� validator�repr�cmp�hash�init� converter�metadatar9��kw_only�eq�eq_key�order� order_key� on_setattr) �_determine_attrib_eq_order� TypeErrorr$�� ValueError�callable�Factory� isinstance�list�tupler��pipe�and_� _CountingAttr)r;��r<��r=��r>��r?��r@��rB��r9��rA��factoryrC��rD��rF��rH��rE��rG��r!��r!��r"��attribv��sR�� rU��r1��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��r^��c��C��sB��i�}\|du�ri�}t�\|\|\|\|��t\|�d\|�d�\|ftj\|<�\|\|��S�)zO Create the method with the script given and return the method object. NT)r^��len� splitlines� linecache�cache)�namerY��r\��rZ��r[��r!��r!��r"��_make_methodB��s�� rd��c��C��sp��d��\|��}d��\|�dg}\|r"t\|�D�]\}}\|�tj�\|\|d��qn\|�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 {}(tuple):z __slots__ = ())�index� attr_namez pass)�_attrs_itemgetter�_attrs_property� )�format� enumerate�append�_tuple_property_patr��propertyr^��join)�cls_name� attr_names�attr_class_name�attr_class_template�irf��rZ��r!��r!��r"��_make_attr_tuple_classX��s�� ru��_Attributes)�attrs� base_attrs�base_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��)�str� startswith�endswith�_classvar_prefixes)�annotr!��r!��r"�� _is_class_var��s�� r��c��C��sJ��t�\|�\|t�}\|tu�rdS�\|�jdd��D�]}t�\|\|d�}\|\|u�r"�dS�qdS�)zj Check whether cls defines attrib_name (and doesn't just inherit it). Requires Python 3. Fr��NT)r8�� _sentinel�__mro__)r��attrib_name�attr�base_cls�ar!��r!��r"��_has_own_attribute��s��r��c��C��s��t�\|�d�r\|�jS�i�S�)z$ Get annotations for cls. �__annotations__)r��r��r��r!��r!��r"��_get_annotations��s�� r��c��C�� \|�d�j�S�)zQ Key function for sorting to avoid re-creating a lambda for every class. r��counter��er!��r!��r"��_counter_getter��s�� r��c��C��s��g�}i�}t�\|�jdd��D�]$}t\|dg��D�]}\|js\|j\|v�r q\|jdd�}\|�\|��\|\|\|j<�qq g�}t��}t�\|�D�]}\|j\|v�rCq;\|�d\|��\|� \|j��q;\|\|fS�)zQ Collect attr.ibs from base classes of cls, except taken_attr_names. r��r\|��__attrs_attrs__T�� inheritedr��) �reversedr��r8��r��rc��evolverl��set�insert�add)r��taken_attr_namesrx�� base_attr_mapr��r��filtered�seenr!��r!��r"��_collect_base_attrs��s$�� r��c��C��sn��g�}i�}\|�j�dd��D�]'}t\|dg��D�]}\|j\|v�rq\|jdd�}\|�\|j��\|�\|��\|\|\|j<�qq\|\|fS�)a-�� Collect attr.ibs from base classes of cls, except taken_attr_names. N.B. taken_attr_names will be mutated. Adhere to the old incorrect behavior. Notably it collects from the front and considers inherited attributes which leads to the buggy behavior reported in #428. r��r\|��r��Tr��)r��r8��rc��r��r��rl��)r��r��rx��r��r��r��r!��r!��r"��_collect_base_attrs_broken��s�� r��c�� s(��\|�j��t\|��\|dur dd��t\|�D��}t\|t�s\|jtd��nq\|du�r�dd��D��}g�}t��}��D�]-\} } t \| �r?q6\|� \| ��\| t�}t\|t �s\\|tu�rWt��}nt\|d�}\|�\| \|f��q6\|\|�}t\|�d kr�td d�t\|�fdd �d��d��ntdd��D��dd ��d�}��fdd�\|D��} \|r�t\|�dd��\| D��\}}nt\|�dd��\| D��\}}dd��\|\| �D��}t\|�j\|�}\|r�dd��\| D��} dd��\|D��}\|\|\| ��}d}dd��\|D��D�]}\|du�r�\|jtu�r�td\|f��\|du��r\|jtu�rd}q�\|du�r \|\|�\|�}t\|\|\|f�S�)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�\|�]\}}\|\|f�qS�r!��r!��)�.0rc��car!��r!��r"�� <listcomp>��z$_transform_attrs.<locals>.<listcomp>)�keyTc��S��s��h�\|�]\}}t�\|t�r\|�qS�r!��rN��rS��r��rc��r��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��)�getr��)�n)�cdr!��r"��<lambda> ��s��z"_transform_attrs.<locals>.<lambda>�.c��s��s&��\|�]\}}t�\|t�r\|\|fV��qd�S�r��r��r��r!��r!��r"�� <genexpr>&��s�� z#_transform_attrs.<locals>.<genexpr>c��S��r��Nr��r��r��r!��r!��r"��r��+�� c��s&��g�\|�]\}}t�j\|\|��\|�d��qS�))rc��r��r9��)� Attribute�from_counting_attrr��)r��rf��r��)�annsr!��r"��r��.��s��c��S��h�\|�]}\|j��qS�r!��rc��r��r��r!��r!��r"��r��7��c��S��r��r!��r��r��r!��r!��r"��r��;��r��c��S��s��g�\|�]}\|j��qS�r!��r��r��r!��r!��r"��r��>��r��c��S��g�\|�]}\|j�d�d��qS��T)rC��r��r��r!��r!��r"��r��C��r��c��S��r��r��r��r��r!��r!��r"��r��D��r��Fc��s��s(��\|�]}\|j�d�ur\|jd�u�r\|V��qdS�)FN)r@��rC��r��r!��r!��r"��r��M��s��&�znNo mandatory attributes allowed after an attribute with a default value or factory. Attribute in question: %r)�__dict__r��r��rN��r��sortr��itemsr��r��r��r��r$��rS��rU��rl��r_��r��ro��sortedr��r��ru��r+��r;��rK��rv��)r��these�auto_attribsrC��collect_by_mro�field_transformer�ca_list�ca_names�annot_namesrf��r9��r��unannotated� own_attrsrx��r��rq�� AttrsClassrw��had_defaultr!��)r��r��r"��_transform_attrs��s�� r��c��C��s��t�\|�t�r\|dv�rt�\|�\|\|��dS�t��)�< Attached to frozen classes as __setattr__. )� __cause__�__context__N)rN�� BaseException�__setattr__r��r&��rc��valuer!��r!��r"��_frozen_setattrs^��s��r��c��C��t��)r��r��r��r!��r!��r"��r��n��c��C��r��)z4 Attached to frozen classes as __delattr__. r��)r&��rc��r!��r!��r"��_frozen_delattrsu��r��r��c��@��s��e�Zd�ZdZdZdd��Zdd��Zdd��Zd d ��Zdd��Z d d��Z dd��Zdd��Zdd��Z dd��Zdd��Zdd��Zdd��Zdd��Zdd ��Zd!d"��Zd#S�)$� _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�_has_own_setattr�_has_custom_setattrc��C��s��t�\|\|\|\|\|\|�\}}}\|\|�_\|rt\|j�ni�\|�_\|\|�_tdd��\|D��\|�_\|\|�_t dd��\|D��\|�_ \|\|�_\|\|�_\|\|�_ \| \|�_tt\|dd��\|�_tt\|dd��\|�_t\|��\|�_\| \|�_\|\|�_\| \|�_d\|�_\|�j\|�jd<�\|rxt\|�jd<�t\|�jd <�d \|�_\|r�\|��\\|�jd<�\|�jd<�d�S�d�S�) Nc��s��\|�]}\|j�V��qd�S�r��r��r��r!��r!��r"��r��z)_ClassBuilder.__init__.<locals>.<genexpr>c��s��r��r��r��r��r!��r!��r"��r��r��__attrs_pre_init__F�__attrs_post_init__r��r��__delattr__T�__getstate__�__setstate__)r��r��dictr��r��r��r��r��r��rP��r��r��r��r��r��boolr8��r��r��r��r��r��r��r��r��r��_make_getstate_setstate)r&��r��r��slots�frozen�weakref_slot�getstate_setstater��rC�� cache_hash�is_excr��rH��has_custom_setattrr��rw��rx��base_mapr!��r!��r"��__init__��sH�� z_ClassBuilder.__init__c��C��s��dj�\|�jjd�S�)Nz<_ClassBuilder(cls={cls})>r��)rj��r��r+��r%��r!��r!��r"��r'��s��z_ClassBuilder.__repr__c��C��s��\|�j�du�r \|��S�\|��S�)z� Finalize class based on the accumulated configuration. Builder cannot be used after calling this method. T)r��_create_slots_class�_patch_original_classr%��r!��r!��r"��build_class��s�� z_ClassBuilder.build_classc�� C��s��\|�j�}\|�j}\|�jr,\|�jD�]}\|\|vr+t\|\|t�tur+zt\|\|��W�q�ty��Y�qw�q\|�j� ��D�] \}}t \|\|\|��q1\|�jsOt\|dd�rOd\|_\|�j sOtj\|_\|S�)zA Apply accumulated methods and return the class. �__attrs_own_setattr__F)r��r��r��r��r8��r��delattr�AttributeErrorr��r��setattrr��r��r��objectr��)r&��r�� base_namesrc��r��r!��r!��r"��r��s�� z#_ClassBuilder._patch_original_classc�� s��fdd�t��j�D��}�js+d\|d<��js+�jjD�]��j�dd�rtj \|d<��nqt ��}d}�jjdd��D�]��j�dd �d urEd }\|��fdd�t ��dg��D��q8t�j��j}�jrtdt �jdd �vrtd\|vrt\|st\|d7�}�fdd�\|D��fdd�t�\|�D��fdd��D��\|��jr��t��t��\|d<�t �jdd �}\|d ur�\|\|d<�t�j��jj�jj\|�}\|j��D�]G}t\|ttf�r�t \|jdd �}nt\|t�r�t \|jdd �}nt \|dd �}\|s�q�\|D�]} z\| j�ju�} W�n �t �y��Y�q�w�\| �rt!\| \|��q�q�\|S�)zL Build and return a new class with a `__slots__` attribute. c��s(��i�\|�]\}}\|t��j�d��vr\|\|�qS�))r��__weakref__)rP��r��)r��k�vr%��r!��r"�� <dictcomp>��s ��z5_ClassBuilder._create_slots_class.<locals>.<dictcomp>Fr��r��r��r\|��r��NTc��s��i�\|�]}\|t��\|��qS�r!��r8��r��rc��)r��r!��r"��r ��'��s�� __slots__r!��)r��c��g�\|�]}\|��vr\|�qS�r!��r!��r��)r��r!��r"��r��:��r��z5_ClassBuilder._create_slots_class.<locals>.<listcomp>c��s��i�\|�]\}}\|��v�r\|\|�qS�r!��r!��)r��slot�slot_descriptor)� slot_namesr!��r"��r ��?��s ��c��r ��r!��r!��r��)�reused_slotsr!��r"��r��D��r��r-��__closure__)"r��r��r��r��r�� __bases__r��r��r��r��r��r��updater8��r��r��r��r��r��rl��_hash_cache_fieldrP��r9��r+��valuesrN��classmethod�staticmethod�__func__rn��fget� cell_contentsrK��r��)r&��r��existing_slots�weakref_inherited�names�qualnamer��item� closure_cells�cell�matchr!��)r��r��r��r&��r��r"��r��s\|�� z!_ClassBuilder._create_slots_classc��C��s��\|��t\|�j\|d��\|�jd<�\|�S�)N��nsr'��)�_add_method_dunders� _make_reprr��r��)r&��r%��r!��r!��r"��add_reprp��s�� z_ClassBuilder.add_reprc��C��s8��\|�j��d�}\|d�u�rtd��dd��}\|��\|�\|�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__}��r7��z&_ClassBuilder.add_str.<locals>.__str__r��)r��r��rK��r&��)r&��r=��r��r!��r!��r"��add_strv��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��anr!��r!��r"��r��s��z8_ClassBuilder._make_getstate_setstate.<locals>.<genexpr>c��s��t��fdd��D��S�)�9 Automatically created by attrs. c��3��\|�]}t��\|�V��qd�S�r��r ��r��r%��r!��r"��r��zP_ClassBuilder._make_getstate_setstate.<locals>.slots_getstate.<locals>.<genexpr>�rP��r%��)�state_attr_namesr%��r"��slots_getstate��z=_ClassBuilder._make_getstate_setstate.<locals>.slots_getstatec��s@��t��\|�t�}t�\|�D�] \}}\|\|\|��q��r\|td��dS�dS�)r-��N)�_obj_setattr�__get__r��zipr��)r&��state�_ClassBuilder__bound_setattrrc��r��hash_caching_enabledr1��r!��r"��slots_setstate��s��z=_ClassBuilder._make_getstate_setstate.<locals>.slots_setstate)rP��r��r��)r&��r2��r;��r!��r9��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��R��\|��t\|�j\|�j\|�j\|�j\|�j\|�j\|�j\|�j \|�j \|�jd�uo\|�jtj udd��\|�jd<�\|�S�)NF�� attrs_initr��r&�� _make_initr��r��r��r��r��r��r��r��r��r��r��NO_OPr��r%��r!��r!��r"��add_init��"�� z_ClassBuilder.add_initc��C��rA��)NTrB��__attrs_init__rD��r%��r!��r!��r"��add_attrs_init��rH��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�}��fdd�t��j��j�D��\\|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��rO��r!��r%��r"�� add_order��s �� z_ClassBuilder.add_orderc��s��\|�j�r\|�S�i��\|�jD�]}\|jp\|�j}\|r \|tjur \|\|f��\|j<�q ��s%\|�S�\|�jr,td��fdd�}d\|�j d<�\|�� \|�\|�j d<�d\|�_\|�S�)Nz7Can't combine custom __setattr__ with on_setattr hooks.c��sD��z��\|�\}}W�n�t�y��\|}Y�nw�\|\|�\|\|�}t\|�\|\|��d�S�r��)�KeyErrorr4��)r&��rc��valr��hook�nval��sa_attrsr!��r"��r��s��z._ClassBuilder.add_setattr.<locals>.__setattr__Tr��r��)r��r��rH��r��r��rF��rc��r��rK��r��r&��r��)r&��r��rH��r��r!��r\��r"��add_setattr��s&�� z_ClassBuilder.add_setattrc��C��s\|��z\|�j�j\|_W�n �ty��Y�nw�z d�\|�j�j\|jf�\|_W�n �ty'��Y�nw�zd\|�j�jf�\|_W�\|S��ty=��Y�\|S�w�)zL Add __module__ and __qualname__ to a method if possible. r��z'Method generated by attrs for class %s.)r��r,��r��ro��r-��r+��r.��)r&��methodr!��r!��r"��r&��s�� z!_ClassBuilder._add_method_dundersN)r+��r,��r-��r.��r��r��r'��r��r��r��r(��r+��r��r=��r@��rG��rJ��rP��rW��r^��r&��r!��r!��r!��r"��r��\|��s&��;&l " $r��zrThe usage of `cmp` is deprecated and will be removed on or after 2021-06-01. Please use `eq` and `order` instead.c��C��sl��\|�durt�\|du\|duf�rtd��\|�dur\|�\|�fS�\|du�r \|}\|du�r&\|}\|du�r2\|du�r2td��\|\|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.��anyrK��)r>��rD��rF�� default_eqr!��r!��r"��_determine_attrs_eq_order5��s��rf��c��C��s��\|�durt�\|du\|duf�rtd��dd��}\|�dur&\|\|��\}�}\|�\|\|�\|fS�\|du�r0\|d}}n\|\|�\}}\|du�r@\|\|}}n\|\|�\}}\|du�rR\|du�rRtd��\|\|\|\|fS�)r`��Nra��c��S��s&��t�\|��r d\|�}�}\|�\|fS�d}\|�\|fS�)z8 Decide whether a key function is used. TN)rL��)r��r��r!��r!��r"��decide_callable_or_booleanW��s �� z>_determine_attrib_eq_order.<locals>.decide_callable_or_booleanFTrb��rc��)r>��rD��rF��re��rg��cmp_keyrE��rG��r!��r!��r"��rI��O��s��rI��c��C��sF��\|du�s\|du�r \|S�\|du�r\|du�r\|S�\|D�] }t�\|�\|�r �dS�q\|S�)a�� 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. auto_detect must be False on Python 2. TFN)r��)r��flag�auto_detect�dundersr;��dunderr!��r!��r"��_determine_whether_to_implementx��s�� rm��c��s��rt�rtd��t\|\|\|d�\�� \|� t�ttf�rtj�� fdd�}\|�du�r>\|S�\|\|��S�)a�2�� A class decorator that adds `dunder <https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the specified attributes using `attr.ib` or the these argument. :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. If these is an ordered dict (`dict` on Python 3.6+, `collections.OrderedDict` otherwise), the order is deduced from the order of the attributes inside these. Otherwise the order of the definition of the attributes is used. :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. auto_detect requires Python 3. Setting it ``True`` on Python 2 raises a `PythonTooOldError`. :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] 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 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 `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 `glossary entry <slotted classes>`. :param bool frozen: Make instances immutable after initialization. If someone attempts to modify a frozen instance, `attr.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 (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 `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 `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. `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. .. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/ :param bool kw_only: Make all attributes keyword-only (Python 3+) 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-compatability. 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 `attr.setters.pipe`. :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. .. 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 z-auto_detect only works on Python 3 and later.Nc��s��t�\|�dd��d�u�rtd��pt\|��}�du�ot\|�t�}�o!t\|�d�}\|r\|rtd��t\|��\|�t\|��d�d��\|��\|��}t\|��d�rN\|� ��du�rV\|� ��t\|��d �}\|sg\|du�rg\|��\|stt\|�� d �rt\|��\|� �� d�u�r��du�r�t\|�d�r�d}n� }\|dur�\|dur�\|d�ur�td ��\|du�s�\|d�u�r�\|du�s�\|r��r�td��n\|du�s�\|d�u�r�\|du�r�\|du�r�\|��n �r�td��\|��t\|�� d�r�\|��\|��S�\|��r�td��\|��S�)Nr ��z(attrs only works with new-style classes.Tr��z/Can't freeze a class with a custom __setattr__.)r��r��r��r)��)rK��rL��)rR��rS��rT��rU��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.)r8��rJ��_has_frozen_base_class� issubclassr��r��rK��r��rm��r(��r+��rP��rW��r^��r@��r=��rG��rJ��r��)r�� is_frozenr��has_own_setattr�builderrD��r?��r��rj��auto_excr��r��eq_r��r��r��hash_r@��rC��rH��order_r=��repr_nsr��r}��r��r��r!��r"��wrap��s�� zattrs.<locals>.wrap)r ��r��rf��rN��rO��rP��r��rQ��)� maybe_clsr��rx��r=��r>��r?��r@��r��r��r��r}��r��rC��r��rt��rD��rF��rj��r��r��rH��r��ry��r!��rs��r"��rw��s�� 2lrw��c��C��s"��t�\|�jdd�tjko\|�jjtjkS�)�b Check whether cls has a frozen ancestor by looking at its __setattr__. r,��N)r8��r��r��r,��r+��r��r!��r!��r"��rn����s ��rn��c��C��s ��\|�j�tkS�)r{��)r��r��r��r!��r!��r"��rn��8��s�� c��C��sj��t��}d}d} �d�\|\|�jt\|�d\|�j�\|�}ddt\|�f\|f}tj� \|\|�\|kr+\|S�\|d7�}d�\|�}q )zF Create a "filename" suitable for a function being generated. r1��r��Tz <attrs generated {0} {1}.{2}{3}>r-��Nz-{0}) �uuid�uuid4rj��r,��r8��r+��r}��ra��rb�� setdefault)r�� func_name� unique_id�extra�count�unique_filename� cache_liner!��r!��r"��_generate_unique_filename@��s$�� r��c�� s��t�dd��D��d}t\|�d�}t\|��d}d�d�\|s!\|d7�}nts'\|d 7�}\|d 7�}d��d7��\|g��fd d�}\|rs��\|dt��\|r`\|dt�\|d��\|d�d��n \|dt�\|d��\|dt��n\|d\|��d��}td\|\|�S�)Nc��s��s2��\|�]}\|j�d�u�s\|j�du�r\|jd�u�r\|V��qdS�)TN)r?��rD��r��r!��r!��r"��r��_��s��(�z_make_hash.<locals>.<genexpr>z r?��zdef __hash__(selfzhash((z))z):z, zC, _cache_wrapper=__import__('attr._make')._make._CacheHashWrapper):z_cache_wrapper(�)c��sT��\|\|��\|d�f��g��D�]}��\|d\|j��q��\|d��dS�)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 z %d,� self.%s,� N)�extendrl��rc��)�prefix�indentr��rw��closing_braces� hash_func�method_lines� type_hashr!��r"��append_hash_computation_linesz��s�� z1_make_hash.<locals>.append_hash_computation_lineszif self.%s is None:zobject.__setattr__(self, '%s', ��z self.%s = zreturn self.%szreturn ri��r<��)rP��r��r?��r ��rl��r��ro��rd��) r��rw��r��r��tabr��hash_defr��rY��r!��r��r"��r?��^��sD�� r?��c��C��s��t�\|�\|ddd�\|�_\|�S�)z% Add a hash method to cls. Fr>��)r?��r<��r��rw��r!��r!��r"�� _add_hash��s��r��c��C��s��dd��}�\|�S�)z Create __ne__ method. c��S��s��\|��\|�}\|tu�rtS�\|�S�)zj Check equality and either forward a NotImplemented or return the result negated. )rK��NotImplemented)r&��other�resultr!��r!��r"��rL��s�� z_make_ne.<locals>.__ne__r!��)rL��r!��r!��r"��rN��s��rN��c�� C��s��dd��\|D��}t�\|�d�}g�d�}i�}\|r^\|�d��dg}\|D�]7}\|jrCd\|jf�}\|j\|\|<�\|�d\|\|jf��\|�d \|\|jf��q\|�d \|jf��\|�d\|jf��q\|\|dg�7�}n\|�d ��d�\|�}td\|\|\|�S�)z6 Create __eq__ method for cls with attrs. c��S��g�\|�]}\|j�r\|�qS�r!��)rD��r��r!��r!��r"��r��z_make_eq.<locals>.<listcomp>rD��)zdef __eq__(self, other):z- if other.__class__ is not self.__class__:z return NotImplementedz return (z ) == (z_%s_keyz %s(self.%s),z %s(other.%s),r��z other.%s,z )z return Trueri��rK��)r��rl��rE��rc��ro��rd��) r��rw��r��linesrZ��othersr��cmp_namerY��r!��r!��r"��rM��s>�� rM��c��sV��dd��D��fdd��fdd�}�fdd�}�fd d �}�fdd�}\|\|\|\|fS�) z9 Create ordering methods for cls with attrs. c��S��r��r!��)rF��r��r!��r!��r"��r��r��z_make_order.<locals>.<listcomp>c��s ��t�dd��fdd��D��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��)r8��rc��rG��r��objr!��r"��r��s�� r0��r��rw��r��r"��attrs_to_tuple��s �� z#_make_order.<locals>.attrs_to_tuplec��s ��\|j�\|�j�u�r��\|��\|�k�S�tS��1 Automatically created by attrs. �r ��r��r&��r��r��r!��r"��rR��z_make_order.<locals>.__lt__c��s ��\|j�\|�j�u�r��\|��\|�kS�tS�r��r��r��r��r!��r"��rS�� r��z_make_order.<locals>.__le__c��s ��\|j�\|�j�u�r��\|��\|�kS�tS�r��r��r��r��r!��r"��rT��r��z_make_order.<locals>.__gt__c��s ��\|j�\|�j�u�r��\|��\|�kS�tS�r��r��r��r��r!��r"��rU��r��z_make_order.<locals>.__ge__r!��)r��rw��rR��rS��rT��rU��r!��)rw��r��r"��rV��s�� rV��c��C��s&��\|du�r\|�j�}t\|�\|�\|�_t��\|�_\|�S�)z5 Add equality methods to cls with attrs. N)r��rM��rK��rN��rL��r��r!��r!��r"��_add_eq'��s ��r��c��s$��t�dd��\|�D��fdd�}\|S�)z^ Make a repr method that includes relevant attrs, adding ns to the full name. c��s��s4��\|�]}\|j�d�ur\|j\|j�du�rt�n\|j�fV��qdS�)FTN)r=��rc��r��r!��r!��r"��r��?��s�� z_make_repr.<locals>.<genexpr>c�� s��zt�j}W�n�ty��t��}\|t�_Y�nw�t\|��\|v�rdS�\|�j}�du�r;t\|dd�}\|dur7\|�dd�d�}n\|j}n�d�\|j�}\|� t\|��z4\|dg}d }��D�]\}}\|r[d }n\|� d��\|�\|d\|t\|�\|t��f��qRd � \|�d�W�\|�t\|��S�\|�t\|��w�)r��z...Nr-��z>.r��r\|��r��(TFr��=r1��r��)�_already_repring�working_setr��r��idr ��r8��rsplitr+��r��rl��r��r$��ro��remove) r&��r��real_clsr�� class_namer��firstrc�� attr_repr��attr_names_with_reprsr%��r!��r"��r'��E��s8�� z_make_repr.<locals>.__repr__r0��)rw��r%��r'��r!��r��r"��r'��7��s ��r'��c��C��s��\|du�r\|�j�}t\|\|�\|�_\|�S�)z% Add a repr method to cls. N)r��r'��r'��)r��r%��rw��r!��r!��r"�� _add_reprr��s��r��c��C��s8��t�\|��std��t\|�dd�}\|du�rtdj\|�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 attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. :rtype: tuple (with name accessors) of `attr.Attribute` .. versionchanged:: 16.2.0 Returned tuple allows accessing the fields by name. �Passed object must be a class.r��N�({cls!r} is not an attrs-decorated class.r��)r��rJ��r8��r��rj��r��r!��r!��r"��fields}��s�� r��c��C��sF��t�\|��std��t\|�dd�}\|du�rtdj\|�d��tdd��\|D��S�)a8�� 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 attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. :rtype: an ordered dict where keys are attribute names and values are `attr.Attribute`\ s. This will be a `dict` if it's naturally ordered like on Python 3.6+ or an :class:`~collections.OrderedDict` otherwise. .. versionadded:: 18.1.0 r��r��Nr��r��c��s��s��\|�]}\|j�\|fV��qd�S�r��r��r��r!��r!��r"��r��r/��zfields_dict.<locals>.<genexpr>)r��rJ��r8��r��rj��r��r��r!��r!��r"��fields_dict��s�� r��c��C��sD��t�jdu�rdS�t\|�j�D�]}\|j}\|dur\|\|�\|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��_run_validatorsr��r ��r<��r8��rc��)�instr��r��r!��r!��r"��validate��s�� r��c��C��s ��d\|�j�v�S�)Nr��)r��r��r!��r!��r"��_is_slot_cls��s�� r��c��C��s��\|�\|v�o t�\|\|��S�)z> Check if the attribute name comes from a slot class. )r��)�a_namer��r!��r!��r"�� _is_slot_attr��s��r��c��C��s��\|r\| rt�d��\|p\|}g�}i�} \|D�]5}\|js\|jtu�rq\|�\|��\|\| \|j<�\|jd�ur7\|du�r4t�d��d}q\| r?\|jtjusEt \|j\|�rGd}qt \|�d�}t\|\|\|\|\|\|\|\|\|\| \| �\}}}\|�jt jv�rn\|�t j\|�j�j��\|�t\| d��\|r\|t\|d<�t\| r�dnd\|\|\|�}\|\|_\|S�)Nz$Frozen classes can't use on_setattr.Tr@��)r$�� attr_dict�_cached_setattrrI��r��)rK��r@��r;��r$��rl��rc��rH��r��rF��r��r��_attrs_to_init_scriptr,��sys�modulesr��r��r4��rd��r��)r��rw��pre_init� post_initr��r��r��r��r��has_global_on_setattrrC��needs_cached_setattr�filtered_attrsr��r��r��rY��rZ��annotationsr@��r!��r!��r"��rE��s`�� rE��c��C��s��d\|�\|f�S�)zJ Use the cached object.setattr to set attr_name to value_var. �_setattr('%s', %s)r!��rf�� 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_patr��r!��r!��r"��_setattr_with_converter!��s ��r��c��C��s��\|rt�\|�\|d�S�d\|�\|f�S�)zo Unless attr_name has an on_setattr hook, use normal assignment. Otherwise relegate to _setattr. T�self.%s = %s)r��)rf��r��r��r!��r!��r"��_assign-��s��r��c��C��s$��\|rt�\|�\|d�S�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��r��r!��r!��r"��_assign_with_converter8��s��r��c��C��s$��\|dur d\|�}nd}d\|�\|�\|f�S�)z8 Unpack attr_name from _kw_only dict. Nz, %sr1��z%s = _kw_only.pop('%s'%s)r!��)rf��r;��arg_defaultr!��r!��r"��_unpack_kw_only_py2I��s�� r��c��C��s,��dg}\|��dd��\|�D��\|d�d�7�}\|S�)a�� Unpack all kw_only_args from _kw_only dict and handle errors. Given a list of strings "{attr_name}" and "{attr_name}={default}" generates list of lines of code that pop attrs from _kw_only dict and raise TypeError similar to builtin if required attr is missing or extra key is passed. >>> print(" ".join(_unpack_kw_only_lines_py2(["a", "b=42"]))) try: a = _kw_only.pop('a') b = _kw_only.pop('b', 42) except KeyError as _key_error: raise TypeError( ... if _kw_only: raise TypeError( ... ztry:c��s��s"��\|�]}d�t�\|�d��V��qdS�)r��r��N)r��split)r��argr!��r!��r"��r��l��s �� z,_unpack_kw_only_lines_py2.<locals>.<genexpr>a ��except KeyError as _key_error: raise TypeError( '__init__() missing required keyword-only argument: %s' % _key_error ) if _kw_only: raise TypeError( '__init__() got an unexpected keyword argument %r' % next(iter(_kw_only)) ) ri��)r��r��)�kw_only_argsr��r!��r!��r"��_unpack_kw_only_lines_py2W��s�� r��c��!�� s��g�}\|r \|��d��\|r\|��d��\|du�r/\|du�rt}t} n\|��d��fdd�}��fdd�} nt}t} g�}g�}g�}i�}d d i}\|�D��]�}\|jrL\|��\|��\|j}\|jd up[\|jtj uo[\| }\|j� d�}t\|jt �}\|rq\|jjrqd}nd }\|jdu�r�\|r�t�\|j�}\|jd ur�\|��\| \|\|d\|f��\|��t\|jf�}\|j\|\|<�n\|��\|\|\|d\|f��\|��\|jj\|\|<��n\|jd ur�\|��\| \|d\|f�\|��t\|jf�}\|j\|\|<�n�\|��\|\|d\|f�\|��n�\|jtu�r\|�sd\|\|f�}\|jr�\|��\|��n\|��\|��\|jd u�r\|��\| \|\|\|��\|j\|t\|jf�<�n�\|��\|\|\|\|��n�\|�r�d\|f�}\|j�r1\|��\|��n\|��\|��\|��d\|f��t�\|j�}\|jd u�ru\|��d\| \|\|\|��\|��d��\|��d\| \|\|d�\|�d�\|��\|j\|t\|jf�<�n!\|��d\|\|\|\|��\|��d��\|��d\|\|\|d�\|�d�\|��\|jj\|\|<�n1\|j�r�\|��\|��n\|��\|��\|jd u�r�\|��\| \|\|\|��\|j\|t\|jf�<�n \|��\|\|\|\|��\|jdu��r$\|jd u�r�\|jd u��r�\|j\|\|<�qA\|jd u�r$t�s$d }zt�\|j�}W�n�ttf�y��Y�nw�\|�r$t\|j��}\|�r$\|d�j tj!j"u�r$\|d�j \|\|<�qA\|�rUt#\|d<�\|��d��\|D�]!}d\|j�}d\|j�}\|��d\|\|\|jf��\|j\|\|<�\|\|\|<��q3\|�r]\|��d��\|�rw\|�rl\|�rid}nd }nd!}\|��\|t$d"f��\|�r�d#�%d$d%��\|�D��} \|��d&\| f��d'�%\|�}\|�r�t�r�t&\|�\|�}\|d(\|�r�d'nd f�7�}n\|d)\|�r�d'nd d'�%\|�f�7�}dj\| �r�d+nd,\|\|�r�d-�%\|�nd.d/�\|\|fS�)0z� 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__()z8_setattr = _cached_setattr.__get__(self, self.__class__)Tz_inst_dict = self.__dict__c��s"��t�\|��rt\|�\|\|�S�d\|�\|f�S�)N�_inst_dict['%s'] = %s)r��r��r��r��r!��r"�� fmt_setter��s�� z)_attrs_to_init_script.<locals>.fmt_setterc��s.��\|st�\|��r t\|�\|\|�S�d\|�t\|�f�\|f�S�)Nz_inst_dict['%s'] = %s(%s))r��r��r��r��r��r!��r"��fmt_setter_with_converter��s��z8_attrs_to_init_script.<locals>.fmt_setter_with_converter�returnN�_r&��r1��Fz(%s)zattr_dict['%s'].defaultz%s=attr_dict['%s'].defaultz %s=NOTHINGzif %s is not NOTHING:r��zelse:r��r��r��r��z#if _config._run_validators is True:�__attr_validator_�__attr_z %s(self, %s, self.%s)zself.__attrs_post_init__()r��r��r��None�,c��s��s ��\|�]}\|j�rd�\|j�V��qdS�)zself.N)r@��rc��r��r!��r!��r"��r�� s��z(_attrs_to_init_script.<locals>.<genexpr>z BaseException.__init__(self, %s)r��z%s*_kw_onlyz%s, %sz+def {init_name}(self, {args}): {lines} rI��r��z �pass)� init_name�argsr��)'rl��r��r��r��r��r<��rc��rH��r��rF��lstriprN��r;��rM�� takes_selfr@��_init_factory_patrj��rA��r��rT��r$��rC��r9��r ��inspect� signaturerK��rJ��rO�� parametersr�� annotation� Parameter�emptyr��r��ro��r��)!rw��r��r��r��r��r��r��r��r��r��rC��r��r��r��r��r��attrs_to_validate�names_for_globalsr��r��rf��r��arg_name�has_factory� maybe_self�init_factory_name� conv_namer��sig� sig_params�val_name�init_hash_cache�valsr!��r��r"��r��s�� r��c��@��sr��e�Zd�ZdZdZ ddd�Zdd��Zedd d ��Ze dd��Z d d��Zdd��Zdd��Z dd��ZdS�)r��a~�� Read-only representation of an attribute. 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 field transformer hook receives a list of them. :attribute name: The name of the attribute. :attribute inherited: Whether or not that attribute has been inherited from a base class. Plus all arguments of `attr.ib` (except for ``factory`` which is only syntactic sugar for ``default=Factory(...)``. .. 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 For the full version history of the fields, see `attr.ib`. )rc��r;��r<��r=��rD��rE��rF��rG��r?��r@��rB��r9��rA��rC��r��rH��NFc��C��s��t�\|\|p\| \|p\|d�\} }}}t�\|�t�}\|d\|��\|d\|��\|d\|��\|d\|��\|d\| ��\|d\|��\|d\|��\|d \|��\|d \|��\|d\|��\|d\|��\|d \| rTt\| �nt��\|d\| ��\|d\|��\|d\|��\|d\|��d�S�)NTrc��r;��r<��r=��rD��rE��rF��rG��r?��r@��rA��rB��r9��rC��r��rH��)rI��r4��r5��r��r ��_empty_metadata_singleton)r&��rc��r;��r<��r=��r>��r?��r@��r��rB��r9��rA��rC��rD��rE��rF��rG��rH�� bound_setattrr!��r!��r"��r�� s2�� zAttribute.__init__c��C��r��r��r��r��r!��r!��r"��r�� s��zAttribute.__setattr__c�� sV��\|d�u�r��j�}n ��j�d�urtd��fdd�tjD��}\|�d\|��j��j\|d�dd�\|��S�)Nz8Type annotation and type argument cannot both be presentc��s ��i�\|�]}\|d�vr\|t��\|��qS�))rc��r<��r;��r9��r��r ��)r��r��r��r!��r"��r �� s�� z0Attribute.from_counting_attr.<locals>.<dictcomp>F)rc��r<��r;��r9��r>��r��r!��)r9��rK��r��r�� _validator�_default)r��rc��r��r9�� inst_dictr!��r��r"��r�� s&�� zAttribute.from_counting_attrc��C��s��t�jttdd��\|�jo \|�jS�)zD Simulate the presence of a cmp attribute and warn. r��)� stacklevel)�warnings�warn�_CMP_DEPRECATION�DeprecationWarningrD��rF��r%��r!��r!��r"��r>��. ��s��z Attribute.cmpc��K��s��t��\|��}\|�\|��\|S�)z� Copy self and apply changes. This works similarly to `attr.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"��r��8 ��s�� zAttribute.evolvec��t��fdd��jD��S�)�( Play nice with pickle. c��3��s,��\|�]}\|d�kr t��\|�nt��j�V��qdS�)rB��N)r8��r��rB��r��r%��r!��r"��r��N ��s �� z)Attribute.__getstate__.<locals>.<genexpr>�rP��r��r%��r!��r%��r"��r��J ��s��zAttribute.__getstate__c��C��s��\|��t\|�j\|��dS��r��N)r��r6��r��)r&��r7��r!��r!��r"��r��S ��r3��zAttribute.__setstate__c��C��sH��t��\|�t�}\|D�]\}}\|dkr\|\|\|��q\|\|\|rt\|�nt��qd�S�)NrB��)r4��r5��r��r ��r��)r&��name_values_pairsr��rc��r��r!��r!��r"��r��Y ��s�� zAttribute._setattrs) NNNFNNNNNr��)r+��r,��r-��r.��r��r��r��r��r��rn��r>��r��r��r��r��r!��r!��r!��r"��r�� s,�� 5 r��c��C��s,��g�\|�]}t�\|td�dd�dd\|dkddd� �qS�)NTFrB�� rc��r;��r<��r=��r>��rD��rF��r?��r@��r��r��r$��r��r!��r!��r"��r��g ��s�� r��r��c��C��s��g�\|�] }\|j�d�kr\|�qS�r��r��r��r!��r!��r"��r��z ��s��c��C��s ��g�\|�]}\|j�r\|jd�kr\|�qS�r��)r?��rc��r��r!��r!��r"��r��\| ��s�� c��@��sh��e�Zd�ZdZdZedd��dD��edddddd dd ddd dd dd �f�ZdZdd ��Z dd��Z dd��ZdS�)rS��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=��rD��rE��rF��rG��r?��r@��rB��r��rA��r9��rC��rH��c��c��s4��\|�]}t�\|td�dd�ddddd�dd�dd�d�V��qd�S�)NTF�rc��r;��r<��r=��r>��r?��r@��rC��rD��rE��rF��rG��r��rH��r��r��r!��r!��r"��r�� s(�� z_CountingAttr.<genexpr>)r��r��r=��rD��rF��r?��r@��rH��rB��NTFr��r��c��C��sn��t��jd7��_t�j\|�_\|\|�_\|\|�_\|\|�_\|\|�_\|\|�_\|\|�_\| \|�_ \|\|�_ \|\|�_\|\|�_\|\|�_ \| \|�_\| \|�_\|\|�_d�S�r��)rS��cls_counterr��r��r��rA��r=��rD��rE��rF��rG��r?��r@��rB��r9��rC��rH��)r&��r;��r<��r=��r>��r?��r@��rA��rB��r9��rC��rD��rE��rF��rG��rH��r!��r!��r"��r�� s �� z_CountingAttr.__init__c��C��s&��\|�j�du�r \|\|�_�\|S�t\|�j�\|�\|�_�\|S�)z� Decorator that adds meth to the list of validators. Returns meth unchanged. .. versionadded:: 17.1.0 N)r��rR��r&��rQ��r!��r!��r"��r<�� s �� z_CountingAttr.validatorc��C��s"��\|�j�turt��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��rM��r��r!��r!��r"��r;�� s�� z_CountingAttr.default)r+��r,��r-��r.��r��rP��r��r��r��r��r<��r;��r!��r!��r!��r"��rS�� s8��-#rS��c��@��s.��e�Zd�ZdZdZddd�Zdd��Zdd ��Zd S�)rM��a�� Stores a factory callable. If passed as the default value to `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 �rT��r��Fc��C��s��\|\|�_�\|\|�_dS�)z� `Factory` is part of the default machinery so if we want a default value here, we have to implement it ourselves. Nr��)r&��rT��r��r!��r!��r"��r�� s�� zFactory.__init__c��r��)r��c��3��r.��r��r ��r��r%��r!��r"��r��,��r/��z'Factory.__getstate__.<locals>.<genexpr>r��r%��r!��r%��r"��r��(��s��zFactory.__getstate__c��C��s&��t�\|�j\|�D�] \}}t\|�\|\|��qdS�r��)r6��r��r��)r&��r7��rc��r��r!��r!��r"��r��.��s��zFactory.__setstate__N)F)r+��r,��r-��r.��r��r��r��r��r!��r!��r!��r"��rM��s�� rM��c��C��s(��g�\|�]}t�\|td�dd�dddddd� �qS�)NTFr��r��r��r!��r!��r"��r��6��s�� c�� s"��t�\|t�r\|}nt�\|ttf�rtdd��\|D��}ntd��\|�dd�}\|�dd�}\|�dd�}i��\|dur9\|��d<�\|durA\|��d<�\|durI\|��d<�t\|�\|i��fdd ��}z t�d �j � dd�\|_W�n�tt fyl��Y�nw�\|�d d�} t\| \|� d�\|� d�d�\\|d<�\|d<�tdd\|i\|��\|�S�)aB�� 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 attributes. If attrs is a list or an ordered dict (`dict` on Python 3.6+, `collections.OrderedDict` otherwise), 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��\|�]}\|t��fV��qd�S�r��)rU��r��r!��r!��r"��r��e��r/��zmake_class.<locals>.<genexpr>z(attrs argument must be a dict or a list.r��Nr��r��c��s ��\|��S�r��)r��r$��bodyr!��r"��r��u��r��zmake_class.<locals>.<lambda>r��r+��__main__r>��rD��rF��Tr��r!��)rN��r��rO��rP��rJ��popr��r�� _getframe� f_globalsr��r,��r��rK��rf��r��) rc��rw��bases�attributes_arguments�cls_dictr��r�� user_init�type_r>��r!��r��r"�� make_classI��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&��r��r��r��r��r!��r!��r"��__call__��s�� z_AndValidator.__call__N)r+��r,��r-��r.��rU��r&��r'��r!��r!��r!��r"��r%��s��r%��c��G��s6��g�}\|�D�]}\|��t\|t�r\|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 )r��rN��r%��r&��rP��)� validatorsr��r<��r!��r!��r"��rR��s�� rR��c�� s��fdd�}t�sq��st�d�}\|\|d�\|_\|S�d}z t��d��}W�n�ttfy-��Y�nw�\|rJt\|j � ��}\|rJ\|d�jtjj urJ\|d�j\|jd<�d}z t��d��}W�n�ttfy`��Y�nw�\|rq\|jt��j urq\|j\|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!��)rY��rA�� convertersr!��r"��pipe_converter��s�� zpipe.<locals>.pipe_converter�A)rY��r��Nr��rY��r\|��r��)r ��typing�TypeVarr��r��r��rK��rJ��rO��r��r��r��r��r��return_annotation� Signature)r��r+��r,��r��paramsr!��r)��r"��rQ��sD�� rQ��)Nr1��r��)T)NNNNNNNFFTFFFFFNNFFNNN)NN)f� __future__r��r��r��r ��r��ra��r�� threadingr\|��r��operatorr��r1��r��r��_compatr ��r ��r��r��r ��r��r��r�� exceptionsr��r��r��r��r��r-��r��r��r4��r��r��rm��r��r��r��r��r��r$��intr0��rU��r^��rd��ru��rv��r��r��r��r��r��r��r��r��r��r��r��rf��rI��rm��rw��r��rn��r��r?��r��rN��rM��rV��r��localr��r'��r��r��r��r��r��r��rE��r��r��r��r��r��r��r��r��r��_arS��rM��_fr$��r%��rR��rQ��r!��r!��r!��r"��<module>��s2��( � �� E � k ��7� � �� B4 8 ;I )��+�? � �� ' � LPK��!��ے��#��__pycache__/filters.cpython-310.pycnu��[��o ��`J��@��sL��d�Z�ddlmZmZmZ�ddlmZ�ddlmZ�dd��Z dd ��Z d d��ZdS�) z, Commonly useful filters for `attr.asdict`. ��)�absolute_import�division�print_function��isclass)� Attributec��C��s$��t�dd��\|�D��t�dd��\|�D��fS�)zD Returns a tuple of `frozenset`s of classes and attributes. c��s��s��\|�] }t�\|�r\|V��qd�S��Nr��.0�cls��r ��./usr/lib/python3/dist-packages/attr/filters.py� <genexpr>��s��z_split_what.<locals>.<genexpr>c��s��s��\|�] }t�\|t�r\|V��qd�S�r ��)� isinstancer��r ��r ��r ��r��r��s��)� frozenset)�whatr ��r ��r��_split_what��s��r��c��t�\|��\��fdd�}\|S�)z� Whitelist what. :param what: What to whitelist. :type what: `list` of `type` or `attr.Attribute`\ s :rtype: `callable` c��s��\|j��v�p\|��v�S�r �� __class__�� attribute�value��attrsr��r ��r��include_ ��zinclude.<locals>.include_�r��)r��r��r ��r��r��include�� r��c��r��)z� Blacklist what. :param what: What to blacklist. :type what: `list` of classes or `attr.Attribute`\ s. :rtype: `callable` c��s��\|j��vo\|��vS�r ��r��r��r��r ��r��exclude_1��r��zexclude.<locals>.exclude_r��)r��r!��r ��r��r��exclude&��r ��r"��N)�__doc__� __future__r��r��r��_compatr��_maker��r��r��r"��r ��r ��r ��r��<module>��s�� PK��!�:�<��#��__pycache__/_compat.cpython-310.pycnu��[��o ��`��@��s$��d�dl�mZmZmZ�d�dlZd�dlZd�dlZd�dlZejd��dkZ e� ��dkZes2ejdd��dkr5eZ nd�dlmZ�eZ e rld�dlmZmZ�d�dlmZ�d d ��Zdd��Zd Zdd��ZG�dd��de�Zdd��Zdd��Znd�dlmZmZ�dd��Zdd ��ZdZdd��ZejZdd��Zdd��Ze��ZdS�)��)�absolute_import�division�print_functionN��PyPy)��)�OrderedDict)�Mapping�Sequence)�IterableUserDictc��C��s��t�\|�ttjf�S��N)� isinstance�type�types� ClassType��klass��r��./usr/lib/python3/dist-packages/attr/_compat.py�isclass��r��c��C��s��i�}\|\|��t�\|�\|\|�S�)zP A minimal stub of types.new_class that we need for make_class. )r��)�name�bases�kwds� exec_body�nsr��r��r�� new_class��s��r��r��c��C��\|��S�r ��)� iteritems��dr��r��r��r��+��r��c��@��sT��e�Zd�ZdZdd��Zdd��Zdd��Zdd ��Zddd�Zd d��Z ddd�Z dd��Zd S�)�ReadOnlyDictz5 Best-effort read-only dict wrapper. c��C��t�d��)Nz6'mappingproxy' object does not support item assignment�� TypeError)�self�key�valr��r��r��__setitem__4��zReadOnlyDict.__setitem__c��C��r$��)Nz/'mappingproxy' object has no attribute 'update'��AttributeError�r'��_r��r��r��update:��r+��zReadOnlyDict.updatec��C��r$��)Nz4'mappingproxy' object does not support item deletionr%��r.��r��r��r��__delitem__@��r+��zReadOnlyDict.__delitem__c��C��r$��)Nz.'mappingproxy' object has no attribute 'clear'r,��r'��r��r��r��clearF��r+��zReadOnlyDict.clearNc��C��r$��)Nz,'mappingproxy' object has no attribute 'pop'r,��r'��r(��defaultr��r��r��popL��r+��zReadOnlyDict.popc��C��r$��)Nz0'mappingproxy' object has no attribute 'popitem'r,��r2��r��r��r��popitemR��r+��zReadOnlyDict.popitemc��C��r$��)Nz3'mappingproxy' object has no attribute 'setdefault'r,��r4��r��r��r�� setdefaultX��r+��zReadOnlyDict.setdefaultc��C��s��dt�\|�j��d�S�)Nz mappingproxy(�))�repr�datar2��r��r��r��__repr__^��s��zReadOnlyDict.__repr__r ��)�__name__� __module__�__qualname__�__doc__r��r0��r1��r3��r6��r7��r8��r<��r��r��r��r��r#��/��s�� r#��c��C��s��t��}\|j�\|��\|S�r ��)r#��r;��r0��)r!��resr��r��r��metadata_proxyb��s��rB��c��O��s��dS�)�� We only warn on Python 3 because we are not aware of any concrete consequences of not setting the cell on Python 2. Nr��args�kwr��r��r�� just_warng��s��rG��c��O��s��t�jdtdd��dS�)rC��z�Running interpreter doesn't sufficiently support code object introspection. Some features like bare super() or accessing __class__ will not work with slotted classes.r��)� stacklevelN)�warnings�warn�RuntimeWarningrD��r��r��r��rG��q��s �� c��C��s ��t�\|�t�S�r ��)r��r��r��r��r��r��r��~��s�� classc��C��r��r ��)�itemsr ��r��r��r��r��r"��c��C��s��t��t\|��S�r ��)r��MappingProxyType�dictr ��r��r��r��rB��s��c��s(��t�rdd��}�\|�S�dd��}z\|tr\|j}n\|j}\|jdks \|jdkr"t�tjdkr1\|j \|j\|jd��n0\|j g}ts=\|�\|j��\|� \|j\|j\|j\|j\|j\|j\|j\|j\|j\|j\|j\|j\|jg ��tj\|��fd d�}�d d��}trt\|��jd�}n\|��jd�}\|�\|d ��\|jd kr�t�W�\|�S��ty��t�Y�S�w�)z\|Return a function of two arguments (cell, value) which sets the value stored in the closure cell `cell` to `value`. c��S��s��\|��\|f��d�S�r ��)�__setstate__)�cell�valuer��r��r��set_closure_cell��r��z/make_set_closure_cell.<locals>.set_closure_cellc��s��\|��d�S�r ��r��)rR��force_x_to_be_a_cellr��xr��set_first_cellvar_to��s��z3make_set_closure_cell.<locals>.set_first_cellvar_torU��r��)r��)�co_cellvars�co_freevarsc��s ��t��i�dd\|�f�}\|\|��d�S�)N�setterr��)r��FunctionType)rQ��rR��r[��set_first_freevar_coder��r��rS��s��c��s��d��fdd�}�\|�S�)Nc��s��S�r ��r��r��rU��r��r��func��s��z@make_set_closure_cell.<locals>.make_func_with_cell.<locals>.funcr��)r_��r��rU��r��make_func_with_cell��s��z2make_set_closure_cell.<locals>.make_func_with_cellr��d��) �PYPY�PY2� func_code�__code__rY��rZ��AssertionError�sys�version_info�replace�co_argcount�append�co_kwonlyargcount�extend� co_nlocals�co_stacksize�co_flags�co_code� co_consts�co_names�co_varnames�co_filename�co_name�co_firstlineno� co_lnotabr��CodeType�func_closure�__closure__� cell_contents� ExceptionrG��)rS��rW��corE��r`��rQ��r��r]��r��make_set_closure_cell��s^�� r��)� __future__r��r��r��platformrg��r��rI��rh��rc��python_implementationrb��rO��ordered_dict�collectionsr ��r ��r��UserDictr��r��r��TYPEr��r#��rB��rG��collections.abcr��rS��r��r��r��r��<module>��s<�� 3 fPK��!��I �� %��__pycache__/_next_gen.cpython-310.pycnu��[��o ��`��@��s��d�Z�ddlmZ�ddlmZ�ddlmZ�ddlmZm Z m Z mZ� ddddddd dd dd d ddd ddddd �dd�ZeZ eeddd �Zedddddddd dddd�dd�ZdS�)zr These are Python 3.6+-only and keyword-only APIs that call `attr.s` and `attr.ib` with different default values. ��)�partial)�UnannotatedAttributeError��)�setters)�NOTHING�_frozen_setattrs�attrib�attrsNTF)�these�repr�hash�init�slots�frozen�weakref_slot�str�auto_attribs�kw_only� cache_hash�auto_exc�eq�order�auto_detect�getstate_setstate� on_setattr�field_transformerc��sR�� fdd��fdd�}\|�du�r%\|S�\|\|��S�)aD�� The only behavioral differences are the handling of the auto_attribs* option: :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves exactly like `attr.s`. If left `None`, `attr.s` will try to guess: 1. If any attributes are annotated and no unannotated `attr.ib`\ s are found, it assumes auto_attribs=True. 2. Otherwise it assumes auto_attribs=False and tries to collect `attr.ib`\ s. and that mutable classes (``frozen=False``) validate on ``__setattr__``. .. versionadded:: 20.1.0 c��s��t�di�d\|��d��d��d��d��d� �d��d��d ��d \|�d� �d��d ��d��d��d��dd�d��d� �d��S�)N� maybe_clsr ��r��r��r ��r��r��r��r��r��r��r��r��r��r��r��collect_by_mroTr��r��r��)r ��)�clsr��)r��r��r��r��r��r��r��r��r ��r��r��r��r��r��r��r ��r��r��0/usr/lib/python3/dist-packages/attr/_next_gen.py�do_it5��sR�� zdefine.<locals>.do_itc��s��dt�jfv}�du�r�du�rt�j�\|�jD�]}\|jtu�r'\|r"td��t�j��nq��dur1�\|��S�z�\|�d�W�S��tyE��\|�d��Y�S�w�)z� Making this a wrapper ensures this code runs during class creation. We also ensure that frozen-ness of classes is inherited. NFz@Frozen classes can't use on_setattr (frozen-ness was inherited).T)r��NO_OP�validate� __bases__�__setattr__r�� ValueErrorr��)r��had_on_setattr�base_cls)r��r!��r��r��r��r ��wrapM��s&�� zdefine.<locals>.wrapNr��)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��r��r��r ��r��r��r��r��r��r��r ��r��r ��define��s ��,'%r��)r��r��default� validatorr��r��r ��metadata� converter�factoryr��r��r��r��c��C��s ��t�\|�\|\|\|\|\|\|\|\|\| \| \|d�S�)zx Identical to `attr.ib`, except keyword-only and with some arguments removed. .. versionadded:: 20.1.0 r+��)r��r+��r��r��r ��field\|��s��r1��)N)�__doc__� functoolsr��attr.exceptionsr��r��_maker��r��r��r ��r��mutabler��r1��r��r��r��r ��<module>��sR��j�PK��!��B�h>��>��&��__pycache__/converters.cpython-310.pycnu��[��o ��`��@��sn��d�Z�ddlmZmZmZ�ddlmZ�ddlmZm Z m Z �es&ddlZddlZg�d�Z dd ��Zedfd d�ZdS�)z Commonly useful converters. ��)�absolute_import�division�print_function��)�PY2)�NOTHING�Factory�pipeN)r ��optional�default_if_nonec�� s��fdd�}t�sLd}zt��}W�n�ttfy��Y�nw�\|rLt\|j��}\|r<\|d�jtj j ur<tj\|d�j�\|j d<�\|jtjj urLtj\|j�\|j d<�\|S�)aO�� A converter that allows an attribute to be optional. An optional attribute is one which can be set to ``None``. Type annotations will be inferred from the wrapped converter's, if it has any. :param callable converter: the converter that is used for non-``None`` values. .. versionadded:: 17.1.0 c��s��\|�d�u�rd�S��\|��S��N��val�� converterr ��1/usr/lib/python3/dist-packages/attr/converters.py�optional_converter%��s��z$optional.<locals>.optional_converterNr��r��return)r��inspect� signature� ValueError� TypeError�list� parameters�values� annotation� Parameter�empty�typing�Optional�__annotations__�return_annotation� Signature)r��r��sig�paramsr ��r��r��r ��s&�� r ��c��sx��t�u�r\|du�rtd��t�ur\|durtd��\|dur t\|��t��t�r4��jr,td��fdd�}\|S��fdd�}\|S�)a�� A converter that allows to replace ``None`` values by default or the result of factory. :param default: Value to be used if ``None`` is passed. Passing an instance of `attr.Factory` is supported, however the ``takes_self`` option is not. :param callable factory: A callable that takes no parameters whose result is used if ``None`` is passed. :raises TypeError: If neither default or factory is passed. :raises TypeError: If both default and factory are passed. :raises ValueError: If an instance of `attr.Factory` is passed with ``takes_self=True``. .. versionadded:: 18.2.0 Nz(Must pass either `default` or `factory`.z5Must pass either `default` or `factory` but not both.z1`takes_self` is not supported by default_if_none.c��s��\|�d�ur\|�S��S�r��)�factoryr��defaultr ��r��default_if_none_convertera��s��z2default_if_none.<locals>.default_if_none_converterc��s��\|�d�ur\|�S��S�r��r ��r��r'��r ��r��r)��i��s��)r��r��r�� isinstance� takes_selfr��)r(��r&��r)��r ��r'��r��r��>��s"�� r��)�__doc__� __future__r��r��r��_compatr��_maker��r��r ��r��r��__all__r ��r��r ��r ��r ��r��<module>��s��'PK��!� D)/��$��__pycache__/__init__.cpython-310.pycnu��[��o ��`M��@��s^��d�dl�mZmZmZ�d�dlZd�dlmZ�ddlmZm Z m Z mZmZ�ddl mZ�ddlmZmZ�ddlmZmZmZmZmZmZ�dd lmZmZmZmZmZmZm Z m!Z!m"Z"�dd l#m$Z$�dZ%e$�&e%�Z'dZ(d Z)dZeZ+e)d�e+�d�Z,dZ-dZ.dZ/dZ0e�Z1Z2e�Z3Z4eedd�Z5g�d�Z6ej7dd��dkr�ddl8m9Z9m:Z:m;Z;m<Z<�e6�=e9e:e;e<f��dS�dS�)��)�absolute_import�division�print_functionN)�partial��)� converters� exceptions�filters�setters� validators)� cmp_using)�get_run_validators�set_run_validators)�asdict�assoc�astuple�evolve�has� resolve_types) �NOTHING� Attribute�Factory�attrib�attrs�fields�fields_dict� make_class�validate)�VersionInfoz21.2.0r��zClasses Without Boilerplatezhttps://www.attrs.org/z <�>zHynek Schlawackzhs@ox.cx�MITz"Copyright (c) 2015 Hynek SchlawackT)�auto_attribs)r��r��r��r��r��r��attrr�� attributesr��r��r��r��r��r��r��r ��r ��r��ibr��r��sr��r ��r��r��)��)�define�field�frozen�mutable)>� __future__r��r��r��sys� functoolsr��r��r��r ��r ��r��_cmpr��_configr ��r��_funcsr��r��r��r��r��r��_maker��r��r��r��r��r��r��r��r�� _version_infor��__version__�_from_version_string�__version_info__� __title__�__description__�__url__�__uri__�__doc__� __author__� __email__�__license__� __copyright__r%��r#��r$��r"�� dataclass�__all__�version_info� _next_genr)��r��r+��r,��extend��rG��rG��//usr/lib/python3/dist-packages/attr/__init__.py�<module>��s8�� , �PK��!��[�%��%��&��__pycache__/exceptions.cpython-310.pycnu��[��o ��`��@��s��d�dl�mZmZmZ�G�dd��de�ZG�dd��de�ZG�dd��de�ZG�dd ��d e�Z G�d d��de�Z G�dd ��d e�ZG�dd��de�Z G�dd��de�ZG�dd��de�ZdS�)��)�absolute_import�division�print_functionc��@��s��e�Zd�ZdZdZegZdS�)�FrozenErrorz� A frozen/immutable instance or attribute have been attempted to be modified. It mirrors the behavior of ``namedtuples`` by using the same error message and subclassing `AttributeError`. .. versionadded:: 20.1.0 zcan't set attributeN)�__name__� __module__�__qualname__�__doc__�msg�args��r��r��1/usr/lib/python3/dist-packages/attr/exceptions.pyr��s�� r��c��@��e�Zd�ZdZdS�)�FrozenInstanceErrorz\ A frozen instance has been attempted to be modified. .. versionadded:: 16.1.0 N�r��r��r��r ��r��r��r��r ��r��r��c��@��r��)�FrozenAttributeErrorz] A frozen attribute has been attempted to be modified. .. versionadded:: 20.1.0 Nr��r��r��r��r ��r��r��r��c��@��r��)�AttrsAttributeNotFoundErrorzq An ``attrs`` function couldn't find an attribute that the user asked for. .. versionadded:: 16.2.0 Nr��r��r��r��r ��r��#��r��r��c��@��r��)�NotAnAttrsClassErrorzi A non-``attrs`` class has been passed into an ``attrs`` function. .. versionadded:: 16.2.0 Nr��r��r��r��r ��r��+��r��r��c��@��r��)�DefaultAlreadySetErrorz� A default has been set using ``attr.ib()`` and is attempted to be reset using the decorator. .. versionadded:: 17.1.0 Nr��r��r��r��r ��r��3��r��r��c��@��r��)�UnannotatedAttributeErrorz~ A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type annotation. .. versionadded:: 17.3.0 Nr��r��r��r��r ��r��<��r��r��c��@��r��)�PythonTooOldErrorz~ It was attempted to use an ``attrs`` feature that requires a newer Python version. .. versionadded:: 18.2.0 Nr��r��r��r��r ��r��E��r��r��c��s(��e�Zd�ZdZ��fdd�Zdd��Z��ZS�)�NotCallableErrorz� A ``attr.ib()`` requiring a callable has been set with a value that is not callable. .. versionadded:: 19.2.0 c��s"��t�t\|��\|\|��\|\|�_\|\|�_d�S��N)�super� TypeError�__init__r ��value)�selfr ��r�� __class__r��r ��r��V��s�� zNotCallableError.__init__c��C��s ��t�\|�j�S�r��)�strr ��)r��r��r��r ��__str__[��s�� zNotCallableError.__str__)r��r��r��r ��r��r"�� __classcell__r��r��r��r ��r��N��s��r��N)� __future__r��r��r��AttributeErrorr��r��r�� ValueErrorr��r��RuntimeErrorr��r��r��r��r��r��r��r��r ��<module>��s�� PK��!��V ��V ��)��__pycache__/_version_info.cpython-310.pycnu��[��o ��`r��@��sd��d�dl�mZmZmZ�d�dlmZ�ddlmZ�ddlm Z m Z �ee ddddd�G�d d ��d e��ZdS�)��)�absolute_import�division�print_function)�total_ordering��)�astuple)�attrib�attrsFT)�eq�order�slots�frozenc��@��s\��e�Zd�ZdZeed�Zeed�Zeed�Zee d�Z edd��Zdd��Z dd��Zd d ��ZdS�)�VersionInfoa�� A version object that can be compared to tuple of length 1--4: >>> attr.VersionInfo(19, 1, 0, "final") <= (19, 2) True >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1) True >>> vi = attr.VersionInfo(19, 2, 0, "final") >>> vi < (19, 1, 1) False >>> vi < (19,) False >>> vi == (19, 2,) True >>> vi == (19, 2, 1) False .. versionadded:: 19.2 )�typec��C��sL��\|��d�}t\|�dkr\|�d��\|�t\|d��t\|d��t\|d��\|d�d�S�)z6 Parse s* and return a _VersionInfo. �.��finalr��r��)�year�minor�micro�releaselevel)�split�len�append�int)�cls�s�v��r��4/usr/lib/python3/dist-packages/attr/_version_info.py�_from_version_string%��s�� $�z VersionInfo._from_version_stringc��C��sZ��\|�j�\|j�u�r t\|�}t\|t�st�dt\|��krdks!t��t�t\|��dt\|��\|fS�)z� Ensure other is a tuple of a valid length. Returns a possibly transformed other and ourselves as a tuple of the same length as other. r��N)� __class__r�� isinstance�tuple�NotImplementedErrorr��)�self�otherr��r��r �� _ensure_tuple2��s�� zVersionInfo._ensure_tuplec��C��s0��z\|��\|�\}}W�\|\|kS��ty��t�Y�S�w��N�r)��r&��NotImplemented�r'��r(��us�themr��r��r ��__eq__E��s��zVersionInfo.__eq__c��C��s0��z\|��\|�\}}W�\|\|k�S��ty��t�Y�S�w�r��r+��r-��r��r��r ��__lt__M��s��zVersionInfo.__lt__N)�__name__� __module__�__qualname__�__doc__r��r��r��r��r��strr��classmethodr!��r)��r0��r1��r��r��r��r ��r�� s�� r��N) � __future__r��r��r�� functoolsr��_funcsr��_maker��r ��objectr��r��r��r��r ��<module>��s��PK��!��#��__pycache__/_config.cpython-310.pycnu��[��o ��`��@��s4��d�dl�mZmZmZ�ddgZdadd��Zdd��ZdS�)��)�absolute_import�division�print_function�set_run_validators�get_run_validatorsTc��C��s��t�\|�t�s td��\|�adS�)zK Set whether or not validators are run. By default, they are run. z'run' must be bool.N)� isinstance�bool� TypeError�_run_validators)�run��r��./usr/lib/python3/dist-packages/attr/_config.pyr�� s�� c��C��s��t�S�)z3 Return whether or not validators are run. )r ��r��r��r��r ��r��s��N)� __future__r��r��r��__all__r ��r��r��r��r��r��r ��<module>��s �� PK��!��Tdk�� __pycache__/_cmp.cpython-310.pycnu��[��o ��`%��@��s��d�dl�mZmZmZ�d�dlZddlmZ�ddlmZ�dddd d d�Z ddd�Z dd��Zdd��Zdd��Z dd��ZdS�)��)�absolute_import�division�print_functionN��)� new_class)�_make_nez==�<z<=�>z>=)�eq�lt�le�gt�geT� Comparablec�� s��dgt��g�td��d}d}\|�durd}td\|��d<�t��d <�\|dur.\|d 7�}td\|��d<�\|dur=\|d 7�}td \|��d<�\|durL\|d 7�}td\|��d<�\|dur[\|d 7�}td\|��d<�t\|tfi��fdd��} \|ro\| j�t��d\|��k�rydk�r�n�\| S�\|s�t d��t �\| �} \| S�)a�� Create a class that can be passed into `attr.ib`'s ``eq``, ``order``, and ``cmp`` arguments to customize field comparison. The resulting class will have a full set of ordering methods if at least one of ``{lt, le, gt, ge}`` and ``eq`` are provided. :param Optional[callable] eq: `callable` used to evaluate equality of two objects. :param Optional[callable] lt: `callable` used to evaluate whether one object is less than another object. :param Optional[callable] le: `callable` used to evaluate whether one object is less than or equal to another object. :param Optional[callable] gt: `callable` used to evaluate whether one object is greater than another object. :param Optional[callable] ge: `callable` used to evaluate whether one object is greater than or equal to another object. :param bool require_same_type: When `True`, equality and ordering methods will return `NotImplemented` if objects are not of the same type. :param Optional[str] class_name: Name of class. Defaults to 'Comparable'. See `comparison` for more details. .. versionadded:: 21.1.0 �value)� __slots__�__init__� _requirements�_is_comparable_tor��FNTr ��__eq__�__ne__r��r��__lt__r��__le__r ��__gt__r��__ge__c��s ��\|��S��N)�update)�ns��body��+/usr/lib/python3/dist-packages/attr/_cmp.py�<lambda>Q��s�� zcmp_using.<locals>.<lambda>��zDeq must be define is order to complete ordering from lt, le, gt, ge.)� _make_initr��_make_operatorr��r��objectr��append�_check_same_type� ValueError� functools�total_ordering) r ��r��r��r ��r��require_same_type� class_name�num_order_functions�has_eq_function�type_r ��r��r!�� cmp_using��sD��&� �� r1��c��C��s��dd��}�\|�S�)z! Create __init__ method. c��S��s ��\|\|�_�dS�)z1 Initialize object with value. N)r��)�selfr��r ��r ��r!��r��j��s�� z_make_init.<locals>.__init__r ��)r��r ��r ��r!��r$��e��s��r$��c��s,��fdd�}d\|�f�\|_�dt\|��f�\|_\|S�)z! Create operator method. c��s,��\|��\|�stS��\|�j\|j�}\|tu�rtS�\|S�r��)r��NotImplementedr��)r2��other�result��funcr ��r!��methodx��s�� z_make_operator.<locals>.methodz__%s__z"Return a %s b. Computed by attrs.)�__name__�_operation_names�__doc__)�namer7��r8��r ��r6��r!��r%��s��s�� r%��c��C��s ��\|�j�D�] }\|\|�\|�s �dS�qdS�)z8 Check whether `other` is comparable to `self`. FT)r��)r2��r4��r7��r ��r ��r!��r��s �� r��c��C��s��\|j�j\|�j�ju�S�)zR Return True if self* and other are of the same type, False otherwise. )r�� __class__)r2��r4��r ��r ��r!��r(��s��r(��)NNNNNTr��)� __future__r��r��r��r��_compatr��_maker��r:��r1��r$��r%��r��r(��r ��r ��r ��r!��<module>��s"�� Y PK��!�d��,��,��#��__pycache__/setters.cpython-310.pycnu��[��o ��`��@��sZ��d�Z�ddlmZmZmZ�ddlmZ�ddlmZ�dd��Z dd ��Z d d��Zdd ��Ze ��ZdS�)z% Commonly used hooks for on_setattr. ��)�absolute_import�division�print_function��)�_config��FrozenAttributeErrorc��s��fdd�}\|S�)zf Run all setters* and return the return value of the last one. .. versionadded:: 20.1.0 c��s��\|}��D�]}\|\|�\|\|�}q\|S�)N��)�instance�attrib� new_value�rv�setter��settersr ��./usr/lib/python3/dist-packages/attr/setters.py�wrapped_pipe��s��zpipe.<locals>.wrapped_piper ��)r��r��r ��r��r��pipe��s��r��c��C��s��t��)zL Prevent an attribute to be modified. .. versionadded:: 20.1.0 r��)�_�__�___r ��r ��r��frozen��s��r��c��C��s,��t�jdu�r\|S�\|j}\|s\|S�\|\|�\|\|��\|S�)z^ Run attrib's validator on new_value if it has one. .. versionadded:: 20.1.0 F)r��_run_validators� validator)r ��r��r��vr ��r ��r��validate&��s�� r��c��C��s��\|j�}\|r \|\|�S�\|S�)z Run attrib's converter -- if it has one -- on new_value and return the result. .. versionadded:: 20.1.0 )� converter)r ��r��r��cr ��r ��r��convert8��s��r��N)�__doc__� __future__r��r��r��r�� exceptionsr��r��r��r��r��object�NO_OPr ��r ��r ��r��<module>��s�� PK��!��N�&��&��"��__pycache__/_funcs.cpython-310.pycnu��[��o ��`V4��@��s��d�dl�mZmZmZ�d�dlZddlmZ�ddlmZm Z m Z �ddlmZ�dde ddfd d �Zdd��Zddedfd d�Zdd��Zdd��Zdd��Zddd�ZdS�)��)�absolute_import�division�print_functionN��)� iteritems)�NOTHING�_obj_setattr�fields)�AttrsAttributeNotFoundErrorTFc��s��t�\|�j�}��}\|D�]\|}t\|�\|j�} �dur�\|\| �sq �dur&�\|�\|\| �} \|du�r�t\| j�r<t\| d��\|\|j<�q t\| ttt t f�r`�du�rL\| jnt} \| ��fdd�\| D��\|\|j<�q t\| t�r{��fdd�t\| �D��\|\|j<�q \| \|\|j<�q \| \|\|j<�q \|S�)a�� Return the ``attrs`` attribute values of inst as a dict. Optionally recurse into other ``attrs``-decorated classes. :param inst: Instance of an ``attrs``-decorated class. :param bool recurse: Recurse into classes that are also ``attrs``-decorated. :param callable filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the `attr.Attribute` as the first argument and the value as the second argument. :param callable dict_factory: A callable to produce dictionaries from. For example, to produce ordered dictionaries instead of normal Python dictionaries, pass in ``collections.OrderedDict``. :param bool retain_collection_types: Do not convert to ``list`` when encountering an attribute whose type is ``tuple`` or ``set``. Only meaningful if ``recurse`` is ``True``. :param Optional[callable] value_serializer: A hook that is called for every attribute or dict key/value. It receives the current instance, field and value and must return the (updated) value. The hook is run after the optional filter has been applied. :rtype: return type of dict_factory :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 16.0.0 dict_factory .. versionadded:: 16.1.0 retain_collection_types .. versionadded:: 20.3.0 value_serializer NTc��g�\|�] }t�\|��qS��_asdict_anything��.0�i��dict_factory�filter�retain_collection_types�value_serializerr��-/usr/lib/python3/dist-packages/attr/_funcs.py� <listcomp>I��zasdict.<locals>.<listcomp>c��3��4��\|�]\}}t�\|��t�\|��fV��qd�S��Nr ��r��kk�vv��dfr��r��r��r��r�� <genexpr>V��s&�� zasdict.<locals>.<genexpr>) r �� __class__�getattr�name�has�asdict� isinstance�tuple�list�set� frozenset�dictr��)�inst�recurser��r��r��r��attrs�rv�a�v�cfr��r ��r��r��r��r��r��r&�� sB�� ( �� r&��c��s��t�\|�jdd�durt\|�d��}\|S�t\|�ttttf�r6�du�r$\|�jnt}\|��fdd�\|�D��}\|S�t\|�t�rO��fdd�t \|��D��}\|S�\|�}�dur[�dd\|�}\|S�)zK ``asdict`` only works on attrs instances, this works on anything. �__attrs_attrs__NTc��r��r��r ��r��r��r��r��r��r��z$_asdict_anything.<locals>.<listcomp>c��3��r��r��r ��r��r��r��r��r!��s�� z#_asdict_anything.<locals>.<genexpr>) r#��r"��r&��r'��r(��r)��r��r+��r,��r��)�valr��r��r��r��r0��r3��r��r4��r��r��p��s8�� (�� r��c�� s��t�\|�j�}g�}\|�\|D�]v}t\|�\|j�}��dur��\|\|�sq\|du�r\|t\|j�r3\|�t\|d��d��qt\|tt t tf�rV�du�rC\|jnt } \|�\| ��fdd�\|D��qt\|t�rv�du�rb\|jnt} \|�\| ��fdd�t \|�D��q\|�\|��q\|�\|��q�t u�r�\|S��\|�S�)a1�� Return the ``attrs`` attribute values of inst* as a tuple. Optionally recurse into other ``attrs``-decorated classes. :param inst: Instance of an ``attrs``-decorated class. :param bool recurse: Recurse into classes that are also ``attrs``-decorated. :param callable filter: A callable whose return code determines whether an attribute or element is included (``True``) or dropped (``False``). Is called with the `attr.Attribute` as the first argument and the value as the second argument. :param callable tuple_factory: A callable to produce tuples from. For example, to produce lists instead of tuples. :param bool retain_collection_types: Do not convert to ``list`` or ``dict`` when encountering an attribute which type is ``tuple``, ``dict`` or ``set``. Only meaningful if ``recurse`` is ``True``. :rtype: return type of tuple_factory :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 16.2.0 NT�r.��r�� tuple_factoryr��c�� s,��g�\|�]}t�\|j�rt\|d��d�n\|�qS�)Tr7��r%��r"��astuple)r��j�r��retainr8��r��r��r��s�� zastuple.<locals>.<listcomp>c��3��sL��\|�]!\}}t�\|j�rt\|��d��n\|t�\|j�rt\|��d��n\|fV��qdS�))r8��r��Nr9��r��)r=��r8��r��r��r!��s&�� zastuple.<locals>.<genexpr>)r ��r"��r#��r$��r%��appendr:��r'��r(��r)��r��r+��r,��r��)r-��r.��r��r8��r��r/��r0��r1��r2��r3��r ��r��r<��r��r:��sJ�� ! �� r:��c��C��s��t�\|�dd�duS�)z� Check whether cls* is a class with ``attrs`` attributes. :param type cls: Class to introspect. :raise TypeError: If cls is not a class. :rtype: bool r5��N)r#��)�clsr��r��r��r%��s�� r%��c��K��sv��ddl�}\|jdtdd��t�\|��}t\|�j�}t\|�D�]\}}t\|\|t�}\|tu�r2t dj \|\|jd��t\|\|\|��q\|S�)a�� Copy inst and apply changes. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. :return: A copy of inst with changes incorporated. :raise attr.exceptions.AttrsAttributeNotFoundError: If attr_name couldn't be found on cls. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. deprecated:: 17.1.0 Use `evolve` instead. r��Nz6assoc is deprecated and will be removed after 2018/01.��)� stacklevelz&{k} is not an attrs attribute on {cl}.)�k�cl)�warnings�warn�DeprecationWarning�copyr ��r"��r��r#��r��r ��formatr��)r-��changesrD��newr/��rB��r2��r1��r��r��r��assoc��s$�� rK��c��K��sf��\|�j�}t\|�}\|D�]"}\|jsq \|j}\|d�dkr\|n\|dd��}\|\|vr+t\|�\|�\|\|<�q \|di�\|��S�)a�� Create a new instance, based on inst with changes applied. :param inst: Instance of a class with ``attrs`` attributes. :param changes: Keyword changes in the new copy. :return: A copy of inst with changes incorporated. :raise TypeError: If attr_name couldn't be found in the class ``__init__``. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class. .. versionadded:: 17.1.0 r��_r��Nr��)r"��r ��initr$��r#��)r-��rI��r?��r/��r1�� attr_name� init_namer��r��r��evolve=��s��rP��c�� C��sv��z\|�j��W�\|�S��ty:��ddl}\|j\|�\|\|d�}\|du�r!t\|��n\|D�]}\|j\|v�r3t\|d\|\|j��q#d\|�_�Y�\|�S�w�)a �� Resolve any strings and forward annotations in type annotations. This is only required if you need concrete types in `Attribute`'s type field. In other words, you don't need to resolve your types if you only use them for static type checking. With no arguments, names will be looked up in the module in which the class was created. If this is not what you want, e.g. if the name only exists inside a method, you may pass globalns or localns to specify other dictionaries in which to look up these names. See the docs of `typing.get_type_hints` for more details. :param type cls: Class to resolve. :param Optional[dict] globalns: Dictionary containing global variables. :param Optional[dict] localns: Dictionary containing local variables. :param Optional[list] attribs: List of attribs for the given class. This is necessary when calling from inside a ``field_transformer`` since cls is not an ``attrs`` class yet. :raise TypeError: If cls is not a class. :raise attr.exceptions.NotAnAttrsClassError: If cls is not an ``attrs`` class and you didn't pass any attribs. :raise NameError: If types cannot be resolved because of missing variables. :returns: cls so you can use this function also as a class decorator. Please note that you have to apply it after `attr.s`. That means the decorator has to come in the line before `attr.s`. .. versionadded:: 20.1.0 .. versionadded:: 21.1.0 attribs r��N)�globalns�localns�typeT)�__attrs_types_resolved__�AttributeError�typing�get_type_hintsr ��r$��r��)r?��rQ��rR��attribsrV��hints�fieldr��r��r�� resolve_typesZ��s��"� ��r[��)NNN)� __future__r��r��r��rG��_compatr��_maker��r��r �� exceptionsr ��r,��r&��r��r(��r:��r%��rK��rP��r[��r��r��r��r��<module>��s�� f9 �d&PK��!��Š��+��+��&��__pycache__/validators.cpython-310.pycnu��[��o ��`�,��@��s��d�Z�ddlmZmZmZ�ddlZddlmZmZm Z m Z �ddlmZ�g�d�Z e dd d d �G�dd��de��Zd d��Ze dd d d�G�dd��de��Zd,dd�Ze dd d d �G�dd��de��Zdd��Ze dd d d �G�dd��de��Zdd��Ze dd d d �G�dd��de��Zdd��Ze ddd d �G�d d!��d!e��Zd"d#��Ze dd d d �G�d$d%��d%e��Zd-d&d'�Ze dd d d �G�d(d)��d)e��Zd-dd+�ZdS�).z Commonly useful validators. ��)�absolute_import�division�print_functionN��)� _AndValidator�and_�attrib�attrs)�NotCallableError) r�� deep_iterable�deep_mapping�in_�instance_of�is_callable� matches_re�optional�providesFT)�repr�slots�hashc��@��"��e�Zd�Ze��Zdd��Zdd��ZdS�)�_InstanceOfValidatorc��C��s4��t�\|\|�j�stdj\|j\|�j\|j\|d�\|\|�j\|��dS�)�P We use a callable class to be able to change the ``__repr__``. z?'{name}' must be {type!r} (got {value!r} that is a {actual!r}).)�name�type�actual�valueN)� isinstancer�� TypeError�formatr�� __class__��self�inst�attrr��r%��1/usr/lib/python3/dist-packages/attr/validators.py�__call__��s��z_InstanceOfValidator.__call__c��C��dj�\|�jd�S�)Nz)<instance_of validator for type {type!r}>�r��)r��r��r"��r%��r%��r&��__repr__0��z_InstanceOfValidator.__repr__N)�__name__� __module__�__qualname__r��r��r'��r+��r%��r%��r%��r&��r��s��r��c��C��t�\|��S�)a�� A validator that raises a `TypeError` if the initializer is called with a wrong type for this particular attribute (checks are performed using `isinstance` therefore it's also valid to pass a tuple of types). :param type: The type to check for. :type type: type or tuple of types :raises TypeError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected type, and the value it got. )r��r)��r%��r%��r&��r��6��s�� r��)r��frozenr��c��@��s.��e�Zd�Ze��Ze��Ze��Zdd��Zdd��ZdS�)�_MatchesReValidatorc��C��s0��\|��\|�stdj\|j\|�jj\|d�\|\|�j\|��dS�)r��z7'{name}' must match regex {regex!r} ({value!r} doesn't))r��regexr��N)� match_func� ValueErrorr��r��r3��patternr!��r%��r%��r&��r'��L��s�� z_MatchesReValidator.__call__c��C��r(��)Nz,<matches_re validator for pattern {regex!r}>)r3��)r��r3��r��r%��r%��r&��r+��[��r,��z_MatchesReValidator.__repr__N) r-��r.��r/��r��r3��flagsr4��r'��r+��r%��r%��r%��r&��r2��F��s��r2��c��C��s��t�tdd�}\|dtjtjf}\|\|vr%tdd�tdd��t\|�D��f��t�\|�\|�}\|tju�r4\|j}n\|tju�r=\|j}n\|rC\|j }nt�d� \|��\|�}\|j}t\|\|\|�S�)a}�� A validator that raises `ValueError` if the initializer is called with a string that doesn't match regex. :param str regex: a regex string to match against :param int flags: flags that will be passed to the underlying re function (default 0) :param callable func: which underlying `re` function to call (options are `re.fullmatch`, `re.search`, `re.match`, default is ``None`` which means either `re.fullmatch` or an emulation of it on Python 2). For performance reasons, they won't be used directly but on a pre-`re.compile`\ ed pattern. .. versionadded:: 19.2.0 � fullmatchNz'func' must be one of %s.z, c��s��s��\|�] }\|r \|j�p d�V��qdS�)�NoneN)r-��)�.0�er%��r%��r&�� <genexpr>x��s�� zmatches_re.<locals>.<genexpr>z(?:{})\Z)�getattr�re�search�matchr5��join�sorted�set�compiler8��r��r2��)r3��r7��funcr8��valid_funcsr6��r4��r%��r%��r&��r��a��s.�� r��c��@��r��)�_ProvidesValidatorc��C��s0��\|�j��\|�stdj\|j\|�j�\|d�\|\|�j�\|��dS�)r��z<'{name}' must provide {interface!r} which {value!r} doesn't.)r�� interfacer��N)rH�� providedByr��r��r��r!��r%��r%��r&��r'��s�� z_ProvidesValidator.__call__c��C��r(��)Nz0<provides validator for interface {interface!r}>�rH��)r��rH��r��r%��r%��r&��r+��r,��z_ProvidesValidator.__repr__N)r-��r.��r/��r��rH��r'��r+��r%��r%��r%��r&��rG��s��rG��c��C��r0��)a(�� A validator that raises a `TypeError` if the initializer is called with an object that does not provide the requested interface (checks are performed using ``interface.providedBy(value)`` (see `zope.interface <https://zopeinterface.readthedocs.io/en/latest/>`_). :param interface: The interface to check for. :type interface: ``zope.interface.Interface`` :raises TypeError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected interface, and the value it got. )rG��rJ��r%��r%��r&��r��s��r��c��@��r��)�_OptionalValidatorc��C��s��\|d�u�rd�S�\|��\|\|\|��d�S��N�� validatorr!��r%��r%��r&��r'��s��z_OptionalValidator.__call__c��C��s��dj�t\|�j�d�S�)Nz'<optional validator for {what} or None>)�what)r��r��rN��r��r%��r%��r&��r+��s��z_OptionalValidator.__repr__N)r-��r.��r/��r��rN��r'��r+��r%��r%��r%��r&��rK��s��rK��c��C��s��t�\|�t�rtt\|��S�t\|��S�)a�� A validator that makes an attribute optional. An optional attribute is one which can be set to ``None`` in addition to satisfying the requirements of the sub-validator. :param validator: A validator (or a list of validators) that is used for non-``None`` values. :type validator: callable or `list` of callables. .. versionadded:: 15.1.0 .. versionchanged:: 17.1.0 validator* can be a list of validators. )r��listrK��r��rM��r%��r%��r&��r��s�� r��c��@��r��)�_InValidatorc��C��sF��z\|\|�j�v�}W�n�ty��d}Y�nw�\|s!tdj\|j\|�j�\|d��d�S�)NFz/'{name}' must be in {options!r} (got {value!r}))r��optionsr��)rR��r��r5��r��r��)r"��r#��r$��r�� in_optionsr%��r%��r&��r'��s�� z_InValidator.__call__c��C��r(��)Nz(<in_ validator with options {options!r}>�rR��)r��rR��r��r%��r%��r&��r+��r,��z_InValidator.__repr__N)r-��r.��r/��r��rR��r'��r+��r%��r%��r%��r&��rQ��s�� rQ��c��C��r0��)a�� A validator that raises a `ValueError` if the initializer is called with a value that does not belong in the options provided. The check is performed using ``value in options``. :param options: Allowed options. :type options: list, tuple, `enum.Enum`, ... :raises ValueError: With a human readable error message, the attribute (of type `attr.Attribute`), the expected options, and the value it got. .. versionadded:: 17.1.0 )rQ��rT��r%��r%��r&��r ��s��r ��c��@��s��e�Zd�Zdd��Zdd��ZdS�)�_IsCallableValidatorc��C��s,��t�\|�sd}t\|j\|j\|\|jd�\|d��dS�)r��z?'{name}' must be callable (got {value!r} that is a {actual!r}).)r��r��r��)�msgr��N)�callabler ��r��r��r ��)r"��r#��r$��r��messager%��r%��r&��r'��s�� z_IsCallableValidator.__call__c��C��s��dS�)Nz<is_callable validator>r%��r��r%��r%��r&��r+��s��z_IsCallableValidator.__repr__N)r-��r.��r/��r'��r+��r%��r%��r%��r&��rU��s��rU��c��C��s��t��S�)aw�� A validator that raises a `attr.exceptions.NotCallableError` if the initializer is called with a value for this particular attribute that is not callable. .. versionadded:: 19.1.0 :raises `attr.exceptions.NotCallableError`: With a human readable error message containing the attribute (`attr.Attribute`) name, and the value it got. )rU��r%��r%��r%��r&��r��s��r��c��@��s:��e�Zd�Zee��d�Zedee��d�Zdd��Zdd��Z dS�)� _DeepIterablerM��N��defaultrN��c��C��s4��\|�j�dur\|��\|\|\|��\|D�] }\|��\|\|\|��qdS��r��N)�iterable_validator�member_validator)r"��r#��r$��r��memberr%��r%��r&��r'��/��s �� z_DeepIterable.__call__c��C��s,��\|�j�d�u�rdndj\|�j�d�}dj\|\|�jd�S�)N��z {iterable!r})�iterablezJ<deep_iterable validator for{iterable_identifier} iterables of {member!r}>)�iterable_identifierr_��)r]��r��r^��)r"��rb��r%��r%��r&��r+��9��s�� z_DeepIterable.__repr__) r-��r.��r/��r��r��r^��r��r]��r'��r+��r%��r%��r%��r&��rY��(��s�� rY��c��C��s ��t�\|�\|�S�)a1�� A validator that performs deep validation of an iterable. :param member_validator: Validator to apply to iterable members :param iterable_validator: Validator to apply to iterable itself (optional) .. versionadded:: 19.1.0 :raises TypeError: if any sub-validators fail )rY��)r^��r]��r%��r%��r&��r��H��s�� r��c��@��sF��e�Zd�Zee��d�Zee��d�Zedee��d�Zdd��Z dd��Z dS�)�_DeepMappingrM��NrZ��c��C��sF��\|�j�dur\|��\|\|\|��\|D�]}\|��\|\|\|��\|��\|\|\|\|��qdS�r\��)�mapping_validator� key_validator�value_validator)r"��r#��r$��r��keyr%��r%��r&��r'��]��s�� z_DeepMapping.__call__c��C��s��dj�\|�j\|�jd�S�)NzA<deep_mapping validator for objects mapping {key!r} to {value!r}>)rg��r��)r��re��rf��r��r%��r%��r&��r+��h��s�� z_DeepMapping.__repr__)r-��r.��r/��r��r��re��rf��r��rd��r'��r+��r%��r%��r%��r&��rc��W��s��rc��c��C��s��t�\|�\|\|�S�)a}�� A validator that performs deep validation of a dictionary. :param key_validator: Validator to apply to dictionary keys :param value_validator: Validator to apply to dictionary values :param mapping_validator: Validator to apply to top-level mapping attribute (optional) .. versionadded:: 19.1.0 :raises TypeError: if any sub-validators fail )rc��)re��rf��rd��r%��r%��r&��r��n��s�� r��)r��NrL��)�__doc__� __future__r��r��r��r>��_maker��r��r��r �� exceptionsr ��__all__�objectr��r��r2��r��rG��r��rK��r��rQ��r ��rU��r��rY��r��rc��r��r%��r%��r%��r&��<module>��s<�� - PK��!��80Z��filters.pyinu��[��from typing import Any, Union from . import Attribute, _FilterType def include(what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... def exclude(what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... PK��!�_-^5�� _config.pynu��[��from __future__ import absolute_import, division, print_function __all__ = ["set_run_validators", "get_run_validators"] _run_validators = True def set_run_validators(run): """ Set whether or not validators are run. By default, they are run. """ if not isinstance(run, bool): raise TypeError("'run' must be bool.") global _run_validators _run_validators = run def get_run_validators(): """ Return whether or not validators are run. """ return _run_validators PK��!��_version_info.pyinu��[��class VersionInfo: @property def year(self) -> int: ... @property def minor(self) -> int: ... @property def micro(self) -> int: ... @property def releaselevel(self) -> str: ... PK��!�mt^��currentnu�W+A��PK��!��B��prevnu��6�$��PK��!��v��execnu�W+A��PK��!��fscreatenu�W+A��PK��!�� keycreatenu�W+A��PK��!�� sockcreatenu�W+A��PK��!�� U��smack/currentnu�W+A��PK��!�mt^��apparmor/currentnu�W+A��PK��!�� apparmor/prevnu��6�$��PK��!�� apparmor/execnu�W+A��PK��!��b��}��}��W��_make.pynu��[��PK��!�8�4�V4��V4�� ^��_funcs.pynu��[��PK��!��^�� exceptions.pynu��[��PK��!��V~��~��Ǽ�converters.pyinu��[��PK��!�� >��>��_cmp.pyinu��[��PK��!��Y�r��r��_version_info.pynu��[��PK��!�:dc�J��J�� filters.pynu��[��PK��!�� /��setters.pynu��[��PK��!��>��>��setters.pyinu��[��PK��!��M�%��%��\|��_cmp.pynu��[��PK��!�J&LN��N��validators.pyinu��[��PK��!�F�'�,��,�� d��validators.pynu��[��PK��!��t;�� _compat.pynu��[��PK��!��N8�py.typednu��[��PK��!��`ͮM��M��8�__init__.pynu��[��PK��!��d�� ?�converters.pynu��[��PK��!�괎�9��9��K�__init__.pyinu��[��PK��!�X}��[��exceptions.pyinu��[��PK��!�Q";��_next_gen.pynu��[��PK��!�њ%��!��ٗ�__pycache__/_make.cpython-310.pycnu��[��PK��!��ے��#��__pycache__/filters.cpython-310.pycnu��[��PK��!�:�<��#��__pycache__/_compat.cpython-310.pycnu��[��PK��!��I �� %��v��__pycache__/_next_gen.cpython-310.pycnu��[��PK��!��B�h>��>��&��__pycache__/converters.cpython-310.pycnu��[��PK��!� D)/��$��i��__pycache__/__init__.cpython-310.pycnu��[��PK��!��[�%��%��&��W��__pycache__/exceptions.cpython-310.pycnu��[��PK��!��V ��V ��)��__pycache__/_version_info.cpython-310.pycnu��[��PK��!��#��__pycache__/_config.cpython-310.pycnu��[��PK��!��Tdk�� __pycache__/_cmp.cpython-310.pycnu��[��PK��!�d��,��,��#��__pycache__/setters.cpython-310.pycnu��[��PK��!��N�&��&��"��x �__pycache__/_funcs.cpython-310.pycnu��[��PK��!��Š��+��+��&��G�__pycache__/validators.cpython-310.pycnu��[��PK��!��80Z��s�filters.pyinu��[��PK��!�_-^5�� t�_config.pynu��[��PK��!��.w�_version_info.pyinu��[��PK��-�-�o��@x��

| ver. 1.4 | Github | . | PHP 8.3.30 | Generation time: 0.92 | proxy | phpinfo | Settings