UncountablePythonSDK 0.0.92__tar.gz → 0.0.95__tar.gz

{uncountablepythonsdk-0.0.92/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: UncountablePythonSDK
-Version: 0.0.92
+Version: 0.0.95
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -38,6 +38,7 @@ Requires-Dist: simplejson==3.*
 Requires-Dist: grpcio==1.67.1
 Requires-Dist: protobuf>=4.21.1
 Requires-Dist: azure-storage-blob==12.*
+Requires-Dist: boto3-stubs[essential,ses]==1.36.4
 Provides-Extra: test
 Requires-Dist: mypy==1.*; extra == "test"
 Requires-Dist: ruff==0.*; extra == "test"

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: UncountablePythonSDK
-Version: 0.0.92
+Version: 0.0.95
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -38,6 +38,7 @@ Requires-Dist: simplejson==3.*
 Requires-Dist: grpcio==1.67.1
 Requires-Dist: protobuf>=4.21.1
 Requires-Dist: azure-storage-blob==12.*
+Requires-Dist: boto3-stubs[essential,ses]==1.36.4
 Provides-Extra: test
 Requires-Dist: mypy==1.*; extra == "test"
 Requires-Dist: ruff==0.*; extra == "test"

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ pkgs/serialization/serial_generic.py
 pkgs/serialization/serial_union.py
 pkgs/serialization/yaml.py
 pkgs/serialization_util/__init__.py
+pkgs/serialization_util/_env_flags.py
 pkgs/serialization_util/_get_type_for_serialization.py
 pkgs/serialization_util/convert_to_snakecase.py
 pkgs/serialization_util/dataclasses.py

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/UncountablePythonSDK.egg-info/requires.txt

@@ -20,6 +20,7 @@ simplejson==3.*
 grpcio==1.67.1
 protobuf>=4.21.1
 azure-storage-blob==12.*
+boto3-stubs[essential,ses]==1.36.4
 
 [test]
 mypy==1.*

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/argument_parser/argument_parser.py

@@ -96,7 +96,7 @@ def is_missing(field_type: typing.Any) -> bool:
     return not (len(args) == 0 or args[0] is not MissingSentryType)
 
 
-def _invoke_tuple_parsers(
+def _invoke_tuple_parsers[T](
     tuple_type: type[T],
     arg_parsers: typing.Sequence[typing.Callable[[typing.Any], object]],
     has_ellipsis: bool,
@@ -133,7 +133,7 @@ def _invoke_fallback_parsers(
     ) from ExceptionGroup("Fallback Parser Exception", exceptions)
 
 
-def _invoke_membership_parser(
+def _invoke_membership_parser[T](
     expected_values: set[T],
     value: typing.Any,
 ) -> T:
@@ -148,7 +148,7 @@ def _invoke_membership_parser(
     raise ValueError(f"Expected value from {expected_values} but got value {value}")
 
 
-def _build_parser_discriminated_union(
+def _build_parser_discriminated_union[T](
     context: ParserContext,
     discriminator: str,
     discriminator_map: dict[str, ParserFunction[T]],
@@ -170,7 +170,7 @@ def _build_parser_discriminated_union(
     return parse
 
 
-def _build_parser_inner(
+def _build_parser_inner[T](
     parsed_type: type[T],
     context: ParserContext,
 ) -> ParserFunction[T]:
@@ -368,7 +368,7 @@ def _build_parser_inner(
     raise ValueError(f"Unhandled type {parsed_type}")
 
 
-def _build_parser_dataclass(
+def _build_parser_dataclass[T](
     parsed_type: type[T],
     context: ParserContext,
 ) -> ParserFunction[T]:
@@ -479,7 +479,7 @@ def _build_parser_dataclass(
 _CACHE_MAP: dict[ParserOptions, ParserCache] = defaultdict(ParserCache)
 
 
-def build_parser(
+def build_parser[T](
     parsed_type: type[T],
     options: ParserOptions,
 ) -> ParserFunction[T]:
@@ -501,7 +501,7 @@ def build_parser(
     return built_parser
 
 
-class CachedParser(typing.Generic[T]):
+class CachedParser[T]:
     def __init__(
         self,
         args: type[T],

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/filesystem_utils/_s3_session.py

@@ -1,6 +1,7 @@
 from io import BytesIO
 
 from boto3.session import Session
+from mypy_boto3_s3.service_resource import Bucket
 
 from pkgs.filesystem_utils.file_type_utils import (
     FileObjectData,
@@ -37,7 +38,7 @@ class S3Session(FileSystemSession):
             aws_session_token=self.config.session_token,
         )
 
-        self.bucket = s3_resource.Bucket(self.config.bucket_name)
+        self.bucket: Bucket | None = s3_resource.Bucket(self.config.bucket_name)
 
     def __enter__(self) -> "S3Session":
         self.start()

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/annotation.py

@@ -16,7 +16,7 @@ class SerialBase:
     from_decorator: bool = False
 
 
-def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
+def get_serial_annotation[T](parsed_type: type[T]) -> SerialBase | None:
     if not hasattr(parsed_type, "__metadata__"):
         return None
     metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
@@ -28,7 +28,7 @@ def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
     return serial
 
 
-class SerialInspector(typing.Generic[T]):
+class SerialInspector[T]:
     def __init__(self, parsed_type: type[T], serial_base: SerialBase) -> None:
         self._parsed_type = parsed_type
         self._serial_base = serial_base
@@ -53,7 +53,7 @@ class SerialInspector(typing.Generic[T]):
         return self._serial_base.is_dynamic_allowed
 
 
-def unwrap_annotated(parsed_type: type[T]) -> type[T]:
+def unwrap_annotated[T](parsed_type: type[T]) -> type[T]:
     """
     If the type is an annotated type then return the origin of it.
     Otherwise return the original type.

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/missing_sentry.py

@@ -26,5 +26,5 @@ MISSING_SENTRY = MissingSentryType()
 MissingType = Union[MissingSentryType, ClassT]
 
 
-def coalesce_missing_sentry(value: MissingType[ClassT]) -> ClassT | None:
+def coalesce_missing_sentry[ClassT](value: MissingType[ClassT]) -> ClassT | None:
     return None if isinstance(value, MissingSentryType) else value

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/serial_alias.py

@@ -26,7 +26,7 @@ def serial_alias_annotation(
     )
 
 
-def _get_serial_alias(parsed_type: type[T]) -> _SerialAlias | None:
+def _get_serial_alias[T](parsed_type: type[T]) -> _SerialAlias | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialAlias):
         return None
@@ -39,7 +39,7 @@ class SerialAliasInspector(SerialInspector[T]):
         self._serial_alias = serial_alias
 
 
-def get_serial_alias_data(parsed_type: type[T]) -> SerialAliasInspector[T] | None:
+def get_serial_alias_data[T](parsed_type: type[T]) -> SerialAliasInspector[T] | None:
     serial = _get_serial_alias(parsed_type)
     if serial is None:
         return None

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/serial_class.py

@@ -119,7 +119,7 @@ def get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | No
     return base_class_data
 
 
-def get_serial_class_data(
+def get_serial_class_data[_ClassT](
     type_class: type[_ClassT],
 ) -> SerialClassDataInspector[_ClassT]:
     return SerialClassDataInspector(

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/serial_generic.py

@@ -6,7 +6,7 @@ from .serial_class import get_merged_serial_class_data
 T = typing.TypeVar("T")
 
 
-def get_serial_data(parsed_type: type[T]) -> SerialInspector[T] | None:
+def get_serial_data[T](parsed_type: type[T]) -> SerialInspector[T] | None:
     serial = get_serial_annotation(parsed_type)
     if serial is None:
         serial = get_merged_serial_class_data(parsed_type)

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization/serial_union.py

@@ -6,7 +6,7 @@ from .annotation import SerialBase, SerialInspector, get_serial_annotation
 T = typing.TypeVar("T")
 
 
-class IdentityHashWrapper(typing.Generic[T]):
+class IdentityHashWrapper[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."""
@@ -49,7 +49,7 @@ def serial_union_annotation(
     )
 
 
-def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
+def _get_serial_union[T](parsed_type: type[T]) -> _SerialUnion | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialUnion):
         return None
@@ -76,7 +76,7 @@ class SerialClassInspector(SerialInspector[T]):
         return self._serial_union.discriminator_map.inner
 
 
-def get_serial_union_data(parsed_type: type[T]) -> SerialClassInspector[T] | None:
+def get_serial_union_data[T](parsed_type: type[T]) -> SerialClassInspector[T] | None:
     serial = _get_serial_union(parsed_type)
     if serial is None:
         return None

uncountablepythonsdk-0.0.95/pkgs/serialization_util/_env_flags.py

@@ -0,0 +1,3 @@
+import os
+
+USE_FASTJSON: bool = os.environ.get("USE_FASTJSON", "false").lower() == "true"

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/serialization_util/serialization_helpers.py

@@ -12,7 +12,6 @@ from typing import (
     Any,
     ClassVar,
     Protocol,
-    TypeVar,
     Union,
     overload,
 )
@@ -24,6 +23,7 @@ from pkgs.serialization import (
     get_serial_class_data,
 )
 
+from ._env_flags import USE_FASTJSON
 from ._get_type_for_serialization import SerializationType, get_serialization_type
 from .dataclasses import iterate_fields
 
@@ -34,14 +34,12 @@ 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 identity(x: T) -> T:
+def identity[T](x: T) -> T:
     return x
 
 
@@ -112,7 +110,9 @@ def _get_dataclass_conversion_lookups(dataclass_type: Any) -> DataclassConversio
         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
+            value_conversion_functions[key] = (
+                serialize_for_storage if USE_FASTJSON else identity
+            )
         else:
             value_conversion_functions[key] = serialize_for_api
 

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/actions_registry/__main__.py

@@ -6,7 +6,6 @@ import os
 import sys
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import TypeVar
 
 from main.base.types import actions_registry_t
 from pkgs.type_spec import builder
@@ -22,9 +21,6 @@ key_short_description = "short_description"
 key_description = "description"
 
 
-TypeT = TypeVar("TypeT")
-
-
 class InvalidSpecException(Exception):
     pass
 

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/builder.py

@@ -901,16 +901,9 @@ class SpecEndpoint:
     account_type: str | None
     route_group: str | None
 
-    # to be deprecated in favor of path_per_api_endpoint:
-    # default function, path details
-    function: str | None
-    root: EndpointKey
-    path_root: str
-    path_dirname: str
-    path_basename: str
-
     # function, path details per api endpoint
     path_per_api_endpoint: dict[str, EndpointSpecificPath]
+    default_endpoint_key: EndpointKey
 
     is_external: bool = False
 
@@ -997,14 +990,18 @@ class SpecEndpoint:
         self.has_attachment = data.get("has_attachment", False)
         self.desc = data.get("desc")
 
+        # compatibility with single-endpoint files
         default_endpoint_path = parse_endpoint_specific_path(
             builder,
             {"path": data.get("path"), "function": data.get("function")},
         )
         if default_endpoint_path is not None:
-            self.root = default_endpoint_path.root
+            assert default_endpoint_path.root in builder.api_endpoints, (
+                "Default endpoint is not a valid API endpoint"
+            )
+            self.default_endpoint_key = default_endpoint_path.root
             self.path_per_api_endpoint = {
-                self.root: default_endpoint_path,
+                self.default_endpoint_key: default_endpoint_path,
             }
         else:
             self.path_per_api_endpoint = {}
@@ -1021,27 +1018,34 @@ class SpecEndpoint:
                         if shared_function_name is None:
                             shared_function_name = fn_name
                         assert shared_function_name == fn_name
-            assert self.path_per_api_endpoint != {}
 
-            assert builder.top_namespace in self.path_per_api_endpoint
-            self.root = builder.top_namespace
+            if builder.top_namespace in self.path_per_api_endpoint:
+                self.default_endpoint_key = builder.top_namespace
+            elif len(self.path_per_api_endpoint) == 1:
+                self.default_endpoint_key = next(
+                    iter(self.path_per_api_endpoint.keys())
+                )
+            else:
+                raise RuntimeError("no clear default endpoint")
 
-        default_endpoint_path = self.path_per_api_endpoint[self.root]
-        self.function = default_endpoint_path.function
-        self.path_dirname = default_endpoint_path.path_dirname
-        self.path_basename = default_endpoint_path.path_basename
-        self.path_root = default_endpoint_path.path_root
+        assert len(self.path_per_api_endpoint) > 0, (
+            "Missing API endpoint path and function definitions for API call"
+        )
 
         # IMPROVE: remove need for is_external flag
-        self.is_external = self.path_root == "api/external"
+        self.is_external = (
+            self.path_per_api_endpoint[self.default_endpoint_key].path_root
+            == "api/external"
+        )
 
         assert self.is_sdk != EndpointEmitType.EMIT_ENDPOINT or self.desc is not None, (
-            f"Endpoint description required for SDK endpoints, missing: {self.path_dirname}/{self.path_basename}"
+            f"Endpoint description required for SDK endpoints, missing: {self.resolved_path}"
         )
 
     @property
     def resolved_path(self: Self) -> str:
-        return f"{self.path_root}/{self.path_dirname}/{self.path_basename}"
+        default_endpoint_path = self.path_per_api_endpoint[self.default_endpoint_key]
+        return f"{default_endpoint_path.path_root}/{default_endpoint_path.path_dirname}/{default_endpoint_path.path_basename}"
 
 
 def _parse_const(

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/config.py

@@ -1,7 +1,7 @@
 import os
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Self, TypeVar
+from typing import Self
 
 from pkgs.serialization import yaml
 
@@ -103,10 +103,7 @@ class Config:
     open_api: OpenAPIConfig | None
 
 
-_T = TypeVar("_T")
-
-
-def _parse_language(config_class: type[_T], raw_value: ConfigValueType) -> _T:
+def _parse_language[_T](config_class: type[_T], raw_value: ConfigValueType) -> _T:
     assert isinstance(raw_value, dict), "expecting language config to have key/values."
     return config_class(**raw_value)
 

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/emit_open_api.py

@@ -563,7 +563,7 @@ def _emit_endpoint(
     ep = namespace.endpoint
     gctx.paths.append(
         EmitOpenAPIPath(
-            path=f"/{ep.path_root}/{ep.path_dirname}/{ep.path_basename}",
+            path=f"/{ep.resolved_path}",
             ref=ref_path,
         )
     )

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/emit_python.py

@@ -5,16 +5,14 @@ from decimal import Decimal
 from typing import Any
 
 from . import builder, util
-from .builder import EndpointEmitType
+from .builder import EndpointEmitType, EndpointSpecificPath
 from .config import PythonConfig
 
 INDENT = "    "
 LINE_BREAK = "\n"
 MODIFY_NOTICE = "# DO NOT MODIFY -- This file is generated by type_spec\n"
 # Turn excess line length warning and turn off ruff formatting
-LINT_HEADER = (
-    "# flake8: noqa: F821\n# ruff: noqa: E402 Q003\n# fmt: off\n# isort: skip_file\n"
-)
+LINT_HEADER = "# ruff: noqa: E402 Q003\n# fmt: off\n# isort: skip_file\n"
 LINT_FOOTER = "# fmt: on\n"
 ROUTE_NOTICE = """# Routes are generated from $endpoint specifications in the
 # type_spec API YAML files. Refer to the section on endpoints in the type_spec/README"""
@@ -221,7 +219,7 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
     out.write("import datetime  # noqa: F401\n")
     out.write("from decimal import Decimal  # noqa: F401\n")
     if ctx.use_enum:
-        out.write("from pkgs.strenum_compat import StrEnum\n")
+        out.write("from enum import StrEnum\n")
     if ctx.use_dataclass:
         out.write("import dataclasses\n")
         out.write("from pkgs.serialization import serial_class\n")
@@ -349,13 +347,17 @@ ENDPOINT_PATH = "ENDPOINT_PATH"
 ENDPOINT_PATH_ALTERNATE = "ENDPOINT_PATH_ALTERNATE"
 
 
+def _get_epf_root(endpoint_specific_path: EndpointSpecificPath) -> str:
+    return endpoint_specific_path.root
+
+
 def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
     endpoint = namespace.endpoint
     if endpoint is not None:
         ctx.out.write("\n")
         ctx.out.write(f'{ENDPOINT_METHOD} = "{endpoint.method.upper()}"\n')
         for endpoint_specific_path in sorted(
-            endpoint.path_per_api_endpoint.values(), key=lambda epf: epf.root
+            endpoint.path_per_api_endpoint.values(), key=_get_epf_root
         ):
             endpoint_path_name = ENDPOINT_PATH
 
@@ -457,8 +459,10 @@ def _emit_endpoint_invocation_function_signature(
         else []
     ) + (extra_params if extra_params is not None else [])
 
-    assert endpoint.function is not None
-    function_name = endpoint.function.split(".")[-1]
+    # All endpoints share a function name
+    function = endpoint.path_per_api_endpoint[endpoint.default_endpoint_key].function
+    assert function is not None
+    function_name = function.split(".")[-1]
     ctx.out.write(
         f"""
     def {function_name}(
@@ -716,40 +720,43 @@ def _emit_properties(
     if len(properties) > 0:
 
         def write_field(prop: builder.SpecProperty) -> None:
+            stype = prop.spec_type
             if prop.name_case == builder.NameCase.preserve:
                 unconverted_keys.add(prop.name)
             py_name = python_field_name(prop.name, prop.name_case)
 
             if prop.convert_value == builder.PropertyConvertValue.no_convert:
                 unconverted_values.add(py_name)
-            elif not prop.spec_type.is_value_converted():
+            elif not stype.is_value_converted():
                 assert prop.convert_value == builder.PropertyConvertValue.auto
                 unconverted_values.add(py_name)
-            if prop.spec_type.is_value_to_string():
+            if stype.is_value_to_string():
                 to_string_values.add(py_name)
 
             if prop.parse_require:
                 parse_require.add(py_name)
 
-            ref_type = refer_to(ctx, prop.spec_type)
+            ref_type = refer_to(ctx, stype)
             default = None
             if prop.extant == builder.PropertyExtant.missing:
                 ref_type = f"MissingType[{ref_type}]"
                 default = "MISSING_SENTRY"
                 ctx.use_missing = True
             elif prop.extant == builder.PropertyExtant.optional:
-                if ref_type != "None":
+                if isinstance(
+                    stype, builder.SpecTypeInstance
+                ) and stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+                    pass  # base type already adds the None union
+                elif ref_type == "None":
+                    pass  # no need to add a None union to a none type
+                else:
                     ref_type = f"{ref_type} | None"
                 default = "None"
             elif prop.has_default:
-                default = _emit_value(ctx, prop.spec_type, prop.default)
+                default = _emit_value(ctx, stype, prop.default)
                 if (
-                    isinstance(prop.spec_type, builder.SpecTypeInstance)
-                    and (
-                        prop.spec_type.defn_type.is_base_type(
-                            builder.BaseTypeName.s_list
-                        )
-                    )
+                    isinstance(stype, builder.SpecTypeInstance)
+                    and (stype.defn_type.is_base_type(builder.BaseTypeName.s_list))
                     and default == "[]"
                 ):
                     default = "dataclasses.field(default_factory=list)"
@@ -939,13 +946,22 @@ base_name_map = {
 
 def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
     if isinstance(stype, builder.SpecTypeInstance):
-        params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
+        params = [refer_to(ctx, p) for p in stype.parameters]
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_union):
+            if len(stype.parameters) == 1:
+                return f"typing.Union[{params[0]}]"
+            return " | ".join(params)
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_readonly_array):
-            assert len(stype.parameters) == 1, "Read Only Array takes one parameter"
-            params = f"{params}, ..."
+            assert len(params) == 1, "Read Only Array takes one parameter"
+            return f"tuple[{params[0]}, ...]"
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+            assert len(params) == 1, "Optional only takes one parameter"
+            return f"{params[0]} | None"
 
-        return f"{refer_to(ctx, stype.defn_type)}[{params}]"
+        return f"{refer_to(ctx, stype.defn_type)}[{', '.join(params)}]"
 
     if isinstance(stype, builder.SpecTypeLiteralWrapper):
         return _emit_value(ctx, stype.value_type, stype.value)
@@ -1111,8 +1127,8 @@ def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
         return None
     enum_out = io.StringIO()
     enum_out.write(f"{LINT_HEADER}{MODIFY_NOTICE}\n")
-    enum_out.write("from typing import Literal, Union\n")
-    enum_out.write("from pkgs.strenum_compat import StrEnum\n")
+    enum_out.write("import typing\n")
+    enum_out.write("from enum import StrEnum\n")
 
     ctx = TrackingContext()
     # In this context the propername
@@ -1128,11 +1144,11 @@ def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
     known_keys = []
     enum_out.write("\nENUM_MAP: dict[str, type[StrEnum]] = {\n")
     for key in sorted(named_enums.keys()):
-        enum_out.write(f'"{key}": {named_enums[key]},\n')
-        known_keys.append(f'Literal["{key}"]')
+        enum_out.write(f'{INDENT}"{key}": {named_enums[key]},\n')
+        known_keys.append(f'"{key}"')
     enum_out.write(f"}}\n{MODIFY_NOTICE}\n")
 
-    enum_out.write(f"\nKnownEnumsType = Union[\n{INDENT}")
+    enum_out.write(f"\nKnownEnumsType = typing.Literal[\n{INDENT}")
     enum_out.write(f",\n{INDENT}".join(known_keys))
     enum_out.write(f"\n]\n{MODIFY_NOTICE}\n")
 

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/emit_typescript.py

@@ -2,6 +2,7 @@ import io
 import os
 
 from . import builder, util
+from .builder import EndpointKey, EndpointSpecificPath
 from .config import TypeScriptConfig
 from .emit_io_ts import emit_type_io_ts
 from .emit_typescript_util import (
@@ -46,7 +47,10 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             and len(namespace.constants) == 0
         ):
             # Try to capture some common incompleteness errors
-            if namespace.endpoint is None or namespace.endpoint.function is None:
+            if namespace.endpoint is None or any(
+                endpoint_specific_path.function is None
+                for endpoint_specific_path in namespace.endpoint.path_per_api_endpoint.values()
+            ):
                 raise Exception(
                     f"Namespace {'/'.join(namespace.path)} is incomplete. It should have an endpoint with function, types, and/or constants"
                 )
@@ -209,12 +213,15 @@ export type Response = DeprecatedResult
 
     """
 
-    endpoint_path_part = (
-        f'"{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",'
-    )
-
-    if has_multiple_endpoints:
+    if not has_multiple_endpoints:
+        default_endpoint_path = endpoint.path_per_api_endpoint[
+            endpoint.default_endpoint_key
+        ]
+        endpoint_path_part = f'"{default_endpoint_path.path_root}/{default_endpoint_path.path_dirname}/{default_endpoint_path.path_basename}",'
+    else:
         path_lookup_map = ""
+        api_endpoint_key: EndpointKey
+        endpoint_specific_path: EndpointSpecificPath
         for (
             api_endpoint_key,
             endpoint_specific_path,

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/parts/base.py.prepart

@@ -22,6 +22,8 @@ PureJsonScalar = Union[str, float, bool, None]
 # Regular expressions for identifying ref names and IDs. Ref names should be
 # using this regular expression as a constriant in the database.
 REF_NAME_REGEX = r"^[a-zA-Z0-9_/-]+$"
+REF_NAME_STRICT_REGEX_STRING = "^[a-zA-Z_][a-zA-Z0-9_]*$"
+REF_NAME_STRICT_REGEX = rf"{REF_NAME_STRICT_REGEX_STRING}"
 # Ids matching a strict integer number are converted to integers
 ID_REGEX = r"-?[1-9][0-9]{0,20}"
 

{uncountablepythonsdk-0.0.92 → uncountablepythonsdk-0.0.95}/pkgs/type_spec/util.py

@@ -1,12 +1,10 @@
 import json
 import os
 from dataclasses import dataclass
-from typing import TypeVar, Union
+from typing import Union
 
 import regex as re
 
-T = TypeVar("T")
-
 
 def rewrite_file(filename: str, content: str) -> bool:
     os.makedirs(os.path.dirname(filename), exist_ok=True)
@@ -156,7 +154,7 @@ def is_valid_property_name(name: str) -> bool:
     return re_pattern_property_name.match(name) is not None
 
 
-def check_fields(data: dict[str, T], allowed: list[str]) -> None:
+def check_fields[T](data: dict[str, T], allowed: list[str]) -> None:
     for key in data:
         if key not in allowed:
             raise Exception(f"unexpected-field: {key}. Allowed: {allowed}")
@@ -180,7 +178,7 @@ def encode_common_string(value: str) -> str:
     return rep
 
 
-def unused(_arg: T) -> None:
+def unused[T](_arg: T) -> None:
     """
     Identifies that an argument is intended not be used, as opposed to
     simply forgotten, or a remnant. This can happen in patterned calls