UncountablePythonSDK 0.0.82__py3-none-any.whl → 0.0.132__py3-none-any.whl

pkgs/type_spec/emit_typescript.py

@@ -1,15 +1,18 @@
 import io
 import os
+from typing import assert_never
 
 from . import builder, util
+from .builder import EndpointKey, EndpointSpecificPath, PathMapping
 from .config import TypeScriptConfig
+from .cross_output_links import get_path_links
 from .emit_io_ts import emit_type_io_ts
 from .emit_typescript_util import (
     MODIFY_NOTICE,
     EmitTypescriptContext,
+    emit_constant_ts,
     emit_namespace_imports_ts,
     emit_type_ts,
-    emit_value_ts,
     resolve_namespace_name,
     resolve_namespace_ref,
     ts_type_name,
@@ -31,7 +34,12 @@ 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)
+        ctx = EmitTypescriptContext(
+            out=io.StringIO(),
+            namespace=namespace,
+            cross_output_paths=builder.cross_output_paths,
+            api_endpoints=builder.api_endpoints,
+        )
 
         _emit_namespace(ctx, config, namespace)
 
@@ -46,7 +54,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"
                 )
@@ -69,6 +80,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             full.write("\n")
             full.write(MODIFY_NOTICE)
             full.write(f"// === START section from {namespace.name}.ts.part ===\n")
+            full.write("\n")
             full.write(part)
             full.write(f"// === END section from {namespace.name}.ts.part ===\n")
 
