More work on slotted dataclasses

Author: Tinche

HISTORY.md

@@ -30,6 +30,8 @@ Our backwards-compatibility policy can be found [here](https://github.com/python
   This allows hashability, better immutability and is more consistent with the [`collections.abc.Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence) type.
   See [Migrations](https://catt.rs/en/latest/migrations.html#sequences-structuring-into-tuples) for steps to restore legacy behavior.
   ([#663](https://github.com/python-attrs/cattrs/pull/663))
+- Python 3.14 is now supported and part of the test matrix.
+  ([#653](https://github.com/python-attrs/cattrs/pull/653))
 - Add a `use_alias` parameter to {class}`cattrs.Converter`.
   {func}`cattrs.gen.make_dict_unstructure_fn_from_attrs`, {func}`cattrs.gen.make_dict_unstructure_fn`,
   {func}`cattrs.gen.make_dict_structure_fn_from_attrs`, {func}`cattrs.gen.make_dict_structure_fn`

Justfile

@@ -10,7 +10,7 @@ lint:
 	uv run -p python3.13 --group lint black --check src tests docs/conf.py
 
 test *args="-x --ff -n auto tests":
-    uv run {{ if python != '' { '-p ' + python } else { '' } }} --all-extras --group test pytest {{args}}
+    uv run {{ if python != '' { '-p ' + python } else { '' } }} --all-extras --group test --group lint pytest {{args}}
 
 testall:
     just python=python3.9 test
@@ -21,7 +21,7 @@ testall:
     just python=python3.13 test
 
 cov *args="-x --ff -n auto tests":
-    uv run {{ if python != '' { '-p ' + python } else { '' } }} --all-extras --group test coverage run -m pytest {{args}}
+    uv run {{ if python != '' { '-p ' + python } else { '' } }} --all-extras --group test --group lint coverage run -m pytest {{args}}
     {{ if covcleanup == "true" { "uv run coverage combine" } else { "" } }}
     {{ if covcleanup == "true" { "uv run coverage report" } else { "" } }}
     {{ if covcleanup == "true" { "@rm .coverage*" } else { "" } }}

src/cattrs/strategies/_subclasses.py

@@ -9,22 +9,21 @@
 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)
+        sscl for scl in subclasses(cls_origin) for sscl in _make_subclasses_tree(scl)
     ]
 
 
 def _has_subclasses(cl: type, given_subclasses: tuple[type, ...]) -> bool:
     """Whether the given class has subclasses from `given_subclasses`."""
     cls_origin = typing.get_origin(cl) or cl
-    actual = set(cls_origin.__subclasses__())
+    actual = set(subclasses(cls_origin.__subclasses__()))
     given = set(given_subclasses)
     return bool(actual & given)
 
@@ -69,6 +68,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()

src/cattrs/subclasses.py

@@ -0,0 +1,24 @@
+import sys
+
+if sys.version_info <= (3, 13):
+
+    def subclasses(cls: type) -> list[type]:
+        """A proxy for `cls.__subclasses__()` on older Pythons."""
+        return cls.__subclasses__()
+
+else:
+
+    def subclasses(cls: type) -> list[type]:
+        """A helper for getting subclasses of a class.
+
+        Filters out duplicate subclasses of slot dataclasses.
+        """
+        return [
+            cl
+            for cl in cls.__subclasses__()
+            if not (
+                "__slots__" not in cl.__dict__
+                and hasattr(cls, "__dataclass_params__")
+                and cls.__dataclass_params__.slots
+            )
+        ]

tests/strategies/test_include_subclasses.py

@@ -1,6 +1,7 @@
 import functools
 import typing
 from copy import deepcopy
+from dataclasses import dataclass
 from functools import partial
 from typing import Any
 
@@ -11,6 +12,8 @@
 from cattrs.errors import ClassValidationError, StructureHandlerNotFoundError
 from cattrs.strategies import configure_tagged_union, include_subclasses
 
+from .._compat import is_py311_plus
+
 T = typing.TypeVar("T")
 
 
@@ -473,3 +476,36 @@ class Child2G(GenericParent[int]):
     assert genconverter.structure(
         {"p": 1, "c": "5", "_type": "Child2G"}, GenericParent[Any]
     ) == Child2G(1, "5")
+
+
+def test_dataclasses(genconverter: Converter):
+    """Dict dataclasses work."""
+
+    @dataclass
+    class ParentDC:
+        a: int
+
+    @dataclass
+    class ChildDC1(ParentDC):
+        b: str
+
+    include_subclasses(ParentDC, genconverter)
+
+    assert genconverter.structure({"a": 1, "b": "a"}, ParentDC) == ChildDC1(1, "a")
+
+
+@pytest.mark.skipif(not is_py311_plus, reason="slotted dataclasses supported on 3.11+")
+def test_dataclasses_slots(genconverter: Converter):
+    """Slotted dataclasses work."""
+
+    @dataclass(slots=True)
+    class ParentDC:
+        a: int
+
+    @dataclass(slots=True)
+    class ChildDC1(ParentDC):
+        b: str
+
+    include_subclasses(ParentDC, genconverter)
+
+    assert genconverter.structure({"a": 1, "b": "a"}, ParentDC) == ChildDC1(1, "a")