UncountablePythonSDK 0.0.126__py3-none-any.whl → 0.0.142.dev0__py3-none-any.whl

pkgs/type_spec/builder.py

@@ -13,7 +13,7 @@ from enum import Enum, StrEnum, auto
 from typing import Any, Self
 
 from . import util
-from .cross_output_links import CrossOutputPaths
+from .builder_types import CrossOutputPaths
 from .non_discriminated_union_exceptions import NON_DISCRIMINATED_UNION_EXCEPTIONS
 from .util import parse_type_str
 
@@ -308,6 +308,7 @@ class SpecTypeDefn(SpecType):
         self._is_value_to_string = False
         self._is_valid_parameter = True
         self._is_dynamic_allowed = False
+        self._default_extant: PropertyExtant | None = None
         self.ext_info: Any = None
 
     def is_value_converted(self) -> bool:
@@ -340,6 +341,7 @@ class SpecTypeDefn(SpecType):
                 "ext_info",
                 "label",
                 "is_dynamic_allowed",
+                "default_extant",
             ]
             + extra_names,
         )
@@ -351,6 +353,10 @@ class SpecTypeDefn(SpecType):
         assert isinstance(is_dynamic_allowed, bool)
         self._is_dynamic_allowed = is_dynamic_allowed
 
+        default_extant = data.get("default_extant")
+        if default_extant is not None:
+            self._default_extant = PropertyExtant(default_extant)
+
     def _process_property(
         self, builder: SpecBuilder, spec_name: str, data: RawDict
     ) -> SpecProperty:
@@ -369,18 +375,18 @@ class SpecTypeDefn(SpecType):
             ],
         )
         try:
-            extant_type = data.get("extant")
+            extant_type_str = data.get("extant")
+            extant_type = (
+                PropertyExtant(extant_type_str) if extant_type_str is not None else None
+            )
+            extant = extant_type or self._default_extant
             if spec_name.endswith("?"):
-                if extant_type is not None:
+                if extant is not None:
                     raise Exception("cannot specify extant with ?")
                 extant = PropertyExtant.optional
                 name = spec_name[:-1]
             else:
-                extant = (
-                    PropertyExtant.required
-                    if extant_type is None
-                    else PropertyExtant(extant_type)
-                )
+                extant = extant or PropertyExtant.required
                 name = spec_name
 
             property_name_case = self.name_case
@@ -417,7 +423,16 @@ class SpecTypeDefn(SpecType):
             parse_require = False
             literal = unwrap_literal_type(ptype)
             if literal is not None:
-                default = literal.value
+                if isinstance(
+                    literal.value_type, SpecTypeDefnStringEnum
+                ) and isinstance(literal.value, str):
+                    resolved_value = literal.value_type.values.get(literal.value)
+                    assert resolved_value is not None, (
+                        f"Value {literal.value} not found in enum"
+                    )
+                    default = resolved_value.value
+                else:
+                    default = literal.value
                 has_default = True
                 parse_require = True
 
@@ -1095,7 +1110,7 @@ def _parse_const(
         elif const_type.defn_type.name == BaseTypeName.s_dict:
             assert isinstance(value, dict)
             builder.ensure(
-                len(const_type.parameters) == 2, "constant-dict-expects-one-type"
+                len(const_type.parameters) == 2, "constant-dict-expects-two-types"
             )
             key_type = const_type.parameters[0]
             value_type = const_type.parameters[1]
@@ -1144,6 +1159,11 @@ def _parse_const(
             )
             return value
 
+        if not const_type.is_base:
+            # IMPROVE: validate the object type properties before emission stage
+            builder.ensure(isinstance(value, dict), "invalid value for object constant")
+            return value
+
     raise Exception("unsupported-const-scalar-type", const_type)
 
 
@@ -1265,7 +1285,8 @@ class SpecNamespace:
 
             assert util.is_valid_type_name(name), f"{name} is not a valid type name"
             assert name not in self.types, f"{name} is duplicate"
-            defn_type = defn["type"]
+            defn_type = defn.get("type")
+            assert isinstance(defn_type, str), f"{name} requires a string type"
             spec_type: SpecTypeDefn
             if defn_type == DefnTypeName.s_alias:
                 spec_type = SpecTypeDefnAlias(self, name)
@@ -1392,9 +1413,13 @@ class SpecBuilder:
         self.emit_id_source_enums: set[SpecTypeDefnStringEnum] = set()
 
         this_dir = os.path.dirname(os.path.realpath(__file__))
-        with open(f"{this_dir}/parts/base.py.prepart") as py_base_part:
+        with open(
+            f"{this_dir}/parts/base.py.prepart", encoding="utf-8"
+        ) as py_base_part:
             self.preparts["python"][base_namespace_name] = py_base_part.read()
-        with open(f"{this_dir}/parts/base.ts.prepart") as ts_base_part:
+        with open(
+            f"{this_dir}/parts/base.ts.prepart", encoding="utf-8"
+        ) as ts_base_part:
             self.preparts["typescript"][base_namespace_name] = ts_base_part.read()
 
         base_namespace.types["ObjectId"] = SpecTypeDefnObject(
@@ -1571,6 +1596,11 @@ class SpecBuilder:
                 f"'examples' in example files are expected to be a list, endpoint_path={path_details.resolved_path}"
             )
         for example in examples_data:
+            if not isinstance(example, dict):
+                raise Exception(
+                    f"each example in example file is expected to be a dict, endpoint_path={path_details.resolved_path}"
+                )
+
             arguments = example["arguments"]
             data_example = example["data"]
             if not isinstance(arguments, dict) or not isinstance(data_example, dict):

pkgs/type_spec/builder_types.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True, frozen=True)
+class CrossOutputPaths:
+    python_types_output: str
+    typescript_types_output: str
+    typescript_routes_output_by_endpoint: dict[str, str]
+    typespec_files_input: list[str]

