add updates libs

2026-06-18 17:21:58 +02:00
parent 91ce762570
commit 41f331d4c4
150 changed files with 8249 additions and 2550 deletions
@@ -9,21 +9,25 @@ from typing import Any, Callable, TypeVar, Union
 from ..converters import BaseConverter
 from ..gen import AttributeOverride, make_dict_structure_fn, make_dict_unstructure_fn
 from ..gen._consts import already_generating
+from ..subclasses import subclasses


 def _make_subclasses_tree(cl: type) -> list[type]:
    # get class origin for accessing subclasses (see #648 for more info)
    cls_origin = typing.get_origin(cl) or cl
-    return [cl] + [
-        sscl
-        for scl in cls_origin.__subclasses__()
-        for sscl in _make_subclasses_tree(scl)
-    ]
+
+    # Use a dict to deduplicate and keep insertion order.
+    seen = {cl: None}
+    for scl in subclasses(cls_origin):
+        for sscl in _make_subclasses_tree(scl):
+            seen[sscl] = None
+    return list(seen)


 def _has_subclasses(cl: type, given_subclasses: tuple[type, ...]) -> bool:
    """Whether the given class has subclasses from `given_subclasses`."""
-    actual = set(cl.__subclasses__())
+    cls_origin = typing.get_origin(cl) or cl
+    actual = set(subclasses(cls_origin))
    given = set(given_subclasses)
    return bool(actual & given)

