Decode enums that mix in str or int and int enum dict keys

Author: RaphaelFakhri

CHANGELOG.md

@@ -58,6 +58,8 @@ to include examples, links to docs, or any other relevant information.
 
 - Restore `frozenset` values when decoding JSON payloads with a `frozenset` type hint,
   including nested frozen sets.
+- Decode enums that mix in `str` or `int` (for example `class Color(str, Enum)`) to the enum
+  instead of a list of characters or an error, and decode `dict` keys typed as an `int` enum.
 
 - Ordinary absolute imports of already-loaded modules in sandboxed workflows no longer go through
   importlib's module locks, fixing intermittent `Failed validating workflow` errors on Python 3.10

README.md

@@ -330,7 +330,7 @@ The default data converter supports converting multiple types including:
   * Anything that [`json.dump`](https://docs.python.org/3/library/json.html#json.dump) supports natively
   * [dataclasses](https://docs.python.org/3/library/dataclasses.html)
   * Iterables including ones JSON dump may not support by default, e.g. `set`
-  * [IntEnum, StrEnum](https://docs.python.org/3/library/enum.html) based enumerates
+  * [IntEnum, StrEnum](https://docs.python.org/3/library/enum.html) based enumerates, including enums that mix in `int` or `str`
   * [UUID](https://docs.python.org/3/library/uuid.html)
   * `datetime.datetime`
 

temporalio/converter/_payload_converter.py

@@ -15,7 +15,7 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Mapping, Sequence
 from datetime import datetime
-from enum import IntEnum
+from enum import Enum
 from itertools import zip_longest
 from types import UnionType
 from typing import (
@@ -42,9 +42,6 @@
 if sys.version_info < (3, 11):
     # Python's datetime.fromisoformat doesn't support certain formats pre-3.11
     from dateutil import parser  # type: ignore
-# StrEnum is available in 3.11+
-if sys.version_info >= (3, 11):
-    from enum import StrEnum  # type: ignore[reportUnreachable]
 
 from temporalio.converter._serialization_context import (
     SerializationContext,
@@ -961,6 +958,13 @@ def value_to_type(
                     if isinstance(key, str):
                         if key_type is int or key_type is float:
                             key = key_type(key)
+                        elif (
+                            inspect.isclass(key_type)
+                            and issubclass(key_type, Enum)
+                            and issubclass(key_type, int)
+                        ):
+                            # JSON serializes int enum keys as their number
+                            key = int(key)
                         elif key_type is bool:
                             key = {"true": True, "false": False}[key]
                         elif key_type is type(None):
@@ -1034,22 +1038,21 @@ def value_to_type(
             )
         return getattr(hint, "parse_obj")(value)
 
-    # IntEnum
-    if inspect.isclass(hint) and issubclass(hint, IntEnum):
+    # IntEnum, or any enum that mixes in int
+    if inspect.isclass(hint) and issubclass(hint, Enum) and issubclass(hint, int):
         if not isinstance(value, int):
             raise TypeError(
                 f"Cannot convert to enum {hint}, value not an integer, value is {type(value)}"
             )
         return hint(value)
 
-    # StrEnum, available in 3.11+
-    if sys.version_info >= (3, 11):
-        if inspect.isclass(hint) and issubclass(hint, StrEnum):  # type:ignore[reportUnreachable]
-            if not isinstance(value, str):
-                raise TypeError(
-                    f"Cannot convert to enum {hint}, value not a string, value is {type(value)}"
-                )
-            return hint(value)
+    # StrEnum, or any enum that mixes in str
+    if inspect.isclass(hint) and issubclass(hint, Enum) and issubclass(hint, str):
+        if not isinstance(value, str):
+            raise TypeError(
+                f"Cannot convert to enum {hint}, value not a string, value is {type(value)}"
+            )
+        return hint(value)
 
     # UUID
     if inspect.isclass(hint) and issubclass(hint, uuid.UUID):

tests/test_converter.py

@@ -72,6 +72,14 @@ class SerializableEnum(IntEnum):
     FOO = 1
 
 
+class SerializableMixinStrEnum(str, Enum):
+    FOO = "foo"
+
+
+class SerializableMixinIntEnum(int, Enum):
+    FOO = 1
+
+
 if sys.version_info >= (3, 11):
 
     class SerializableStrEnum(StrEnum):  # type:ignore[reportUnreachable]
@@ -498,6 +506,18 @@ def fail(hint: Any, value: Any) -> None:
     # IntEnum
     ok(SerializableEnum, SerializableEnum.FOO)
     ok(list[SerializableEnum], [SerializableEnum.FOO, SerializableEnum.FOO])
+    ok(dict[SerializableEnum, str], {SerializableEnum.FOO: "foo"})
+
+    # Enums that mix in int or str
+    ok(SerializableMixinIntEnum, SerializableMixinIntEnum.FOO)
+    ok(dict[SerializableMixinIntEnum, str], {SerializableMixinIntEnum.FOO: "foo"})
+    ok(SerializableMixinStrEnum, SerializableMixinStrEnum.FOO)
+    ok(
+        list[SerializableMixinStrEnum],
+        [SerializableMixinStrEnum.FOO, SerializableMixinStrEnum.FOO],
+    )
+    ok(dict[SerializableMixinStrEnum, int], {SerializableMixinStrEnum.FOO: 1})
+    fail(SerializableMixinStrEnum, 5)
 
     # UUID
     ok(UUID, uuid4())