Enable Python 3.14 (#653)

* Enable Python 3.14

* Bump orjson

* Bump typing_extensions

* Fix `is_generic`

* Fix test_structuring_unsupported

* Skip orjson on 3.14, stop skipping msgspec

* Fix more tests

* Conditionally import `_UnionGenericAlias`

* More work on slotted dataclasses

* Fix rebase

* Update to attrs 25.4

* Tweak changelog

* Reenable orjson

Author: Tinche

.github/workflows/main.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "pypy3.10"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14", "pypy3.10"]
       fail-fast: false
 
     steps:

HISTORY.md

@@ -17,11 +17,13 @@ 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.Set`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Set) type.
   See [Migrations](https://catt.rs/en/latest/migrations.html#abstract-sets-structuring-into-frozensets) for steps to restore legacy behavior.
   ([#](https://github.com/python-attrs/cattrs/pull/))
+- Python 3.14 is now supported and part of the test matrix.
+  ([#653](https://github.com/python-attrs/cattrs/pull/653))
 - Fix unstructuring NewTypes with the {class}`BaseConverter`.
   ([#684](https://github.com/python-attrs/cattrs/pull/684))
 - Make some Hypothesis tests more robust.
   ([#684](https://github.com/python-attrs/cattrs/pull/684))
-- {func} `cattrs.strategies.include_subclasses` now works with generic parent classes and the tagged union strategy.
+- {func}`cattrs.strategies.include_subclasses` now works with generic parent classes and the tagged union strategy.
   ([#683](https://github.com/python-attrs/cattrs/pull/683))
 
 ## 25.2.0 (2025-08-31)

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 { "" } }}

pyproject.toml

@@ -40,8 +40,8 @@ authors = [
     {name = "Tin Tvrtkovic", email = "tinchester@gmail.com"},
 ]
 dependencies = [
-    "attrs>=24.3.0",
-    "typing-extensions>=4.12.2",
+    "attrs>=25.4.0",
+    "typing-extensions>=4.14.0",
     "exceptiongroup>=1.1.1; python_version < '3.11'",
 ]
 requires-python = ">=3.9"
@@ -57,6 +57,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Typing :: Typed",
@@ -75,7 +76,7 @@ ujson = [
     "ujson>=5.10.0",
 ]
 orjson = [
-    "orjson>=3.10.7; implementation_name == \"cpython\"",
+    "orjson>=3.11.3; implementation_name == \"cpython\"",
 ]
 msgpack = [
     "msgpack>=1.0.5",

src/cattrs/_compat.py

@@ -29,7 +29,6 @@
     _AnnotatedAlias,
     _GenericAlias,
     _SpecialGenericAlias,
-    _UnionGenericAlias,
     get_args,
     get_origin,
     get_type_hints,
@@ -256,7 +255,22 @@ def is_tuple(type):
     )
 
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 14):
+
+    def is_union_type(obj):
+        from types import UnionType  # noqa: PLC0415
+
+        return obj is Union or isinstance(obj, UnionType)
+
+    def get_newtype_base(typ: Any) -> Optional[type]:
+        if typ is NewType or isinstance(typ, NewType):
+            return typ.__supertype__
+        return None
+
+    from typing import NotRequired, Required
+
+elif sys.version_info >= (3, 10):
+    from typing import _UnionGenericAlias
 
     def is_union_type(obj):
         from types import UnionType  # noqa: PLC0415
@@ -279,6 +293,8 @@ def get_newtype_base(typ: Any) -> Optional[type]:
 
 else:
     # 3.9
+    from typing import _UnionGenericAlias
+
     from typing_extensions import NotRequired, Required
 
     def is_union_type(obj):
@@ -411,8 +427,10 @@ def is_generic(type) -> bool:
     """Whether `type` is a generic type."""
     # Inheriting from protocol will inject `Generic` into the MRO
     # without `__orig_bases__`.
-    return isinstance(type, (_GenericAlias, GenericAlias)) or (
-        is_subclass(type, Generic) and hasattr(type, "__orig_bases__")
+    return (
+        isinstance(type, (_GenericAlias, GenericAlias))
+        or (is_subclass(type, Generic) and hasattr(type, "__orig_bases__"))
+        or type.__class__ is Union  # On 3.14, unions are no longer typing._GenericAlias
     )
 
 

src/cattrs/_generics.py

@@ -1,10 +1,10 @@
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, get_args
 
 from attrs import NOTHING
 from typing_extensions import Self
 
-from ._compat import copy_with, get_args, is_annotated, is_generic
+from ._compat import copy_with, is_annotated, is_generic
 
 
 def deep_copy_with(t, mapping: Mapping[str, Any], self_is=NOTHING):

src/cattrs/disambiguators.py

@@ -7,7 +7,7 @@
 from dataclasses import MISSING
 from functools import reduce
 from operator import or_
-from typing import TYPE_CHECKING, Any, Callable, Literal, Union
+from typing import TYPE_CHECKING, Any, Callable, Literal, Union, get_origin
 
 from attrs import NOTHING, Attribute, AttrsInstance
 
@@ -16,7 +16,6 @@
     adapted_fields,
     fields_dict,
     get_args,
-    get_origin,
     has,
     is_literal,
     is_union_type,

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))
     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,27 @@
+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 and attrs classes.
+        """
+        return [
+            cl
+            for cl in cls.__subclasses__()
+            if (
+                not (
+                    "__slots__" not in cl.__dict__
+                    and hasattr(cls, "__dataclass_params__")
+                    and cls.__dataclass_params__.slots
+                )
+                and not hasattr(cls, "__attrs_base_of_slotted__")
+            )
+        ]

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