UncountablePythonSDK 0.0.31__py3-none-any.whl → 0.0.33__py3-none-any.whl

{UncountablePythonSDK-0.0.31.dist-info → UncountablePythonSDK-0.0.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.31
+Version: 0.0.33
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: aiotus ==0.*
 Requires-Dist: aiohttp ==3.*
 Requires-Dist: requests ==2.*
-Requires-Dist: SQLAlchemy ==1.4.*
+Requires-Dist: SQLAlchemy >=1.4.0
 Requires-Dist: APScheduler ==3.*
 Requires-Dist: python-dateutil ==2.*
 Requires-Dist: shelljob ==0.*

{UncountablePythonSDK-0.0.31.dist-info → UncountablePythonSDK-0.0.33.dist-info}/RECORD

@@ -21,26 +21,28 @@ pkgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pkgs/argument_parser/__init__.py,sha256=CsQ6QoPKSLLRVl-z6URAmPkiUL9ZPZoV4rJHgy_-RjA,385
 pkgs/argument_parser/_is_enum.py,sha256=Gw6jJa8nBwYGqXwwCZbSnWL8Rvr5alkg5lSVAqXtOZM,257
 pkgs/argument_parser/_is_namedtuple.py,sha256=Rjc1bKanIPPogl3qG5JPBxglG1TqWYOo1nxxhBASQWY,265
-pkgs/argument_parser/argument_parser.py,sha256=eqw4ge9Sh9z35Vztq_dUQUvVMluo7YgnmMjHNMhrhVw,15937
+pkgs/argument_parser/argument_parser.py,sha256=pcU4IhgFkea-I6PhHUex43BoVaQvnoRV-Mw3qOqCdBQ,17274
 pkgs/argument_parser/case_convert.py,sha256=NuJLJUJRbyVb6_Slen4uqaStEHbcOS1d-hBBfDrrw-c,605
-pkgs/serialization/__init__.py,sha256=quvXMSl1szddLTr4Yxo9KA9oBMoeX7qGpFkkAplFBbY,603
+pkgs/serialization/__init__.py,sha256=LifasRW0a50A3qRFmo2bf3FQ6TXhZWOTz2-CVTgPjcQ,753
 pkgs/serialization/missing_sentry.py,sha256=aM_9KxbCk9dVvXvcOKgkIQBqFWvLhv8QlIUCiuFEXMo,806
 pkgs/serialization/opaque_key.py,sha256=FIfXEE0DA1U8R_taFbQ1RCoTSgehrPjP06-qvo-GeNQ,177
 pkgs/serialization/serial_class.py,sha256=r0hrQdIbJA_X0W0_jKEVrxi_JzVRT9qHCjsUgGu3cCI,5290
-pkgs/serialization_util/__init__.py,sha256=4vX5j1pvd1NkznSVqwWqunVyOvQtLCgVuwRjVwDk7qg,447
+pkgs/serialization/serial_union.py,sha256=z8Ptj4bVHyb1ROfg0UPTwZ6Ef6iXLr0YJfAH5o_PU9A,2601
+pkgs/serialization_util/__init__.py,sha256=MVKqHTUl2YnWZAFG9xCxu1SgmkQ5xPofrAGlYg6h7rI,330
 pkgs/serialization_util/_get_type_for_serialization.py,sha256=dW5_W9MFd6wgWfW5qlWork-GBb-QFLtiOZkjk2Zqn2M,1177
-pkgs/serialization_util/serialization_helpers.py,sha256=koyGyvdlEmGFK1BUiHtM2gTzAyHygbe1JpKLdZ-Aw84,5124
+pkgs/serialization_util/convert_to_snakecase.py,sha256=H2BAo5ZdcCDN77RpLb-uP0s7-FQ5Ukwnsd3VYc1vD0M,583
+pkgs/serialization_util/serialization_helpers.py,sha256=byotZo00SVREW_aM0sbKQEzuI7O3zwjk_nB_OQ6S5M8,4999
 pkgs/strenum_compat/__init__.py,sha256=wXRFeNvBm8RU6dy1PFJ5sRLgUIEeH_DVR95Sv5qpGbk,59
 pkgs/strenum_compat/strenum_compat.py,sha256=uOUAgpYTjHs1MX8dG81jRlyTkt3KNbkV_25zp7xTX2s,36
 pkgs/type_spec/__init__.py,sha256=h5DmJTca4QVV10sZR1x0-MlkZfuGYDfapR3zHvXfzto,19
 pkgs/type_spec/__main__.py,sha256=5bJaX9Y_-FavP0qwzhk-z-V97UY7uaezJTa1zhO_HHQ,1048
-pkgs/type_spec/builder.py,sha256=1C_ELB7KfK118QxZDLLc_Uf_nh5TAg96ilpOCfEQuN4,43685
+pkgs/type_spec/builder.py,sha256=un86i9LqTmCMVj-g6lrZ8lU4JZEElzCfUlsn--GkTvA,46049
 pkgs/type_spec/config.py,sha256=INfEiDcUsZFUKasHprsE6i33siPB0RnfmTKOsWcGnQ8,5043
 pkgs/type_spec/emit_io_ts.py,sha256=Ghd8XYqyNYldHQDepwa9GLfHXcoi48ztBw84K28ETic,5707
-pkgs/type_spec/emit_open_api.py,sha256=rAxfPVsqJU7ass76dPhImgPao6AW6xyz-rMaQDhSp1I,23822
+pkgs/type_spec/emit_open_api.py,sha256=Aw7Ct1itmAqhb_nsM9yDz87EoF0XWHM56MhKqtOLOio,24005
 pkgs/type_spec/emit_open_api_util.py,sha256=XAA6zH59aZWLVl0BvKAICXXl4sdBqx01QAtv5oB0bMI,2266
-pkgs/type_spec/emit_python.py,sha256=vuVgyts9zfEgRMTGsI6LKejMnq9_lxLxawjxoz4p7DE,44098
-pkgs/type_spec/emit_typescript.py,sha256=4hpCJwiDf-v8LJaNFVfFtf8zvtG73YNPFwwa_5NuffI,17729
+pkgs/type_spec/emit_python.py,sha256=zP3AWJ5u0vzDcnvzSehCUgvXM0J9ZUtfLBVHerW6_wI,45164
+pkgs/type_spec/emit_typescript.py,sha256=cdr5h8N70PuwORcvhURUujzwH9r1LVwJB8V2EoipGkw,17917
 pkgs/type_spec/emit_typescript_util.py,sha256=93FzJnpYse4PKFzgdw4DGV4zFTi5tF4WR-CIi7cW498,873
 pkgs/type_spec/load_types.py,sha256=xEHwdB_miR3vNs161Oy1luafE0VC-yk9-utAyCJmbEo,3629
 pkgs/type_spec/open_api_util.py,sha256=IGh-_snGPST_P_8FdYtO8MTEa9PUxRW6Rzg9X9EgQik,7114
@@ -52,7 +54,7 @@ pkgs/type_spec/actions_registry/emit_typescript.py,sha256=ben0W7qwaVCzLO-t3NEJPP
 pkgs/type_spec/parts/base.py.prepart,sha256=wGNoDyQnLolHRZGRwHQX5TrPfKnu558NXCocYvqyroc,2174
 pkgs/type_spec/parts/base.ts.prepart,sha256=2FJJvpg2olCcavxj0nbYWdwKl6KeScour2JjSvN42l8,1001
 pkgs/type_spec/type_info/__main__.py,sha256=pmVjVqXyVh8vKTNCTFgz80Sg74C5BKToP3E6GS-X_So,857
-pkgs/type_spec/type_info/emit_type_info.py,sha256=S3K5_VHbhwR0A7ZiJ5Qed2zjkici-J2ZdVKPDpc2OrI,12362
+pkgs/type_spec/type_info/emit_type_info.py,sha256=XqAyJgzkYY2woG5O-IA5O9gnfja_slTZGd-GnS7xPts,13280
 pkgs/type_spec/value_spec/__init__.py,sha256=Z-grlcZtxAfEXhPHsK0nD7PFLGsv4eqvunaPN7_TA84,83
 pkgs/type_spec/value_spec/__main__.py,sha256=-9L5pXYx02plnTetqNknaUZPieLRtzbyWdZDT6B-cWA,8294
 pkgs/type_spec/value_spec/convert_type.py,sha256=SAYyEV6orQJJbkXSE4hhtOQJ2vKUXJCKPeYPrB8G9oA,2272
@@ -102,7 +104,7 @@ uncountable/types/recipe_links.py,sha256=RldSV7SdeBYa0bx02DzMg4jfPdgrlMRE40T16Fd
 uncountable/types/recipe_metadata.py,sha256=cebGg_lJzqZzGnKnDgmuQFrw4Xhoz6HEiGM6G0az120,1437
 uncountable/types/recipe_output_metadata.py,sha256=XJA8R1r4NTzyR_DhMkmH4ZtYD-vqpvBMji9Be8OcFmo,613
 uncountable/types/recipe_tags.py,sha256=lYpksHAxXCcIjZKR7JoZOTH2cBSovwxZaHwjZy_yqiQ,581
-uncountable/types/recipe_workflow_steps.py,sha256=LmyFwWWwJv30vuaQ4qtd0hzDdeJaIxHQZqwRb1Wi_6A,2626
+uncountable/types/recipe_workflow_steps.py,sha256=ZMZI6SteOTVSolhPPZsSqU139i4NYFc1ACbS1rSBLJQ,2997
 uncountable/types/recipes.py,sha256=tY8MNmQiky94eIFOxSLyflXVno3pfDygxJ6WPqJlyDU,549
 uncountable/types/response.py,sha256=ZI0CG7ZxBM2k5_W-6mNMU3UlB0p1i-0nrwOvsMaS-vU,620
 uncountable/types/units.py,sha256=_kZ7KkXIbRiY2fOdkTsbJBpWRah5TCC2WWiG05e-1DA,565
@@ -163,7 +165,7 @@ uncountable/types/api/recipes/associate_recipe_as_lot.py,sha256=bTYjbnY3B7GKz4MV
 uncountable/types/api/recipes/create_recipe.py,sha256=jizKdsc761zrJXOi0xlmge7-Z9QlzRQdbLNtUoVLQCI,1420
 uncountable/types/api/recipes/create_recipes.py,sha256=qwIYa8hfcjY7_VOFt9lxmVtJ-HOJqQN3GDNSbZsRCZU,1544
 uncountable/types/api/recipes/disassociate_recipe_as_input.py,sha256=L25fpiK1Y5PByPVVgsZy9t4podz3xSSLIwKHj8CUrSg,913
-uncountable/types/api/recipes/edit_recipe_inputs.py,sha256=I0o-LKBjjNryQqwKM4g6jdy6YtX7P2Ga2lKzXU_RuRk,4153
+uncountable/types/api/recipes/edit_recipe_inputs.py,sha256=_dLulVZLqi-CrFIVMRts8h0OHx-nUG3vFOSKS1juGUc,4568
 uncountable/types/api/recipes/get_curve.py,sha256=UIWfpqtU5sQokaxwYfQFNFl6HMyzWEF_Sjd8UMz0U88,939
 uncountable/types/api/recipes/get_recipe_calculations.py,sha256=eQmkdZzCEuq8S2f_kf_7GPvDLX1pTnY1CRmkK0SkMCI,1472
 uncountable/types/api/recipes/get_recipe_links.py,sha256=hk5dfQjv7yU2r-S9b8vwWEJLPHqU0-M6SFiTLMR3fVk,985
@@ -178,7 +180,7 @@ uncountable/types/api/recipes/set_recipe_tags.py,sha256=U710hgq9-t6QZGRB-ZGHskpt
 uncountable/types/api/recipes/unarchive_recipes.py,sha256=WcwFYbBsX2SKXnoBQ8locnRn7Bj1rHdtrURQVOfqgfU,814
 uncountable/types/api/triggers/__init__.py,sha256=gCgbynxG3jA8FQHzercKtrHKHkiIKr8APdZYUniAor8,55
 uncountable/types/api/triggers/run_trigger.py,sha256=9m9M8-nlGB_sAU2Qm2lWugp4h4Osqj6QpjNfU8osd1U,901
-UncountablePythonSDK-0.0.31.dist-info/METADATA,sha256=jaFYbK371JiK653-RWGnpqIWCo1Ql0gQRJ4B9_0L4EQ,1577
-UncountablePythonSDK-0.0.31.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-UncountablePythonSDK-0.0.31.dist-info/top_level.txt,sha256=1UVGjAU-6hJY9qw2iJ7nCBeEwZ793AEN5ZfKX9A1uj4,31
-UncountablePythonSDK-0.0.31.dist-info/RECORD,,
+UncountablePythonSDK-0.0.33.dist-info/METADATA,sha256=bPMG0vmoieJ8foThqNXZK5DRWNQO0mZz3ypltJAx6Ck,1577
+UncountablePythonSDK-0.0.33.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+UncountablePythonSDK-0.0.33.dist-info/top_level.txt,sha256=1UVGjAU-6hJY9qw2iJ7nCBeEwZ793AEN5ZfKX9A1uj4,31
+UncountablePythonSDK-0.0.33.dist-info/RECORD,,

{UncountablePythonSDK-0.0.31.dist-info → UncountablePythonSDK-0.0.33.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pkgs/argument_parser/argument_parser.py

@@ -10,7 +10,12 @@ from importlib import resources
 import dateutil.parser
 import yaml
 
-from pkgs.serialization import MissingSentryType, OpaqueKey, get_serial_class_data
+from pkgs.serialization import (
+    MissingSentryType,
+    OpaqueKey,
+    get_serial_class_data,
+    get_serial_union_data,
+)
 
 from ._is_enum import is_string_enum_class
 from ._is_namedtuple import is_namedtuple_type
@@ -112,6 +117,23 @@ def _invoke_membership_parser(
     raise ValueError(f"Expected value from {expected_values} but got value {value}")
 
 
+def _build_parser_discriminated_union(
+    discriminator: str, discriminator_map: dict[str, ParserFunction[T]]
+) -> ParserFunction[T]:
+    def parse(value: typing.Any) -> typing.Any:
+        discriminant = value.get(discriminator)
+        if discriminant is None:
+            raise ValueError("missing-union-discriminant")
+        if not isinstance(discriminant, str):
+            raise ValueError("union-discriminant-is-not-string")
+        parser = discriminator_map.get(discriminant)
+        if parser is None:
+            raise ValueError("missing-type-for-union-discriminant", discriminant)
+        return parser(value)
+
+    return parse
+
+
 def _build_parser_inner(
     parsed_type: type[T],
     context: ParserContext,
@@ -130,6 +152,23 @@ def _build_parser_inner(
     are cached now, as they don't use the argument, and they're known to be safe.
     This is also enough to support some recursion.
     """
+
+    serial_union = get_serial_union_data(parsed_type)
+    if serial_union is not None:
+        discriminator = serial_union.discriminator
+        discriminator_map = serial_union.discriminator_map
+        if discriminator is None or discriminator_map is None:
+            # fallback to standard union parsing
+            parsed_type = serial_union.get_union_underlying()
+        else:
+            return _build_parser_discriminated_union(
+                discriminator,
+                {
+                    key: _build_parser_inner(value, context)
+                    for key, value in discriminator_map.items()
+                },
+            )
+
     if dataclasses.is_dataclass(parsed_type):
         return _build_parser_dataclass(parsed_type, context)  # type: ignore[arg-type]
 
@@ -341,7 +380,7 @@ def _build_parser_dataclass(
 
             except Exception as e:
                 raise ValueError(
-                    f"unable to parse field:{field.name}", field_raw_value
+                    f"unable-to-parse-field:{field.name}", field_raw_value
                 ) from e
 
         if context.options.strict_property_parsing:

pkgs/serialization/__init__.py

@@ -8,3 +8,5 @@ from .serial_class import get_serial_class_data as get_serial_class_data
 from .serial_class import get_serial_string_enum_data as get_serial_string_enum_data
 from .serial_class import serial_class as serial_class
 from .serial_class import serial_string_enum as serial_string_enum
+from .serial_union import serial_union_annotation as serial_union_annotation
+from .serial_union import get_serial_union_data as get_serial_union_data

pkgs/serialization/serial_union.py

@@ -0,0 +1,81 @@
+import dataclasses
+import typing
+
+T = typing.TypeVar("T")
+
+
+class IdentityHashWrapper(typing.Generic[T]):
+    """This allows unhashable types to be used in the SerialUnion, like dict.
+    Since we have only one copy of the types themselves, we rely on
+    object identity for the hashing."""
+
+    def __init__(self, inner: T) -> None:
+        self.inner = inner
+
+    def __hash__(self) -> int:
+        return id(self.inner)
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class _SerialUnion:
+    """
+    This class is to be kept private, to provide flexibility in registration/lookup.
+    Places that need the data should access it via help classes/methods.
+    """
+
+    # If specified, indicates the Union has a discriminator which should be used to
+    # determine which type to parse.
+    discriminator: typing.Optional[str] = None
+    discriminator_map: typing.Optional[IdentityHashWrapper[dict[str, type]]] = None
+
+
+def serial_union_annotation(
+    *,
+    discriminator: typing.Optional[str] = None,
+    discriminator_map: typing.Optional[dict[str, type]] = None,
+) -> _SerialUnion:
+    return _SerialUnion(
+        discriminator=discriminator,
+        discriminator_map=IdentityHashWrapper(discriminator_map)
+        if discriminator_map is not None
+        else None,
+    )
+
+
+def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
+    if not hasattr(parsed_type, "__metadata__"):
+        return None
+    metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
+    if not isinstance(metadata, tuple) or len(metadata) != 1:
+        return None
+    serial = metadata[0]
+    if not isinstance(serial, _SerialUnion):
+        return None
+    return serial
+
+
+class SerialClassInspector(typing.Generic[T]):
+    def __init__(self, parsed_type: type[T], serial_union: _SerialUnion) -> None:
+        self._parsed_type = parsed_type
+        self._serial_union = serial_union
+
+    def get_union_underlying(self) -> type[T]:
+        return typing.get_args(self._parsed_type)[0]  # type:ignore[no-any-return]
+
+    @property
+    def discriminator(self) -> typing.Optional[str]:
+        return self._serial_union.discriminator
+
+    @property
+    def discriminator_map(self) -> typing.Optional[dict[str, type]]:
+        if self._serial_union.discriminator_map is None:
+            return None
+        return self._serial_union.discriminator_map.inner
+
+
+def get_serial_union_data(parsed_type: type[T]) -> SerialClassInspector[T] | None:
+    serial = _get_serial_union(parsed_type)
+    if serial is None:
+        return None
+
+    return SerialClassInspector(parsed_type, serial)

pkgs/serialization_util/__init__.py

@@ -1,8 +1,5 @@
+from .convert_to_snakecase import convert_dict_to_snake_case
 from .serialization_helpers import (
-    convert_dict_to_snake_case,
-    convert_to_camelcase,
-    resolve_missing_to_none,
-    serialize,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
@@ -10,9 +7,6 @@ from .serialization_helpers import (
 
 __all__: list[str] = [
     "convert_dict_to_snake_case",
-    "convert_to_camelcase",
-    "resolve_missing_to_none",
-    "serialize",
     "serialize_for_api",
     "serialize_for_storage",
     "serialize_for_storage_dict",

pkgs/serialization_util/convert_to_snakecase.py

@@ -0,0 +1,27 @@
+from typing import (
+    Any,
+)
+
+from pkgs.argument_parser import camel_to_snake_case
+from pkgs.serialization import (
+    MISSING_SENTRY,
+    OpaqueKey,
+)
+
+
+def _key_convert_to_snake_case(o: Any) -> Any:
+    if isinstance(o, OpaqueKey):
+        return o
+    if isinstance(o, str):
+        return camel_to_snake_case(o)
+    return o
+
+
+def convert_dict_to_snake_case(data: Any) -> Any:
+    return {
+        _key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
+        if isinstance(v, dict)
+        else v
+        for k, v in data.items()
+        if v != MISSING_SENTRY
+    }

pkgs/serialization_util/serialization_helpers.py

@@ -5,16 +5,16 @@ from decimal import Decimal
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
+    ClassVar,
+    Protocol,
     TypeVar,
     Union,
+    overload,
 )
 
-from pkgs.argument_parser import camel_to_snake_case, snake_to_camel_case
+from pkgs.argument_parser import snake_to_camel_case
 from pkgs.serialization import (
     MISSING_SENTRY,
-    MissingSentryType,
-    MissingType,
     OpaqueKey,
     get_serial_class_data,
 )
@@ -28,52 +28,60 @@ if TYPE_CHECKING:
 else:
     JsonValue = Union[JsonScalar, dict[str, Any], list[Any]]
 
+T = TypeVar("T")
+
+
+class Dataclass(Protocol):
+    __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
+
 
-def key_convert_to_camelcase(o: Any) -> Any:
+def identity(x: T) -> T:
+    return x
+
+
+def key_convert_to_camelcase(o: Any) -> str:
     if isinstance(o, OpaqueKey):
         return o
     if isinstance(o, enum.Enum):
-        return o.value
+        return o.value  # type: ignore[no-any-return]
     if isinstance(o, str):
         return snake_to_camel_case(o)
-    return o
+    return o  # type: ignore[no-any-return]
 
 
-def _convert_dict(d: Any) -> Any:
+def _convert_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {
-        key_convert_to_camelcase(k): convert_to_camelcase(v)
+        key_convert_to_camelcase(k): serialize_for_api(v)
         for k, v in d.items()
         if v != MISSING_SENTRY
     }
 
 
-def _serialize_dict(d: Any) -> dict[str, Any]:
-    return {k: serialize(v) for k, v in d.items() if v != MISSING_SENTRY}
+def _serialize_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
+    return {k: serialize_for_storage(v) for k, v in d.items() if v != MISSING_SENTRY}
 
 
-def _convert_dataclass(d: Any) -> Any:
+def _convert_dataclass(d: Dataclass) -> dict[str, JsonValue]:
     dct = type(d)
     scd = get_serial_class_data(dct)
 
-    def key_convert(key: Any) -> Any:
+    def key_convert(key: str) -> str:
         if scd.has_unconverted_key(key):
             return key
         return key_convert_to_camelcase(key)
 
-    def value_convert(key: Any, value: Any) -> Any:
-        if value is None:
-            return None
+    def value_convert(key: str, value: Any) -> JsonValue:
         if scd.has_to_string_value(key):
             # Limit to types we know we need to support to avoid surprises
             # Generics, like List/Dict would need to be per-value stringified
             assert isinstance(value, (Decimal, int))
             return str(value)
         if scd.has_unconverted_value(key):
-            return value
-        return convert_to_camelcase(value)
+            return value  # type: ignore[no-any-return]
+        return serialize_for_api(value)  # type: ignore[no-any-return,unused-ignore]
 
     return {
-        key_convert(k): value_convert(k, v)
+        key_convert(k): (value_convert(k, v) if v is not None else None)
         for k, v in d.__dict__.items()
         if v != MISSING_SENTRY
     }
@@ -83,24 +91,35 @@ _SERIALIZATION_FUNCS_STANDARD = {
     SerializationType.ENUM: lambda x: str(x.value),
     SerializationType.DATE: lambda x: x.isoformat(),
     SerializationType.TIMEDELTA: lambda x: x.total_seconds(),
-    SerializationType.UNKNOWN: lambda x: x,
+    SerializationType.UNKNOWN: identity,
 }
 
-_CONVERSION_SERIALIZATION_FUNCS = {
+_CONVERSION_SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     SerializationType.NAMED_TUPLE: lambda x: _convert_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [convert_to_camelcase(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_api(v) for v in x],
     SerializationType.DICT: _convert_dict,
     SerializationType.DATACLASS: _convert_dataclass,
 }
 
 
-def convert_to_camelcase(obj: Any) -> Any:
-    """@DEPRECATED prefer serialize_for_api"""
-    return serialize_for_api(obj)
+@overload
+def serialize_for_api(obj: None) -> None: ...
+
+
+@overload
+def serialize_for_api(obj: dict[str, Any]) -> dict[str, JsonValue]: ...
 
 
-def serialize_for_api(obj: Any) -> Any:
+@overload
+def serialize_for_api(obj: Dataclass) -> dict[str, JsonValue]: ...
+
+
+@overload
+def serialize_for_api(obj: Any) -> JsonValue: ...
+
+
+def serialize_for_api(obj: Any) -> JsonValue:
     """
     Serialize to a parsed-JSON format suitably encoded for API output.
 
@@ -122,15 +141,10 @@ _SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     **_SERIALIZATION_FUNCS_DICT,
     SerializationType.NAMED_TUPLE: lambda x: _serialize_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [serialize(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_storage(v) for v in x],
 }
 
 
-def serialize(obj: Any) -> Any:
-    """@DEPRECATED: prefer serialize_for_storage"""
-    return serialize_for_storage(obj)
-
-
 def serialize_for_storage(obj: Any) -> JsonValue:
     """
     Convert a value into the pseudo-JSON form for
@@ -142,34 +156,9 @@ def serialize_for_storage(obj: Any) -> JsonValue:
     return _SERIALIZATION_FUNCS[serialization_type](obj)
 
 
-def serialize_for_storage_dict(obj: Any) -> dict[str, JsonValue]:
+def serialize_for_storage_dict(obj: dict | Dataclass) -> dict[str, JsonValue]:  # type: ignore[type-arg]
     """
     Same as serialize for storage but guarantees outer object is a dictionary
     """
-    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    serialization_type = get_serialization_type(type(obj))
     return _SERIALIZATION_FUNCS_DICT[serialization_type](obj)
-
-
-def key_convert_to_snake_case(o: Any) -> Any:
-    if isinstance(o, OpaqueKey):
-        return o
-    if isinstance(o, str):
-        return camel_to_snake_case(o)
-    return o
-
-
-def convert_dict_to_snake_case(data: Any) -> Any:
-    return {
-        key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
-        if isinstance(v, dict)
-        else v
-        for k, v in data.items()
-        if v != MISSING_SENTRY
-    }
-
-
-T = TypeVar("T")
-
-
-def resolve_missing_to_none(val: MissingType[T]) -> Optional[T]:
-    return val if not isinstance(val, MissingSentryType) else None

pkgs/type_spec/builder.py

@@ -102,6 +102,8 @@ class DefnTypeName(StrEnum):
     s_string_enum = "StringEnum"
     # a particular literal value
     s_string_literal = "_StringLiteral"
+    # A union of several other types
+    s_union = "Union"
 
 
 base_namespace_name = "base"
@@ -547,13 +549,65 @@ class SpecTypeDefnAlias(SpecTypeDefn):
         super().base_process(builder, data, ["type", "desc", "alias", "discriminator"])
         self.alias = builder.parse_type(self.namespace, data["alias"])
         self.desc = data.get("desc", None)
-        # Should be limited to Union type aliases
         self.discriminator = data.get("discriminator", None)
 
     def get_referenced_types(self) -> list[SpecType]:
         return [self.alias]
 
 
+class SpecTypeDefnUnion(SpecTypeDefn):
+    def __init__(self, namespace: SpecNamespace, name: str) -> None:
+        super().__init__(namespace, name)
+        self.discriminator: str | None = None
+        self.types: list[SpecType] = []
+        self._alias_type: SpecType | None = None
+        self.discriminator_map: dict[str, SpecType] | None = None
+        self.desc: str | None = None
+
+    def process(self, builder: SpecBuilder, data: RawDict) -> None:
+        super().base_process(builder, data, ["type", "desc", "types", "discriminator"])
+
+        self.desc = data.get("desc", None)
+        self.discriminator = data.get("discriminator", None)
+
+        for sub_type_str in data["types"]:
+            sub_type = builder.parse_type(self.namespace, sub_type_str)
+            self.types.append(sub_type)
+
+        base_type = builder.namespaces[base_namespace_name].types[BaseTypeName.s_union]
+        self._backing_type = SpecTypeInstance(base_type, self.types)
+
+        if self.discriminator is not None:
+            self.discriminator_map = {}
+            for sub_type in self.types:
+                builder.push_where(sub_type.name)
+                assert isinstance(
+                    sub_type, SpecTypeDefnObject
+                ), "union-type-must-be-object"
+                assert sub_type.properties is not None
+                discriminator_type = sub_type.properties.get(self.discriminator)
+                assert (
+                    discriminator_type is not None
+                ), f"missing-discriminator-field: {sub_type}"
+                prop_type = unwrap_literal_type(discriminator_type.spec_type)
+                assert prop_type is not None
+                assert prop_type.is_value_to_string()
+                discriminant = str(prop_type.value)
+                assert (
+                    discriminant not in self.discriminator_map
+                ), f"duplicated-discriminant, {discriminant} in {sub_type}"
+                self.discriminator_map[discriminant] = sub_type
+
+                builder.pop_where()
+
+    def get_referenced_types(self) -> list[SpecType]:
+        return self.types
+
+    def get_backing_type(self) -> SpecType:
+        assert self._backing_type is not None
+        return self._backing_type
+
+
 class SpecTypeDefnExternal(SpecTypeDefn):
     external_map: dict[str, str]
 
@@ -1017,6 +1071,8 @@ class SpecNamespace:
             spec_type: SpecTypeDefn
             if defn_type == DefnTypeName.s_alias:
                 spec_type = SpecTypeDefnAlias(self, name)
+            elif defn_type == DefnTypeName.s_union:
+                spec_type = SpecTypeDefnUnion(self, name)
             elif defn_type == DefnTypeName.s_external:
                 spec_type = SpecTypeDefnExternal(self, name)
             elif defn_type == DefnTypeName.s_string_enum:

pkgs/type_spec/emit_open_api.py

@@ -430,6 +430,12 @@ def _emit_type(
         ctx.types[stype.name] = open_api_type(ctx, stype.alias, config=config)
         return
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.types[stype.name] = open_api_type(
+            ctx, stype.get_backing_type(), config=config
+        )
+        return
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         # TODO: check that these are always string enums
         # IMPROVE: reflect the enum names in the description

pkgs/type_spec/emit_python.py

@@ -43,6 +43,7 @@ class TrackingContext:
     use_serial_string_enum: bool = False
     use_dataclass: bool = False
     use_serial_class: bool = False
+    use_serial_union: bool = False
     use_missing: bool = False
     use_opaque_key: bool = False
 
@@ -219,6 +220,8 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
         out.write("from dataclasses import dataclass\n")
     if ctx.use_serial_class:
         out.write("from pkgs.serialization import serial_class\n")
+    if ctx.use_serial_union:
+        out.write("from pkgs.serialization import serial_union_annotation\n")
     if ctx.use_serial_string_enum:
         out.write("from pkgs.serialization import serial_string_enum\n")
     if ctx.use_missing:
@@ -727,6 +730,26 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
         ctx.out.write(f"{stype.name} = {refer_to(ctx, stype.alias)}\n")
         return
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.use_serial_union = True
+        ctx.out.write(f"{stype.name} = typing.Annotated[\n")
+        ctx.out.write(f"{INDENT}{refer_to(ctx, stype.get_backing_type())},\n")
+        ctx.out.write(f"{INDENT}serial_union_annotation(\n")
+        if stype.discriminator is not None:
+            ctx.out.write(
+                f"{INDENT * 2}discriminator={util.encode_common_string(stype.discriminator)},\n"
+            )
+        if stype.discriminator_map is not None:
+            ctx.out.write(f"{INDENT * 2}discriminator_map={{\n")
+            for key, value in stype.discriminator_map.items():
+                ctx.out.write(
+                    f"{INDENT * 3}{util.encode_common_string(key)}: {refer_to(ctx, value)},\n"
+                )
+            ctx.out.write(f"{INDENT * 2}}},\n")
+        ctx.out.write(f"{INDENT}),\n")
+        ctx.out.write("]\n")
+        return
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         return _emit_string_enum(ctx, stype)
 

pkgs/type_spec/emit_typescript.py

@@ -303,6 +303,12 @@ def _emit_type(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
         ctx.out.write(f"export type {stype.name} = {refer_to(ctx, stype.alias)}\n")
         return
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.out.write(
+            f"export type {stype.name} = {refer_to(ctx, stype.get_backing_type())}\n"
+        )
+        return
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         ctx.out.write(f"export enum {stype.name} {{\n")
         assert stype.values

pkgs/type_spec/type_info/emit_type_info.py

@@ -1,5 +1,6 @@
 import copy
 import dataclasses
+import decimal
 import io
 import json
 from typing import Any, Optional, TypeAlias, Union, cast
@@ -7,7 +8,10 @@ from typing import Any, Optional, TypeAlias, Union, cast
 from main.base.types import data_t
 from main.base.types.base import PureJsonValue
 from pkgs.argument_parser import CachedParser
-from pkgs.serialization_util import serialize_for_api, serialize_for_storage
+from pkgs.serialization_util import (
+    serialize_for_api,
+    serialize_for_storage,
+)
 
 from .. import builder, util
 from ..emit_typescript_util import MODIFY_NOTICE, ts_name
@@ -69,12 +73,21 @@ def _dict_null_strip(data: dict[str, object]) -> dict[str, object]:
     }
 
 
+class JsonEncoder(json.JSONEncoder):
+    """We have some defaults of special types that we need to emit"""
+
+    def default(self, obj: object) -> object:
+        if isinstance(obj, decimal.Decimal):
+            return str(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
 def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
     type_map = _build_map_all(build)
 
     # sort for stability, indent for smaller diffs
     stripped = _dict_null_strip(dataclasses.asdict(type_map))
-    serial = json.dumps(stripped, sort_keys=True, indent=2)
+    serial = json.dumps(stripped, sort_keys=True, indent=2, cls=JsonEncoder)
     type_map_out = io.StringIO()
     type_map_out.write(MODIFY_NOTICE)
     type_map_out.write(f"export const TYPE_MAP = {serial}")
@@ -287,7 +300,7 @@ def _build_map_type(
             properties=properties,
             desc=stype.desc,
             base_type_path=type_path_of(stype.base),
-            ext_info=serialize_for_api(ext_info),
+            ext_info=serialize_for_api(ext_info),  # type: ignore[arg-type]
         )
 
         if stype.properties is not None:
@@ -301,7 +314,7 @@ def _build_map_type(
                     api_name=ts_name(prop.name, prop.name_case),
                     extant=prop.extant,
                     type_path=type_path_of(prop.spec_type),
-                    ext_info=serialize_for_api(parts.ext_info),
+                    ext_info=serialize_for_api(parts.ext_info),  # type: ignore[arg-type]
                     desc=parts.desc,
                     default=prop.default,
                 )
@@ -319,6 +332,19 @@ def _build_map_type(
             discriminator=stype.discriminator,
         )
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        # Emit as a basic alias for now, as the front-end supports only those for now
+        # IMPROVE: We should emit a proper union type and support that
+        backing = stype.get_backing_type()
+        return MapTypeAlias(
+            type_name=stype.name,
+            label=stype.label,
+            desc=stype.desc,
+            alias_type_path=type_path_of(backing),
+            ext_info=_convert_ext_info(stype.ext_info),
+            discriminator=stype.discriminator,
+        )
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         return MapStringEnum(
             type_name=stype.name,

uncountable/types/api/recipes/edit_recipe_inputs.py

@@ -10,6 +10,7 @@ from decimal import Decimal  # noqa: F401
 from pkgs.strenum_compat import StrEnum
 from dataclasses import dataclass
 from pkgs.serialization import serial_class
+from pkgs.serialization import serial_union_annotation
 from ... import identifier as identifier_t
 from ... import recipe_inputs as recipe_inputs_t
 from ... import recipe_workflow_steps as recipe_workflow_steps_t
@@ -114,7 +115,18 @@ class RecipeInputEditUpdateAnnotations(RecipeInputEditInputBase):
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
-RecipeInputEdit = typing.Union[RecipeInputEditClearInputs, RecipeInputEditUpsertInput, RecipeInputEditAddInput, RecipeInputEditUpdateAnnotations]
+RecipeInputEdit = typing.Annotated[
+    typing.Union[RecipeInputEditClearInputs, RecipeInputEditUpsertInput, RecipeInputEditAddInput, RecipeInputEditUpdateAnnotations],
+    serial_union_annotation(
+        discriminator="type",
+        discriminator_map={
+            "clear_inputs": RecipeInputEditClearInputs,
+            "upsert_input": RecipeInputEditUpsertInput,
+            "add_input": RecipeInputEditAddInput,
+            "update_annotations": RecipeInputEditUpdateAnnotations,
+        },
+    ),
+]
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/recipe_workflow_steps.py

@@ -10,6 +10,7 @@ from decimal import Decimal  # noqa: F401
 from pkgs.strenum_compat import StrEnum
 from dataclasses import dataclass
 from pkgs.serialization import serial_class
+from pkgs.serialization import serial_union_annotation
 from . import identifier as identifier_t
 
 __all__: list[str] = [
@@ -64,14 +65,24 @@ class RecipeWorkflowStepIdentifierWorkflowStep(RecipeWorkflowStepIdentifierBase)
 
 # DO NOT MODIFY -- This file is generated by type_spec
 @serial_class(
-    parse_require={"key_type"},
+    parse_require={"type"},
 )
 @dataclass(kw_only=True)
 class RecipeWorkflowStepIdentifierKey:
-    key_type: typing.Literal[RecipeWorkflowStepIdentifierType.IDENTIFIER_KEY] = RecipeWorkflowStepIdentifierType.IDENTIFIER_KEY
+    type: typing.Literal[RecipeWorkflowStepIdentifierType.IDENTIFIER_KEY] = RecipeWorkflowStepIdentifierType.IDENTIFIER_KEY
     recipe_workflow_step_key: identifier_t.IdentifierKey
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
-RecipeWorkflowStepIdentifier = typing.Union[RecipeWorkflowStepIdentifierDefault, RecipeWorkflowStepIdentifierWorkflowStep, RecipeWorkflowStepIdentifierKey]
+RecipeWorkflowStepIdentifier = typing.Annotated[
+    typing.Union[RecipeWorkflowStepIdentifierDefault, RecipeWorkflowStepIdentifierWorkflowStep, RecipeWorkflowStepIdentifierKey],
+    serial_union_annotation(
+        discriminator="type",
+        discriminator_map={
+            "default": RecipeWorkflowStepIdentifierDefault,
+            "workflow_step": RecipeWorkflowStepIdentifierWorkflowStep,
+            "identifier_key": RecipeWorkflowStepIdentifierKey,
+        },
+    ),
+]
 # DO NOT MODIFY -- This file is generated by type_spec