UncountablePythonSDK 0.0.114__py3-none-any.whl → 0.0.116__py3-none-any.whl

examples/integration-server/jobs/materials_auto/example_http.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+
+from uncountable.integration.http_server import (
+    GenericHttpRequest,
+    GenericHttpResponse,
+)
+from uncountable.integration.job import CustomHttpJob, register_job
+from uncountable.types import job_definition_t
+
+
+@dataclass(kw_only=True)
+class ExampleWebhookPayload:
+    id: int
+    message: str
+
+
+@register_job
+class HttpExample(CustomHttpJob):
+    @staticmethod
+    def validate_request(
+        *,
+        request: GenericHttpRequest,  # noqa: ARG004
+        job_definition: job_definition_t.HttpJobDefinitionBase,  # noqa: ARG004
+        profile_meta: job_definition_t.ProfileMetadata,  # noqa: ARG004
+    ) -> None:
+        return None
+
+    @staticmethod
+    def handle_request(
+        *,
+        request: GenericHttpRequest,  # noqa: ARG004
+        job_definition: job_definition_t.HttpJobDefinitionBase,  # noqa: ARG004
+        profile_meta: job_definition_t.ProfileMetadata,  # noqa: ARG004
+    ) -> GenericHttpResponse:
+        return GenericHttpResponse(response="OK", status_code=200)

examples/integration-server/jobs/materials_auto/example_instrument.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+
+from uncountable.integration.job import JobArguments, WebhookJob, register_job
+from uncountable.types import base_t, entity_t, job_definition_t
+
+
+@dataclass(kw_only=True)
+class InstrumentPayload:
+    equipment_id: base_t.ObjectId
+
+
+@register_job
+class InstrumentExample(WebhookJob[InstrumentPayload]):
+    def run(
+        self, args: JobArguments, payload: InstrumentPayload
+    ) -> job_definition_t.JobResult:
+        equipment_data = args.client.get_entities_data(
+            entity_type=entity_t.EntityType.EQUIPMENT,
+            entity_ids=[payload.equipment_id],
+        ).entity_details[0]
+
+        # Load the instrument's connection details from the entity
+        instrument_id = None
+        for field in equipment_data.field_values:
+            if field.field_ref_name == "ins_instrument_id":
+                instrument_id = field.value
+
+        if instrument_id is None:
+            args.logger.log_error("Could not find instrument ID")
+            return job_definition_t.JobResult(success=False)
+
+        args.logger.log_info(f"Instrument ID: {instrument_id}")
+
+        return job_definition_t.JobResult(success=True)
+
+    @property
+    def webhook_payload_type(self) -> type:
+        return InstrumentPayload

examples/integration-server/jobs/materials_auto/profile.yaml

@@ -60,6 +60,12 @@ jobs:
     executor:
       type: script
       import_path: example_wh
+  - id: example_http
+    type: custom_http
+    name: Custom HTTP
+    executor:
+      type: script
+      import_path: example_http
   - id: example_runsheet_wh
     type: webhook
     name: Runsheet Webhook
@@ -69,3 +75,12 @@ jobs:
     executor:
       type: script
       import_path: example_runsheet_wh
+  - id: example_instrument
+    type: webhook
+    name: Webhook Instrument Connection
+    signature_key_secret:
+      type: env
+      env_key: WH_INSTRUMENT_SIGNATURE_KEY
+    executor:
+      type: script
+      import_path: example_instrument

pkgs/type_spec/builder.py

@@ -15,12 +15,23 @@ from typing import Any, Self
 from . import util
 from .cross_output_links import CrossOutputPaths
 from .non_discriminated_union_exceptions import NON_DISCRIMINATED_UNION_EXCEPTIONS
-from .util import parse_type_str, unused
+from .util import parse_type_str
 
 RawDict = dict[Any, Any]
 EndpointKey = str
 
 