@@ -103,7 +115,7 @@ def _emit_namespace(
             emit_type_ts(ctx, stype)
 
     for sconst in namespace.constants.values():
-        _emit_constant(ctx, sconst)
+        emit_constant_ts(ctx, sconst)
 
     if namespace.endpoint is not None:
         _emit_endpoint(ctx, config, namespace, namespace.endpoint)
@@ -123,6 +135,7 @@ def _emit_endpoint(
     has_data = "Data" in namespace.types
     has_deprecated_result = "DeprecatedResult" in namespace.types
     is_binary = endpoint.result_type == builder.ResultType.binary
+    has_multiple_endpoints = len(endpoint.path_per_api_endpoint) > 1
 
     result_type_count = sum([has_data, has_deprecated_result, is_binary])
     assert result_type_count < 2
@@ -134,6 +147,13 @@ def _emit_endpoint(
     if not is_binary:
         assert endpoint.result_type == builder.ResultType.json
 
+    paths_string = get_path_links(
+        ctx.cross_output_paths,
+        namespace,
+        current_path_type="TypeScript",
+        endpoint=endpoint,
+    )
+
     data_loader_head = ""
     data_loader_body = ""
     if endpoint.data_loader:
@@ -141,7 +161,7 @@ def _emit_endpoint(
         assert has_data
 
         data_loader_head = (
-            'import { buildApiDataLoader, argsKey } from "unc_base/data_manager"\n'
+            'import { argsKey, buildApiDataLoader } from "unc_base/data_manager"\n'
         )
         data_loader_body = (
             "\nexport const data = buildApiDataLoader(argsKey(), apiCall)\n"
@@ -157,24 +177,49 @@ def _emit_endpoint(
     wrap_call = (
         f"{wrap_name}<Arguments>" if is_binary else f"{wrap_name}<Arguments, Response>"
     )
-    type_path = f"unc_mat/types/{'/'.join(namespace.path)}"
+
+    unc_base_api_imports = (
+        f"appSpecificApiPath, {wrap_name}" if has_multiple_endpoints else wrap_name
+    )
+    path_mapping = ctx.api_endpoints[endpoint.default_endpoint_key].path_mapping
+
+    match path_mapping:
+        case PathMapping.NO_MAPPING:
+            path_mapping_part = (
+                "\n  { pathMapping: ApplicationT.APIPathMapping.noMapping },"
+            )
+        case PathMapping.DEFAULT_MAPPING:
+            path_mapping_part = ""
+        case _:
+            assert_never(path_mapping)
+
+    unc_types_imports = (
+        'import { ApplicationT } from "unc_types"\n'
+        if has_multiple_endpoints or path_mapping_part != ""
+        else ""
+    )
+
+    type_path = f"unc_types/{'/'.join(namespace.path)}"
 
     if is_binary:
-        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
-import type {{ Arguments }} from "{type_path}"
+        tsx_response_head = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
+"""
+        tsx_response_part = f"""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}"
+        tsx_response_head = f"""import {{ type AttachmentResponse, {unc_base_api_imports} }} from "unc_base/api"
+"""
+        tsx_response_part = f"""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}"
+        tsx_response_head = f"""import {{ {unc_base_api_imports}, type JsonResponse }} from "unc_base/api"
+"""
+        tsx_response_part = f"""import type {{ Arguments, Data }} from "{type_path}"
 
 export type {{ Arguments, Data }}
 export type Response = JsonResponse<Data>
@@ -182,49 +227,77 @@ 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}"
+        tsx_response_head = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
+"""
+        tsx_response_part = f"""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 = buildWrappedGetCall<Arguments, Response>(
+      appSpecificApiPath({
+        [ApplicationT.FrontendApplication.materials]: "api/materials/common/list_id_source",
+      }),
+    )
+
+
+    """
+
+    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,
+        ) in endpoint.path_per_api_endpoint.items():
+            full_path = f"{endpoint_specific_path.path_root}/{endpoint_specific_path.path_dirname}/{endpoint_specific_path.path_basename}"
+            frontend_app_value = config.endpoint_to_frontend_app_type[api_endpoint_key]
+
+            path_lookup_map += (
+                f'\n    [ApplicationT.{frontend_app_value}]: "{full_path}",'
+            )
+
+        endpoint_path_part = f"""appSpecificApiPath({{{path_lookup_map}
+  }}),"""
+
+    # tsx_api = f"""{MODIFY_NOTICE}
+    tsx_api = f"""{MODIFY_NOTICE}{paths_string}
+{tsx_response_head}{data_loader_head}{unc_types_imports}{tsx_response_part}
 export const apiCall = {wrap_call}(
-  "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",
+  {endpoint_path_part}{path_mapping_part}
 )
 {data_loader_body}"""
 
-    output = f"{config.routes_output}/{'/'.join(namespace.path)}.tsx"
+    output = f"{config.endpoint_to_routes_output[endpoint.default_endpoint_key]}/{'/'.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"
+    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")
 
 
-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:

pkgs/type_spec/emit_typescript_util.py

@@ -3,12 +3,12 @@ import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
+from .builder_types import CrossOutputPaths
 
 INDENT = "  "
 
 MODIFY_NOTICE = "// DO NOT MODIFY -- This file is generated by type_spec\n"
 
-
 base_name_map = {
     builder.BaseTypeName.s_boolean: "boolean",
     builder.BaseTypeName.s_date: "string",  # IMPROVE: Aliased DateStr
@@ -31,6 +31,8 @@ class EmitTypescriptContext:
     out: io.StringIO
     namespace: builder.SpecNamespace
     namespaces: set[builder.SpecNamespace] = field(default_factory=set)
+    cross_output_paths: CrossOutputPaths | None = None
+    api_endpoints: dict[builder.EndpointKey, builder.APIEndpointInfo]
 
 
 def ts_type_name(name: str) -> str:
@@ -49,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)
@@ -79,16 +84,24 @@ def emit_value_ts(
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_dict):
             key_type = stype.parameters[0]
             value_type = stype.parameters[1]
+
+            if not key_type.is_base_type(
+                builder.BaseTypeName.s_string
+            ) and not isinstance(key_type, builder.SpecTypeDefnStringEnum):
+                raise Exception("invalid dict keys -- dict keys must be string or enum")
+
             return (
-                "{\n\t"
-                + ",\n\t".join(
-                    "["
-                    + emit_value_ts(ctx, key_type, dkey)
-                    + "]: "
-                    + emit_value_ts(ctx, value_type, dvalue)
+                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, 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):
@@ -99,8 +112,35 @@ 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)
+    raise Exception("invalid constant type", value, stype, type(stype))
+
+
+def emit_constant_ts(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_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
@@ -115,6 +155,7 @@ def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
 
     if isinstance(stype, builder.SpecTypeDefnExternal):
         assert not stype.is_exported, "expecting private names"
+        ctx.out.write("\n")
         ctx.out.write(stype.external_map["ts"])
         ctx.out.write("\n")
         return
@@ -263,3 +304,18 @@ def emit_namespace_imports_ts(
         )
         import_from = f"{import_path}{resolve_namespace_name(ns)}"
         out.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+
+
+def emit_namespace_imports_from_root_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    root: str,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        out.write(
+            f'import * as {import_as} from "{root}/{resolve_namespace_name(ns)}"\n'
+        )  # noqa: E501

pkgs/type_spec/load_types.py

@@ -1,13 +1,13 @@
 import os
 from collections.abc import Callable
 from io import StringIO
-from typing import Optional
 
 from shelljob import fs
 
 from pkgs.serialization import yaml
 
 from .builder import SpecBuilder
+from .builder_types import CrossOutputPaths
 from .config import Config
 
 ext_map = {
@@ -41,9 +41,22 @@ def find_and_handle_files(
             handler(file_name, file.read())
 
 
-def load_types(config: Config) -> Optional[SpecBuilder]:
+def load_types(config: Config) -> SpecBuilder | None:
+    if config.typescript is not None and config.python is not None:
+        cross_output_paths = CrossOutputPaths(
+            python_types_output=config.python.types_output,
+            typescript_types_output=config.typescript.types_output,
+            typescript_routes_output_by_endpoint=config.typescript.endpoint_to_routes_output,
+            typespec_files_input=config.type_spec_types,
+            # IMPROVE not sure how to know which one is the correct one in emit_typescript
+        )
+    else:
+        cross_output_paths = None
+
     builder = SpecBuilder(
-        api_endpoints=config.api_endpoint, top_namespace=config.top_namespace
+        api_endpoints=config.api_endpoint,
+        top_namespace=config.top_namespace,
+        cross_output_paths=cross_output_paths,
     )
 
     def handle_builder_add(

pkgs/type_spec/non_discriminated_union_exceptions.py

@@ -0,0 +1,14 @@
+NON_DISCRIMINATED_UNION_EXCEPTIONS = [
+    "generate_tool_parameters.UnionWithoutDiscrim",
+    "output_calculation_entities.ConditionParameterFilterCondition",
+    "output_parameters.AnalyticalMethodParameterOptions",
+    "output_parameters.AnalyticalMethodLinkedOptionValue",
+    "recipes_redirect.RecipesRedirectResult",
+    "value_spec.ResolvedPathAll",
+    "weighted_sum.WeightedSumEntities",
+    "workflows.WorkflowTotalDisplay",
+    "type_info.TypeFormActionConstraint",
+    "structured_loading.CompatibleFilterNode",
+    "structured_display_element.DisplayElementColumn",
+    "field_values.FieldValue",
+]

pkgs/type_spec/open_api_util.py

@@ -1,15 +1,23 @@
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Optional
+
+from pkgs.serialization_util import JsonValue
 
 
 class OpenAPIType(ABC):
     description: str | None = None
     nullable: bool = False
+    default: JsonValue
 
-    def __init__(self, description: str | None = None, nullable: bool = False) -> None:
+    def __init__(
+        self,
+        description: str | None = None,
+        nullable: bool = False,
+        default: JsonValue = None,
+    ) -> None:
         self.description = description
         self.nullable = nullable
+        self.default = default
 
     @abstractmethod
     def asdict(self) -> dict[str, object]:
@@ -20,6 +28,8 @@ class OpenAPIType(ABC):
             emitted["description"] = self.description
         if self.nullable:
             emitted["nullable"] = self.nullable
+        if self.default is not None:
+            emitted["default"] = self.default
         return emitted
 
 
@@ -158,7 +168,7 @@ class OpenAPIObjectType(OpenAPIType):
         description: str | None = None,
         nullable: bool = False,
         *,
-        property_desc: Optional[dict[str, str]] = None,
+        property_desc: dict[str, str] | None = None,
     ) -> None:
         self.properties = properties
         if property_desc is None:
@@ -213,13 +223,28 @@ class OpenAPIUnionType(OpenAPIType):
         base_types: list[OpenAPIType],
         description: str | None = None,
         nullable: bool = False,
+        discriminator: str | None = None,
+        discriminator_map: dict[str, OpenAPIRefType] | None = None,
     ) -> None:
         self.base_types = base_types
+        self._discriminator = discriminator
+        self._discriminator_map = discriminator_map
         super().__init__(description=description, nullable=nullable)
 
     def asdict(self) -> dict[str, object]:
         # TODO: use parents description and nullable
-        return {"oneOf": [base_type.asdict() for base_type in self.base_types]}
+        return {
+            "oneOf": [base_type.asdict() for base_type in self.base_types],
+            "discriminator": {
+                "propertyName": self._discriminator,
+                "mapping": {
+                    discriminator_value: base_type.source
+                    for discriminator_value, base_type in self._discriminator_map.items()
+                },
+            }
+            if self._discriminator is not None and self._discriminator_map is not None
+            else None,
+        }
 
 
 class OpenAPIIntersectionType(OpenAPIType):

pkgs/type_spec/parts/base.py.prepart

@@ -22,10 +22,16 @@ 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}"
 
 
+# ENABLE_SLOTS should be removed after slots have been tested locally
+import os
+ENABLE_SLOTS = os.environ.get("UNC_ENABLE_DATACLASS_SLOTS") == "true"
+
 if TYPE_CHECKING:
     JsonValue = Union[JsonScalar, Mapping[str, "JsonValue"], Sequence["JsonValue"]]
     ExtJsonValue = JsonValue
@@ -52,15 +58,12 @@ def is_pure_json_value(value: ExtJsonValue) -> bool:
         return True
 
     if isinstance(value, list):
-        for item in value:
-            if not is_pure_json_value(item):
-                return False
-        return True
+        return all(is_pure_json_value(item) for item in value)
 
     if isinstance(value, dict):
-        for key, item in value.items():
-            if not is_pure_json_value(key) or not is_pure_json_value(item):
-                return False
-        return True
+        return all(
+            is_pure_json_value(key) and is_pure_json_value(item)
+            for key, item in value.items()
+        )
 
     return False

pkgs/type_spec/parts/base.ts.prepart

@@ -3,6 +3,7 @@
 // doesn't allow referring explicitly to global names (thus cannot override here)
 // IMPROVE: invert relationship for global.d.ts looks here instead
 import * as IO from 'io-ts';
+
 type localJsonScalar = JsonScalar
 type localJsonValue = JsonValue
 type localObjectId = ObjectId
@@ -28,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/__main__.py

@@ -9,7 +9,7 @@ import sys
 
 from ..config import parse_yaml_config
 from ..load_types import load_types
-from .emit_type_info import emit_type_info
+from .emit_type_info import emit_type_info, emit_type_info_python
 
 
 def main() -> bool:
@@ -26,6 +26,8 @@ def main() -> bool:
 
     assert config.typescript is not None
     emit_type_info(builder, config.typescript.type_info_output)
+    if config.python.type_info_output is not None:
+        emit_type_info_python(builder, config.python.type_info_output)
 
     return True