UncountablePythonSDK 0.0.72__tar.gz → 0.0.74__tar.gz

{uncountablepythonsdk-0.0.72/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.74}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.72
+Version: 0.0.74
 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.72 → uncountablepythonsdk-0.0.74}/examples/integration-server/jobs/materials_auto/profile.yaml

@@ -1,4 +1,4 @@
-base_url: http://0.0.0.0:5000
+base_url: http://host.docker.internal:5000
 auth_retrieval:
   type: basic
   api_id_secret:

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/argument_parser/__init__.py

@@ -1,4 +1,5 @@
 from .argument_parser import CachedParser as CachedParser
+from .argument_parser import ParserFunction as ParserFunction
 from .argument_parser import ParserOptions as ParserOptions
 from .argument_parser import build_parser as build_parser
 from .case_convert import camel_to_snake_case as camel_to_snake_case

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/argument_parser/argument_parser.py

@@ -1,4 +1,5 @@
 import dataclasses
+import math
 import types
 import typing
 from collections import defaultdict
@@ -299,7 +300,18 @@ def _build_parser_inner(
 
         return parse_str
 
-    if parsed_type in (float, dict, bool, Decimal) or is_string_enum_class(parsed_type):
+    if parsed_type in (float, Decimal):
+
+        def parse_as_numeric_type(value: typing.Any) -> T:
+            numeric_value: Decimal | float = parsed_type(value)  # type: ignore
+            if math.isnan(numeric_value):
+                raise ValueError(f"Invalid numeric value: {numeric_value}")
+
+            return numeric_value  # type: ignore
+
+        return parse_as_numeric_type
+
+    if parsed_type in (dict, bool) or is_string_enum_class(parsed_type):
         return lambda value: parsed_type(value)  # type: ignore
 
     if parsed_type is MissingSentryType:

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/serialization/serial_class.py

@@ -14,6 +14,11 @@ class _SerialClassData:
     unconverted_values: set[str] = dataclasses.field(default_factory=set)
     to_string_values: set[str] = dataclasses.field(default_factory=set)
     parse_require: set[str] = dataclasses.field(default_factory=set)
+    named_type_path: Optional[str] = None
+    # Tracks if this data was provided as a decorator to the type.
+    # This is used to track "proper types" which are appropriate
+    # for serialization and/or dynamic discovery
+    from_decorator: bool = False
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -25,6 +30,7 @@ def serial_class(
     unconverted_values: Optional[set[str]] = None,
     to_string_values: Optional[set[str]] = None,
     parse_require: Optional[set[str]] = None,
+    named_type_path: Optional[str] = None,
 ) -> Callable[[_ClassT], _ClassT]:
     """
     An additional decorator to a dataclass that specifies serialization options.
@@ -45,6 +51,8 @@ def serial_class(
         This field is always required while parsing, even if it has a default in the definition.
         This allows supporting literal type defaults for Python instantiation, but
         requiring them for the API input.
+    @param named_type_path
+        The type_spec type-path to this type. This applies only to named types.
     """
 
     def decorate(orig_class: _ClassT) -> _ClassT:
@@ -53,6 +61,8 @@ def serial_class(
             unconverted_values=unconverted_values or set(),
             to_string_values=to_string_values or set(),
             parse_require=parse_require or set(),
+            named_type_path=named_type_path,
+            from_decorator=True,
         )
         return orig_class
 
@@ -78,6 +88,14 @@ class SerialClassDataInspector:
     def has_parse_require(self, key: str) -> bool:
         return key in self.current.parse_require
 
+    @property
+    def from_decorator(self) -> bool:
+        return self.current.from_decorator
+
+    @property
+    def named_type_path(self) -> Optional[str]:
+        return self.current.named_type_path
+
 
 def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
     base_class_data = (

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/serialization/serial_union.py

@@ -27,18 +27,21 @@ class _SerialUnion:
     # determine which type to parse.
     discriminator: typing.Optional[str] = None
     discriminator_map: typing.Optional[IdentityHashWrapper[dict[str, type]]] = None
+    named_type_path: typing.Optional[str] = None
 
 
 def serial_union_annotation(
     *,
     discriminator: typing.Optional[str] = None,
     discriminator_map: typing.Optional[dict[str, type]] = None,
+    named_type_path: typing.Optional[str] = None,
 ) -> _SerialUnion:
     return _SerialUnion(
         discriminator=discriminator,
         discriminator_map=IdentityHashWrapper(discriminator_map)
         if discriminator_map is not None
         else None,
+        named_type_path=named_type_path,
     )
 
 

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/builder.py

@@ -307,6 +307,9 @@ class SpecTypeDefn(SpecType):
     def is_base_type(self, type_: BaseTypeName) -> bool:
         return self.is_base and self.name == type_
 
+    def can_process(self, builder: SpecBuilder, data: RawDict) -> bool:
+        return True
+
     @abc.abstractmethod
     def process(self, builder: SpecBuilder, data: RawDict) -> None: ...
 
@@ -666,15 +669,30 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
         self.desc: str | None = None
         self.sql_type_name: Optional[str] = None
         self.emit_id_source = False
+        self.source_enums: list[SpecType] = []
+
+    def can_process(self, builder: SpecBuilder, data: dict[Any, Any]) -> bool:
+        source_enums = data.get("source_enums")
+        try:
+            for sub_type_str in source_enums or []:
+                sub_type = builder.parse_type(self.namespace, sub_type_str)
+                assert isinstance(sub_type, SpecTypeDefnStringEnum)
+                assert len(sub_type.values) > 0
+        except AssertionError:
+            return False
+        return super().can_process(builder, data)
 
     def process(self, builder: SpecBuilder, data: RawDict) -> None:
         super().base_process(
-            builder, data, ["type", "desc", "values", "name_case", "sql", "emit"]
+            builder,
+            data,
+            ["type", "desc", "values", "name_case", "sql", "emit", "source_enums"],
         )
         self.name_case = NameCase(data.get("name_case", "convert"))
         self.values = {}
-        data_values = data["values"]
+        data_values = data.get("values")
         self.desc = data.get("desc", None)
+        source_enums = data.get("source_enums", None)
         if isinstance(data_values, dict):
             for name, value in data_values.items():
                 builder.push_where(name)
@@ -717,7 +735,8 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
                     )
                 self.values[value] = StringEnumEntry(name=value, value=value)
         else:
-            raise Exception("unsupported values type")
+            if source_enums is None or data_values is not None:
+                raise Exception("unsupported values type")
 
         sql_data = data.get("sql")
         if sql_data is not None:
@@ -739,9 +758,18 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
                 builder.ensure(
                     entry.label is not None, f"need-label-for-id-source:{entry.name}"
                 )
+        for sub_type_str in source_enums or []:
+            sub_type = builder.parse_type(self.namespace, sub_type_str)
+            self.source_enums.append(sub_type)
+
+        for sub_type in self.source_enums:
+            builder.push_where(sub_type.name)
+            if isinstance(sub_type, SpecTypeDefnStringEnum):
+                self.values.update(sub_type.values)
+            builder.pop_where()
 
     def get_referenced_types(self) -> list[SpecType]:
-        return []
+        return self.source_enums
 
 
 TOKEN_ENDPOINT = "$endpoint"
@@ -1122,28 +1150,41 @@ class SpecNamespace:
         Complete the definition of each type.
         """
         builder.push_where(self.name)
-        for full_name, defn in data.items():
-            parsed_name = parse_type_str(full_name)[0]
-            name = parsed_name.name
+        items_to_process: list[NameDataPair] = [
+            NameDataPair(full_name=full_name, data=defn)
+            for full_name, defn in data.items()
+        ]
+        while len(items_to_process) > 0:
+            deferred_items: list[NameDataPair] = []
+            for item in items_to_process:
+                full_name = item.full_name
+                defn = item.data
+                parsed_name = parse_type_str(full_name)[0]
+                name = parsed_name.name
+
+                if name in [TOKEN_EMIT_IO_TS, TOKEN_EMIT_TYPE_INFO, TOKEN_IMPORT]:
+                    continue
 
-            if name in [TOKEN_EMIT_IO_TS, TOKEN_EMIT_TYPE_INFO, TOKEN_IMPORT]:
-                continue
+                builder.push_where(name)
 
-            builder.push_where(name)
+                if "value" in defn:
+                    spec_constant = self.constants[name]
+                    spec_constant.process(builder, defn)
 
-            if "value" in defn:
-                spec_constant = self.constants[name]
-                spec_constant.process(builder, defn)
+                elif name == TOKEN_ENDPOINT:
+                    assert self.endpoint
+                    self.endpoint.process(builder, defn)
 
-            elif name == TOKEN_ENDPOINT:
-                assert self.endpoint
-                self.endpoint.process(builder, defn)
-
-            else:
-                spec_type = self.types[name]
-                spec_type.process(builder, defn)
+                else:
+                    spec_type = self.types[name]
+                    if spec_type.can_process(builder, defn):
+                        spec_type.process(builder, defn)
+                    else:
+                        deferred_items.append(item)
 
-            builder.pop_where()
+                builder.pop_where()
+            assert len(deferred_items) < len(items_to_process)
+            items_to_process = [deferred for deferred in deferred_items]
 
         builder.pop_where()
 
@@ -1158,8 +1199,15 @@ class NamespaceDataPair:
     data: RawDict
 
 
+@dataclass(kw_only=True)
+class NameDataPair:
+    full_name: str
+    data: RawDict
+
+
 class SpecBuilder:
-    def __init__(self, *, api_endpoints: dict[str, str]) -> None:
+    def __init__(self, *, api_endpoints: dict[str, str], top_namespace: str) -> None:
+        self.top_namespace = top_namespace
         self.where: list[str] = []
         self.namespaces = {}
         self.pending: list[NamespaceDataPair] = []

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/config.py

@@ -86,6 +86,7 @@ class OpenAPIConfig(BaseLanguageConfig):
 
 @dataclass(kw_only=True)
 class Config:
+    top_namespace: str
     type_spec_types: list[str]  # folders containing the yaml type spec definitions
     api_endpoint: dict[str, str]
     # languages
@@ -130,7 +131,11 @@ def parse_yaml_config(config_file: str) -> Config:
         else None
     )
 
+    top_namespace = raw_config["top_namespace"]
+    assert isinstance(top_namespace, str)
+
     return Config(
+        top_namespace=top_namespace,
         type_spec_types=type_spec_types,
         api_endpoint=api_endpoint,
         typescript=typescript,

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/emit_python.py

@@ -44,7 +44,6 @@ class TrackingContext:
     use_enum: bool = False
     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
@@ -54,6 +53,7 @@ class TrackingContext:
 class Context(TrackingContext):
     out: io.StringIO
     namespace: builder.SpecNamespace
+    builder: builder.SpecBuilder
 
 
 def _resolve_namespace_name(namespace: builder.SpecNamespace) -> str:
@@ -222,7 +222,6 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
         out.write("from pkgs.strenum_compat import StrEnum\n")
     if ctx.use_dataclass:
         out.write("import dataclasses\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")
@@ -258,6 +257,7 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
         ctx = Context(
             out=io.StringIO(),
             namespace=namespace,
+            builder=builder,
         )
 
         _emit_namespace(ctx, namespace)
@@ -753,6 +753,12 @@ def _emit_properties(
     )
 
 
+def _named_type_path(ctx: Context, stype: builder.SpecTypeDefn) -> str:
+    parts = [] if stype.is_base else stype.namespace.path.copy()
+    parts.append(stype.name)
+    return f"{ctx.builder.top_namespace}.{".".join(parts)}"
+
+
 def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     if not isinstance(stype, builder.SpecTypeDefn):
         return
@@ -781,6 +787,9 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
         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")
+        ctx.out.write(
+            f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"
+        )
         if stype.discriminator is not None:
             ctx.out.write(
                 f"{INDENT * 2}discriminator={util.encode_common_string(stype.discriminator)},\n"
@@ -822,28 +831,26 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
 
     _emit_generic(ctx, stype.get_generic())
 
-    if (
-        len(unconverted_values) > 0
-        or len(to_string_values) > 0
-        or len(unconverted_keys) > 0
-        or len(parse_require) > 0
-    ):
-        ctx.use_serial_class = True
-        ctx.out.write("@serial_class(\n")
+    # Emit serial_class decorator
+    ctx.out.write("@serial_class(\n")
+    ctx.out.write(
+        f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"
+    )
 
-        def write_values(key: str, values: set[str]) -> None:
-            if len(values) == 0:
-                return
-            value_str = ", ".join([f'"{name}"' for name in sorted(values)])
-            ctx.out.write(f"{INDENT}{key}={{{value_str}}},\n")
+    def write_values(key: str, values: set[str]) -> None:
+        if len(values) == 0:
+            return
+        value_str = ", ".join([f'"{name}"' for name in sorted(values)])
+        ctx.out.write(f"{INDENT}{key}={{{value_str}}},\n")
 
-        write_values("unconverted_keys", unconverted_keys)
-        write_values("unconverted_values", unconverted_values)
-        write_values("to_string_values", to_string_values)
-        write_values("parse_require", parse_require)
+    write_values("unconverted_keys", unconverted_keys)
+    write_values("unconverted_values", unconverted_values)
+    write_values("to_string_values", to_string_values)
+    write_values("parse_require", parse_require)
 
-        ctx.out.write(")\n")
+    ctx.out.write(")\n")
 
+    # Emit dataclass decorator
     dataclass = "@dataclasses.dataclass"
     dc_args = []
     if stype.is_kw_only():
@@ -1275,7 +1282,9 @@ def _emit_async_batch_processor(
 
     async_batch_processor_out = io.StringIO()
     ctx = Context(
-        out=io.StringIO(), namespace=builder.SpecNamespace("async_batch_processor")
+        out=io.StringIO(),
+        namespace=builder.SpecNamespace("async_batch_processor"),
+        builder=spec_builder,
     )
 
     for namespace in sorted(
@@ -1325,7 +1334,11 @@ def _emit_client_class(
         return
 
     client_base_out = io.StringIO()
-    ctx = Context(out=io.StringIO(), namespace=builder.SpecNamespace("client_base"))
+    ctx = Context(
+        out=io.StringIO(),
+        builder=spec_builder,
+        namespace=builder.SpecNamespace("client_base"),
+    )
     for namespace in sorted(
         spec_builder.namespaces.values(),
         key=lambda ns: _resolve_namespace_name(ns),

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/emit_typescript.py

@@ -82,6 +82,25 @@ def emit_typescript(builder: builder.SpecBuilder, config: TypeScriptConfig) -> N
     _emit_id_source(builder, config)
 
 
+def emit_namespace_imports_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    current_namespace: builder.SpecNamespace,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: _resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        import_path = (
+            "./"
+            if len(current_namespace.path) == 1
+            else "../" * (len(current_namespace.path) - 1)
+        )
+        import_from = f"{import_path}{_resolve_namespace_name(ns)}"
+        out.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+
+
 def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     index_out = io.StringIO()
     index_out.write(MODIFY_NOTICE)
@@ -92,11 +111,9 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
         builder.namespaces.values(),
         key=lambda ns: _resolve_namespace_name(ns),
     ):
-        ctx = EmitTypescriptContext(
-            out=io.StringIO(), namespace=namespace, config=config
-        )
+        ctx = EmitTypescriptContext(out=io.StringIO(), namespace=namespace)
 
-        _emit_namespace(ctx, namespace)
+        _emit_namespace(ctx, config, namespace)
 
         prepart = builder.preparts["typescript"].get(namespace.name)
         part = builder.parts["typescript"].get(namespace.name)
@@ -123,16 +140,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             full.write(f"// === END section from {namespace.name}.ts.prepart ===\n")
             full.write("\n")
 
-        for ns in sorted(
-            ctx.namespaces,
-            key=lambda name: _resolve_namespace_name(name),
-        ):
-            import_as = resolve_namespace_ref(ns)
-            import_path = (
-                "./" if len(namespace.path) == 1 else "../" * (len(namespace.path) - 1)
-            )
-            import_from = f"{import_path}{_resolve_namespace_name(ns)}"
-            full.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+        emit_namespace_imports_ts(ctx.namespaces, out=full, current_namespace=namespace)
         if namespace.emit_io_ts:
             full.write("import * as IO from 'io-ts';")
         full.write(ctx.out.getvalue())
@@ -164,23 +172,26 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
 
 def _emit_namespace(
-    ctx: EmitTypescriptContext, namespace: builder.SpecNamespace
+    ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
+    namespace: builder.SpecNamespace,
 ) -> None:
     for stype in namespace.types.values():
         if namespace.emit_io_ts:
             emit_type_io_ts(ctx, stype, namespace.derive_types_from_io_ts)
         if not namespace.emit_io_ts or not namespace.derive_types_from_io_ts:
-            _emit_type(ctx, stype)
+            emit_type_ts(ctx, stype)
 
     for sconst in namespace.constants.values():
         _emit_constant(ctx, sconst)
 
     if namespace.endpoint is not None:
-        _emit_endpoint(ctx, namespace, namespace.endpoint)
+        _emit_endpoint(ctx, config, namespace, namespace.endpoint)
 
 
 def _emit_endpoint(
     ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
     namespace: builder.SpecNamespace,
     endpoint: builder.SpecEndpoint,
 ) -> None:
@@ -265,14 +276,12 @@ export const apiCall = {wrap_call}(
 )
 {data_loader_body}"""
 
-    output = f"{ctx.config.routes_output}/{"/".join(namespace.path)}.tsx"
+    output = f"{config.routes_output}/{"/".join(namespace.path)}.tsx"
     util.rewrite_file(output, tsx_api)
 
     # Hacky index support, until enough is migrated to regen entirely
     # Emits the import into the UI API index file
-    index_path = (
-        f"{ctx.config.routes_output}/{"/".join(namespace.path[0:-1])}/index.tsx"
-    )
+    index_path = f"{config.routes_output}/{"/".join(namespace.path[0:-1])}/index.tsx"
     api_name = f"Api{ts_type_name(namespace.path[0 - 1])}"
     if os.path.exists(index_path):
         with open(index_path) as index:
@@ -288,7 +297,7 @@ export const apiCall = {wrap_call}(
             index.write(f"export {{ {api_name} }}\n")
 
 
-def _emit_type(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
+def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
     if not isinstance(stype, builder.SpecTypeDefn):
         return
 

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/emit_typescript_util.py

@@ -2,7 +2,6 @@ import io
 from dataclasses import dataclass, field
 
 from . import builder, util
-from .config import TypeScriptConfig
 
 INDENT = "  "
 
@@ -11,7 +10,6 @@ MODIFY_NOTICE = "// DO NOT MODIFY -- This file is generated by type_spec\n"
 
 @dataclass(kw_only=True)
 class EmitTypescriptContext:
-    config: TypeScriptConfig
     out: io.StringIO
     namespace: builder.SpecNamespace
     namespaces: set[builder.SpecNamespace] = field(default_factory=set)

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/load_types.py

@@ -42,7 +42,9 @@ def find_and_handle_files(
 
 
 def load_types(config: Config) -> Optional[SpecBuilder]:
-    builder = SpecBuilder(api_endpoints=config.api_endpoint)
+    builder = SpecBuilder(
+        api_endpoints=config.api_endpoint, top_namespace=config.top_namespace
+    )
 
     def handle_builder_add(
         file_name: str, file_content: str, handler: Callable[[str, str, str], None]
@@ -115,4 +117,3 @@ def load_types(config: Config) -> Optional[SpecBuilder]:
         return None
 
     return builder
-    return True

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/type_info/emit_type_info.py

@@ -5,7 +5,7 @@ import io
 import json
 from typing import Any, Optional, Union, cast
 
-from main.base.types import data_t
+from main.base.types import data_t, type_info_t
 from main.base.types.base_t import PureJsonValue
 from pkgs.argument_parser import CachedParser
 from pkgs.serialization_util import (
@@ -17,7 +17,7 @@ from .. import builder, util
 from ..emit_typescript_util import MODIFY_NOTICE, ts_name
 from ..value_spec import convert_to_value_spec_type
 
-ext_info_parser = CachedParser(data_t.ExtInfo)
+ext_info_parser = CachedParser(type_info_t.ExtInfo, strict_property_parsing=True)
 
 
 def type_path_of(stype: builder.SpecType) -> object:  # NamePath
@@ -174,7 +174,7 @@ class InheritablePropertyParts:
 
     label: Optional[str] = None
     desc: Optional[str] = None
-    ext_info: Optional[data_t.ExtInfo] = None
+    ext_info: Optional[type_info_t.ExtInfo] = None
 
 
 def _extract_inheritable_property_parts(
@@ -201,7 +201,7 @@ def _extract_inheritable_property_parts(
     elif base_parts.ext_info is None:
         ext_info = local_ext_info
     else:
-        ext_info = data_t.ExtInfo(
+        ext_info = type_info_t.ExtInfo(
             **(local_ext_info.__dict__ | base_parts.ext_info.__dict__)
         )
 
@@ -214,7 +214,7 @@ ALL_FIELDS_GROUP = "*all_fields"
 
 def _extract_and_validate_layout(
     stype: builder.SpecTypeDefnObject,
-    ext_info: data_t.ExtInfo,
+    ext_info: type_info_t.ExtInfo,
     base_layout: ExtInfoLayout | None,
 ) -> ExtInfoLayout:
     """
@@ -264,7 +264,7 @@ def _extract_and_validate_layout(
 
 def _validate_type_ext_info(
     stype: builder.SpecTypeDefnObject,
-) -> tuple[ExtInfoLayout | None, Optional[data_t.ExtInfo]]:
+) -> tuple[ExtInfoLayout | None, Optional[type_info_t.ExtInfo]]:
     ext_info = _parse_ext_info(stype.ext_info)
     if ext_info is None:
         return None, None
@@ -364,7 +364,7 @@ def _build_map_type(
     return None
 
 
-def _parse_ext_info(in_ext: Any) -> Optional[data_t.ExtInfo]:
+def _parse_ext_info(in_ext: Any) -> Optional[type_info_t.ExtInfo]:
     if in_ext is None:
         return None
     assert isinstance(in_ext, dict)

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/pkgs/type_spec/util.py

@@ -159,7 +159,7 @@ def is_valid_property_name(name: str) -> bool:
 def check_fields(data: dict[str, T], allowed: list[str]) -> None:
     for key in data:
         if key not in allowed:
-            raise Exception(f"unexpected-field: {key}")
+            raise Exception(f"unexpected-field: {key}. Allowed: {allowed}")
 
 
 def split_any_name(name: str) -> list[str]:

{uncountablepythonsdk-0.0.72 → uncountablepythonsdk-0.0.74}/uncountable/core/client.py

@@ -65,7 +65,7 @@ class ClientConfig(ClientConfigOptions):
 OAUTH_REFRESH_WINDOW_SECONDS = 60 * 5
 
 
-class APIResponseError(BaseException):
+class APIResponseError(Exception):
     status_code: int
     message: str
     extra_details: dict[str, JsonValue] | None
@@ -107,7 +107,7 @@ class APIResponseError(BaseException):
         )
 
 
-class SDKError(BaseException):
+class SDKError(Exception):
     message: str
     request_id: str