# Source code for cattrs.converters

    from collections import Counter
    from collections.abc import MutableSet as AbcMutableSet
    from dataclasses import Field
    from enum import Enum
    from functools import lru_cache
    from typing import (
        Any,
        Callable,
        Dict,
        Iterable,
        List,
        NoReturn,
        Optional,
        Tuple,
        Type,
        TypeVar,
        Union,
    )

    from attr import Attribute
    from attr import has as attrs_has
    from attr import resolve_types

    from cattrs.errors import IterableValidationError, StructureHandlerNotFoundError

    from ._compat import (
        FrozenSetSubscriptable,
        Mapping,
        MutableMapping,
        MutableSequence,
        OriginAbstractSet,
        OriginMutableSet,
        Sequence,
        Set,
        fields,
        get_newtype_base,
        get_origin,
        has,
        has_with_generic,
        is_annotated,
        is_bare,
        is_counter,
        is_frozenset,
        is_generic,
        is_generic_attrs,
        is_hetero_tuple,
        is_literal,
        is_mapping,
        is_mutable_set,
        is_protocol,
        is_sequence,
        is_tuple,
        is_union_type,
    )
    from .disambiguators import create_uniq_field_dis_func
    from .dispatch import MultiStrategyDispatch
    from .gen import (
        AttributeOverride,
        DictStructureFn,
        HeteroTupleUnstructureFn,
        IterableUnstructureFn,
        MappingStructureFn,
        MappingUnstructureFn,
        make_dict_structure_fn,
        make_dict_unstructure_fn,
        make_hetero_tuple_unstructure_fn,
        make_iterable_unstructure_fn,
        make_mapping_structure_fn,
        make_mapping_unstructure_fn,
    )

    NoneType = type(None)
    T = TypeVar("T")
    V = TypeVar("V")

    class UnstructureStrategy(Enum):
        """`attrs` classes unstructuring strategies."""

        AS_DICT = "asdict"
        AS_TUPLE = "astuple"

    def _subclass(typ: Type) -> Callable[[Type], bool]:
        """a shortcut"""
        return lambda cls: issubclass(cls, typ)

    def is_attrs_union(typ: Type) -> bool:
        return is_union_type(typ) and all(has(get_origin(e) or e) for e in typ.__args__)

    def is_attrs_union_or_none(typ: Type) -> bool:
        return is_union_type(typ) and all(
            e is NoneType or has(get_origin(e) or e) for e in typ.__args__
        )

    def is_optional(typ: Type) -> bool:
        return is_union_type(typ) and NoneType in typ.__args__ and len(typ.__args__) == 2

    def is_literal_containing_enums(typ: Type) -> bool:
        return is_literal(typ) and any(isinstance(val, Enum) for val in typ.__args__)

    class BaseConverter:
        """Converts between structured and unstructured data."""

        __slots__ = (
            "_dis_func_cache",
            "_unstructure_func",
            "_unstructure_attrs",
            "_structure_attrs",
            "_dict_factory",
            "_union_struct_registry",
            "_structure_func",
            "_prefer_attrib_converters",
            "detailed_validation",
        )

        def __init__(
            self,
            dict_factory: Callable[[], Any] = dict,
            unstruct_strat: UnstructureStrategy = UnstructureStrategy.AS_DICT,
            prefer_attrib_converters: bool = False,
            detailed_validation: bool = True,
        ) -> None:
            unstruct_strat = UnstructureStrategy(unstruct_strat)
            self._prefer_attrib_converters = prefer_attrib_converters

            self.detailed_validation = detailed_validation

            # Create a per-instance cache.
            if unstruct_strat is UnstructureStrategy.AS_DICT:
                self._unstructure_attrs = self.unstructure_attrs_asdict
                self._structure_attrs = self.structure_attrs_fromdict
            else:
                self._unstructure_attrs = self.unstructure_attrs_astuple
                self._structure_attrs = self.structure_attrs_fromtuple

            self._dis_func_cache = lru_cache()(self._get_dis_func)

            self._unstructure_func = MultiStrategyDispatch(self._unstructure_identity)
            self._unstructure_func.register_cls_list(
                [(bytes, self._unstructure_identity), (str, self._unstructure_identity)]
            )
            self._unstructure_func.register_func_list(
                [
                    (
                        is_protocol,
                        lambda o: self.unstructure(o, unstructure_as=o.__class__),
                    ),
                    (is_mapping, self._unstructure_mapping),
                    (is_sequence, self._unstructure_seq),
                    (is_mutable_set, self._unstructure_seq),
                    (is_frozenset, self._unstructure_seq),
                    (_subclass(Enum), self._unstructure_enum),
                    (has, self._unstructure_attrs),
                    (is_union_type, self._unstructure_union),
                ]
            )

            # Per-instance register of to-attrs converters.
            # Singledispatch dispatches based on the first argument, so we
            # store the function and switch the arguments in self.loads.
            self._structure_func = MultiStrategyDispatch(BaseConverter._structure_error)
            self._structure_func.register_func_list(
                [
                    (lambda cl: cl is Any or cl is Optional or cl is None, lambda v, _: v),
                    (is_generic_attrs, self._gen_structure_generic, True),
                    (lambda t: get_newtype_base(t) is not None, self._structure_newtype),
                    (is_literal, self._structure_simple_literal),
                    (is_literal_containing_enums, self._structure_enum_literal),
                    (is_sequence, self._structure_list),
                    (is_mutable_set, self._structure_set),
                    (is_frozenset, self._structure_frozenset),
                    (is_tuple, self._structure_tuple),
                    (is_mapping, self._structure_dict),
                    (is_attrs_union_or_none, self._gen_attrs_union_structure, True),
                    (
                        lambda t: is_union_type(t) and t in self._union_struct_registry,
                        self._structure_union,
                    ),
                    (is_optional, self._structure_optional),
                    (has, self._structure_attrs),
                ]
            )
            # Strings are sequences.
            self._structure_func.register_cls_list(
                [
                    (str, self._structure_call),
                    (bytes, self._structure_call),
                    (int, self._structure_call),
                    (float, self._structure_call),
                    (Enum, self._structure_call),
                ]
            )

            self._dict_factory = dict_factory

            # Unions are instances now, not classes. We use different registries.
            self._union_struct_registry: Dict[Any, Callable[[Any, Type[T]], T]] = {}

        def unstructure(self, obj: Any, unstructure_as: Any = None) -> Any:
            return self._unstructure_func.dispatch(
                obj.__class__ if unstructure_as is None else unstructure_as
            )(obj)

        @property
        def unstruct_strat(self) -> UnstructureStrategy:
            """The default way of unstructuring ``attrs`` classes."""
            return (
                UnstructureStrategy.AS_DICT
                if self._unstructure_attrs == self.unstructure_attrs_asdict
                else UnstructureStrategy.AS_TUPLE
            )

        def register_unstructure_hook(self, cls: Any, func: Callable[[Any], Any]) -> None:
            """Register a class-to-primitive converter function for a class.

            The converter function should take an instance of the class and return
            its Python equivalent.
            """
            if attrs_has(cls):
                resolve_types(cls)
            if is_union_type(cls):
                self._unstructure_func.register_func_list([(lambda t: t == cls, func)])
            elif get_newtype_base(cls) is not None:
                # This is a newtype, so we handle it specially.
                self._unstructure_func.register_func_list([(lambda t: t is cls, func)])
            else:
                self._unstructure_func.register_cls_list([(cls, func)])

        def register_unstructure_hook_func(
            self, check_func: Callable[[Any], bool], func: Callable[[Any], Any]
        ) -> None:
            """Register a class-to-primitive converter function for a class, using
            a function to check if it's a match.
            """
            self._unstructure_func.register_func_list([(check_func, func)])

        def register_unstructure_hook_factory(
            self,
            predicate: Callable[[Any], bool],
            factory: Callable[[Any], Callable[[Any], Any]],
        ) -> None:
            """
            Register a hook factory for a given predicate.

            A predicate is a function that, given a type, returns whether the factory
            can produce a hook for that type.

            A factory is a callable that, given a type, produces an unstructuring
            hook for that type. This unstructuring hook will be cached.
            """
            self._unstructure_func.register_func_list([(predicate, factory, True)])

        def register_structure_hook(
            self, cl: Any, func: Callable[[Any, Type[T]], T]
        ) -> None:
            """Register a primitive-to-class converter function for a type.

            The converter function should take two arguments:
              * a Python object to be converted,
              * the type to convert to

            and return the instance of the class. The type may seem redundant, but
            is sometimes needed (for example, when dealing with generic classes).
            """
            if attrs_has(cl):
                resolve_types(cl)
            if is_union_type(cl):
                self._union_struct_registry[cl] = func
                self._structure_func.clear_cache()
            elif get_newtype_base(cl) is not None:
                # This is a newtype, so we handle it specially.
                self._structure_func.register_func_list([(lambda t: t is cl, func)])
            else:
                self._structure_func.register_cls_list([(cl, func)])

        def register_structure_hook_func(
            self, check_func: Callable[[Type[T]], bool], func: Callable[[Any, Type[T]], T]
        ) -> None:
            """Register a class-to-primitive converter function for a class, using
            a function to check if it's a match.
            """
            self._structure_func.register_func_list([(check_func, func)])

        def register_structure_hook_factory(
            self,
            predicate: Callable[[Any], bool],
            factory: Callable[[Any], Callable[[Any, Any], Any]],
        ) -> None:
            """
            Register a hook factory for a given predicate.

            A predicate is a function that, given a type, returns whether the factory
            can produce a hook for that type.

            A factory is a callable that, given a type, produces a structuring
            hook for that type. This structuring hook will be cached.
            """
            self._structure_func.register_func_list([(predicate, factory, True)])

        def structure(self, obj: Any, cl: Type[T]) -> T:
            """Convert unstructured Python data structures to structured data."""

            return self._structure_func.dispatch(cl)(obj, cl)

        # Classes to Python primitives.

        def unstructure_attrs_asdict(self, obj: Any) -> Dict[str, Any]:
            """Our version of `attrs.asdict`, so we can call back to us."""
            attrs = fields(obj.__class__)
            dispatch = self._unstructure_func.dispatch
            rv = self._dict_factory()
            for a in attrs:
                name = a.name
                v = getattr(obj, name)
                rv[name] = dispatch(a.type or v.__class__)(v)
            return rv

        def unstructure_attrs_astuple(self, obj: Any) -> Tuple[Any, ...]:
            """Our version of `attrs.astuple`, so we can call back to us."""
            attrs = fields(obj.__class__)
            dispatch = self._unstructure_func.dispatch
            res = list()
            for a in attrs:
                name = a.name
                v = getattr(obj, name)
                res.append(dispatch(a.type or v.__class__)(v))
            return tuple(res)

        def _unstructure_enum(self, obj: Enum) -> Any:
            """Convert an enum to its value."""
            return obj.value

        @staticmethod
        def _unstructure_identity(obj: T) -> T:
            """Just pass it through."""
            return obj

        def _unstructure_seq(self, seq: Sequence[T]) -> Sequence[T]:
            """Convert a sequence to primitive equivalents."""
            # We can reuse the sequence class, so tuples stay tuples.
            dispatch = self._unstructure_func.dispatch
            return seq.__class__(dispatch(e.__class__)(e) for e in seq)

        def _unstructure_mapping(self, mapping: Mapping[T, V]) -> Mapping[T, V]:
            """Convert a mapping of attr classes to primitive equivalents."""

            # We can reuse the mapping class, so dicts stay dicts and OrderedDicts
            # stay OrderedDicts.
            dispatch = self._unstructure_func.dispatch
            return mapping.__class__(
                (dispatch(k.__class__)(k), dispatch(v.__class__)(v))
                for k, v in mapping.items()
            )

        # note: Use UnionType when 3.11 is released as
        # the behaviour of @final is changed. This would
        # affect how we can support UnionType in ._compat.py
        def _unstructure_union(self, obj: Any) -> Any:
            """
            Unstructure an object as a union.

            By default, just unstructures the instance.
            """
            return self._unstructure_func.dispatch(obj.__class__)(obj)

        # Python primitives to classes.

        @staticmethod
        def _structure_error(_, cl: Type) -> NoReturn:
            """At the bottom of the condition stack, we explode if we can't handle it."""
            msg = "Unsupported type: {0!r}. Register a structure hook for " "it.".format(cl)
            raise StructureHandlerNotFoundError(msg, type_=cl)

        def _gen_structure_generic(self, cl: Type[T]) -> DictStructureFn[T]:
            """Create and return a hook for structuring generics."""
            fn = make_dict_structure_fn(
                cl, self, _cattrs_prefer_attrib_converters=self._prefer_attrib_converters
            )
            return fn

        def _gen_attrs_union_structure(
            self, cl: Any
        ) -> Callable[[Any, Type[T]], Optional[Type[T]]]:
            """Generate a structuring function for a union of attrs classes (and maybe None)."""
            dis_fn = self._get_dis_func(cl)
            has_none = NoneType in cl.__args__

            if has_none:

                def structure_attrs_union(obj, _):
                    if obj is None:
                        return None
                    return self.structure(obj, dis_fn(obj))

            else:

                def structure_attrs_union(obj, _):
                    return self.structure(obj, dis_fn(obj))

            return structure_attrs_union

        @staticmethod
        def _structure_call(obj: Any, cl: Type[T]) -> Any:
            """Just call ``cl`` with the given ``obj``.

            This is just an optimization on the ``_structure_default`` case, when
            we know we can skip the ``if`` s. Use for ``str``, ``bytes``, ``enum``,
            etc.
            """
            return cl(obj)

        @staticmethod
        def _structure_simple_literal(val, type):
            if val not in type.__args__:
                raise Exception(f"{val} not in literal {type}")
            return val

        @staticmethod
        def _structure_enum_literal(val, type):
            vals = {(x.value if isinstance(x, Enum) else x): x for x in type.__args__}
            try:
                return vals[val]
            except KeyError:
                raise Exception(f"{val} not in literal {type}") from None

        def _structure_newtype(self, val, type):
            base = get_newtype_base(type)
            return self._structure_func.dispatch(base)(val, base)

        # Attrs classes.

        def structure_attrs_fromtuple(self, obj: Tuple[Any, ...], cl: Type[T]) -> T:
            """Load an attrs class from a sequence (tuple)."""
            conv_obj = []  # A list of converter parameters.
            for a, value in zip(fields(cl), obj):
                # We detect the type by the metadata.
                converted = self._structure_attribute(a, value)
                conv_obj.append(converted)

            return cl(*conv_obj)

        def _structure_attribute(self, a: Union[Attribute, Field], value: Any) -> Any:
            """Handle an individual attrs attribute."""
            type_ = a.type
            attrib_converter = getattr(a, "converter", None)
            if self._prefer_attrib_converters and attrib_converter:
                # A attrib converter is defined on this attribute, and prefer_attrib_converters is set
                # to give these priority over registered structure hooks. So, pass through the raw
                # value, which attrs will flow into the converter
                return value
            if type_ is None:
                # No type metadata.
                return value

            try:
                return self._structure_func.dispatch(type_)(value, type_)
            except StructureHandlerNotFoundError:
                if attrib_converter:
                    # Return the original value and fallback to using an attrib converter.
                    return value
                else:
                    raise

        def structure_attrs_fromdict(self, obj: Mapping[str, Any], cl: Type[T]) -> T:
            """Instantiate an attrs class from a mapping (dict)."""
            # For public use.

            conv_obj = {}  # Start with a fresh dict, to ignore extra keys.
            for a in fields(cl):
                name = a.name

                try:
                    val = obj[name]
                except KeyError:
                    continue

                if name[0] == "_":
                    name = name[1:]

                conv_obj[name] = self._structure_attribute(a, val)

            return cl(**conv_obj)

        def _structure_list(self, obj: Iterable[T], cl: Any) -> List[T]:
            """Convert an iterable to a potentially generic list."""
            if is_bare(cl) or cl.__args__[0] is Any:
                res = [e for e in obj]
            else:
                elem_type = cl.__args__[0]
                handler = self._structure_func.dispatch(elem_type)
                if self.detailed_validation:
                    errors = []
                    res = []
                    ix = 0  # Avoid `enumerate` for performance.
                    for e in obj:
                        try:
                            res.append(handler(e, elem_type))
                        except Exception as e:
                            msg = f"Structuring {cl} @ index {ix}"
                            e.__notes__ = getattr(e, "__notes__", []) + [msg]
                            errors.append(e)
                        finally:
                            ix += 1
                    if errors:
                        raise IterableValidationError(
                            f"While structuring {cl!r}", errors, cl
                        )
                else:
                    res = [handler(e, elem_type) for e in obj]
            return res

        def _structure_set(
            self, obj: Iterable[T], cl: Any, structure_to: type = set
        ) -> Set[T]:
            """Convert an iterable into a potentially generic set."""
            if is_bare(cl) or cl.__args__[0] is Any:
                return structure_to(obj)
            elem_type = cl.__args__[0]
            handler = self._structure_func.dispatch(elem_type)
            if self.detailed_validation:
                errors = []
                res = set()
                for e in obj:
                    try:
                        res.add(handler(e, elem_type))
                    except Exception as exc:
                        msg = f"Structuring {structure_to.__name__} @ element {e!r}"
                        exc.__notes__ = getattr(e, "__notes__", []) + [msg]
                        errors.append(exc)
                if errors:
                    raise IterableValidationError(f"While structuring {cl!r}", errors, cl)
                return res if structure_to is set else structure_to(res)
            elif structure_to is set:
                return {handler(e, elem_type) for e in obj}
            else:
                return structure_to([handler(e, elem_type) for e in obj])

        def _structure_frozenset(
            self, obj: Iterable[T], cl: Any
        ) -> FrozenSetSubscriptable[T]:
            """Convert an iterable into a potentially generic frozenset."""
            return self._structure_set(obj, cl, structure_to=frozenset)

        def _structure_dict(self, obj: Mapping[T, V], cl: Any) -> Dict[T, V]:
            """Convert a mapping into a potentially generic dict."""
            if is_bare(cl) or cl.__args__ == (Any, Any):
                return dict(obj)
            else:
                key_type, val_type = cl.__args__
                if key_type is Any:
                    val_conv = self._structure_func.dispatch(val_type)
                    return {k: val_conv(v, val_type) for k, v in obj.items()}
                elif val_type is Any:
                    key_conv = self._structure_func.dispatch(key_type)
                    return {key_conv(k, key_type): v for k, v in obj.items()}
                else:
                    key_conv = self._structure_func.dispatch(key_type)
                    val_conv = self._structure_func.dispatch(val_type)
                    return {
                        key_conv(k, key_type): val_conv(v, val_type) for k, v in obj.items()
                    }

        def _structure_optional(self, obj, union):
            if obj is None:
                return None
            union_params = union.__args__
            other = union_params[0] if union_params[1] is NoneType else union_params[1]
            # We can't actually have a Union of a Union, so this is safe.
            return self._structure_func.dispatch(other)(obj, other)

        def _structure_union(self, obj, union):
            """Deal with structuring a union."""
            handler = self._union_struct_registry[union]
            return handler(obj, union)

        def _structure_tuple(self, obj: Any, tup: Type[T]) -> T:
            """Deal with structuring into a tuple."""
            if tup in (Tuple, tuple):
                tup_params = None
            else:
                tup_params = tup.__args__
            has_ellipsis = tup_params and tup_params[-1] is Ellipsis
            if tup_params is None or (has_ellipsis and tup_params[0] is Any):
                # Just a Tuple. (No generic information.)
                return tuple(obj)
            if has_ellipsis:
                # We're dealing with a homogenous tuple, Tuple[int, ...]
                tup_type = tup_params[0]
                conv = self._structure_func.dispatch(tup_type)
                if self.detailed_validation:
                    errors = []
                    res = []
                    for ix, e in enumerate(obj):
                        try:
                            res.append(conv(e, tup_type))
                        except Exception as exc:
                            msg = f"Structuring {tup} @ index {ix}"
                            exc.__notes__ = getattr(e, "__notes__", []) + [msg]
                            errors.append(exc)
                    if errors:
                        raise IterableValidationError(
                            f"While structuring {tup!r}", errors, tup
                        )
                    return tuple(res)
                else:
                    return tuple(conv(e, tup_type) for e in obj)
            else:
                # We're dealing with a heterogenous tuple.
                exp_len = len(tup_params)
                try:
                    len_obj = len(obj)
                except TypeError:
                    pass  # most likely an unsized iterator, eg generator
                else:
                    if len_obj > exp_len:
                        exp_len = len_obj
                if self.detailed_validation:
                    errors = []
                    res = []
                    for ix, (t, e) in enumerate(zip(tup_params, obj)):
                        try:
                            conv = self._structure_func.dispatch(t)
                            res.append(conv(e, t))
                        except Exception as exc:
                            msg = f"Structuring {tup} @ index {ix}"
                            exc.__notes__ = getattr(e, "__notes__", []) + [msg]
                            errors.append(exc)
                    if len(res) < exp_len:
                        problem = "Not enough" if len(res) < len(tup_params) else "Too many"
                        exc = ValueError(
                            f"{problem} values in {obj!r} to structure as {tup!r}"
                        )
                        msg = f"Structuring {tup}"
                        exc.__notes__ = getattr(e, "__notes__", []) + [msg]
                        errors.append(exc)
                    if errors:
                        raise IterableValidationError(
                            f"While structuring {tup!r}", errors, tup
                        )
                    return tuple(res)
                else:
                    res = tuple(
                        [
                            self._structure_func.dispatch(t)(e, t)
                            for t, e in zip(tup_params, obj)
                        ]
                    )
                    if len(res) < exp_len:
                        problem = "Not enough" if len(res) < len(tup_params) else "Too many"
                        raise ValueError(
                            f"{problem} values in {obj!r} to structure as {tup!r}"
                        )
                    return res

        @staticmethod
        def _get_dis_func(union) -> Callable[..., Type]:
            """Fetch or try creating a disambiguation function for a union."""
            union_types = union.__args__
            if NoneType in union_types:  # type: ignore
                # We support unions of attrs classes and NoneType higher in the
                # logic.
                union_types = tuple(
                    e for e in union_types if e is not NoneType  # type: ignore
                )

            if not all(has(get_origin(e) or e) for e in union_types):
                raise StructureHandlerNotFoundError(
                    "Only unions of attrs classes supported "
                    "currently. Register a loads hook manually.",
                    type_=union,
                )
            return create_uniq_field_dis_func(*union_types)

        def __deepcopy__(self, _) -> "BaseConverter":
            return self.copy()

        def copy(
            self,
            dict_factory: Optional[Callable[[], Any]] = None,
            unstruct_strat: Optional[UnstructureStrategy] = None,
            prefer_attrib_converters: Optional[bool] = None,
            detailed_validation: Optional[bool] = None,
        ) -> "BaseConverter":
            res = self.__class__(
                dict_factory if dict_factory is not None else self._dict_factory,
                unstruct_strat
                if unstruct_strat is not None
                else (
                    UnstructureStrategy.AS_DICT
                    if self._unstructure_attrs == self.unstructure_attrs_asdict
                    else UnstructureStrategy.AS_TUPLE
                ),
                prefer_attrib_converters
                if prefer_attrib_converters is not None
                else self._prefer_attrib_converters,
                detailed_validation
                if detailed_validation is not None
                else self.detailed_validation,
            )

            self._unstructure_func.copy_to(res._unstructure_func)
            self._structure_func.copy_to(res._structure_func)

            return res

    class Converter(BaseConverter):
        """A converter which generates specialized un/structuring functions."""

        __slots__ = (
            "omit_if_default",
            "forbid_extra_keys",
            "type_overrides",
            "_unstruct_collection_overrides",
            "_struct_copy_skip",
            "_unstruct_copy_skip",
        )

        def __init__(
            self,
            dict_factory: Callable[[], Any] = dict,
            unstruct_strat: UnstructureStrategy = UnstructureStrategy.AS_DICT,
            omit_if_default: bool = False,
            forbid_extra_keys: bool = False,
            type_overrides: Mapping[Type, AttributeOverride] = {},
            unstruct_collection_overrides: Mapping[Type, Callable] = {},
            prefer_attrib_converters: bool = False,
            detailed_validation: bool = True,
        ):
            super().__init__(
                dict_factory=dict_factory,
                unstruct_strat=unstruct_strat,
                prefer_attrib_converters=prefer_attrib_converters,
                detailed_validation=detailed_validation,
            )
            self.omit_if_default = omit_if_default
            self.forbid_extra_keys = forbid_extra_keys
            self.type_overrides = dict(type_overrides)

            unstruct_collection_overrides = {
                get_origin(k) or k: v for k, v in unstruct_collection_overrides.items()
            }

            self._unstruct_collection_overrides = unstruct_collection_overrides

            # Do a little post-processing magic to make things easier for users.
            co = unstruct_collection_overrides

            # abc.Set overrides, if defined, apply to abc.MutableSets and sets
            if OriginAbstractSet in co:
                if OriginMutableSet not in co:
                    co[OriginMutableSet] = co[OriginAbstractSet]
                    co[AbcMutableSet] = co[OriginAbstractSet]  # For 3.7/3.8 compatibility.
                if FrozenSetSubscriptable not in co:
                    co[FrozenSetSubscriptable] = co[OriginAbstractSet]

            # abc.MutableSet overrrides, if defined, apply to sets
            if OriginMutableSet in co:
                if set not in co:
                    co[set] = co[OriginMutableSet]

            if FrozenSetSubscriptable in co:
                co[frozenset] = co[FrozenSetSubscriptable]  # For 3.7/3.8 compatibility.

            # abc.Sequence overrides, if defined, can apply to MutableSequences, lists and tuples
            if Sequence in co:
                if MutableSequence not in co:
                    co[MutableSequence] = co[Sequence]
                if tuple not in co:
                    co[tuple] = co[Sequence]

            # abc.MutableSequence overrides, if defined, can apply to lists
            if MutableSequence in co:
                if list not in co:
                    co[list] = co[MutableSequence]

            # abc.Mapping overrides, if defined, can apply to MutableMappings
            if Mapping in co:
                if MutableMapping not in co:
                    co[MutableMapping] = co[Mapping]

            # abc.MutableMapping overrides, if defined, can apply to dicts
            if MutableMapping in co:
                if dict not in co:
                    co[dict] = co[MutableMapping]

            # builtins.dict overrides, if defined, can apply to counters
            if dict in co:
                if Counter not in co:
                    co[Counter] = co[dict]

            if unstruct_strat is UnstructureStrategy.AS_DICT:
                # Override the attrs handler.
                self.register_unstructure_hook_factory(
                    has_with_generic, self.gen_unstructure_attrs_fromdict
                )
                self.register_structure_hook_factory(
                    has_with_generic, self.gen_structure_attrs_fromdict
                )
            self.register_unstructure_hook_factory(
                is_annotated, self.gen_unstructure_annotated
            )
            self.register_unstructure_hook_factory(
                is_hetero_tuple, self.gen_unstructure_hetero_tuple
            )
            self.register_unstructure_hook_factory(
                is_sequence, self.gen_unstructure_iterable
            )
            self.register_unstructure_hook_factory(is_mapping, self.gen_unstructure_mapping)
            self.register_unstructure_hook_factory(
                is_mutable_set,
                lambda cl: self.gen_unstructure_iterable(cl, unstructure_to=set),
            )
            self.register_unstructure_hook_factory(
                is_frozenset,
                lambda cl: self.gen_unstructure_iterable(cl, unstructure_to=frozenset),
            )
            self.register_unstructure_hook_factory(
                lambda t: get_newtype_base(t) is not None,
                lambda t: self._unstructure_func.dispatch(get_newtype_base(t)),
            )
            self.register_structure_hook_factory(is_annotated, self.gen_structure_annotated)
            self.register_structure_hook_factory(is_mapping, self.gen_structure_mapping)
            self.register_structure_hook_factory(is_counter, self.gen_structure_counter)
            self.register_structure_hook_factory(
                lambda t: get_newtype_base(t) is not None, self.get_structure_newtype
            )

            # We keep these so we can more correctly copy the hooks.
            self._struct_copy_skip = self._structure_func.get_num_fns()
            self._unstruct_copy_skip = self._unstructure_func.get_num_fns()

        def get_structure_newtype(self, type: Type[T]) -> Callable[[Any, Any], T]:
            base = get_newtype_base(type)
            handler = self._structure_func.dispatch(base)
            return lambda v, _: handler(v, base)

        def gen_unstructure_annotated(self, type):
            origin = type.__origin__
            h = self._unstructure_func.dispatch(origin)
            return h

        def gen_structure_annotated(self, type):
            origin = type.__origin__
            h = self._structure_func.dispatch(origin)
            return h

        def gen_unstructure_attrs_fromdict(
            self, cl: Type[T]
        ) -> Callable[[T], Dict[str, Any]]:
            origin = get_origin(cl)
            attribs = fields(origin or cl)
            if attrs_has(cl) and any(isinstance(a.type, str) for a in attribs):
                # PEP 563 annotations - need to be resolved.
                resolve_types(cl)
            attrib_overrides = {
                a.name: self.type_overrides[a.type]
                for a in attribs
                if a.type in self.type_overrides
            }

            h = make_dict_unstructure_fn(
                cl, self, _cattrs_omit_if_default=self.omit_if_default, **attrib_overrides
            )
            return h

        def gen_structure_attrs_fromdict(
            self, cl: Type[T]
        ) -> Callable[[Mapping[str, Any], Any], T]:
            attribs = fields(get_origin(cl) if is_generic(cl) else cl)
            if attrs_has(cl) and any(isinstance(a.type, str) for a in attribs):
                # PEP 563 annotations - need to be resolved.
                resolve_types(cl)
            attrib_overrides = {
                a.name: self.type_overrides[a.type]
                for a in attribs
                if a.type in self.type_overrides
            }
            h = make_dict_structure_fn(
                cl,
                self,
                _cattrs_forbid_extra_keys=self.forbid_extra_keys,
                _cattrs_prefer_attrib_converters=self._prefer_attrib_converters,
                _cattrs_detailed_validation=self.detailed_validation,
                **attrib_overrides,
            )
            # only direct dispatch so that subclasses get separately generated
            return h

        def gen_unstructure_iterable(
            self, cl: Any, unstructure_to: Any = None
        ) -> IterableUnstructureFn:
            unstructure_to = self._unstruct_collection_overrides.get(
                get_origin(cl) or cl, unstructure_to or list
            )
            h = make_iterable_unstructure_fn(cl, self, unstructure_to=unstructure_to)
            self._unstructure_func.register_cls_list([(cl, h)], direct=True)
            return h

        def gen_unstructure_hetero_tuple(
            self, cl: Any, unstructure_to: Any = None
        ) -> HeteroTupleUnstructureFn:
            unstructure_to = self._unstruct_collection_overrides.get(
                get_origin(cl) or cl, unstructure_to or list
            )
            h = make_hetero_tuple_unstructure_fn(cl, self, unstructure_to=unstructure_to)
            self._unstructure_func.register_cls_list([(cl, h)], direct=True)
            return h

        def gen_unstructure_mapping(
            self,
            cl: Any,
            unstructure_to: Any = None,
            key_handler: Optional[Callable[[Any, Optional[Any]], Any]] = None,
        ) -> MappingUnstructureFn:
            unstructure_to = self._unstruct_collection_overrides.get(
                get_origin(cl) or cl, unstructure_to or dict
            )
            h = make_mapping_unstructure_fn(
                cl, self, unstructure_to=unstructure_to, key_handler=key_handler
            )
            self._unstructure_func.register_cls_list([(cl, h)], direct=True)
            return h

        def gen_structure_counter(self, cl: Any) -> MappingStructureFn[T]:
            h = make_mapping_structure_fn(
                cl,
                self,
                structure_to=Counter,
                val_type=int,
                detailed_validation=self.detailed_validation,
            )
            self._structure_func.register_cls_list([(cl, h)], direct=True)
            return h

        def gen_structure_mapping(self, cl: Any) -> MappingStructureFn[T]:
            h = make_mapping_structure_fn(
                cl, self, detailed_validation=self.detailed_validation
            )
            self._structure_func.register_cls_list([(cl, h)], direct=True)
            return h

        def copy(
            self,
            dict_factory: Optional[Callable[[], Any]] = None,
            unstruct_strat: Optional[UnstructureStrategy] = None,
            omit_if_default: Optional[bool] = None,
            forbid_extra_keys: Optional[bool] = None,
            type_overrides: Optional[Mapping[Type, AttributeOverride]] = None,
            unstruct_collection_overrides: Optional[Mapping[Type, Callable]] = None,
            prefer_attrib_converters: Optional[bool] = None,
            detailed_validation: Optional[bool] = None,
        ) -> "Converter":
            res = self.__class__(
                dict_factory if dict_factory is not None else self._dict_factory,
                unstruct_strat
                if unstruct_strat is not None
                else (
                    UnstructureStrategy.AS_DICT
                    if self._unstructure_attrs == self.unstructure_attrs_asdict
                    else UnstructureStrategy.AS_TUPLE
                ),
                omit_if_default if omit_if_default is not None else self.omit_if_default,
                forbid_extra_keys
                if forbid_extra_keys is not None
                else self.forbid_extra_keys,
                type_overrides if type_overrides is not None else self.type_overrides,
                unstruct_collection_overrides
                if unstruct_collection_overrides is not None
                else self._unstruct_collection_overrides,
                prefer_attrib_converters
                if prefer_attrib_converters is not None
                else self._prefer_attrib_converters,
                detailed_validation
                if detailed_validation is not None
                else self.detailed_validation,
            )

            self._unstructure_func.copy_to(
                res._unstructure_func, skip=self._unstruct_copy_skip
            )
            self._structure_func.copy_to(res._structure_func, skip=self._struct_copy_skip)

            return res

    GenConverter = Converter