# SPDX-License-Identifier: MIT

import copy

import sys

import types

import typing

# We need to import _compat itself in addition to the _compat members to avoid

# having the thread-local in the globals here.

from . import _compat, _config, setters

from ._compat import (

    HAS_F_STRINGS,

    PY310,

    PYPY,

    _AnnotationExtractor,

    ordered_dict,

    set_closure_cell,

)

    UnannotatedAttributeError,

_init_converter_pat = "__attr_converter_%s"

_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 = types.MappingProxyType({})

# Unique object for unequivocal getattr() defaults.

_sentinel = object()

_ng_default_on_setattr = setters.pipe(setters.convert, setters.validate)

class _Nothing:

    ``_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().__new__(cls)

        return _Nothing._singleton

    def __bool__(self):

        return False

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.

    """

    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,

):

    """

        `attr.s`!

        If the value is an instance of `attrs.Factory`, its callable will be

        used to construct a new value (useful for mutable data types like lists

        If a default is not set (or set manually to `attrs.NOTHING`), a value

        *must* be supplied when instantiating; otherwise a `TypeError`

    :type default: Any value

    :param callable factory: Syntactic sugar for

        ``default=attr.Factory(factory)``.

    :param validator: `callable` that is called by ``attrs``-generated

        receive the initialized instance, the :func:`~attrs.Attribute`, and the

        If a `list` is passed, its items are treated as validators and must

        `get_run_validators`.

    :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 callable converter: `callable` that is called by

        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`).

        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 `attrs.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

        `attrs.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 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)

        cmp=None,

        converter=converter,

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

    """

    Create the method with the script given and return the method object.

    """

    locs = {}

    # In order of debuggers like PDB being able to step through the code,

    # we add a fake linecache entry.

    count = 1

    base_filename = filename

    while True:

        linecache_tuple = (

            len(script),

            None,

            script.splitlines(True),

            filename,

        )

        old_val = linecache.cache.setdefault(filename, linecache_tuple)

        if old_val == linecache_tuple:

            break

        else:

            filename = "{}-{}>".format(base_filename[:-1], count)

            count += 1

    _compile_and_eval(script, globs, locs, filename)

    return locs[name]

            attr_class_template.append(

                _tuple_property_pat.format(index=i, attr_name=attr_name)

            )

    globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property}

    _compile_and_eval("\n".join(attr_class_template), globs)

# 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.

    *collect_by_mro* is True, collect them in the correct MRO order, otherwise

    use the old -- incorrect -- order.  See #428.

    Return an `_Attributes`.