Conditionally import _UnionGenericAlias

Author: Tinche

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

tests/test_baseconverter.py

@@ -149,16 +149,14 @@ def handler(obj, _):
     simple_typed_classes(
         defaults="never", newtypes=False, allow_nan=False, min_attrs=1
     ),
-    unstructure_strats,
 )
-def test_310_union_field_roundtrip(cl_and_vals_a, cl_and_vals_b, strat):
+def test_310_union_field_roundtrip_dict(cl_and_vals_a, cl_and_vals_b):
     """
     Classes with union fields can be unstructured and structured.
     """
-    converter = BaseConverter(unstruct_strat=strat)
+    converter = BaseConverter()
     cl_a, vals_a, kwargs_a = cl_and_vals_a
     cl_b, _, _ = cl_and_vals_b
-    assume(strat is UnstructureStrategy.AS_DICT or not kwargs_a)
     a_field_names = {a.name for a in fields(cl_a)}
     b_field_names = {a.name for a in fields(cl_b)}
 
@@ -171,18 +169,47 @@ class C:
 
     inst = C(a=cl_a(*vals_a, **kwargs_a))
 
-    if strat is UnstructureStrategy.AS_DICT:
-        assert inst == converter.structure(converter.unstructure(inst), C)
-    else:
-        # Our disambiguation functions only support dictionaries for now.
-        with pytest.raises(StructureHandlerNotFoundError):
-            converter.structure(converter.unstructure(inst), C)
+    assert inst == converter.structure(converter.unstructure(inst), C)
 
-        def handler(obj, _):
-            return converter.structure(obj, cl_a)
 
-        converter.register_structure_hook(cl_a | cl_b, handler)
-        assert inst == converter.structure(converter.unstructure(inst), C)
+@pytest.mark.skipif(not is_py310_plus, reason="3.10+ union syntax")
+@settings(suppress_health_check=[HealthCheck.too_slow])
+@given(
+    simple_typed_classes(
+        defaults="never", newtypes=False, allow_nan=False, min_attrs=1, kw_only="never"
+    ),
+    simple_typed_classes(
+        defaults="never", newtypes=False, allow_nan=False, min_attrs=1, kw_only="never"
+    ),
+)
+def test_310_union_field_roundtrip_tuple(cl_and_vals_a, cl_and_vals_b):
+    """
+    Classes with union fields can be unstructured and structured.
+    """
+    converter = BaseConverter(unstruct_strat=UnstructureStrategy.AS_TUPLE)
+    cl_a, vals_a, kwargs_a = cl_and_vals_a
+    cl_b, _, _ = cl_and_vals_b
+    a_field_names = {a.name for a in fields(cl_a)}
+    b_field_names = {a.name for a in fields(cl_b)}
+
+    common_names = a_field_names & b_field_names
+    assume(len(a_field_names) > len(common_names))
+
+    @define
+    class C:
+        a: cl_a | cl_b
+
+    inst = C(a=cl_a(*vals_a, **kwargs_a))
+
+    # Our disambiguation functions only support dictionaries for now.
+    with pytest.raises(StructureHandlerNotFoundError):
+        converter.structure(converter.unstructure(inst), C)
+
+    def handler(obj, _):
+        return converter.structure(obj, cl_a)
+
+    converter.register_structure_hook(cl_a | cl_b, handler)
+    assert inst == converter.structure(converter.unstructure(inst), C)
 
 
 @given(simple_typed_classes(defaults="never", newtypes=False, allow_nan=False))