UncountablePythonSDK 0.0.190__py3-none-any.whl → 0.0.192__py3-none-any.whl

pkgs/argument_parser/parse_fallback.py

@@ -0,0 +1,26 @@
+import dataclasses
+import inspect
+import typing
+from collections.abc import Callable, Mapping
+
+from .parser_function_type import ParserFunction
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class DataclassParseFallback:
+    legacy_key: str
+    legacy_parser: ParserFunction[object]
+    convert: Callable[[typing.Any], object]
+
+    def applies(self, *, value: Mapping[str, object], field_raw_value: object) -> bool:
+        return (
+            field_raw_value is dataclasses.MISSING or field_raw_value is None
+        ) and value.get(self.legacy_key) is not None
+
+    def parse(self, value: Mapping[str, object]) -> object:
+        return self.convert(self.legacy_parser(value[self.legacy_key]))
+
+
+def parse_fallback_legacy_type(convert: Callable[..., object]) -> typing.Any:
+    legacy_parameter = next(iter(inspect.signature(convert).parameters))
+    return typing.get_type_hints(convert, include_extras=True)[legacy_parameter]

pkgs/argument_parser/parser_inner.py

@@ -15,6 +15,7 @@ import dateutil.parser
 from pkgs.serialization import (
     MissingSentryType,
     OpaqueKey,
+    SerialClassDataInspector,
     UnknownBrand,
     get_serial_class_data,
     get_serial_union_data,
@@ -22,6 +23,7 @@ from pkgs.serialization import (
 
 from .case_convert import camel_to_snake_case, snake_to_camel_case
 from .field_name_resolution import resolve_serialized_field_name
+from .parse_fallback import DataclassParseFallback, parse_fallback_legacy_type
 from .parser_error import (
     ParserEnumError,
     ParserError,
@@ -255,6 +257,39 @@ def _build_parser_for_type_alias(
     return build_parser_inner(alias.__value__, context, merged_alias_map)
 
 
+def _build_parser_for_dict(
+    *,
+    key_type: typing.Any,
+    value_type: typing.Any,
+    context: ParserContext,
+    type_var_map: dict[typing.TypeVar, type],
+) -> ParserFunction[T]:
+    k_inner_parser = build_parser_inner(
+        key_type,
+        context,
+        type_var_map,
+    )
+
+    def key_parser(value: typing.Any) -> object:
+        inner = k_inner_parser(value)
+        if (
+            isinstance(inner, str)
+            # enum keys and OpaqueData's would also have string value types,
+            # but their explicit type is not a string, thus shouldn't be converted
+            and key_type is str
+            and context.options.is_api_encoding
+        ):
+            return camel_to_snake_case(value)
+        return inner
+
+    v_parser = build_parser_inner(value_type, context, type_var_map)
+
+    def parse_dict(value: typing.Any) -> typing.Any:
+        return {key_parser(k): v_parser(v) for k, v in value.items()}
+
+    return parse_dict
+
+
 def _build_parser_for_collection(
     *,
     parsed_type: type[T]
@@ -289,6 +324,32 @@ def _build_parser_for_collection(
     return parse
 
 
+# first parse ints to decimal to allow scientific notation and decimals
+# e.g. (1) 1e4 => 1000, (2) 3.0 => 3
+def _parse_int(value: typing.Any) -> int:
+    if isinstance(value, str):
+        assert "_" not in value, "numbers with underscores not considered integers"
+
+    dec_value = Decimal(value)
+    int_value = int(dec_value)
+    assert int_value == dec_value, (
+        f"value ({value}) cannot be parsed to int without discarding precision"
+    )
+    return int_value
+
+
+def _parse_str(value: typing.Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (Decimal, float, int)):
+        return str(value)
+    raise ParserError(
+        f"Invalid string value: {type(value)}: {value}",
+        value=value,
+        expected_type=str,
+    )
+
+
 def build_parser_inner(
     parsed_type: type[T]
     | typing.TypeVar
@@ -437,53 +498,20 @@ def build_parser_inner(
                 "Dict types only support two arguments for now",
                 expected_type=parsed_type,
             )
-        k_inner_parser = build_parser_inner(
-            args[0],
-            context,
-            type_var_map,
+        key_type, value_type = args
+        return _build_parser_for_dict(
+            key_type=key_type,
+            value_type=value_type,
+            context=context,
+            type_var_map=type_var_map,
         )
 
-        def key_parser(value: typing.Any) -> object:
-            inner = k_inner_parser(value)
-            if (
-                isinstance(inner, str)
-                # enum keys and OpaqueData's would also have string value types,
-                # but their explicit type is not a string, thus shouldn't be converted
-                and args[0] is str
-                and context.options.is_api_encoding
-            ):
-                return camel_to_snake_case(value)
-            return inner
-
-        v_parser = build_parser_inner(args[1], context, type_var_map)
-
-        def parse_dict(value: typing.Any) -> typing.Any:
-            return origin((key_parser(k), v_parser(v)) for k, v in value.items())
-
-        return parse_dict
-
     if origin == typing.Literal:
         valid_values: set[T] = set(typing.get_args(parsed_type))
         return lambda value: _invoke_membership_parser(valid_values, value)
 
     if parsed_type is int:
-        # first parse ints to decimal to allow scientific notation and decimals
-        # e.g. (1) 1e4 => 1000, (2) 3.0 => 3
-
-        def parse_int(value: typing.Any) -> int:
-            if isinstance(value, str):
-                assert "_" not in value, (
-                    "numbers with underscores not considered integers"
-                )
-
-            dec_value = Decimal(value)
-            int_value = int(dec_value)
-            assert int_value == dec_value, (
-                f"value ({value}) cannot be parsed to int without discarding precision"
-            )
-            return int_value
-
-        return parse_int  # type: ignore[return-value]
+        return _parse_int  # type: ignore[return-value]
 
     if parsed_type is datetime.datetime:
 
@@ -511,19 +539,7 @@ def build_parser_inner(
     # MyPy: It's unclear why `parsed_type in (str, OpaqueKey)` is flagged as invalid
     # Thus an or statement is used instead, which isn't flagged as invalid.
     if parsed_type is str or parsed_type is OpaqueKey:
-
-        def parse_str(value: typing.Any) -> str:
-            if isinstance(value, str):
-                return value
-            if isinstance(value, (Decimal, float, int)):
-                return str(value)
-            raise ParserError(
-                f"Invalid string value: {type(value)}: {value}",
-                value=value,
-                expected_type=str,
-            )
-
-        return parse_str  # type: ignore[return-value]
+        return _parse_str  # type: ignore[return-value]
 
     if parsed_type in (float, Decimal):
         numeric_type: type[Decimal | float] = (
@@ -636,6 +652,7 @@ def _build_parser_dataclass(
     ] = []
 
     serial_class_data = get_serial_class_data(parsed_type)
+    dc_parse_fallbacks: dict[str, DataclassParseFallback] = {}
 
     def parse(value: typing.Any) -> typing.Any:
         # Use an exact type match to prevent base/derived class mismatches
@@ -656,10 +673,17 @@ def _build_parser_dataclass(
                     serialized_field_name,
                     dataclasses.MISSING,
                 )
+                parse_fallback = dc_parse_fallbacks.get(field.name)
                 if context.options.strict_property_parsing:
                     all_allowed_field_names.add(serialized_field_name)
+                    if parse_fallback is not None:
+                        all_allowed_field_names.add(parse_fallback.legacy_key)
                 field_value: typing.Any
-                if field_raw_value == dataclasses.MISSING:
+                if parse_fallback is not None and parse_fallback.applies(
+                    value=value, field_raw_value=field_raw_value
+                ):
+                    field_value = parse_fallback.parse(value)
+                elif field_raw_value == dataclasses.MISSING:
                     if serial_class_data.has_parse_require(field.name):
                         raise ParserError(
                             "missing-required-field", field_name=field.name
@@ -726,4 +750,42 @@ def _build_parser_dataclass(
             build_parser_inner(field_type_hint, context, type_var_map),
         ))
 
+    dc_parse_fallbacks.update(
+        _build_dataclass_parse_fallbacks(
+            parsed_type=parsed_type,
+            serial_class_data=serial_class_data,
+            context=context,
+            type_var_map=type_var_map,
+        )
+    )
+
     return parser_function
+
+
+def _build_dataclass_parse_fallbacks(
+    *,
+    parsed_type: type[DataclassT],
+    serial_class_data: SerialClassDataInspector[DataclassT],
+    context: ParserContext,
+    type_var_map: dict[typing.TypeVar, type],
+) -> dict[str, DataclassParseFallback]:
+    field_names = {field.name for field in dataclasses.fields(parsed_type)}
+    dc_parse_fallbacks: dict[str, DataclassParseFallback] = {}
+    for field_name, parse_fallback in serial_class_data.get_parse_fallbacks().items():
+        assert field_name in field_names, (
+            f"parse fallback for {field_name!r}, which is not a field of {parsed_type}"
+        )
+        dc_parse_fallbacks[field_name] = DataclassParseFallback(
+            legacy_key=resolve_serialized_field_name(
+                serial_class_data=serial_class_data,
+                field_name=parse_fallback.legacy_field,
+                source_encoding=context.options.encoding,
+            ),
+            legacy_parser=build_parser_inner(
+                parse_fallback_legacy_type(parse_fallback.convert),
+                context,
+                type_var_map,
+            ),
+            convert=parse_fallback.convert,
+        )
+    return dc_parse_fallbacks

pkgs/serialization/__init__.py

@@ -12,6 +12,7 @@ from .serial_alias import (
     serial_alias_annotation as serial_alias_annotation,
 )
 from .serial_class import (
+    ParseFallback as ParseFallback,
     SerialClassDataInspector as SerialClassDataInspector,
     get_serial_class_data as get_serial_class_data,
     get_serial_string_enum_data as get_serial_string_enum_data,

pkgs/serialization/serial_class.py

@@ -3,11 +3,18 @@ from __future__ import annotations
 import dataclasses
 from collections.abc import Callable
 from enum import StrEnum
-from typing import Any, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 
 from .annotation import SerialBase, SerialInspector, SerialType
 
 ClassT = TypeVar("ClassT")
+LegacyT = TypeVar("LegacyT")
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class ParseFallback(Generic[LegacyT]):
+    legacy_field: str
+    convert: Callable[[LegacyT], object]
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
@@ -17,6 +24,9 @@ class _SerialClassData(SerialBase):
     to_string_values: set[str] = dataclasses.field(default_factory=set)
     parse_require: set[str] = dataclasses.field(default_factory=set)
     emit_api_overrides: dict[str, str] = dataclasses.field(default_factory=dict)
+    parse_fallbacks: dict[str, ParseFallback[Any]] = dataclasses.field(
+        default_factory=dict
+    )
     named_type_path: str | None = None
 
 
@@ -30,6 +40,7 @@ def serial_class(
     to_string_values: set[str] | None = None,
     parse_require: set[str] | None = None,
     emit_api_overrides: dict[str, str] | None = None,
+    parse_fallbacks: dict[str, ParseFallback[Any]] | None = None,
     named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> Callable[[ClassT], ClassT]:
@@ -59,6 +70,12 @@ def serial_class(
         storage encoding are unaffected. Replaces the default camelCase
         conversion. Cannot be combined with `unconverted_keys` for the
         same field; doing so raises at parse and serialize time.
+    @param parse_fallbacks
+        Maps Python field name -> a legacy field that the parser reads when
+        the input omits the field or sets it to null. The parser parses the
+        legacy value with the type of the first parameter of `convert`, and
+        stores the result of `convert` in the field. The legacy field is not
+        part of the type, so serialization never writes it.
     @param named_type_path
         The type_spec type-path to this type. This applies only to named types.
     """
@@ -70,6 +87,7 @@ def serial_class(
             to_string_values=to_string_values or set(),
             parse_require=parse_require or set(),
             emit_api_overrides=emit_api_overrides or {},
+            parse_fallbacks=parse_fallbacks or {},
             named_type_path=named_type_path,
             from_decorator=True,
             is_dynamic_allowed=is_dynamic_allowed,
@@ -103,6 +121,9 @@ class SerialClassDataInspector(SerialInspector[ClassT]):
     def get_emit_api_override(self, key: str) -> str | None:
         return self.current.emit_api_overrides.get(key)
 
+    def get_parse_fallbacks(self) -> dict[str, ParseFallback[Any]]:
+        return self.current.parse_fallbacks
+
 
 def get_merged_serial_class_data(
     type_class: SerialType[Any],
@@ -136,6 +157,10 @@ def get_merged_serial_class_data(
                         **curr_base_class_data.emit_api_overrides,
                         **base_class_data.emit_api_overrides,
                     },
+                    parse_fallbacks={
+                        **curr_base_class_data.parse_fallbacks,
+                        **base_class_data.parse_fallbacks,
+                    },
                 )
     return base_class_data
 

pkgs/type_spec/builder.py

@@ -17,11 +17,12 @@ import regex
 from pkgs.serialization import Usage
 
 from . import util
-from .builder_types import CrossOutputPaths
+from .builder_types import CrossOutputPaths, PythonParseFallback
 from .non_discriminated_union_exceptions import NON_DISCRIMINATED_UNION_EXCEPTIONS
 from .util import parse_type_str
 
 RawDict = dict[Any, Any]
+PYTHON_PARSE_FALLBACK_KEYS = {"legacy_property", "convert"}
 EndpointKey = str
 RE_TYPESCRIPT_ENUM_MEMBER_NAME = regex.compile(
     r"^[$_\p{ID_Start}][$\p{ID_Continue}\u200c\u200d]*$"
@@ -312,6 +313,13 @@ def unwrap_literal_type(stype: SpecType) -> SpecTypeLiteralWrapper | None:
     return None
 
 
+def serialized_literal_value(*, literal: SpecTypeLiteralWrapper) -> str:
+    if isinstance(literal.value_type, SpecTypeDefnStringEnum):
+        assert isinstance(literal.value, str)
+        return literal.value_type.values[literal.value].value
+    return str(literal.value)
+
+
 class SpecTypeDefn(SpecType):
     """
     Base for type definitions. Do not instantiate this directly, use a derived class.
@@ -582,7 +590,7 @@ class SpecTypeDefnObject(SpecTypeDefn):
         self.properties: dict[str, SpecProperty] | None = None
         self._kw_only: bool = True
         self.desc: str | None = None
-        self.python_post_init: str | None = None
+        self.python_parse_fallbacks: dict[str, PythonParseFallback] = {}
 
     def is_value_converted(self) -> bool:
         if self.base and not self.base.is_value_converted():
@@ -615,7 +623,7 @@ class SpecTypeDefnObject(SpecTypeDefn):
                 "name_case",
                 "hashable",
                 "kw_only",
-                "python_post_init",
+                "python_parse_fallbacks",
             ],
         )
         type_base = builder.parse_type(self.namespace, data["type"], scope=self)
@@ -652,17 +660,47 @@ class SpecTypeDefnObject(SpecTypeDefn):
         self._kw_only = data.get("kw_only", True)
         self.desc = data.get("desc", None)
 
-        python_post_init = data.get("python_post_init")
-        if python_post_init is not None:
-            assert isinstance(python_post_init, str)
-            python_prepart = builder.preparts["python"].get(self.namespace.name, "")
-            python_post_init_def_prefix = f"def {python_post_init}"
+        python_parse_fallbacks = data.get("python_parse_fallbacks")
+        if python_parse_fallbacks is not None:
+            self.python_parse_fallbacks = self._process_python_parse_fallbacks(
+                builder, python_parse_fallbacks
+            )
+
+    def _process_python_parse_fallbacks(
+        self, builder: SpecBuilder, data: object
+    ) -> dict[str, PythonParseFallback]:
+        builder.ensure(
+            isinstance(data, dict),
+            "python_parse_fallbacks: expected a mapping of property name to fallback",
+        )
+        assert isinstance(data, dict)
+        property_names = set(self.properties or {})
+        parse_fallbacks: dict[str, PythonParseFallback] = {}
+        for property_name, fallback_data in data.items():
+            builder.ensure(
+                property_name in property_names,
+                f"python_parse_fallbacks: {property_name} is not a property of this type",
+            )
             builder.ensure(
-                f"{python_post_init_def_prefix}(" in python_prepart
-                or f"{python_post_init_def_prefix}[" in python_prepart,
-                f"python_post_init: the {self.namespace.name} python prepart file must define {python_post_init}",
+                isinstance(fallback_data, dict)
+                and set(fallback_data.keys()) == PYTHON_PARSE_FALLBACK_KEYS,
+                f"python_parse_fallbacks: {property_name} needs exactly the keys {sorted(PYTHON_PARSE_FALLBACK_KEYS)}",
             )
-            self.python_post_init = python_post_init
+            legacy_property = fallback_data["legacy_property"]
+            convert = fallback_data["convert"]
+            builder.ensure(
+                isinstance(legacy_property, str) and isinstance(convert, str),
+                f"python_parse_fallbacks: {property_name} legacy_property and convert must be strings",
+            )
+            builder.ensure_python_prepart_function(
+                namespace_name=self.namespace.name,
+                function_name=convert,
+                option_name="python_parse_fallbacks",
+            )
+            parse_fallbacks[property_name] = PythonParseFallback(
+                legacy_property=legacy_property, convert=convert
+            )
+        return parse_fallbacks
 
     def is_kw_only(self) -> bool:
         return self._kw_only
@@ -758,12 +796,7 @@ class SpecTypeDefnUnion(SpecTypeDefn):
                 prop_type = unwrap_literal_type(discriminator_type.spec_type)
                 assert prop_type is not None
                 assert prop_type.is_value_to_string()
-                value_type = prop_type.value_type
-                if isinstance(value_type, SpecTypeDefnStringEnum):
-                    assert isinstance(prop_type.value, str)
-                    discriminant = value_type.values[prop_type.value].value
-                else:
-                    discriminant = str(prop_type.value)
+                discriminant = serialized_literal_value(literal=prop_type)
                 assert discriminant not in self.discriminator_map, (
                     f"duplicated-discriminant, {discriminant} in {sub_type}"
                 )
@@ -1741,6 +1774,16 @@ class SpecBuilder:
             print(msg)
             raise BuilderError()
 
+    def ensure_python_prepart_function(
+        self, *, namespace_name: str, function_name: str, option_name: str
+    ) -> None:
+        python_prepart = self.preparts["python"].get(namespace_name, "")
+        def_prefix = f"def {function_name}"
+        self.ensure(
+            f"{def_prefix}(" in python_prepart or f"{def_prefix}[" in python_prepart,
+            f"{option_name}: the {namespace_name} python prepart file must define {function_name}",
+        )
+
     def prescan(self, namespace_path: str, data: RawDict) -> None:
         assert namespace_path not in self.namespaces
         namespace = SpecNamespace(namespace_path)

pkgs/type_spec/builder_types.py

@@ -7,3 +7,9 @@ class CrossOutputPaths:
     typescript_types_output: str
     typescript_routes_output_by_endpoint: dict[str, str]
     typespec_files_input: list[str]
+
+
+@dataclass(kw_only=True, frozen=True)
+class PythonParseFallback:
+    legacy_property: str
+    convert: str

pkgs/type_spec/emit_io_ts.py

@@ -73,7 +73,7 @@ def _emit_type_io_ts_impl(ctx: EmitTypescriptContext, stype: builder.SpecType) -
         missable_lines = []
         for prop in stype.properties.values():
             ref_type = refer_to_io_ts(ctx, prop.spec_type)
-            prop_name = ts_property_name(prop, stype.name_case)
+            prop_name = ts_property_name(prop)
             if prop.extant == builder.PropertyExtant.missing:
                 # Unlike optional below, missing does not imply null is possible. They
                 # treated distinctly.

pkgs/type_spec/emit_open_api.py

@@ -12,11 +12,11 @@ from enum import StrEnum
 from typing import assert_never, cast
 
 from pkgs.serialization import yaml
-from pkgs.serialization_util import serialize_for_api
 
 from . import builder, util
 from .builder import EndpointGuideKey, RootGuideKey
 from .config import OpenAPIConfig
+from .emit_open_api_examples import emit_endpoint_example
 from .emit_open_api_util import (
     MODIFY_NOTICE,
     EmitOpenAPIContext,
@@ -50,6 +50,9 @@ from .open_api_util import (
     OpenAPIUnionType,
 )
 
+ARGUMENTS_TYPE_NAME = "Arguments"
+DATA_TYPE_NAME = "Data"
+
 base_name_map = {
     builder.BaseTypeName.s_boolean: OpenAPIBooleanT,
     builder.BaseTypeName.s_date: OpenAPIStringT,  # IMPROVE: Aliased DateStr
@@ -212,14 +215,14 @@ def _emit_endpoint_argument_examples(
     if len(examples) == 0:
         return {}
 
-    response_examples = {}
+    argument_examples = {}
     for example in examples:
-        response_examples[example.ref_name] = {
+        argument_examples[example.ref_name] = {
             "summary": example.summary,
             "description": example.description,
             "value": example.arguments,
         }
-    return {"examples": response_examples}
+    return {"examples": argument_examples}
 
 
 def _emit_endpoint_parameter_examples(
@@ -228,7 +231,7 @@ def _emit_endpoint_parameter_examples(
     if len(examples) == 0:
         return {}
 
-    paramater_examples = []
+    parameter_examples = []
     comment_new_line = "\n// "
     new_line = "\n"
     for example in examples:
@@ -236,12 +239,12 @@ def _emit_endpoint_parameter_examples(
             f"// {comment_new_line.join(example.description.split(new_line))}"
         )
         javascript_json_payload = f"{json.dumps(example.arguments, indent=2)}"
-        paramater_examples.append({
+        parameter_examples.append({
             "lang": "JavaScript",
             "label": f"Payload - {example.summary}",
             "source": f"{javascript_description}\n{javascript_json_payload}",
         })
-    return {"x-codeSamples": paramater_examples}
+    return {"x-codeSamples": parameter_examples}
 
 
 def _emit_endpoint_parameters(
@@ -428,7 +431,7 @@ def _emit_namespace(
 
     if ctx.endpoint is not None:
         endpoint = ctx.endpoint
-        argument_type = ctx.types.get("Arguments")
+        argument_type = ctx.types.get(ARGUMENTS_TYPE_NAME)
         oa_endpoint = dict()
         oa_endpoint[endpoint.method] = (
             {
@@ -464,19 +467,19 @@ def _emit_namespace(
     if ctx.endpoint is not None:
         # OpenAPI always expected Arguments and Data create
         # them here if they were not already created
-        if "Arguments" not in types:
-            types["Arguments"] = OpenAPIObjectType({})
-        if "Data" not in types:
-            types["Data"] = OpenAPIObjectType({})
+        if ARGUMENTS_TYPE_NAME not in types:
+            types[ARGUMENTS_TYPE_NAME] = OpenAPIObjectType({})
+        if DATA_TYPE_NAME not in types:
+            types[DATA_TYPE_NAME] = OpenAPIObjectType({})
 
-    if ctx.endpoint is not None and "Data" in ctx.types:
+    if ctx.endpoint is not None and DATA_TYPE_NAME in ctx.types:
         # IMPROVE: Handle the general case here: wrap result in data object
-        types["Data"] = OpenAPIObjectType({"data": types["Data"]})
+        types[DATA_TYPE_NAME] = OpenAPIObjectType({"data": types[DATA_TYPE_NAME]})
 
-    if ctx.endpoint is not None and "Arguments" in ctx.types:
+    if ctx.endpoint is not None and ARGUMENTS_TYPE_NAME in ctx.types:
         # OpenAPI Expects a different format for arguments
         # then for regular types; do conversion here
-        raw_type = types["Arguments"]
+        raw_type = types[ARGUMENTS_TYPE_NAME]
         if isinstance(
             raw_type, (OpenAPIIntersectionType, OpenAPIUnionType, OpenAPIRefType)
         ):
@@ -584,7 +587,7 @@ def _emit_type(
 
     for prop in stype.properties.values():
         ref_type = open_api_type(ctx, prop.spec_type, config=config)
-        prop_name = ts_property_name(prop, prop.name_case or stype.name_case)
+        prop_name = ts_property_name(prop)
         if prop.desc:
             property_desc[prop_name] = prop.desc
         if prop.has_default and not prop.parse_require:
@@ -638,18 +641,17 @@ def _emit_endpoint(
     assert namespace.endpoint is not None
     assert namespace.path[0] == "api"
 
-    has_arguments = "Arguments" in namespace.types
-    has_data = "Data" in namespace.types
+    arguments_type = namespace.types.get(ARGUMENTS_TYPE_NAME)
+    data_type = namespace.types.get(DATA_TYPE_NAME)
     has_deprecated_result = "DeprecatedResult" in namespace.types
     is_binary = endpoint.result_type == builder.ResultType.binary
 
-    result_type_count = sum([has_data, has_deprecated_result, is_binary])
+    result_type_count = sum([data_type is not None, has_deprecated_result, is_binary])
 
     assert result_type_count < 2
-    is_binary = endpoint.result_type == builder.ResultType.binary
 
     # Don't emit interface for those with unsupported types
-    if not has_arguments or result_type_count == 0:
+    if arguments_type is None or result_type_count == 0:
         return
     if not is_binary and endpoint.result_type != builder.ResultType.json:
         return
@@ -686,12 +688,11 @@ def _emit_endpoint(
         deprecated=namespace.endpoint.deprecated,
         stability_level=namespace.endpoint.stability_level,
         examples=[
-            EmitOpenAPIEndpointExample(
+            emit_endpoint_example(
+                arguments_type=arguments_type,
+                data_type=data_type,
+                example=example,
                 ref_name=f"ex_{i}",
-                summary=example.summary,
-                description=example.description,
-                arguments=serialize_for_api(example.arguments),
-                data=serialize_for_api(example.data),
             )
             for i, example in enumerate(endpoint_examples)
         ],
@@ -752,11 +753,7 @@ def open_api_type(
             parts: list[str] = []
             for parameter in stype.parameters:
                 assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
-                if isinstance(parameter.value_type, builder.SpecTypeDefnStringEnum):
-                    assert isinstance(parameter.value, str)
-                    parts.append(parameter.value_type.values[parameter.value].value)
-                else:
-                    parts.append(str(parameter.value))
+                parts.append(builder.serialized_literal_value(literal=parameter))
 
             return OpenAPIEnumType(parts)
         if stype.defn_type.name == builder.BaseTypeName.s_optional: