|
|
from __future__ import absolute_import, division, print_function
|
|
|
|
|
|
import hashlib
|
|
|
import linecache
|
|
|
|
|
|
from operator import itemgetter
|
|
|
|
|
|
from . import _config
|
|
|
from ._compat import PY2, iteritems, isclass, iterkeys, metadata_proxy
|
|
|
from .exceptions import (
|
|
|
DefaultAlreadySetError,
|
|
|
FrozenInstanceError,
|
|
|
NotAnAttrsClassError,
|
|
|
)
|
|
|
|
|
|
|
|
|
# This is used at least twice, so cache it here.
|
|
|
_obj_setattr = object.__setattr__
|
|
|
_init_convert_pat = "__attr_convert_{}"
|
|
|
_init_factory_pat = "__attr_factory_{}"
|
|
|
_tuple_property_pat = " {attr_name} = property(itemgetter({index}))"
|
|
|
_empty_metadata_singleton = metadata_proxy({})
|
|
|
|
|
|
|
|
|
class _Nothing(object):
|
|
|
"""
|
|
|
Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
|
|
|
|
|
|
All instances of `_Nothing` are equal.
|
|
|
"""
|
|
|
def __copy__(self):
|
|
|
return self
|
|
|
|
|
|
def __deepcopy__(self, _):
|
|
|
return self
|
|
|
|
|
|
def __eq__(self, other):
|
|
|
return other.__class__ == _Nothing
|
|
|
|
|
|
def __ne__(self, other):
|
|
|
return not self == other
|
|
|
|
|
|
def __repr__(self):
|
|
|
return "NOTHING"
|
|
|
|
|
|
def __hash__(self):
|
|
|
return 0xdeadbeef
|
|
|
|
|
|
|
|
|
NOTHING = _Nothing()
|
|
|
"""
|
|
|
Sentinel to indicate the lack of a value when ``None`` is ambiguous.
|
|
|
"""
|
|
|
|
|
|
|
|
|
def attr(default=NOTHING, validator=None,
|
|
|
repr=True, cmp=True, hash=None, init=True,
|
|
|
convert=None, metadata={}):
|
|
|
"""
|
|
|
Create a new attribute on a class.
|
|
|
|
|
|
.. warning::
|
|
|
|
|
|
Does *not* do anything unless the class is also decorated with
|
|
|
:func:`attr.s`!
|
|
|
|
|
|
:param default: A value that is used if an ``attrs``-generated ``__init__``
|
|
|
is used and no value is passed while instantiating or the attribute is
|
|
|
excluded using ``init=False``.
|
|
|
|
|
|
If the value is an instance of :class:`Factory`, its callable will be
|
|
|
used to construct a new value (useful for mutable datatypes like lists
|
|
|
or dicts).
|
|
|
|
|
|
If a default is not set (or set manually to ``attr.NOTHING``), a value
|
|
|
*must* be supplied when instantiating; otherwise a :exc:`TypeError`
|
|
|
will be raised.
|
|
|
|
|
|
The default can also be set using decorator notation as shown below.
|
|
|
|
|
|
:type default: Any value.
|
|
|
|
|
|
:param validator: :func:`callable` that is called by ``attrs``-generated
|
|
|
``__init__`` methods after the instance has been initialized. They
|
|
|
receive the initialized instance, the :class:`Attribute`, and the
|
|
|
passed value.
|
|
|
|
|
|
The return value is *not* inspected so the validator has to throw an
|
|
|
exception itself.
|
|
|
|
|
|
If a ``list`` is passed, its items are treated as validators and must
|
|
|
all pass.
|
|
|
|
|
|
Validators can be globally disabled and re-enabled using
|
|
|
:func:`get_run_validators`.
|
|
|
|
|
|
The validator can also be set using decorator notation as shown below.
|
|
|
|
|
|
:type validator: ``callable`` or a ``list`` of ``callable``\ s.
|
|
|
|
|
|
:param bool repr: Include this attribute in the generated ``__repr__``
|
|
|
method.
|
|
|
:param bool cmp: Include this attribute in the generated comparison methods
|
|
|
(``__eq__`` et al).
|
|
|
:param hash: Include this attribute in the generated ``__hash__``
|
|
|
method. If ``None`` (default), mirror *cmp*'s value. This is the
|
|
|
correct behavior according the Python spec. Setting this value to
|
|
|
anything else than ``None`` is *discouraged*.
|
|
|
:type hash: ``bool`` or ``None``
|
|
|
:param bool init: Include this attribute in the generated ``__init__``
|
|
|
method. It is possible to set this to ``False`` and set a default
|
|
|
value. In that case this attributed is unconditionally initialized
|
|
|
with the specified default value or factory.
|
|
|
:param callable convert: :func:`callable` that is called by
|
|
|
``attrs``-generated ``__init__`` methods to convert attribute's value
|
|
|
to the desired format. It is given the passed-in value, and the
|
|
|
returned value will be used as the new value of the attribute. The
|
|
|
value is converted before being passed to the validator, if any.
|
|
|
:param metadata: An arbitrary mapping, to be used by third-party
|
|
|
components. See :ref:`extending_metadata`.
|
|
|
|
|
|
.. versionchanged:: 17.1.0 *validator* can be a ``list`` now.
|
|
|
.. versionchanged:: 17.1.0
|
|
|
*hash* is ``None`` and therefore mirrors *cmp* by default .
|
|
|
"""
|
|
|
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."
|
|
|
)
|
|
|
return _CountingAttr(
|
|
|
default=default,
|
|
|
validator=validator,
|
|
|
repr=repr,
|
|
|
cmp=cmp,
|
|
|
hash=hash,
|
|
|
init=init,
|
|
|
convert=convert,
|
|
|
metadata=metadata,
|
|
|
)
|
|
|
|
|
|
|
|
|
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 = {"itemgetter": itemgetter}
|
|
|
eval(compile("\n".join(attr_class_template), "", "exec"), globs)
|
|
|
return globs[attr_class_name]
|
|
|
|
|
|
|
|
|
def _transform_attrs(cls, these):
|
|
|
"""
|
|
|
Transforms all `_CountingAttr`s on a class into `Attribute`s and saves the
|
|
|
list in `__attrs_attrs__`.
|
|
|
|
|
|
If *these* is passed, use that and don't look for them on the class.
|
|
|
"""
|
|
|
super_cls = []
|
|
|
for c in reversed(cls.__mro__[1:-1]):
|
|
|
sub_attrs = getattr(c, "__attrs_attrs__", None)
|
|
|
if sub_attrs is not None:
|
|
|
super_cls.extend(a for a in sub_attrs if a not in super_cls)
|
|
|
if these is None:
|
|
|
ca_list = [(name, attr)
|
|
|
for name, attr
|
|
|
in cls.__dict__.items()
|
|
|
if isinstance(attr, _CountingAttr)]
|
|
|
else:
|
|
|
ca_list = [(name, ca)
|
|
|
for name, ca
|
|
|
in iteritems(these)]
|
|
|
|
|
|
non_super_attrs = [
|
|
|
Attribute.from_counting_attr(name=attr_name, ca=ca)
|
|
|
for attr_name, ca
|
|
|
in sorted(ca_list, key=lambda e: e[1].counter)
|
|
|
]
|
|
|
attr_names = [a.name for a in super_cls + non_super_attrs]
|
|
|
|
|
|
AttrsClass = _make_attr_tuple_class(cls.__name__, attr_names)
|
|
|
|
|
|
cls.__attrs_attrs__ = AttrsClass(super_cls + [
|
|
|
Attribute.from_counting_attr(name=attr_name, ca=ca)
|
|
|
for attr_name, ca
|
|
|
in sorted(ca_list, key=lambda e: e[1].counter)
|
|
|
])
|
|
|
|
|
|
had_default = False
|
|
|
for a in cls.__attrs_attrs__:
|
|
|
if these is None and a not in super_cls:
|
|
|
setattr(cls, a.name, a)
|
|
|
if had_default is True and a.default is NOTHING and a.init is True:
|
|
|
raise ValueError(
|
|
|
"No mandatory attributes allowed after an attribute with a "
|
|
|
"default value or factory. Attribute in question: {a!r}"
|
|
|
.format(a=a)
|
|
|
)
|
|
|
elif had_default is False and \
|
|
|
a.default is not NOTHING and \
|
|
|
a.init is not False:
|
|
|
had_default = True
|
|
|
|
|
|
|
|
|
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()
|
|
|
|
|
|
|
|
|
def attributes(maybe_cls=None, these=None, repr_ns=None,
|
|
|
repr=True, cmp=True, hash=None, init=True,
|
|
|
slots=False, frozen=False, str=False):
|
|
|
r"""
|
|
|
A class decorator that adds `dunder
|
|
|
<https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the
|
|
|
specified attributes using :func:`attr.ib` or the *these* argument.
|
|
|
|
|
|
:param these: A dictionary of name to :func:`attr.ib` mappings. This is
|
|
|
useful to avoid the definition of your attributes within the class body
|
|
|
because you can't (e.g. if you want to add ``__repr__`` methods to
|
|
|
Django models) or don't want to.
|
|
|
|
|
|
If *these* is not ``None``, ``attrs`` will *not* search the class body
|
|
|
for attributes.
|
|
|
|
|
|
:type these: :class:`dict` of :class:`str` to :func:`attr.ib`
|
|
|
|
|
|
:param str repr_ns: When using nested classes, there's no way in Python 2
|
|
|
to automatically detect that. Therefore it's possible to set the
|
|
|
namespace explicitly for a more meaningful ``repr`` output.
|
|
|
:param bool repr: Create a ``__repr__`` method with a human readable
|
|
|
represantation of ``attrs`` attributes..
|
|
|
:param bool str: Create a ``__str__`` method that is identical to
|
|
|
``__repr__``. This is usually not necessary except for
|
|
|
:class:`Exception`\ s.
|
|
|
:param bool cmp: Create ``__eq__``, ``__ne__``, ``__lt__``, ``__le__``,
|
|
|
``__gt__``, and ``__ge__`` methods that compare the class as if it were
|
|
|
a tuple of its ``attrs`` attributes. But the attributes are *only*
|
|
|
compared, if the type of both classes is *identical*!
|
|
|
:param hash: If ``None`` (default), the ``__hash__`` method is generated
|
|
|
according how *cmp* and *frozen* are set.
|
|
|
|
|
|
1. If *both* are True, ``attrs`` will generate a ``__hash__`` for you.
|
|
|
2. If *cmp* is True and *frozen* is False, ``__hash__`` will be set to
|
|
|
None, marking it unhashable (which it is).
|
|
|
3. If *cmp* is False, ``__hash__`` will be left untouched meaning the
|
|
|
``__hash__`` method of the superclass will be used (if superclass is
|
|
|
``object``, this means it will fall back to id-based hashing.).
|
|
|
|
|
|
Although not recommended, you can decide for yourself and force
|
|
|
``attrs`` to create one (e.g. if the class is immutable even though you
|
|
|
didn't freeze it programmatically) by passing ``True`` or not. Both of
|
|
|
these cases are rather special and should be used carefully.
|
|
|
|
|
|
See the `Python documentation \
|
|
|
<https://docs.python.org/3/reference/datamodel.html#object.__hash__>`_
|
|
|
and the `GitHub issue that led to the default behavior \
|
|
|
<https://github.com/python-attrs/attrs/issues/136>`_ for more details.
|
|
|
:type hash: ``bool`` or ``None``
|
|
|
:param bool init: Create a ``__init__`` method that initialiazes the
|
|
|
``attrs`` attributes. Leading underscores are stripped for the
|
|
|
argument name. If a ``__attrs_post_init__`` method exists on the
|
|
|
class, it will be called after the class is fully initialized.
|
|
|
:param bool slots: Create a slots_-style class that's more
|
|
|
memory-efficient. See :ref:`slots` for further ramifications.
|
|
|
:param bool frozen: Make instances immutable after initialization. If
|
|
|
someone attempts to modify a frozen instance,
|
|
|
:exc:`attr.exceptions.FrozenInstanceError` is raised.
|
|
|
|
|
|
Please note:
|
|
|
|
|
|
1. This is achieved by installing a custom ``__setattr__`` method
|
|
|
on your class so you can't implement an own one.
|
|
|
|
|
|
2. True immutability is impossible in Python.
|
|
|
|
|
|
3. This *does* have a minor a runtime performance :ref:`impact
|
|
|
<how-frozen>` when initializing new instances. In other words:
|
|
|
``__init__`` is slightly slower with ``frozen=True``.
|
|
|
|
|
|
4. If a class is frozen, you cannot modify ``self`` in
|
|
|
``__attrs_post_init__`` or a self-written ``__init__``. You can
|
|
|
circumvent that limitation by using
|
|
|
``object.__setattr__(self, "attribute_name", value)``.
|
|
|
|
|
|
.. _slots: https://docs.python.org/3.5/reference/datamodel.html#slots
|
|
|
|
|
|
.. versionadded:: 16.0.0 *slots*
|
|
|
.. versionadded:: 16.1.0 *frozen*
|
|
|
.. versionadded:: 16.3.0 *str*, and support for ``__attrs_post_init__``.
|
|
|
.. versionchanged::
|
|
|
17.1.0 *hash* supports ``None`` as value which is also the default
|
|
|
now.
|
|
|
"""
|
|
|
def wrap(cls):
|
|
|
if getattr(cls, "__class__", None) is None:
|
|
|
raise TypeError("attrs only works with new-style classes.")
|
|
|
|
|
|
if repr is False and str is True:
|
|
|
raise ValueError(
|
|
|
"__str__ can only be generated if a __repr__ exists."
|
|
|
)
|
|
|
|
|
|
if slots:
|
|
|
# Only need this later if we're using slots.
|
|
|
if these is None:
|
|
|
ca_list = [name
|
|
|
for name, attr
|
|
|
in cls.__dict__.items()
|
|
|
if isinstance(attr, _CountingAttr)]
|
|
|
else:
|
|
|
ca_list = list(iterkeys(these))
|
|
|
_transform_attrs(cls, these)
|
|
|
|
|
|
# Can't just re-use frozen name because Python's scoping. :(
|
|
|
# Can't compare function objects because Python 2 is terrible. :(
|
|
|
effectively_frozen = _has_frozen_superclass(cls) or frozen
|
|
|
if repr is True:
|
|
|
cls = _add_repr(cls, ns=repr_ns)
|
|
|
if str is True:
|
|
|
cls.__str__ = cls.__repr__
|
|
|
if cmp is True:
|
|
|
cls = _add_cmp(cls)
|
|
|
|
|
|
if hash is not True and hash is not False and hash is not None:
|
|
|
raise TypeError(
|
|
|
"Invalid value for hash. Must be True, False, or None."
|
|
|
)
|
|
|
elif hash is False or (hash is None and cmp is False):
|
|
|
pass
|
|
|
elif hash is True or (hash is None and cmp is True and frozen is True):
|
|
|
cls = _add_hash(cls)
|
|
|
else:
|
|
|
cls.__hash__ = None
|
|
|
|
|
|
if init is True:
|
|
|
cls = _add_init(cls, effectively_frozen)
|
|
|
if effectively_frozen is True:
|
|
|
cls.__setattr__ = _frozen_setattrs
|
|
|
cls.__delattr__ = _frozen_delattrs
|
|
|
if slots is True:
|
|
|
# slots and frozen require __getstate__/__setstate__ to work
|
|
|
cls = _add_pickle(cls)
|
|
|
if slots is True:
|
|
|
cls_dict = dict(cls.__dict__)
|
|
|
cls_dict["__slots__"] = tuple(ca_list)
|
|
|
for ca_name in ca_list:
|
|
|
# It might not actually be in there, e.g. if using 'these'.
|
|
|
cls_dict.pop(ca_name, None)
|
|
|
cls_dict.pop("__dict__", None)
|
|
|
|
|
|
qualname = getattr(cls, "__qualname__", None)
|
|
|
cls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
|
|
|
if qualname is not None:
|
|
|
cls.__qualname__ = qualname
|
|
|
|
|
|
return cls
|
|
|
|
|
|
# attrs_or class type depends on the usage of the decorator. It's a class
|
|
|
# if it's used as `@attributes` but ``None`` if used # as `@attributes()`.
|
|
|
if maybe_cls is None:
|
|
|
return wrap
|
|
|
else:
|
|
|
return wrap(maybe_cls)
|
|
|
|
|
|
|
|
|
if PY2:
|
|
|
def _has_frozen_superclass(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_superclass(cls):
|
|
|
"""
|
|
|
Check whether *cls* has a frozen ancestor by looking at its
|
|
|
__setattr__.
|
|
|
"""
|
|
|
return cls.__setattr__ == _frozen_setattrs
|
|
|
|
|
|
|
|
|
def _attrs_to_tuple(obj, attrs):
|
|
|
"""
|
|
|
Create a tuple of all values of *obj*'s *attrs*.
|
|
|
"""
|
|
|
return tuple(getattr(obj, a.name) for a in attrs)
|
|
|
|
|
|
|
|
|
def _add_hash(cls, attrs=None):
|
|
|
"""
|
|
|
Add a hash method to *cls*.
|
|
|
"""
|
|
|
if attrs is None:
|
|
|
attrs = [a
|
|
|
for a in cls.__attrs_attrs__
|
|
|
if a.hash is True or (a.hash is None and a.cmp is True)]
|
|
|
|
|
|
def hash_(self):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
return hash(_attrs_to_tuple(self, attrs))
|
|
|
|
|
|
cls.__hash__ = hash_
|
|
|
return cls
|
|
|
|
|
|
|
|
|
def _add_cmp(cls, attrs=None):
|
|
|
"""
|
|
|
Add comparison methods to *cls*.
|
|
|
"""
|
|
|
if attrs is None:
|
|
|
attrs = [a for a in cls.__attrs_attrs__ if a.cmp]
|
|
|
|
|
|
def attrs_to_tuple(obj):
|
|
|
"""
|
|
|
Save us some typing.
|
|
|
"""
|
|
|
return _attrs_to_tuple(obj, attrs)
|
|
|
|
|
|
def eq(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
if other.__class__ is self.__class__:
|
|
|
return attrs_to_tuple(self) == attrs_to_tuple(other)
|
|
|
else:
|
|
|
return NotImplemented
|
|
|
|
|
|
def ne(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
result = eq(self, other)
|
|
|
if result is NotImplemented:
|
|
|
return NotImplemented
|
|
|
else:
|
|
|
return not result
|
|
|
|
|
|
def lt(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
if isinstance(other, self.__class__):
|
|
|
return attrs_to_tuple(self) < attrs_to_tuple(other)
|
|
|
else:
|
|
|
return NotImplemented
|
|
|
|
|
|
def le(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
if isinstance(other, self.__class__):
|
|
|
return attrs_to_tuple(self) <= attrs_to_tuple(other)
|
|
|
else:
|
|
|
return NotImplemented
|
|
|
|
|
|
def gt(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
if isinstance(other, self.__class__):
|
|
|
return attrs_to_tuple(self) > attrs_to_tuple(other)
|
|
|
else:
|
|
|
return NotImplemented
|
|
|
|
|
|
def ge(self, other):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
if isinstance(other, self.__class__):
|
|
|
return attrs_to_tuple(self) >= attrs_to_tuple(other)
|
|
|
else:
|
|
|
return NotImplemented
|
|
|
|
|
|
cls.__eq__ = eq
|
|
|
cls.__ne__ = ne
|
|
|
cls.__lt__ = lt
|
|
|
cls.__le__ = le
|
|
|
cls.__gt__ = gt
|
|
|
cls.__ge__ = ge
|
|
|
|
|
|
return cls
|
|
|
|
|
|
|
|
|
def _add_repr(cls, ns=None, attrs=None):
|
|
|
"""
|
|
|
Add a repr method to *cls*.
|
|
|
"""
|
|
|
if attrs is None:
|
|
|
attrs = [a for a in cls.__attrs_attrs__ if a.repr]
|
|
|
|
|
|
def repr_(self):
|
|
|
"""
|
|
|
Automatically created by attrs.
|
|
|
"""
|
|
|
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__
|
|
|
|
|
|
return "{0}({1})".format(
|
|
|
class_name,
|
|
|
", ".join(a.name + "=" + repr(getattr(self, a.name))
|
|
|
for a in attrs)
|
|
|
)
|
|
|
cls.__repr__ = repr_
|
|
|
return cls
|
|
|
|
|
|
|
|
|
def _add_init(cls, frozen):
|
|
|
"""
|
|
|
Add a __init__ method to *cls*. If *frozen* is True, make it immutable.
|
|
|
"""
|
|
|
attrs = [a for a in cls.__attrs_attrs__
|
|
|
if a.init or a.default is not NOTHING]
|
|
|
|
|
|
# We cache the generated init methods for the same kinds of attributes.
|
|
|
sha1 = hashlib.sha1()
|
|
|
sha1.update(repr(attrs).encode("utf-8"))
|
|
|
unique_filename = "<attrs generated init {0}>".format(
|
|
|
sha1.hexdigest()
|
|
|
)
|
|
|
|
|
|
script, globs = _attrs_to_script(
|
|
|
attrs,
|
|
|
frozen,
|
|
|
getattr(cls, "__attrs_post_init__", False),
|
|
|
)
|
|
|
locs = {}
|
|
|
bytecode = compile(script, unique_filename, "exec")
|
|
|
attr_dict = dict((a.name, a) for a in attrs)
|
|
|
globs.update({
|
|
|
"NOTHING": NOTHING,
|
|
|
"attr_dict": attr_dict,
|
|
|
})
|
|
|
if frozen is True:
|
|
|
# Save the lookup overhead in __init__ if we need to circumvent
|
|
|
# immutability.
|
|
|
globs["_cached_setattr"] = _obj_setattr
|
|
|
eval(bytecode, globs, locs)
|
|
|
init = locs["__init__"]
|
|
|
|
|
|
# In order of debuggers like PDB being able to step through the code,
|
|
|
# we add a fake linecache entry.
|
|
|
linecache.cache[unique_filename] = (
|
|
|
len(script),
|
|
|
None,
|
|
|
script.splitlines(True),
|
|
|
unique_filename
|
|
|
)
|
|
|
cls.__init__ = init
|
|
|
return cls
|
|
|
|
|
|
|
|
|
def _add_pickle(cls):
|
|
|
"""
|
|
|
Add pickle helpers, needed for frozen and slotted classes
|
|
|
"""
|
|
|
def _slots_getstate__(obj):
|
|
|
"""
|
|
|
Play nice with pickle.
|
|
|
"""
|
|
|
return tuple(getattr(obj, a.name) for a in fields(obj.__class__))
|
|
|
|
|
|
def _slots_setstate__(obj, state):
|
|
|
"""
|
|
|
Play nice with pickle.
|
|
|
"""
|
|
|
__bound_setattr = _obj_setattr.__get__(obj, Attribute)
|
|
|
for a, value in zip(fields(obj.__class__), state):
|
|
|
__bound_setattr(a.name, value)
|
|
|
|
|
|
cls.__getstate__ = _slots_getstate__
|
|
|
cls.__setstate__ = _slots_setstate__
|
|
|
return cls
|
|
|
|
|
|
|
|
|
def fields(cls):
|
|
|
"""
|
|
|
Returns the tuple of ``attrs`` attributes for a class.
|
|
|
|
|
|
The tuple also allows accessing the fields by their names (see below for
|
|
|
examples).
|
|
|
|
|
|
:param type cls: Class to introspect.
|
|
|
|
|
|
:raise TypeError: If *cls* is not a class.
|
|
|
:raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
|
|
|
class.
|
|
|
|
|
|
:rtype: tuple (with name accesors) of :class:`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 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 _attrs_to_script(attrs, frozen, post_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 frozen is True:
|
|
|
lines.append(
|
|
|
# Circumvent the __setattr__ descriptor to save one lookup per
|
|
|
# assignment.
|
|
|
"_setattr = _cached_setattr.__get__(self, self.__class__)"
|
|
|
)
|
|
|
|
|
|
def fmt_setter(attr_name, value_var):
|
|
|
return "_setattr('%(attr_name)s', %(value_var)s)" % {
|
|
|
"attr_name": attr_name,
|
|
|
"value_var": value_var,
|
|
|
}
|
|
|
|
|
|
def fmt_setter_with_converter(attr_name, value_var):
|
|
|
conv_name = _init_convert_pat.format(attr_name)
|
|
|
return "_setattr('%(attr_name)s', %(conv)s(%(value_var)s))" % {
|
|
|
"attr_name": attr_name,
|
|
|
"value_var": value_var,
|
|
|
"conv": conv_name,
|
|
|
}
|
|
|
else:
|
|
|
def fmt_setter(attr_name, value):
|
|
|
return "self.%(attr_name)s = %(value)s" % {
|
|
|
"attr_name": attr_name,
|
|
|
"value": value,
|
|
|
}
|
|
|
|
|
|
def fmt_setter_with_converter(attr_name, value_var):
|
|
|
conv_name = _init_convert_pat.format(attr_name)
|
|
|
return "self.%(attr_name)s = %(conv)s(%(value_var)s)" % {
|
|
|
"attr_name": attr_name,
|
|
|
"value_var": value_var,
|
|
|
"conv": conv_name,
|
|
|
}
|
|
|
|
|
|
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 = {}
|
|
|
|
|
|
for a in attrs:
|
|
|
if a.validator:
|
|
|
attrs_to_validate.append(a)
|
|
|
attr_name = a.name
|
|
|
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.convert is not None:
|
|
|
lines.append(fmt_setter_with_converter(
|
|
|
attr_name,
|
|
|
init_factory_name + "({0})".format(maybe_self)))
|
|
|
conv_name = _init_convert_pat.format(a.name)
|
|
|
names_for_globals[conv_name] = a.convert
|
|
|
else:
|
|
|
lines.append(fmt_setter(
|
|
|
attr_name,
|
|
|
init_factory_name + "({0})".format(maybe_self)
|
|
|
))
|
|
|
names_for_globals[init_factory_name] = a.default.factory
|
|
|
else:
|
|
|
if a.convert is not None:
|
|
|
lines.append(fmt_setter_with_converter(
|
|
|
attr_name,
|
|
|
"attr_dict['{attr_name}'].default"
|
|
|
.format(attr_name=attr_name)
|
|
|
))
|
|
|
conv_name = _init_convert_pat.format(a.name)
|
|
|
names_for_globals[conv_name] = a.convert
|
|
|
else:
|
|
|
lines.append(fmt_setter(
|
|
|
attr_name,
|
|
|
"attr_dict['{attr_name}'].default"
|
|
|
.format(attr_name=attr_name)
|
|
|
))
|
|
|
elif a.default is not NOTHING and not has_factory:
|
|
|
args.append(
|
|
|
"{arg_name}=attr_dict['{attr_name}'].default".format(
|
|
|
arg_name=arg_name,
|
|
|
attr_name=attr_name,
|
|
|
)
|
|
|
)
|
|
|
if a.convert is not None:
|
|
|
lines.append(fmt_setter_with_converter(attr_name, arg_name))
|
|
|
names_for_globals[_init_convert_pat.format(a.name)] = a.convert
|
|
|
else:
|
|
|
lines.append(fmt_setter(attr_name, arg_name))
|
|
|
elif has_factory:
|
|
|
args.append("{arg_name}=NOTHING".format(arg_name=arg_name))
|
|
|
lines.append("if {arg_name} is not NOTHING:"
|
|
|
.format(arg_name=arg_name))
|
|
|
init_factory_name = _init_factory_pat.format(a.name)
|
|
|
if a.convert is not None:
|
|
|
lines.append(" " + fmt_setter_with_converter(attr_name,
|
|
|
arg_name))
|
|
|
lines.append("else:")
|
|
|
lines.append(" " + fmt_setter_with_converter(
|
|
|
attr_name,
|
|
|
init_factory_name + "({0})".format(maybe_self)
|
|
|
))
|
|
|
names_for_globals[_init_convert_pat.format(a.name)] = a.convert
|
|
|
else:
|
|
|
lines.append(" " + fmt_setter(attr_name, arg_name))
|
|
|
lines.append("else:")
|
|
|
lines.append(" " + fmt_setter(
|
|
|
attr_name,
|
|
|
init_factory_name + "({0})".format(maybe_self)
|
|
|
))
|
|
|
names_for_globals[init_factory_name] = a.default.factory
|
|
|
else:
|
|
|
args.append(arg_name)
|
|
|
if a.convert is not None:
|
|
|
lines.append(fmt_setter_with_converter(attr_name, arg_name))
|
|
|
names_for_globals[_init_convert_pat.format(a.name)] = a.convert
|
|
|
else:
|
|
|
lines.append(fmt_setter(attr_name, arg_name))
|
|
|
|
|
|
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_{}".format(a.name)
|
|
|
attr_name = "__attr_{}".format(a.name)
|
|
|
lines.append(" {}(self, {}, self.{})".format(
|
|
|
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__()")
|
|
|
|
|
|
return """\
|
|
|
def __init__(self, {args}):
|
|
|
{lines}
|
|
|
""".format(
|
|
|
args=", ".join(args),
|
|
|
lines="\n ".join(lines) if lines else "pass",
|
|
|
), names_for_globals
|
|
|
|
|
|
|
|
|
class Attribute(object):
|
|
|
"""
|
|
|
*Read-only* representation of an attribute.
|
|
|
|
|
|
:attribute name: The name of the attribute.
|
|
|
|
|
|
Plus *all* arguments of :func:`attr.ib`.
|
|
|
"""
|
|
|
__slots__ = (
|
|
|
"name", "default", "validator", "repr", "cmp", "hash", "init",
|
|
|
"convert", "metadata",
|
|
|
)
|
|
|
|
|
|
def __init__(self, name, default, validator, repr, cmp, hash, init,
|
|
|
convert=None, metadata=None):
|
|
|
# Cache this descriptor here to speed things up later.
|
|
|
bound_setattr = _obj_setattr.__get__(self, Attribute)
|
|
|
|
|
|
bound_setattr("name", name)
|
|
|
bound_setattr("default", default)
|
|
|
bound_setattr("validator", validator)
|
|
|
bound_setattr("repr", repr)
|
|
|
bound_setattr("cmp", cmp)
|
|
|
bound_setattr("hash", hash)
|
|
|
bound_setattr("init", init)
|
|
|
bound_setattr("convert", convert)
|
|
|
bound_setattr("metadata", (metadata_proxy(metadata) if metadata
|
|
|
else _empty_metadata_singleton))
|
|
|
|
|
|
def __setattr__(self, name, value):
|
|
|
raise FrozenInstanceError()
|
|
|
|
|
|
@classmethod
|
|
|
def from_counting_attr(cls, name, ca):
|
|
|
inst_dict = {
|
|
|
k: getattr(ca, k)
|
|
|
for k
|
|
|
in Attribute.__slots__
|
|
|
if k not in (
|
|
|
"name", "validator", "default",
|
|
|
) # exclude methods
|
|
|
}
|
|
|
return cls(name=name, validator=ca._validator, default=ca._default,
|
|
|
**inst_dict)
|
|
|
|
|
|
# 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.
|
|
|
"""
|
|
|
bound_setattr = _obj_setattr.__get__(self, Attribute)
|
|
|
for name, value in zip(self.__slots__, state):
|
|
|
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=True, hash=(name != "metadata"), init=True)
|
|
|
for name in Attribute.__slots__]
|
|
|
|
|
|
Attribute = _add_hash(
|
|
|
_add_cmp(_add_repr(Attribute, attrs=_a), attrs=_a),
|
|
|
attrs=[a for a in _a if a.hash]
|
|
|
)
|
|
|
|
|
|
|
|
|
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", "cmp", "hash", "init",
|
|
|
"metadata", "_validator", "convert")
|
|
|
__attrs_attrs__ = tuple(
|
|
|
Attribute(name=name, default=NOTHING, validator=None,
|
|
|
repr=True, cmp=True, hash=True, init=True)
|
|
|
for name
|
|
|
in ("counter", "_default", "repr", "cmp", "hash", "init",)
|
|
|
) + (
|
|
|
Attribute(name="metadata", default=None, validator=None,
|
|
|
repr=True, cmp=True, hash=False, init=True),
|
|
|
)
|
|
|
cls_counter = 0
|
|
|
|
|
|
def __init__(self, default, validator, repr, cmp, hash, init, convert,
|
|
|
metadata):
|
|
|
_CountingAttr.cls_counter += 1
|
|
|
self.counter = _CountingAttr.cls_counter
|
|
|
self._default = default
|
|
|
# If validator is a list/tuple, wrap it using helper validator.
|
|
|
if validator and isinstance(validator, (list, tuple)):
|
|
|
self._validator = and_(*validator)
|
|
|
else:
|
|
|
self._validator = validator
|
|
|
self.repr = repr
|
|
|
self.cmp = cmp
|
|
|
self.hash = hash
|
|
|
self.init = init
|
|
|
self.convert = convert
|
|
|
self.metadata = metadata
|
|
|
|
|
|
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_cmp(_add_repr(_CountingAttr))
|
|
|
|
|
|
|
|
|
@attributes(slots=True, init=False)
|
|
|
class Factory(object):
|
|
|
"""
|
|
|
Stores a factory callable.
|
|
|
|
|
|
If passed as the default value to :func:`attr.ib`, the factory is used to
|
|
|
generate a new value.
|
|
|
|
|
|
:param callable factory: A callable that takes either none or exactly one
|
|
|
mandatory positional argument depending on *takes_self*.
|
|
|
:param bool takes_self: Pass the partially initialized instance that is
|
|
|
being initialized as a positional argument.
|
|
|
|
|
|
.. versionadded:: 17.1.0 *takes_self*
|
|
|
"""
|
|
|
factory = attr()
|
|
|
takes_self = attr()
|
|
|
|
|
|
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 make_class(name, attrs, bases=(object,), **attributes_arguments):
|
|
|
"""
|
|
|
A quick way to create a new class called *name* with *attrs*.
|
|
|
|
|
|
:param name: The name for the new class.
|
|
|
:type name: str
|
|
|
|
|
|
:param attrs: A list of names or a dictionary of mappings of names to
|
|
|
attributes.
|
|
|
:type attrs: :class:`list` or :class:`dict`
|
|
|
|
|
|
:param tuple bases: Classes that the new class will subclass.
|
|
|
|
|
|
:param attributes_arguments: Passed unmodified to :func:`attr.s`.
|
|
|
|
|
|
:return: A new class with *attrs*.
|
|
|
:rtype: type
|
|
|
|
|
|
.. versionadded:: 17.1.0 *bases*
|
|
|
"""
|
|
|
if isinstance(attrs, dict):
|
|
|
cls_dict = attrs
|
|
|
elif isinstance(attrs, (list, tuple)):
|
|
|
cls_dict = dict((a, attr()) for a in attrs)
|
|
|
else:
|
|
|
raise TypeError("attrs argument must be a dict or a list.")
|
|
|
|
|
|
return attributes(**attributes_arguments)(type(name, bases, cls_dict))
|
|
|
|
|
|
|
|
|
# These are required by whithin this module so we define them here and merely
|
|
|
# import into .validators.
|
|
|
|
|
|
|
|
|
@attributes(slots=True, hash=True)
|
|
|
class _AndValidator(object):
|
|
|
"""
|
|
|
Compose many validators to a single one.
|
|
|
"""
|
|
|
_validators = attr()
|
|
|
|
|
|
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 validators: Arbitrary number of validators.
|
|
|
:type validators: callables
|
|
|
|
|
|
.. versionadded:: 17.1.0
|
|
|
"""
|
|
|
vals = []
|
|
|
for validator in validators:
|
|
|
vals.extend(
|
|
|
validator._validators if isinstance(validator, _AndValidator)
|
|
|
else [validator]
|
|
|
)
|
|
|
|
|
|
return _AndValidator(tuple(vals))
|
|
|
|
