UncountablePythonSDK 0.0.73__tar.gz → 0.0.75__tar.gz

{uncountablepythonsdk-0.0.73/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.75}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.73
+Version: 0.0.75
 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.73 → uncountablepythonsdk-0.0.75}/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.73 → uncountablepythonsdk-0.0.75}/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.73 → uncountablepythonsdk-0.0.75}/pkgs/serialization/serial_class.py

@@ -15,6 +15,10 @@ class _SerialClassData:
     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()
@@ -58,6 +62,7 @@ def serial_class(
             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
 
@@ -83,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.73 → uncountablepythonsdk-0.0.75}/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,6 +1199,12 @@ 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], top_namespace: str) -> None:
         self.top_namespace = top_namespace

{uncountablepythonsdk-0.0.73 → uncountablepythonsdk-0.0.75}/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
@@ -223,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")
@@ -834,7 +832,6 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     _emit_generic(ctx, stype.get_generic())
 
     # Emit serial_class decorator
-    ctx.use_serial_class = True
     ctx.out.write("@serial_class(\n")
     ctx.out.write(
         f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"

uncountablepythonsdk-0.0.75/pkgs/type_spec/emit_typescript.py

@@ -0,0 +1,256 @@
+import io
+import os
+
+from . import builder, util
+from .config import TypeScriptConfig
+from .emit_io_ts import emit_type_io_ts
+from .emit_typescript_util import (
+    MODIFY_NOTICE,
+    EmitTypescriptContext,
+    emit_namespace_imports_ts,
+    emit_type_ts,
+    emit_value_ts,
+    resolve_namespace_name,
+    resolve_namespace_ref,
+    ts_type_name,
+)
+
+
+def emit_typescript(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
+    _emit_types(builder, config)
+    _emit_id_source(builder, config)
+
+
+def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
+    index_out = io.StringIO()
+    index_out.write(MODIFY_NOTICE)
+
+    index_out_end = io.StringIO()
+
+    for namespace in sorted(
+        builder.namespaces.values(),
+        key=lambda ns: resolve_namespace_name(ns),
+    ):
+        ctx = EmitTypescriptContext(out=io.StringIO(), namespace=namespace)
+
+        _emit_namespace(ctx, config, namespace)
+
+        prepart = builder.preparts["typescript"].get(namespace.name)
+        part = builder.parts["typescript"].get(namespace.name)
+
+        # Don't emit an empty file
+        if (
+            prepart is None
+            and part is None
+            and len(namespace.types) == 0
+            and len(namespace.constants) == 0
+        ):
+            # Try to capture some common incompleteness errors
+            if namespace.endpoint is None or namespace.endpoint.function is None:
+                raise Exception(
+                    f"Namespace {"/".join(namespace.path)} is incomplete. It should have an endpoint with function, types, and/or constants"
+                )
+            continue
+
+        full = io.StringIO()
+        if prepart:
+            full.write(MODIFY_NOTICE)
+            full.write(f"// === START section from {namespace.name}.ts.prepart ===\n")
+            full.write(prepart)
+            full.write(f"// === END section from {namespace.name}.ts.prepart ===\n")
+            full.write("\n")
+
+        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())
+
+        if part:
+            full.write("\n")
+            full.write(MODIFY_NOTICE)
+            full.write(f"// === START section from {namespace.name}.ts.part ===\n")
+            full.write(part)
+            full.write(f"// === END section from {namespace.name}.ts.part ===\n")
+
+        full.write(MODIFY_NOTICE)
+
+        basename = "/".join(namespace.path)
+        filename = f"{config.types_output}/{basename}.ts"
+        util.rewrite_file(filename, full.getvalue())
+
+        if len(namespace.path) == 1:
+            index_out.write(
+                f"import * as {resolve_namespace_ref(namespace)} from './{resolve_namespace_name(namespace)}'\n"
+            )  # noqa: E501
+            index_out_end.write(f"export {{{resolve_namespace_ref(namespace)}}}\n")
+
+    index_out.write("\n")
+    index_out.write(MODIFY_NOTICE)
+    index_out.write(index_out_end.getvalue())
+    index_out.write(MODIFY_NOTICE)
+    util.rewrite_file(f"{config.types_output}/index.ts", index_out.getvalue())
+
+
+def _emit_namespace(
+    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_ts(ctx, stype)
+
+    for sconst in namespace.constants.values():
+        _emit_constant(ctx, sconst)
+
+    if namespace.endpoint is not None:
+        _emit_endpoint(ctx, config, namespace, namespace.endpoint)
+
+
+def _emit_endpoint(
+    ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
+    namespace: builder.SpecNamespace,
+    endpoint: builder.SpecEndpoint,
+) -> None:
+    if endpoint.suppress_ts:
+        return
+
+    assert namespace.path[0] == "api"
+    has_arguments = "Arguments" in namespace.types
+    has_data = "Data" in namespace.types
+    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])
+    assert result_type_count < 2
+
+    # Don't emit interface for those with unsupported types
+    if not has_arguments or result_type_count == 0:
+        return
+
+    if not is_binary:
+        assert endpoint.result_type == builder.ResultType.json
+
+    data_loader_head = ""
+    data_loader_body = ""
+    if endpoint.data_loader:
+        # Don't support alternately named data for now
+        assert has_data
+
+        data_loader_head = (
+            'import { buildApiDataLoader, argsKey } from "unc_base/data_manager"\n'
+        )
+        data_loader_body = (
+            "\nexport const data = buildApiDataLoader(argsKey(), apiCall)\n"
+        )
+
+    method = endpoint.method.capitalize()
+    if endpoint.has_attachment:
+        assert endpoint.method == "post"
+        method = f"{method}Attach"
+    wrap_name = (
+        f"buildWrappedBinary{method}Call" if is_binary else f"buildWrapped{method}Call"
+    )
+    wrap_call = (
+        f"{wrap_name}<Arguments>" if is_binary else f"{wrap_name}<Arguments, Response>"
+    )
+    type_path = f"unc_mat/types/{"/".join(namespace.path)}"
+
+    if is_binary:
+        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
+import type {{ Arguments }} from "{type_path}"
+
+export type {{ Arguments }}
+"""
+    elif has_data and endpoint.has_attachment:
+        tsx_response_part = f"""import {{ {wrap_name}, type AttachmentResponse }} from "unc_base/api"
+import type {{ Arguments, Data }} from "{type_path}"
+
+export type {{ Arguments, Data }}
+export type Response = AttachmentResponse<Data>
+"""
+    elif has_data:
+        tsx_response_part = f"""import {{ {wrap_name}, type JsonResponse }} from "unc_base/api"
+import type {{ Arguments, Data }} from "{type_path}"
+
+export type {{ Arguments, Data }}
+export type Response = JsonResponse<Data>
+"""
+
+    else:
+        assert has_deprecated_result
+        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
+import type {{ Arguments, DeprecatedResult }} from "{type_path}"
+
+export type {{ Arguments }}
+export type Response = DeprecatedResult
+"""
+
+    tsx_api = f"""{MODIFY_NOTICE}
+{data_loader_head}{tsx_response_part}
+export const apiCall = {wrap_call}(
+  "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",
+)
+{data_loader_body}"""
+
+    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"{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:
+            index_data = index.read()
+            need_index = index_data.find(api_name) == -1
+    else:
+        need_index = True
+
+    if need_index:
+        with open(index_path, "a") as index:
+            print(f"Updated API Index {index_path}")
+            index.write(f'import * as {api_name} from "./{namespace.path[-1]}"\n\n')
+            index.write(f"export {{ {api_name} }}\n")
+
+
+def _emit_constant(ctx: EmitTypescriptContext, sconst: builder.SpecConstant) -> None:
+    ctx.out.write("\n\n")
+    ctx.out.write(MODIFY_NOTICE)
+    value = emit_value_ts(ctx, sconst.value_type, sconst.value)
+    const_name = sconst.name.upper()
+    ctx.out.write(f"export const {const_name} = {value}\n")
+
+
+def _emit_id_source(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
+    id_source_output = config.id_source_output
+    if id_source_output is None:
+        return
+    enum_out = io.StringIO()
+    enum_out.write(MODIFY_NOTICE)
+
+    enum_out.write("export type KnownEnumsType =\n")
+    enum_map = {
+        builder.resolve_proper_name(string_enum): string_enum
+        for string_enum in builder.emit_id_source_enums
+    }
+    sorted_keys = sorted(enum_map.keys())
+    for key in sorted_keys:
+        enum_out.write(f'  | "{key}"\n')
+
+    enum_out.write(f"\n{MODIFY_NOTICE}")
+    enum_out.write("export const ENUM_NAME_MAPS = {\n")
+    for key in sorted_keys:
+        string_enum = enum_map[key]
+        enum_out.write(f'  "{builder.resolve_proper_name(string_enum)}": {{\n')
+        for entry in string_enum.values.values():
+            if entry.label is not None:
+                enum_out.write(f'    "{entry.value}": "{entry.label}",\n')
+        enum_out.write("  },\n")
+    enum_out.write("}\n")
+
+    enum_out.write(f"\n{MODIFY_NOTICE}")
+    util.rewrite_file(id_source_output, enum_out.getvalue())