+class PathMapping(StrEnum):
+    NO_MAPPING = "no_mapping"
+    DEFAULT_MAPPING = "default_mapping"
+
+
+@dataclass(kw_only=True)
+class APIEndpointInfo:
+    root_path: str
+    path_mapping: PathMapping
+
+
 class StabilityLevel(StrEnum):
     """These are currently used for open api,
     see: https://github.com/Tufin/oasdiff/blob/main/docs/STABILITY.md
@@ -835,7 +846,7 @@ class _EndpointPathDetails:
 
 
 def _resolve_endpoint_path(
-    path: str, api_endpoints: dict[EndpointKey, str]
+    path: str, api_endpoints: dict[EndpointKey, APIEndpointInfo]
 ) -> _EndpointPathDetails:
     root_path_source = path.split("/")[0]
     root_match = RE_ENDPOINT_ROOT.fullmatch(root_path_source)
@@ -843,7 +854,7 @@ def _resolve_endpoint_path(
         raise Exception(f"invalid-api-path-root:{root_path_source}")
 
     root_var = root_match.group(1)
-    root_path = api_endpoints[root_var]
+    root_path = api_endpoints[root_var].root_path
 
     _, *rest_path = path.split("/", 1)
     resolved_path = "/".join([root_path] + rest_path)
@@ -911,6 +922,7 @@ class SpecEndpoint:
     stability_level: StabilityLevel | None
     # Don't emit TypeScript endpoint code
     suppress_ts: bool
+    deprecated: bool = False
     async_batch_path: str | None = None
     result_type: ResultType = ResultType.json
     has_attachment: bool = False
@@ -928,13 +940,13 @@ class SpecEndpoint:
         pass
 
     def process(self, builder: SpecBuilder, data: RawDict) -> None:
-        unused(builder)
         util.check_fields(
             data,
             [
                 "method",
                 "path",
                 "data_loader",
+                "deprecated",
                 "is_sdk",
                 "stability_level",
                 "async_batch_path",
@@ -954,6 +966,7 @@ class SpecEndpoint:
         data_loader = data.get("data_loader", False)
         assert isinstance(data_loader, bool)
         self.data_loader = data_loader
+        self.deprecated = data.get("deprecated", False)
 
         is_sdk = data.get("is_sdk", EndpointEmitType.EMIT_NOTHING)
 
@@ -1346,7 +1359,7 @@ class SpecBuilder:
     def __init__(
         self,
         *,
-        api_endpoints: dict[EndpointKey, str],
+        api_endpoints: dict[EndpointKey, APIEndpointInfo],
         top_namespace: str,
         cross_output_paths: CrossOutputPaths | None,
     ) -> None:

pkgs/type_spec/config.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from typing import Self, TypeVar
 
 from pkgs.serialization import yaml
+from pkgs.type_spec.builder import APIEndpointInfo, EndpointKey
 
 ConfigValueType = str | None | Mapping[str, str | None] | list[str]
 
@@ -19,6 +20,22 @@ def _parse_string_lookup(
     }
 
 
+VT = TypeVar("VT")
+
+
+def _parse_data_lookup(
+    key: str,
+    raw_value: ConfigValueType,
+    conv_func: type[VT],
+) -> dict[str, VT]:
+    assert isinstance(raw_value, dict), f"{key} must be key/values"
+    return {
+        k: conv_func(**v)
+        for k, v in raw_value.items()
+        if v is not None and isinstance(v, dict)
+    }
+
+
 @dataclass(kw_only=True)
 class BaseLanguageConfig:
     types_output: (
@@ -31,7 +48,9 @@ class BaseLanguageConfig:
 
 @dataclass(kw_only=True)
 class TypeScriptConfig(BaseLanguageConfig):
-    routes_output: str  # folder for generate route files will be located.
+    endpoint_to_routes_output: dict[
+        EndpointKey, str
+    ]  # folder for generate route files will be located.
     type_info_output: str  # folder for generated type info files
     id_source_output: str | None = None  # folder for emitted id source maps.
     endpoint_to_frontend_app_type: dict[
@@ -39,7 +58,7 @@ class TypeScriptConfig(BaseLanguageConfig):
     ]  # map from api_endpoint to frontend app type
 
     def __post_init__(self: Self) -> None:
-        self.routes_output = self.routes_output
+        self.endpoint_to_routes_output = self.endpoint_to_routes_output
         self.type_info_output = os.path.abspath(self.type_info_output)
         self.id_source_output = (
             os.path.abspath(self.id_source_output)
@@ -100,7 +119,7 @@ class OpenAPIConfig(BaseLanguageConfig):
 class Config:
     top_namespace: str
     type_spec_types: list[str]  # folders containing the yaml type spec definitions
-    api_endpoint: dict[str, str]
+    api_endpoint: dict[str, APIEndpointInfo]
     # languages
     typescript: TypeScriptConfig | None
     python: PythonConfig
@@ -125,8 +144,10 @@ def parse_yaml_config(config_file: str) -> Config:
     )
     type_spec_types = [os.path.abspath(folder) for folder in raw_type_spec_types]
 
-    api_endpoint = _parse_string_lookup(
-        "api_endpoint", raw_config.get("api_endpoint", {}), lambda x: x
+    api_endpoint = _parse_data_lookup(
+        "api_endpoint",
+        raw_config.get("api_endpoint", {}),
+        APIEndpointInfo,
     )
 
     raw_typescript = raw_config.get("typescript")

pkgs/type_spec/cross_output_links.py

@@ -21,7 +21,7 @@ def get_python_stub_file_path(
 class CrossOutputPaths:
     python_types_output: str
     typescript_types_output: str
-    typescript_routes_output: str
+    typescript_routes_output_by_endpoint: dict[str, str]
     typespec_files_input: list[str]
 
 
@@ -35,10 +35,9 @@ def get_python_api_file_path(
 def get_typescript_api_file_path(
     cross_output_paths: CrossOutputPaths,
     namespace: builder.SpecNamespace,
+    endpoint_key: builder.EndpointKey,
 ) -> str:
-    return (
-        f"{cross_output_paths.typescript_routes_output}/{'/'.join(namespace.path)}.tsx"
-    )
+    return f"{cross_output_paths.typescript_routes_output_by_endpoint[endpoint_key]}/{'/'.join(namespace.path)}.tsx"
 
 
 def get_yaml_api_file_path(
@@ -68,13 +67,16 @@ def get_path_links(
     namespace: builder.SpecNamespace,
     *,
     current_path_type: str,
+    endpoint: builder.SpecEndpoint,
 ) -> str:
     if cross_output_paths is None:
         return ""
 
     api_paths = {
         "Python": get_python_api_file_path(cross_output_paths, namespace),
-        "TypeScript": get_typescript_api_file_path(cross_output_paths, namespace),
+        "TypeScript": get_typescript_api_file_path(
+            cross_output_paths, namespace, endpoint.default_endpoint_key
+        ),
         "YAML": get_yaml_api_file_path(cross_output_paths, namespace),
     }
 
@@ -95,11 +97,11 @@ def get_path_links(
 
     if namespace.endpoint is not None:
         for (
-            endpoint,
+            endpoint_key,
             path_specific_endpoint,
         ) in namespace.endpoint.path_per_api_endpoint.items():
             path_from_root = get_python_stub_file_path(path_specific_endpoint.function)
             if path_from_root is None:
                 continue
-            paths_string += f"{comment_prefix} Implementation for {endpoint}: file://./{return_to_root_path}{path_from_root}\n"
+            paths_string += f"{comment_prefix} Implementation for {endpoint_key}: file://./{return_to_root_path}{path_from_root}\n"
     return paths_string

pkgs/type_spec/emit_open_api.py

@@ -261,6 +261,10 @@ def _emit_endpoint_parameters(
     } | _emit_endpoint_parameter_examples(examples)
 
 
+def _emit_endpoint_deprecated(deprecated: bool) -> DictApiSchema:
+    return {"deprecated": True} if deprecated else {}
+
+
 def _emit_stability_level(
     stability_level: EmitOpenAPIStabilityLevel | None,
 ) -> DictApiSchema:
@@ -376,6 +380,7 @@ def _emit_namespace(
                 "tags": endpoint.tags,
                 "summary": endpoint.summary,
             }
+            | _emit_endpoint_deprecated(endpoint.deprecated)
             | _emit_endpoint_description(endpoint.description, ctx.endpoint.guides)
             | _emit_stability_level(endpoint.stability_level)
             | _emit_endpoint_parameters(endpoint, argument_type, ctx.endpoint.examples)
@@ -474,8 +479,9 @@ def _emit_type(
         return
 
     if isinstance(stype, builder.SpecTypeDefnUnion):
-        ctx.types[stype.name] = open_api_type(
-            ctx, stype.get_backing_type(), config=config
+        ctx.types[stype.name] = OpenAPIUnionType(
+            [open_api_type(ctx, p, config=config) for p in stype.types],
+            discrimnator=stype.discriminator,
         )
         return
 
@@ -617,6 +623,7 @@ def _emit_endpoint(
         tags=[tag_name],
         summary=f"{'/'.join(namespace.path[path_cutoff:])}",
         description=description,
+        deprecated=namespace.endpoint.deprecated,
         stability_level=namespace.endpoint.stability_level,
         examples=[
             EmitOpenAPIEndpointExample(

pkgs/type_spec/emit_open_api_util.py

@@ -82,6 +82,7 @@ class EmitOpenAPIEndpoint:
     tags: list[str]
     summary: str
     description: str
+    deprecated: bool
     stability_level: EmitOpenAPIStabilityLevel | None
     examples: list[EmitOpenAPIEndpointExample]
     guides: list[EmitOpenAPIGuide]

pkgs/type_spec/emit_python.py

@@ -357,7 +357,10 @@ def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
     endpoint = namespace.endpoint
     if endpoint is not None:
         path_links = get_path_links(
-            ctx.builder.cross_output_paths, namespace, current_path_type="Python"
+            ctx.builder.cross_output_paths,
+            namespace,
+            current_path_type="Python",
+            endpoint=endpoint,
         )
         if path_links != "":
             ctx.out.write("\n")

pkgs/type_spec/emit_typescript.py

@@ -1,17 +1,18 @@
 import io
 import os
+from typing import assert_never
 
 from . import builder, util
-from .builder import EndpointKey, EndpointSpecificPath
+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,
@@ -37,6 +38,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             out=io.StringIO(),
             namespace=namespace,
             cross_output_paths=builder.cross_output_paths,
+            api_endpoints=builder.api_endpoints,
         )
 
         _emit_namespace(ctx, config, namespace)
@@ -78,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")
 
@@ -112,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)
@@ -145,7 +148,10 @@ def _emit_endpoint(
         assert endpoint.result_type == builder.ResultType.json
 
     paths_string = get_path_links(
-        ctx.cross_output_paths, namespace, current_path_type="TypeScript"
+        ctx.cross_output_paths,
+        namespace,
+        current_path_type="TypeScript",
+        endpoint=endpoint,
     )
 
     data_loader_head = ""
@@ -155,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"
@@ -175,38 +181,56 @@ def _emit_endpoint(
     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 else ""
+        '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 {{ {unc_base_api_imports} }} from "unc_base/api"
-import type {{ Arguments }} from "{type_path}"
-{unc_types_imports}
+        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 {{ {unc_base_api_imports}, type AttachmentResponse }} from "unc_base/api"
-import type {{ Arguments, Data }} from "{type_path}"
-{unc_types_imports}
+        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 {{ {unc_base_api_imports}, type JsonResponse }} from "unc_base/api"
-import type {{ Arguments, Data }} from "{type_path}"
-{unc_types_imports}
+        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>
 """
 
     else:
         assert has_deprecated_result
-        tsx_response_part = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
-import type {{ Arguments, DeprecatedResult }} from "{type_path}"
-{unc_types_imports}
+        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
 """
@@ -247,18 +271,18 @@ export type Response = DeprecatedResult
 
     # tsx_api = f"""{MODIFY_NOTICE}
     tsx_api = f"""{MODIFY_NOTICE}{paths_string}
-{data_loader_head}{tsx_response_part}
+{tsx_response_head}{data_loader_head}{unc_types_imports}{tsx_response_part}
 export const apiCall = {wrap_call}(
-  {endpoint_path_part}
+  {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:
@@ -274,14 +298,6 @@ export const apiCall = {wrap_call}(
             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

@@ -32,6 +32,7 @@ class EmitTypescriptContext:
     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:
@@ -80,6 +81,12 @@ 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(
@@ -106,6 +113,14 @@ def emit_value_ts(
     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:
     if not isinstance(stype, builder.SpecTypeDefn):
         return
@@ -118,6 +133,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

pkgs/type_spec/load_types.py

@@ -46,7 +46,7 @@ def load_types(config: Config) -> SpecBuilder | None:
         cross_output_paths = CrossOutputPaths(
             python_types_output=config.python.types_output,
             typescript_types_output=config.typescript.types_output,
-            typescript_routes_output=config.typescript.routes_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
         )

pkgs/type_spec/open_api_util.py

@@ -223,13 +223,21 @@ class OpenAPIUnionType(OpenAPIType):
         base_types: list[OpenAPIType],
         description: str | None = None,
         nullable: bool = False,
+        discrimnator: str | None = None,
+        discriminator_map: dict[str, OpenAPIType] | None = None,
     ) -> None:
         self.base_types = base_types
+        self._discriminator = discrimnator
         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}
+            if self._discriminator is not None
+            else None,
+        }
 
 
 class OpenAPIIntersectionType(OpenAPIType):

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