Fix include_subclasses strategy with a generic parent and tagged_union (backport)

Author: danarmak

HISTORY.md

@@ -11,6 +11,10 @@ The third number is for emergencies when we need to start branches for older rel
 
 Our backwards-compatibility policy can be found [here](https://github.com/python-attrs/cattrs/blob/main/.github/SECURITY.md).
 
+## 25.3.0 (unreleased)
+
+- {func} `cattrs.strategies.include_subclasses` now works with generic parent classes and the tagged union strategy.
+
 ## 25.2.0 (2025-08-31)
 
 - **Potentially breaking**: Sequences are now structured into tuples.
@@ -41,8 +45,8 @@ Our backwards-compatibility policy can be found [here](https://github.com/python
 
 ## 25.1.1 (2025-06-04)
 
-- Fixed `AttributeError: no attribute '__parameters__'` while structuring attrs classes that inherit from parametrized generic aliases from `collections.abc`.
-  ([#654](https://github.com/python-attrs/cattrs/issues/654) [#655](https://github.com/python-attrs/cattrs/pull/655))
+- {func} `cattrs.strategies.include_subclasses` now properly working with generic parent classes.
+  ([#649](https://github.com/python-attrs/cattrs/pull/650))
 
 ## 25.1.0 (2025-05-31)
 

src/cattrs/strategies/_subclasses.py

@@ -23,7 +23,8 @@ def _make_subclasses_tree(cl: type) -> list[type]:
 
 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(cls_origin.__subclasses__())
     given = set(given_subclasses)
     return bool(actual & given)
 
@@ -231,7 +232,13 @@ def cls_is_cl(cls, _cl=cl):
             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)

tests/strategies/test_include_subclasses.py

@@ -1,6 +1,8 @@
+import functools
 import typing
 from copy import deepcopy
 from functools import partial
+from typing import Any
 
 import pytest
 from attrs import define
@@ -432,3 +434,42 @@ class Child1G(GenericParent[str]):
     assert genconverter.structure({"p": 5, "c": 5}, GenericParent[str]) == Child1G(
         "5", "5"
     )
+
+
+def test_parents_with_generics_tagged_union(genconverter: Converter):
+    """Ensure proper handling of generic parents with configure_tagged_union, #682."""
+
+    @define
+    class GenericParent(typing.Generic[T]):
+        p: T
+
+    @define
+    class Child1G(GenericParent[str]):
+        c: str
+
+    @define
+    class Child2G(GenericParent[int]):
+        c: str
+
+    union_strategy = functools.partial(
+        configure_tagged_union,
+        tag_generator=lambda cl: (typing.get_origin(cl) or cl).__name__,
+    )
+    include_subclasses(GenericParent[Any], genconverter, union_strategy=union_strategy)
+
+    assert genconverter.unstructure(Child1G("5", "5")) == {
+        "p": "5",
+        "c": "5",
+        "_type": "Child1G",
+    }
+    assert genconverter.unstructure(Child2G(1, "5")) == {
+        "p": 1,
+        "c": "5",
+        "_type": "Child2G",
+    }
+    assert genconverter.structure(
+        {"p": "5", "c": "5", "_type": "Child1G"}, GenericParent[Any]
+    ) == Child1G("5", "5")
+    assert genconverter.structure(
+        {"p": 1, "c": "5", "_type": "Child2G"}, GenericParent[Any]
+    ) == Child2G(1, "5")