Fix unstructuring literals with enums

Author: Tinche

HISTORY.md

@@ -22,6 +22,7 @@ Our backwards-compatibility policy can be found [here](https://github.com/python
 - Some `defaultdicts` are now [supported by default](https://catt.rs/en/latest/defaulthooks.html#defaultdicts), and
   {func}`cattrs.cols.is_defaultdict`{func} and `cattrs.cols.defaultdict_structure_factory` are exposed through {mod}`cattrs.cols`.
   ([#519](https://github.com/python-attrs/cattrs/issues/519) [#588](https://github.com/python-attrs/cattrs/pull/588))
+- Literals containing enums are now unstructured properly.
 - Replace `cattrs.gen.MappingStructureFn` with `cattrs.SimpleStructureHook[In, T]`.
 - Python 3.13 is now supported.
   ([#543](https://github.com/python-attrs/cattrs/pull/543) [#547](https://github.com/python-attrs/cattrs/issues/547))

src/cattrs/_compat.py

@@ -236,7 +236,8 @@ def get_final_base(type) -> Optional[type]:
     # Not present on 3.9.0, so we try carefully.
     from typing import _LiteralGenericAlias
 
-    def is_literal(type) -> bool:
+    def is_literal(type: Any) -> bool:
+        """Is this a literal?"""
         return type in LITERALS or (
             isinstance(
                 type, (_GenericAlias, _LiteralGenericAlias, _SpecialGenericAlias)

src/cattrs/converters.py

@@ -91,6 +91,7 @@
 )
 from .gen.typeddicts import make_dict_structure_fn as make_typeddict_dict_struct_fn
 from .gen.typeddicts import make_dict_unstructure_fn as make_typeddict_dict_unstruct_fn
+from .literals import is_literal_containing_enums
 from .types import SimpleStructureHook
 
 __all__ = ["UnstructureStrategy", "BaseConverter", "Converter", "GenConverter"]
@@ -146,10 +147,6 @@ class UnstructureStrategy(Enum):
     AS_TUPLE = "astuple"
 
 
-def is_literal_containing_enums(typ: type) -> bool:
-    return is_literal(typ) and any(isinstance(val, Enum) for val in typ.__args__)
-
-
 def _is_extended_factory(factory: Callable) -> bool:
     """Does this factory also accept a converter arg?"""
     # We use the original `inspect.signature` to not evaluate string
@@ -238,6 +235,7 @@ def __init__(
                     lambda t: self.get_unstructure_hook(get_type_alias_base(t)),
                     True,
                 ),
+                (is_literal_containing_enums, self.unstructure),
                 (is_mapping, self._unstructure_mapping),
                 (is_sequence, self._unstructure_seq),
                 (is_mutable_set, self._unstructure_seq),

src/cattrs/literals.py

@@ -0,0 +1,11 @@
+from enum import Enum
+from typing import Any
+
+from ._compat import is_literal
+
+__all__ = ["is_literal", "is_literal_containing_enums"]
+
+
+def is_literal_containing_enums(type: Any) -> bool:
+    """Is this a literal containing at least one Enum?"""
+    return is_literal(type) and any(isinstance(val, Enum) for val in type.__args__)

tests/test_literals.py

@@ -0,0 +1,19 @@
+from enum import Enum
+from typing import Literal
+
+from cattrs import BaseConverter
+from cattrs.fns import identity
+
+
+class TestEnum(Enum):
+    TEST = "test"
+
+
+def test_unstructure_literal(converter: BaseConverter):
+    """Literals without enums are passed through by default."""
+    assert converter.get_unstructure_hook(1, Literal[1]) == identity
+
+
+def test_unstructure_literal_with_enum(converter: BaseConverter):
+    """Literals with enums are properly unstructured."""
+    assert converter.unstructure(TestEnum.TEST, Literal[TestEnum.TEST]) == "test"