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={}):

    r"""

    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):