pkgs/type_spec/cross_output_links.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import os
-from dataclasses import dataclass
 
-from pkgs.type_spec import builder
+from . import builder
+from .builder_types import CrossOutputPaths
 
 
 def get_python_stub_file_path(
@@ -17,14 +17,6 @@ def get_python_stub_file_path(
     return api_stub_file
 
 
-@dataclass(kw_only=True, frozen=True)
-class CrossOutputPaths:
-    python_types_output: str
-    typescript_types_output: str
-    typescript_routes_output_by_endpoint: dict[str, str]
-    typespec_files_input: list[str]
-
-
 def get_python_api_file_path(
     cross_output_paths: CrossOutputPaths,
     namespace: builder.SpecNamespace,

pkgs/type_spec/emit_open_api.py

@@ -610,18 +610,6 @@ def _emit_type(
     ctx.types[stype.name] = final_type
 
 
-def _emit_constant(ctx: EmitOpenAPIContext, sconst: builder.SpecConstant) -> None:
-    if sconst.value_type.is_base_type(builder.BaseTypeName.s_string):
-        value = util.encode_common_string(cast(str, sconst.value))
-    elif sconst.value_type.is_base_type(builder.BaseTypeName.s_integer):
-        value = str(sconst.value)
-    else:
-        raise Exception("invalid constant type", sconst.name)
-
-    const_name = sconst.name.upper()
-    print("_emit_constant", value, const_name)
-
-
 def _emit_endpoint(
     gctx: EmitOpenAPIGlobalContext,
     ctx: EmitOpenAPIContext,

pkgs/type_spec/emit_python.py

@@ -35,6 +35,11 @@ QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
     namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedAsyncBatchRequest"
 )
 
+CLIENT_CONFIG_TYPE_NAMESPACE = builder.SpecNamespace(name="client_config")
+REQUEST_OPTIONS_STYPE = builder.SpecTypeDefnObject(
+    namespace=CLIENT_CONFIG_TYPE_NAMESPACE, name="RequestOptions"
+)
+
 
 @dataclasses.dataclass(kw_only=True)
 class TrackingContext:
@@ -117,26 +122,36 @@ def _check_type_match(stype: builder.SpecType, value: Any) -> bool:
     raise Exception("invalid type", stype, value)
 
 
-def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> str:
+def _emit_value(
+    ctx: TrackingContext, stype: builder.SpecType, value: Any, indent: int = 0
+) -> str:
     literal = builder.unwrap_literal_type(stype)
     if literal is not None:
         return _emit_value(ctx, literal.value_type, literal.value)
 
     if stype.is_base_type(builder.BaseTypeName.s_string):
-        assert isinstance(value, str)
+        assert isinstance(value, str), (
+            f"Expected str value for {stype.name} but got {value}"
+        )
         return util.encode_common_string(value)
     elif stype.is_base_type(builder.BaseTypeName.s_integer):
-        assert isinstance(value, int)
+        assert isinstance(value, int), (
+            f"Expected int value for {stype.name} but got {value}"
+        )
         return str(value)
     elif stype.is_base_type(builder.BaseTypeName.s_boolean):
-        assert isinstance(value, bool)
+        assert isinstance(value, bool), (
+            f"Expected bool value for {stype.name} but got {value}"
+        )
         return "True" if value else "False"
     elif stype.is_base_type(builder.BaseTypeName.s_decimal) or stype.is_base_type(
         builder.BaseTypeName.s_lossy_decimal
     ):
         # Note that decimal requires the `!decimal 123.12` style notation in the YAML
         # file since PyYaml parses numbers as float, unfortuantely
-        assert isinstance(value, (Decimal, int))
+        assert isinstance(value, (Decimal, int)), (
+            f"Expected decimal value for {stype.name} but got {value} (type: {type(value)})"
+        )
         if isinstance(value, int):
             # skip quotes for integers
             return f"Decimal({value})"
@@ -151,14 +166,14 @@ def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> st
             key_type = stype.parameters[0]
             value_type = stype.parameters[1]
             return (
-                "{\n    "
-                + ",\n    ".join(
+                f"{{\n{INDENT * (indent + 1)}"
+                + f",\n{INDENT * (indent + 1)}".join(
                     _emit_value(ctx, key_type, dkey)
                     + ": "
-                    + _emit_value(ctx, value_type, dvalue)
+                    + _emit_value(ctx, value_type, dvalue, indent=indent + 1)
                     for dkey, dvalue in value.items()
                 )
-                + "\n}"
+                + f"\n{INDENT * indent}}}"
             )
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
@@ -184,6 +199,34 @@ def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> st
         return f"{refer_to(ctx, stype)}.{_resolve_enum_name(value, stype.name_case)}"
     elif isinstance(stype, builder.SpecTypeDefnAlias):
         return _emit_value(ctx, stype.alias, value)
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        assert isinstance(value, dict), (
+            f"Expected dict value for {stype.name} but got {value}"
+        )
+        if not stype.is_hashable:
+            raise Exception("invalid constant object type, non-hashable", value, stype)
+        obj_out = f"{refer_to(ctx, stype)}("
+        emitted_fields: set[str] = set()
+        for prop_name, prop in (stype.properties or {}).items():
+            if prop_name not in value:
+                continue
+            else:
+                value_to_emit = value[prop_name]
+            emitted_fields.add(prop_name)
+            py_name = python_field_name(prop.name, prop.name_case)
+            obj_out += f"\n{INDENT * (indent + 1)}{py_name}={_emit_value(ctx, prop.spec_type, value_to_emit, indent=indent + 1)},"
+        whitespace = f"\n{INDENT * indent}" if len(emitted_fields) > 0 else ""
+        obj_out += f"{whitespace})"
+
+        if emitted_fields != set(value.keys()):
+            raise Exception(
+                "invalid object type, extra fields found:",
+                value,
+                stype,
+                set(value.keys()) - emitted_fields,
+            )
+
+        return obj_out
 
     raise Exception("invalid constant type", value, stype)
 
@@ -471,6 +514,19 @@ def _emit_endpoint_invocation_function_signature(
         else []
     ) + (extra_params if extra_params is not None else [])
 
+    request_options_property = builder.SpecProperty(
+        name="_request_options",
+        label="_request_options",
+        spec_type=REQUEST_OPTIONS_STYPE,
+        extant=builder.PropertyExtant.optional,
+        convert_value=builder.PropertyConvertValue.auto,
+        name_case=builder.NameCase.convert,
+        default=None,
+        has_default=True,
+        desc=None,
+    )
+    all_arguments.append(request_options_property)
+
     # All endpoints share a function name
     function = endpoint.path_per_api_endpoint[endpoint.default_endpoint_key].function
     assert function is not None
@@ -641,6 +697,7 @@ def _emit_endpoint_invocation_function(
             method={refer_to(ctx=ctx, stype=endpoint_method_stype)},
             endpoint={refer_to(ctx=ctx, stype=endpoint_path_stype)},
             args=args,
+            request_options=_request_options,
         )
         return self.do_request(api_request=api_request, return_type={refer_to(ctx=ctx, stype=data_type)})"""
     )
@@ -1396,7 +1453,7 @@ CLIENT_CLASS_IMPORTS = [
     "import dataclasses",
 ]
 ASYNC_BATCH_PROCESSOR_FILENAME = "async_batch_processor"
-ASYNC_BATCH_PROCESSOR_IMPORTS = [
+ASYNC_BATCH_PROCESSOR_BASE_IMPORTS = [
     "import uuid",
     "from abc import ABC, abstractmethod",
     "from pkgs.serialization_util import serialize_for_api",
@@ -1434,8 +1491,11 @@ def _emit_async_batch_processor(
         config=config,
     )
 
+    imports = ASYNC_BATCH_PROCESSOR_BASE_IMPORTS.copy()
+    if ctx.use_dataclass:
+        imports.append("import dataclasses")
     async_batch_processor_out.write(
-        f"""{LINE_BREAK.join(ASYNC_BATCH_PROCESSOR_IMPORTS)}
+        f"""{LINE_BREAK.join(imports)}
 
 
 class AsyncBatchProcessorBase(ABC):
@@ -1498,6 +1558,7 @@ class APIRequest:
     method: str
     endpoint: str
     args: typing.Any
+    request_options: {refer_to(ctx=ctx, stype=REQUEST_OPTIONS_STYPE)} | None = None
 
 
 class ClientMethods(ABC):

pkgs/type_spec/emit_typescript.py

@@ -285,14 +285,14 @@ export const apiCall = {wrap_call}(
     index_path = f"{config.endpoint_to_routes_output[endpoint.default_endpoint_key]}/{'/'.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:
+        with open(index_path, encoding="utf-8") 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:
+        with open(index_path, "a", encoding="utf-8") 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")

pkgs/type_spec/emit_typescript_util.py

@@ -3,7 +3,7 @@ import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
-from .cross_output_links import CrossOutputPaths
+from .builder_types import CrossOutputPaths
 
 INDENT = "  "
 
@@ -51,7 +51,10 @@ def ts_name(name: str, name_case: builder.NameCase) -> str:
 
 
 def emit_value_ts(
-    ctx: EmitTypescriptContext, stype: builder.SpecType, value: typing.Any
+    ctx: EmitTypescriptContext,
+    stype: builder.SpecType,
+    value: typing.Any,
+    indent: int = 0,
 ) -> str:
     """Mimics emit_python even if not all types are used in TypeScript yet"""
     literal = builder.unwrap_literal_type(stype)
@@ -88,17 +91,17 @@ def emit_value_ts(
                 raise Exception("invalid dict keys -- dict keys must be string or enum")
 
             return (
-                "{\n\t"
-                + ",\n\t".join(
+                f"{{\n{INDENT * (indent + 1)}"
+                + f",\n{INDENT * (indent + 1)}".join(
                     (
                         f"[{emit_value_ts(ctx, key_type, dkey)}]: "
                         if not key_type.is_base_type(builder.BaseTypeName.s_string)
                         else f"{dkey}: "
                     )
-                    + emit_value_ts(ctx, value_type, dvalue)
+                    + emit_value_ts(ctx, value_type, dvalue, indent=indent + 1)
                     for dkey, dvalue in value.items()
                 )
-                + "\n}"
+                + f"\n{INDENT * (indent)}}}"
             )
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
@@ -109,6 +112,25 @@ def emit_value_ts(
 
     elif isinstance(stype, builder.SpecTypeDefnStringEnum):
         return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        assert isinstance(value, dict), (
+            f"Expected dict value for {stype.name} but got {value}"
+        )
+        obj_out = "{"
+        did_emit = False
+        for prop_name, prop in (stype.properties or {}).items():
+            if prop_name not in value and prop.has_default:
+                value_to_emit = prop.default
+            elif prop_name not in value:
+                continue
+            else:
+                value_to_emit = value[prop_name]
+            did_emit = True
+            typescript_name = ts_name(prop.name, prop.name_case)
+            obj_out += f"\n{INDENT * (indent + 1)}{typescript_name}: {emit_value_ts(ctx, prop.spec_type, value_to_emit, indent=indent + 1)},"
+        whitespace = f"\n{INDENT * indent}" if did_emit else ""
+        obj_out += f"{whitespace}}} as const"
+        return obj_out
 
     raise Exception("invalid constant type", value, stype, type(stype))
 

pkgs/type_spec/load_types.py

@@ -7,8 +7,8 @@ from shelljob import fs
 from pkgs.serialization import yaml
 
 from .builder import SpecBuilder
+from .builder_types import CrossOutputPaths
 from .config import Config
-from .cross_output_links import CrossOutputPaths
 
 ext_map = {
     ".ts": "typescript",

pkgs/type_spec/parts/base.ts.prepart

@@ -29,3 +29,6 @@ export const IOJsonValue: IO.Type<JsonValue> = IO.recursion('JsonValue', () =>
 export interface nominal<T> {
   "nominal structural brand": T
 }
+
+// Ids matching a strict integer number are converted to integers
+export const ID_REGEX = /^-?[1-9][0-9]{0,20}$/

pkgs/type_spec/type_info/emit_type_info.py

@@ -41,10 +41,23 @@ def type_path_of(stype: builder.SpecType) -> object:  # NamePath
             parts: list[object] = ["$literal"]
             for parameter in stype.parameters:
                 assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
+                emit_value = parameter.value
+                if isinstance(parameter.value_type, builder.SpecTypeDefnObject):
+                    emit_value = parameter.value
+                    assert isinstance(emit_value, (str, bool)), (
+                        f"invalid-literal-value:{emit_value}"
+                    )
+                elif isinstance(parameter.value_type, builder.SpecTypeDefnStringEnum):
+                    key = parameter.value
+                    assert isinstance(key, str)
+                    emit_value = parameter.value_type.values[key].value
+                else:
+                    raise Exception("unhandled-literal-type")
+
                 # This allows expansion to enum literal values later
                 parts.append([
                     "$value",
-                    parameter.value,
+                    emit_value,
                     type_path_of(parameter.value_type),
                 ])
             return parts
@@ -158,9 +171,16 @@ class MapTypeAlias(MapTypeBase):
     discriminator: str | None
 
 
+@dataclasses.dataclass
+class StringEnumValue:
+    value: str
+    label: str
+    deprecated: bool = False
+
+
 @dataclasses.dataclass
 class MapStringEnum(MapTypeBase):
-    values: dict[str, str]
+    values: dict[str, StringEnumValue]
 
 
 MapType = MapTypeObject | MapTypeAlias | MapStringEnum
@@ -423,7 +443,11 @@ def _build_map_type(
             # IMPROVE: We probably want the label here, but this requires a change
             # to the front-end type-info and form code to handle
             values={
-                entry.value: (entry.label or entry.name)
+                entry.value: StringEnumValue(
+                    value=entry.value,
+                    label=entry.label or entry.name,
+                    deprecated=entry.deprecated,
+                )
                 for entry in stype.values.values()
             },
         )

pkgs/type_spec/value_spec/__main__.py

@@ -20,7 +20,7 @@ The accepted argument type must accept "None", it is not implied.
 """
 
 import sys
-from typing import TypeVar, cast
+from typing import Match, Pattern, TypeVar, cast
 
 import regex as re
 
@@ -56,7 +56,7 @@ class Source:
     def has_more(self) -> bool:
         return self._at < len(self._text)
 
-    def match(self, expression: re.Pattern) -> re.Match | None:
+    def match(self, expression: Pattern[str]) -> Match[str] | None:
         self.skip_space()
         m = expression.match(self._text, self._at)
         if m is not None:

uncountable/core/client.py

@@ -226,13 +226,15 @@ class Client(ClientMethods):
         except JSONDecodeError as e:
             raise SDKError("unable to process response", request_id=request_id) from e
 
-    def _send_request(self, request: requests.Request) -> requests.Response:
+    def _send_request(
+        self, request: requests.Request, *, timeout: float | None = None
+    ) -> requests.Response:
         if self._cfg.extra_headers is not None:
             request.headers = {**request.headers, **self._cfg.extra_headers}
         if self._cfg.transform_request is not None:
             request = self._cfg.transform_request(request)
         prepared_request = request.prepare()
-        response = self._session.send(prepared_request)
+        response = self._session.send(prepared_request, timeout=timeout)
         return response
 
     def do_request(self, *, api_request: APIRequest, return_type: type[DT]) -> DT:
@@ -257,7 +259,12 @@ class Client(ClientMethods):
         with push_scope_optional(self._cfg.logger, "api_call", attributes=attributes):
             if self._cfg.logger is not None:
                 self._cfg.logger.log_info(api_request.endpoint, attributes=attributes)
-            response = self._send_request(request)
+            timeout = (
+                api_request.request_options.timeout_secs
+                if api_request.request_options is not None
+                else None
+            )
+            response = self._send_request(request, timeout=timeout)
         response_data = self._get_response_json(response, request_id=request_id)
         cached_parser = self._get_cached_parser(return_type)
         try: