UncountablePythonSDK 0.0.91__py3-none-any.whl → 0.0.93__py3-none-any.whl

pkgs/type_spec/emit_open_api.py

@@ -10,7 +10,7 @@ import re
 from typing import Collection, cast
 
 from pkgs.serialization import yaml
-from pkgs.serialization_util.serialization_helpers import serialize_for_api
+from pkgs.serialization_util import serialize_for_api
 
 from . import builder, util
 from .builder import EndpointGuideKey, RootGuideKey
@@ -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,
         )
     )

pkgs/type_spec/emit_open_api_util.py

@@ -7,7 +7,7 @@ WORK-IN-PROGRESS, DON'T USE!
 from collections import defaultdict
 from dataclasses import dataclass, field
 
-from pkgs.serialization_util.serialization_helpers import JsonValue
+from pkgs.serialization_util import JsonValue
 
 from . import builder
 from .open_api_util import OpenAPIType

pkgs/type_spec/emit_python.py

@@ -2,19 +2,17 @@ import dataclasses
 import io
 import os
 from decimal import Decimal
-from typing import Any, Optional
+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"""
@@ -38,7 +36,7 @@ QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
 
 @dataclasses.dataclass(kw_only=True)
 class TrackingContext:
-    namespace: Optional[builder.SpecNamespace] = None
+    namespace: builder.SpecNamespace | None = None
     namespaces: set[builder.SpecNamespace] = dataclasses.field(default_factory=set)
     names: set[str] = dataclasses.field(default_factory=set)
 
@@ -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")
@@ -344,6 +342,13 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
 
 ENDPOINT_METHOD = "ENDPOINT_METHOD"
 ENDPOINT_PATH = "ENDPOINT_PATH"
+# will be removed in Q1 2025 when ENDPOINT_PATH is made api_endpoint-agnostic
+# is used when the API call has multiple endpoints for the one endpoint that isn't equal to the top_namespace
+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:
@@ -351,9 +356,20 @@ def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
     if endpoint is not None:
         ctx.out.write("\n")
         ctx.out.write(f'{ENDPOINT_METHOD} = "{endpoint.method.upper()}"\n')
-        ctx.out.write(
-            f'{ENDPOINT_PATH} = "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}"\n'
-        )
+        for endpoint_specific_path in sorted(
+            endpoint.path_per_api_endpoint.values(), key=_get_epf_root
+        ):
+            endpoint_path_name = ENDPOINT_PATH
+
+            if (
+                len(endpoint.path_per_api_endpoint.keys()) > 1
+                and endpoint_specific_path.root != ctx.builder.top_namespace
+            ):
+                endpoint_path_name = ENDPOINT_PATH_ALTERNATE
+                ctx.names.add(ENDPOINT_PATH_ALTERNATE)
+            ctx.out.write(
+                f'{endpoint_path_name} = "{endpoint_specific_path.path_root}/{endpoint_specific_path.path_dirname}/{endpoint_specific_path.path_basename}"\n'
+            )
 
         ctx.names.add(ENDPOINT_METHOD)
         ctx.names.add(ENDPOINT_PATH)
@@ -443,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}(
@@ -702,39 +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:
-                ref_type = f"typing.Optional[{ref_type}]"
+                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)"
@@ -924,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)
@@ -956,23 +987,21 @@ def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
 SpecEndpoint = builder.SpecEndpoint
 
 
-def _route_identifier(endpoint: builder.SpecEndpoint) -> tuple[str, str, str]:
-    return (endpoint.path_dirname, endpoint.path_basename, endpoint.method)
-
-
 def _emit_routes(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     for endpoint_root in builder.api_endpoints:
         endpoints: list[SpecEndpoint] = []
         output = config.routes_output.get(endpoint_root)
         if output is None:
             continue
+        last_endpoint: SpecEndpoint | None = None
         for namespace in builder.namespaces.values():
             endpoint = namespace.endpoint
+            last_endpoint = endpoint
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+            if endpoint.path_per_api_endpoint[endpoint_root].function is None:
                 continue
 
             endpoints.append(endpoint)
@@ -985,6 +1014,15 @@ def _emit_routes(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
 from main.site.framework.types import StaticRouteType
 """
         )
+
+        def _route_identifier(endpoint: SpecEndpoint) -> tuple[str, str, str]:
+            endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
+            return (
+                endpoint_specific_path.path_dirname,
+                endpoint_specific_path.path_basename,
+                endpoint.method,
+            )
+
         sorted_endpoints = sorted(endpoints, key=_route_identifier)
 
         assert len(endpoints) == len(set(map(_route_identifier, endpoints))), (
@@ -993,17 +1031,21 @@ from main.site.framework.types import StaticRouteType
 
         path_set = set()
         for endpoint in sorted_endpoints:
-            assert endpoint.function
-            func_bits = endpoint.function.split(".")
+            last_endpoint = endpoint
+            endpoint_function_path = endpoint.path_per_api_endpoint[endpoint_root]
+            assert endpoint_function_path.function
+            func_bits = endpoint_function_path.function.split(".")
             path = ".".join(func_bits[:-1])
             if path in path_set:
                 continue
             path_set.add(path)
             static_out.write(f"import {path}\n")
 
+        assert last_endpoint is not None
+
         static_out.write(
             f"""
-ROUTE_PREFIX = "/{endpoint.path_root}"
+ROUTE_PREFIX = "/{last_endpoint.path_per_api_endpoint[endpoint_root].path_root}"
 
 ROUTES: list[StaticRouteType] = [
 """
@@ -1017,20 +1059,21 @@ ROUTES: list[StaticRouteType] = [
 
 from main.site.framework.types import DynamicRouteType
 
-ROUTE_PREFIX = "/{endpoint.path_root}"
+ROUTE_PREFIX = "/{last_endpoint.path_per_api_endpoint[endpoint_root].path_root}"
 
 ROUTES: list[DynamicRouteType] = [
 """
         )
 
         for endpoint in sorted_endpoints:
+            endpoint_function_path = endpoint.path_per_api_endpoint[endpoint_root]
             dynamic_out.write(
-                f'{INDENT}("{endpoint.path_dirname}/{endpoint.path_basename}", "{endpoint.function}", ["{endpoint.method.upper()}"]),\n'
+                f'{INDENT}("{endpoint_function_path.path_dirname}/{endpoint_function_path.path_basename}", "{endpoint_function_path.function}", ["{endpoint.method.upper()}"]),\n'
             )
 
-            assert endpoint.function
+            assert endpoint_function_path.function
             static_out.write(
-                f'{INDENT}("{endpoint.path_dirname}/{endpoint.path_basename}", {endpoint.function}, ["{endpoint.method.upper()}"]),\n'
+                f'{INDENT}("{endpoint_function_path.path_dirname}/{endpoint_function_path.path_basename}", {endpoint_function_path.function}, ["{endpoint.method.upper()}"]),\n'
             )
 
         dynamic_out.write(f"{MODIFY_NOTICE}]\n")
@@ -1046,7 +1089,7 @@ def _emit_namespace_imports(
     *,
     out: io.StringIO,
     namespaces: set[builder.SpecNamespace],
-    from_namespace: Optional[builder.SpecNamespace],
+    from_namespace: builder.SpecNamespace | None,
     config: PythonConfig,
     skip_non_sdk: bool = False,
 ) -> None:
@@ -1084,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
@@ -1101,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")
 
@@ -1122,21 +1165,36 @@ def _emit_api_stubs(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
 
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+
+            endpoint_function = endpoint.path_per_api_endpoint[endpoint_root].function
+            if endpoint_function is None:
                 continue
 
-            module_dir, file_name, func_name = endpoint.function.rsplit(".", 2)
+            module_dir, file_name, func_name = endpoint_function.rsplit(".", 2)
             module_path = os.path.abspath(module_dir.replace(".", "/"))
             api_stub_file = f"{module_path}/{file_name}.py"
             if os.path.isfile(api_stub_file):
                 continue
-            _create_api_stub(api_stub_file, file_name, endpoint, config)
+            _create_api_stub(
+                api_stub_file=api_stub_file,
+                file_name=file_name,
+                endpoint=endpoint,
+                config=config,
+                endpoint_root=endpoint_root,
+                top_namespace=builder.top_namespace,
+            )
 
 
 def _create_api_stub(
-    api_stub_file: str, file_name: str, endpoint: SpecEndpoint, config: PythonConfig
+    *,
+    api_stub_file: str,
+    file_name: str,
+    endpoint: SpecEndpoint,
+    config: PythonConfig,
+    endpoint_root: str,
+    top_namespace: str,
 ) -> None:
     assert (
         endpoint.method == builder.RouteMethod.post
@@ -1144,7 +1202,13 @@ def _create_api_stub(
         or endpoint.method == builder.RouteMethod.delete
         or endpoint.method == builder.RouteMethod.patch
     )
-    api_out = _create_api_function(file_name, endpoint, config)
+    api_out = _create_api_function(
+        file_name=file_name,
+        endpoint=endpoint,
+        config=config,
+        endpoint_root=endpoint_root,
+        top_namespace=top_namespace,
+    )
     util.rewrite_file(api_stub_file, api_out.getvalue())
 
 
@@ -1153,15 +1217,22 @@ WRAP_ARGS_END = "\n"
 
 
 def _create_api_function(
-    file_name: str, endpoint: SpecEndpoint, config: PythonConfig
+    *,
+    file_name: str,
+    endpoint: SpecEndpoint,
+    config: PythonConfig,
+    endpoint_root: str,
+    top_namespace: str,
 ) -> io.StringIO:
+    endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
+    assert endpoint_specific_path is not None
     api_out = io.StringIO()
     python_api_type_root = f"{config.types_package}.api"
-    dot_dirname = endpoint.path_dirname.replace("/", ".")
+    dot_dirname = endpoint_specific_path.path_dirname.replace("/", ".")
     api_import = (
         f"{python_api_type_root}.{dot_dirname}.{file_name}"
         if dot_dirname != ""
-        else f"{python_api_type_root}.{endpoint.path_basename}"
+        else f"{python_api_type_root}.{endpoint_specific_path.path_basename}"
     )
 
     if endpoint.method == builder.RouteMethod.post:
@@ -1173,9 +1244,20 @@ def _create_api_function(
     elif endpoint.method == builder.RouteMethod.patch:
         validated_method = "validated_patch"
 
-    ruff_requires_wrap = len(endpoint.path_basename) > 14
+    ruff_requires_wrap = len(endpoint_specific_path.path_basename) > 14
+
+    account_type = (
+        endpoint_specific_path.root
+        if endpoint_specific_path.root not in ["external", "portal"]
+        else "materials"
+    )
 
-    account_type = endpoint.root if endpoint.root != "external" else "materials"
+    endpoint_path_name = (
+        ENDPOINT_PATH_ALTERNATE
+        if len(endpoint.path_per_api_endpoint.keys()) > 1
+        and endpoint_specific_path.root != top_namespace
+        else ENDPOINT_PATH
+    )
 
     api_out.write(
         f"""import {api_import} as api
@@ -1183,8 +1265,8 @@ from main.db.session import Session, SessionMaker
 from main.site.decorators import APIError, APIResponse, {validated_method}
 
 
-@{validated_method}(api.ENDPOINT_PATH, "{account_type}", api.Arguments)
-def {endpoint.path_basename}({WRAP_ARGS_START if ruff_requires_wrap else ""}args: api.Arguments, client_sm: SessionMaker{WRAP_ARGS_END if ruff_requires_wrap else ""}) -> APIResponse[api.Data]:
+@{validated_method}(api.{endpoint_path_name}, "{account_type}", api.Arguments)
+def {endpoint_specific_path.path_basename}({WRAP_ARGS_START if ruff_requires_wrap else ""}args: api.Arguments, client_sm: SessionMaker{WRAP_ARGS_END if ruff_requires_wrap else ""}) -> APIResponse[api.Data]:
     with Session(client_sm) as session:
         # return APIResponse(data=api.Data())
         pass
@@ -1216,9 +1298,9 @@ def _emit_api_argument_lookup(
 
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+            if endpoint.path_per_api_endpoint[endpoint_root].function is None:
                 continue
             if "Arguments" not in namespace.types or "Data" not in namespace.types:
                 continue
@@ -1244,7 +1326,7 @@ def _emit_api_argument_lookup(
             mapping += f"{INDENT}{INDENT}route_group={route_group},\n"
             mapping += f"{INDENT}{INDENT}account_type={account_type},\n"
             mapping += f"{INDENT}{INDENT}route={import_alias}.ENDPOINT_PATH,\n"
-            mapping += f'{INDENT}{INDENT}handler="{endpoint.function}",\n'
+            mapping += f'{INDENT}{INDENT}handler="{endpoint.path_per_api_endpoint[endpoint_root].function}",\n'
             mapping += f"{INDENT}{INDENT}method={import_alias}.ENDPOINT_METHOD,\n"
             mapping += f"{INDENT})"
             mappings.append(mapping)
@@ -1299,7 +1381,7 @@ ASYNC_BATCH_PROCESSOR_FILENAME = "async_batch_processor"
 ASYNC_BATCH_PROCESSOR_IMPORTS = [
     "import uuid",
     "from abc import ABC, abstractmethod",
-    "from pkgs.serialization_util.serialization_helpers import serialize_for_api",
+    "from pkgs.serialization_util import serialize_for_api",
 ]
 
 

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"
                 )
@@ -123,6 +127,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
@@ -157,42 +162,84 @@ def _emit_endpoint(
     wrap_call = (
         f"{wrap_name}<Arguments>" if is_binary else f"{wrap_name}<Arguments, Response>"
     )
+
+    unc_base_api_imports = (
+        f"appSpecificApiPath, {wrap_name}" if has_multiple_endpoints else wrap_name
+    )
+    unc_types_imports = (
+        'import { ApplicationT } from "unc_types"\n' if has_multiple_endpoints else ""
+    )
+
     type_path = f"unc_types/{'/'.join(namespace.path)}"
 
     if is_binary:
-        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
+        tsx_response_part = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
 import type {{ Arguments }} from "{type_path}"
-
+{unc_types_imports}
 export type {{ Arguments }}
 """
     elif has_data and endpoint.has_attachment:
-        tsx_response_part = f"""import {{ {wrap_name}, type AttachmentResponse }} from "unc_base/api"
+        tsx_response_part = f"""import {{ {unc_base_api_imports}, type AttachmentResponse }} from "unc_base/api"
 import type {{ Arguments, Data }} from "{type_path}"
-
+{unc_types_imports}
 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"
+        tsx_response_part = f"""import {{ {unc_base_api_imports}, type JsonResponse }} from "unc_base/api"
 import type {{ Arguments, Data }} from "{type_path}"
-
+{unc_types_imports}
 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"
+        tsx_response_part = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
 import type {{ Arguments, DeprecatedResult }} from "{type_path}"
-
+{unc_types_imports}
 export type {{ Arguments }}
 export type Response = DeprecatedResult
 """
 
+    """
+
+    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}
 {data_loader_head}{tsx_response_part}
 export const apiCall = {wrap_call}(
-  "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",
+  {endpoint_path_part}
 )
 {data_loader_body}"""
 

pkgs/type_spec/load_types.py

@@ -1,7 +1,6 @@
 import os
 from collections.abc import Callable
 from io import StringIO
-from typing import Optional
 
 from shelljob import fs
 
@@ -41,7 +40,7 @@ def find_and_handle_files(
             handler(file_name, file.read())
 
 
-def load_types(config: Config) -> Optional[SpecBuilder]:
+def load_types(config: Config) -> SpecBuilder | None:
     builder = SpecBuilder(
         api_endpoints=config.api_endpoint, top_namespace=config.top_namespace
     )

pkgs/type_spec/open_api_util.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Optional
 
 
 class OpenAPIType(ABC):
@@ -158,7 +157,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:

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}"