@@ -68,6 +72,9 @@ def include_subclasses(
    .. versionchanged:: 24.1.0
       When overrides are not provided, hooks for individual classes are retrieved from
       the converter instead of generated with no overrides, using converter defaults.
+    .. versionchanged:: 25.2.0
+       Slotted dataclasses work on Python 3.14 via :func:`cattrs.subclasses.subclasses`,
+       which filters out duplicate classes caused by slotting.
    """
    # Due to https://github.com/python-attrs/attrs/issues/1047
    collect()
@@ -231,7 +238,13 @@ def _include_subclasses_with_union_strategy(
            return cls is _cl

        converter.register_unstructure_hook_func(cls_is_cl, unstruct_hook)
-        subclasses = tuple([c for c in union_classes if issubclass(c, cl)])
+        subclasses = tuple(
+            [
+                c
+                for c in union_classes
+                if issubclass(typing.get_origin(c) or c, typing.get_origin(cl) or cl)
+            ]
+        )
        if len(subclasses) > 1:
            u = Union[subclasses]  # type: ignore
            union_strategy(u, converter)
@@ -52,23 +52,10 @@ def configure_tagged_union(
    if is_type_alias(union):
        union = union.__value__
    args = union.__args__
+
    tag_to_hook = {}
    exact_cl_unstruct_hooks = {}
-    for cl in args:
-        tag = tag_generator(cl)
-        struct_handler = converter.get_structure_hook(cl)
-        unstruct_handler = converter.get_unstructure_hook(cl)
-
-        def structure_union_member(val: dict, _cl=cl, _h=struct_handler) -> cl:
-            return _h(val, _cl)
-
-        def unstructure_union_member(val: union, _h=unstruct_handler) -> dict:
-            return _h(val)
-
-        tag_to_hook[tag] = structure_union_member
-        exact_cl_unstruct_hooks[cl] = unstructure_union_member
-
-    cl_to_tag = {cl: tag_generator(cl) for cl in args}
+    cl_to_tag = {}

    if default is not NOTHING:
        default_handler = converter.get_structure_hook(default)
@@ -76,36 +63,9 @@ def configure_tagged_union(
        def structure_default(val: dict, _cl=default, _h=default_handler):
            return _h(val, _cl)

-        tag_to_hook = defaultdict(lambda: structure_default, tag_to_hook)
-        cl_to_tag = defaultdict(lambda: default, cl_to_tag)
+        tag_to_hook = defaultdict(lambda: structure_default)
+        cl_to_tag = defaultdict(lambda: default)

-    def unstructure_tagged_union(
-        val: union,
-        _exact_cl_unstruct_hooks=exact_cl_unstruct_hooks,
-        _cl_to_tag=cl_to_tag,
-        _tag_name=tag_name,
-    ) -> dict:
-        res = _exact_cl_unstruct_hooks[val.__class__](val)
-        res[_tag_name] = _cl_to_tag[val.__class__]
-        return res
-
-    if default is NOTHING:
-        if getattr(converter, "forbid_extra_keys", False):
-
-            def structure_tagged_union(
-                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
-            ) -> union:
-                val = val.copy()
-                return _tag_to_cl[val.pop(_tag_name)](val)
-
-        else:
-
-            def structure_tagged_union(
-                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
-            ) -> union:
-                return _tag_to_cl[val[_tag_name]](val)
-
-    else:
        if getattr(converter, "forbid_extra_keys", False):

            def structure_tagged_union(
@@ -135,11 +95,54 @@ def configure_tagged_union(
                    return _tag_to_hook[val[_tag_name]](val)
                return _dh(val, _default)

+    else:
+        if getattr(converter, "forbid_extra_keys", False):
+
+            def structure_tagged_union(
+                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
+            ) -> union:
+                val = val.copy()
+                return _tag_to_cl[val.pop(_tag_name)](val)
+
+        else:
+
+            def structure_tagged_union(
+                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
+            ) -> union:
+                return _tag_to_cl[val[_tag_name]](val)
+
+    def unstructure_tagged_union(
+        val: union,
+        _exact_cl_unstruct_hooks=exact_cl_unstruct_hooks,
+        _cl_to_tag=cl_to_tag,
+        _tag_name=tag_name,
+    ) -> dict:
+        res = _exact_cl_unstruct_hooks[val.__class__](val)
+        res[_tag_name] = _cl_to_tag[val.__class__]
+        return res
+
    converter.register_unstructure_hook(union, unstructure_tagged_union)
    converter.register_structure_hook(union, structure_tagged_union)

+    for cl in args:
+        tag = tag_generator(cl)
+        struct_handler = converter.get_structure_hook(cl)
+        unstruct_handler = converter.get_unstructure_hook(cl)

-def configure_union_passthrough(union: Any, converter: BaseConverter) -> None:
+        def structure_union_member(val: dict, _cl=cl, _h=struct_handler) -> cl:
+            return _h(val, _cl)
+
+        def unstructure_union_member(val: union, _h=unstruct_handler) -> dict:
+            return _h(val)
+
+        tag_to_hook[tag] = structure_union_member
+        exact_cl_unstruct_hooks[cl] = unstructure_union_member
+        cl_to_tag[cl] = tag
+
+
+def configure_union_passthrough(
+    union: Any, converter: BaseConverter, accept_ints_as_floats: bool = True
+) -> None:
    """
    Configure the converter to support validating and passing through unions of the
    provided types and their subsets.
@@ -162,7 +165,14 @@ def configure_union_passthrough(union: Any, converter: BaseConverter) -> None:
    If the union contains a class and one or more of its subclasses, the subclasses
    will also be included when validating the superclass.

+    :param accept_ints_as_floats: When set (the default), if the provided union
+        contains both ints and floats, actual unions containing only floats will also accept
+        ints. See https://typing.python.org/en/latest/spec/special-types.html#special-cases-for-float-and-complex
+        for more information.
+
    .. versionadded:: 23.2.0
+    .. versionchanged:: 25.2.0
+        Introduced the `accept_ints_as_floats` parameter.
    """
    args = set(union.__args__)

@@ -205,6 +215,16 @@ def configure_union_passthrough(union: Any, converter: BaseConverter) -> None:
            and not is_literal(a)
        }

+        # By default, when floats are part of the union, accept ints too.
+        if (
+            accept_ints_as_floats
+            and int in args
+            and float in args
+            and float in non_literal_classes
+            and int not in non_literal_classes
+        ):
+            non_literal_classes.add(int)
+
        if spillover:
            spillover_type = (
                Union[tuple(spillover)] if len(spillover) > 1 else next(iter(spillover))