# SPDX-License-Identifier: MIT

from ._make import NOTHING, _obj_setattr, fields

def asdict(

    inst,

    recurse=True,

    filter=None,

    dict_factory=dict,

    retain_collection_types=False,

    value_serializer=None,

):

    :param callable filter: A callable whose return code determines whether an

        called with the `attrs.Attribute` as the first argument and the

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

    ..  versionadded:: 20.3.0 *value_serializer*

    ..  versionadded:: 21.3.0 If a dict has a collection for a key, it is

        serialized as a tuple.

        if value_serializer is not None:

            v = value_serializer(inst, a, v)

                rv[a.name] = asdict(

                    v,

                    recurse=True,

                    filter=filter,

                    dict_factory=dict_factory,

                    retain_collection_types=retain_collection_types,

                    value_serializer=value_serializer,

                )

            elif isinstance(v, (tuple, list, set, frozenset)):

                rv[a.name] = cf(

                    [

                        _asdict_anything(

                            i,

                            is_key=False,

                            filter=filter,

                            dict_factory=dict_factory,

                            retain_collection_types=retain_collection_types,

                            value_serializer=value_serializer,

                        )

                        for i in v

                    ]

                )

                rv[a.name] = df(

                    (

                        _asdict_anything(

                            kk,

                            is_key=True,

                            filter=filter,

                            dict_factory=df,

                            retain_collection_types=retain_collection_types,

                            value_serializer=value_serializer,

                        ),

                        _asdict_anything(

                            vv,

                            is_key=False,

                            filter=filter,

                            dict_factory=df,

                            retain_collection_types=retain_collection_types,

                            value_serializer=value_serializer,

                        ),

                    )

                    for kk, vv in v.items()

                )

def _asdict_anything(

    val,

    is_key,

    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,

            recurse=True,

            filter=filter,

            dict_factory=dict_factory,

            retain_collection_types=retain_collection_types,

            value_serializer=value_serializer,

        )

    elif isinstance(val, (tuple, list, set, frozenset)):

        if retain_collection_types is True:

            cf = val.__class__

        elif is_key:

            cf = tuple

        else:

            cf = list

        rv = cf(

            [

                _asdict_anything(

                    i,

                    is_key=False,

                    filter=filter,

                    dict_factory=dict_factory,

                    retain_collection_types=retain_collection_types,

                    value_serializer=value_serializer,

                )

                for i in val

            ]

        )

    elif isinstance(val, dict):

        df = dict_factory

        rv = df(

            (

                _asdict_anything(

                    kk,

                    is_key=True,

                    filter=filter,

                    dict_factory=df,

                    retain_collection_types=retain_collection_types,

                    value_serializer=value_serializer,

                ),

                _asdict_anything(

                    vv,

                    is_key=False,

                    filter=filter,

                    dict_factory=df,

                    retain_collection_types=retain_collection_types,

                    value_serializer=value_serializer,

                ),

            )

            for kk, vv in val.items()

        )

    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,

):

        called with the `attrs.Attribute` as the first argument and the

                rv.append(

                    astuple(

                        v,

                        recurse=True,

                        filter=filter,

                        tuple_factory=tuple_factory,

                        retain_collection_types=retain,

                    )

                )

            elif isinstance(v, (tuple, list, set, frozenset)):

                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

                        ]

                    )

                )

                rv.append(

                    df(

                                retain_collection_types=retain,

                            )

                            if has(kk.__class__)

                            else kk,

                                retain_collection_types=retain,

                            )

                            if has(vv.__class__)

                            else vv,

                        for kk, vv in v.items()

                    )

                )

    :rtype: bool

        Use `attrs.evolve` instead if you can.

        This function will not be removed du to the slightly different approach

        compared to `attrs.evolve`.

    warnings.warn(

        "assoc is deprecated and will be removed after 2018/01.",

        DeprecationWarning,

        stacklevel=2,

    )

    for k, v in changes.items():

                "{k} is not an attrs attribute on {cl}.".format(

                    k=k, cl=new.__class__

                )

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** `attrs.define`. That

        means the decorator has to come in the line **before** `attrs.define`.

    ..  versionadded:: 20.1.0

    ..  versionadded:: 21.1.0 *attribs*

    """

    # Since calling get_type_hints is expensive we cache whether we've

    # done it already.

    if getattr(cls, "__attrs_types_resolved__", None) != cls:

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

        # We store the class we resolved so that subclasses know they haven't

        # been resolved.

        cls.__attrs_types_resolved__ = cls

    # Return the class so you can use it as a decorator too.

    return cls