UncountablePythonSDK 0.0.31__tar.gz → 0.0.34__tar.gz

{uncountablepythonsdk-0.0.31/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.31
+Version: 0.0.34
 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 → uncountablepythonsdk-0.0.34/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.31
+Version: 0.0.34
 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 → uncountablepythonsdk-0.0.34}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -37,8 +37,10 @@ pkgs/serialization/__init__.py
 pkgs/serialization/missing_sentry.py
 pkgs/serialization/opaque_key.py
 pkgs/serialization/serial_class.py
+pkgs/serialization/serial_union.py
 pkgs/serialization_util/__init__.py
 pkgs/serialization_util/_get_type_for_serialization.py
+pkgs/serialization_util/convert_to_snakecase.py
 pkgs/serialization_util/serialization_helpers.py
 pkgs/strenum_compat/__init__.py
 pkgs/strenum_compat/strenum_compat.py

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/UncountablePythonSDK.egg-info/requires.txt

@@ -1,7 +1,7 @@
 aiotus==0.*
 aiohttp==3.*
 requests==2.*
-SQLAlchemy==1.4.*
+SQLAlchemy>=1.4.0
 APScheduler==3.*
 python-dateutil==2.*
 shelljob==0.*

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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:

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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

uncountablepythonsdk-0.0.34/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)

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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",

uncountablepythonsdk-0.0.34/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
+    }

uncountablepythonsdk-0.0.34/pkgs/serialization_util/serialization_helpers.py

@@ -0,0 +1,230 @@
+import dataclasses
+import datetime
+import enum
+import functools
+from collections.abc import Callable, Mapping, Sequence
+from decimal import Decimal
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Protocol,
+    TypeVar,
+    Union,
+    overload,
+)
+
+try:
+    import flask
+except Exception:
+    pass
+
+from pkgs.argument_parser import snake_to_camel_case
+from pkgs.serialization import (
+    MISSING_SENTRY,
+    OpaqueKey,
+    get_serial_class_data,
+)
+
+from ._get_type_for_serialization import SerializationType, get_serialization_type
+
+# Inlined types which otherwise would import from types/base.py
+JsonScalar = Union[str, float, bool, Decimal, None, datetime.datetime, datetime.date]
+if TYPE_CHECKING:
+    JsonValue = Union[JsonScalar, Mapping[str, "JsonValue"], Sequence["JsonValue"]]
+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 identity(x: T) -> T:
+    return x
+
+
+def key_convert_to_camelcase(o: Any) -> str:
+    if isinstance(o, OpaqueKey):
+        return o
+    if isinstance(o, enum.StrEnum):
+        return o.value
+    if isinstance(o, enum.Enum):
+        try:
+            print(
+                "DEPRECATED_SERIALIZATION--non-string-enum-used-as-key",
+                flask.request.path,
+            )
+        except Exception:
+            pass
+        return o.value  # type: ignore[no-any-return]
+    if isinstance(o, str):
+        return snake_to_camel_case(o)
+    if isinstance(o, int):
+        # temporary bypass to maintain behavior
+        return o  # type: ignore[return-value]
+    try:
+        print("DEPRECATED_SERIALIZATION--non-string-used-as-key", o, flask.request.path)
+    except Exception:
+        pass
+    return o  # type: ignore[no-any-return]
+
+
+def _convert_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
+    return {
+        key_convert_to_camelcase(k): serialize_for_api(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 _to_string_value(value: Any) -> str:
+    assert isinstance(value, (Decimal, int))
+    return str(value)
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataclassConversions:
+    key_conversions: dict[str, str]
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]]
+
+
+@functools.lru_cache(maxsize=10000)
+def _get_dataclass_conversion_lookups(dataclass_type: Any) -> DataclassConversions:
+    scd = get_serial_class_data(dataclass_type)
+
+    key_conversions: dict[str, str] = {}
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]] = {}
+
+    for field in dataclasses.fields(dataclass_type):
+        key = field.name
+        if scd.has_unconverted_key(key):
+            key_conversions[key] = key
+        else:
+            key_conversions[key] = key_convert_to_camelcase(key)
+
+        if scd.has_to_string_value(key):
+            value_conversion_functions[key] = _to_string_value
+        elif scd.has_unconverted_value(key):
+            value_conversion_functions[key] = identity
+        else:
+            value_conversion_functions[key] = serialize_for_api
+
+    return DataclassConversions(
+        key_conversions=key_conversions,
+        value_conversion_functions=value_conversion_functions,
+    )
+
+
+def _convert_dataclass(d: Any) -> dict[str, JsonValue]:
+    conversions = _get_dataclass_conversion_lookups(type(d))  # type: ignore[arg-type]
+    # return {
+    #     conversions.key_conversions[k]: (
+    #         conversions.value_conversion_functions[k](v) if v is not None else None
+    #     )
+    #     for k, v in d.__dict__.items()
+    #     if v != MISSING_SENTRY
+    # }
+
+    serialized_data_class: dict[str, JsonValue] = {}
+    for k, v in d.__dict__.items():
+        if v == MISSING_SENTRY:
+            continue
+        if k not in conversions.key_conversions:
+            try:
+                print(
+                    "DEPRECATED_SERIALIZATION--missing-dataclass-key",
+                    k,
+                    flask.request.path,
+                )
+            except Exception:
+                pass
+            continue
+        serialized_data_class[conversions.key_conversions[k]] = (
+            conversions.value_conversion_functions[k](v) if v is not None else None
+        )
+
+    return serialized_data_class
+
+
+_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: identity,
+}
+
+_CONVERSION_SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
+    **_SERIALIZATION_FUNCS_STANDARD,
+    SerializationType.NAMED_TUPLE: lambda x: _convert_dict(x._asdict()),
+    SerializationType.ITERABLE: lambda x: [serialize_for_api(v) for v in x],
+    SerializationType.DICT: _convert_dict,
+    SerializationType.DATACLASS: _convert_dataclass,
+}
+
+
+@overload
+def serialize_for_api(obj: None) -> None: ...
+
+
+@overload
+def serialize_for_api(obj: dict[str, Any]) -> dict[str, JsonValue]: ...
+
+
+@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.
+
+    Use the CachedParser.parse_api to parse this data.
+    """
+    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    return _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+
+
+_SERIALIZATION_FUNCS_DICT: dict[
+    SerializationType, Callable[[Any], dict[str, JsonValue]]
+] = {
+    SerializationType.DICT: _serialize_dict,
+    SerializationType.DATACLASS: lambda x: _serialize_dict(x.__dict__),
+}
+
+
+_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_for_storage(v) for v in x],
+}
+
+
+def serialize_for_storage(obj: Any) -> JsonValue:
+    """
+    Convert a value into the pseudo-JSON form for
+    storage in the DB, file, or other non-API use.
+
+    Use the CachedParser.parse_storage to parse this data.
+    """
+    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    return _SERIALIZATION_FUNCS[serialization_type](obj)
+
+
+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))
+    return _SERIALIZATION_FUNCS_DICT[serialization_type](obj)

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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:

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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)
 

{uncountablepythonsdk-0.0.31 → uncountablepythonsdk-0.0.34}/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