UncountablePythonSDK 0.0.190__tar.gz → 0.0.192__tar.gz

{uncountablepythonsdk-0.0.190/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.192}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.190
+Version: 0.0.192
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UncountablePythonSDK
-Version: 0.0.190
+Version: 0.0.192
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ pkgs/argument_parser/__init__.py
 pkgs/argument_parser/cached_parser.py
 pkgs/argument_parser/case_convert.py
 pkgs/argument_parser/field_name_resolution.py
+pkgs/argument_parser/parse_fallback.py
 pkgs/argument_parser/parser_base.py
 pkgs/argument_parser/parser_builder.py
 pkgs/argument_parser/parser_cache.py
@@ -111,6 +112,7 @@ pkgs/type_spec/config.py
 pkgs/type_spec/cross_output_links.py
 pkgs/type_spec/emit_io_ts.py
 pkgs/type_spec/emit_open_api.py
+pkgs/type_spec/emit_open_api_examples.py
 pkgs/type_spec/emit_open_api_util.py
 pkgs/type_spec/emit_python.py
 pkgs/type_spec/emit_scss.py
@@ -143,6 +145,7 @@ uncountable/core/async_batch.py
 uncountable/core/client.py
 uncountable/core/environment.py
 uncountable/core/file_upload.py
+uncountable/core/tls.py
 uncountable/core/types.py
 uncountable/core/query/__init__.py
 uncountable/core/query/builder.py
@@ -155,6 +158,8 @@ uncountable/integration/construct_client.py
 uncountable/integration/cron.py
 uncountable/integration/entrypoint.py
 uncountable/integration/job.py
+uncountable/integration/job_queue.py
+uncountable/integration/ownership_lock.py
 uncountable/integration/request_context.py
 uncountable/integration/scan_profiles.py
 uncountable/integration/scheduler.py
@@ -260,6 +265,8 @@ uncountable/types/listing.py
 uncountable/types/listing_t.py
 uncountable/types/ml_reports.py
 uncountable/types/ml_reports_t.py
+uncountable/types/notebook_files.py
+uncountable/types/notebook_files_t.py
 uncountable/types/notices.py
 uncountable/types/notices_t.py
 uncountable/types/notifications.py

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/UncountablePythonSDK.egg-info/scm_file_list.json

@@ -56,6 +56,7 @@
     "pkgs/argument_parser/cached_parser.py",
     "pkgs/argument_parser/case_convert.py",
     "pkgs/argument_parser/field_name_resolution.py",
+    "pkgs/argument_parser/parse_fallback.py",
     "pkgs/argument_parser/parser_base.py",
     "pkgs/argument_parser/parser_builder.py",
     "pkgs/argument_parser/parser_cache.py",
@@ -110,6 +111,7 @@
     "pkgs/type_spec/cross_output_links.py",
     "pkgs/type_spec/emit_io_ts.py",
     "pkgs/type_spec/emit_open_api.py",
+    "pkgs/type_spec/emit_open_api_examples.py",
     "pkgs/type_spec/emit_open_api_util.py",
     "pkgs/type_spec/emit_python.py",
     "pkgs/type_spec/emit_scss.py",
@@ -143,6 +145,7 @@
     "uncountable/core/query/column.py",
     "uncountable/core/query/row.py",
     "uncountable/core/query/types.py",
+    "uncountable/core/tls.py",
     "uncountable/core/types.py",
     "uncountable/integration/__init__.py",
     "uncountable/integration/cli.py",
@@ -159,6 +162,8 @@
     "uncountable/integration/http_server/__init__.py",
     "uncountable/integration/http_server/types.py",
     "uncountable/integration/job.py",
+    "uncountable/integration/job_queue.py",
+    "uncountable/integration/ownership_lock.py",
     "uncountable/integration/queue_runner/__init__.py",
     "uncountable/integration/queue_runner/command_server/__init__.py",
     "uncountable/integration/queue_runner/command_server/command_client.py",
@@ -388,6 +393,8 @@
     "uncountable/types/listing_t.py",
     "uncountable/types/ml_reports.py",
     "uncountable/types/ml_reports_t.py",
+    "uncountable/types/notebook_files.py",
+    "uncountable/types/notebook_files_t.py",
     "uncountable/types/notices.py",
     "uncountable/types/notices_t.py",
     "uncountable/types/notifications.py",

uncountablepythonsdk-0.0.192/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]

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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,

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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
 

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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)

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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

{uncountablepythonsdk-0.0.190 → uncountablepythonsdk-0.0.192}/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.