UncountablePythonSDK 0.0.74__py3-none-any.whl → 0.0.76__py3-none-any.whl

pkgs/type_spec/emit_typescript_util.py

@@ -1,4 +1,5 @@
 import io
+import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
@@ -8,6 +9,23 @@ 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
+    builder.BaseTypeName.s_date_time: "string",  # IMPROVE: Aliased DateTimeStr
+    # Decimal's are marked as to_string_values thus are strings in the front-end
+    builder.BaseTypeName.s_decimal: "string",
+    builder.BaseTypeName.s_dict: "PartialRecord",
+    builder.BaseTypeName.s_integer: "number",
+    builder.BaseTypeName.s_lossy_decimal: "number",
+    builder.BaseTypeName.s_opaque_key: "string",
+    builder.BaseTypeName.s_none: "null",
+    builder.BaseTypeName.s_string: "string",
+    # UNC: global types
+    builder.BaseTypeName.s_json_value: "JsonValue",
+}
+
+
 @dataclass(kw_only=True)
 class EmitTypescriptContext:
     out: io.StringIO
@@ -28,3 +46,220 @@ def ts_name(name: str, name_case: builder.NameCase) -> str:
         return name
     bits = util.split_any_name(name)
     return "".join([bits[0], *[x.title() for x in bits[1:]]])
+
+
+def emit_value_ts(
+    ctx: EmitTypescriptContext, stype: builder.SpecType, value: typing.Any
+) -> str:
+    """Mimics emit_python even if not all types are used in TypeScript yet"""
+    literal = builder.unwrap_literal_type(stype)
+    if literal is not None:
+        return emit_value_ts(ctx, literal.value_type, literal.value)
+
+    if stype.is_base_type(builder.BaseTypeName.s_string):
+        assert isinstance(value, str)
+        return util.encode_common_string(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_integer):
+        assert isinstance(value, int)
+        return str(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_boolean):
+        assert isinstance(value, bool)
+        return "true" if value else "false"
+    elif stype.is_base_type(builder.BaseTypeName.s_lossy_decimal):
+        return str(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_decimal):
+        return f"'{value}'"
+    elif isinstance(stype, builder.SpecTypeInstance):
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_list):
+            sub_type = stype.parameters[0]
+            return (
+                "[" + ", ".join([emit_value_ts(ctx, sub_type, x) for x in value]) + "]"
+            )
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_dict):
+            key_type = stype.parameters[0]
+            value_type = stype.parameters[1]
+            return (
+                "{\n\t"
+                + ",\n\t".join(
+                    "["
+                    + emit_value_ts(ctx, key_type, dkey)
+                    + "]: "
+                    + emit_value_ts(ctx, value_type, dvalue)
+                    for dkey, dvalue in value.items()
+                )
+                + "\n}"
+            )
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+            sub_type = stype.parameters[0]
+            if value is None:
+                return "null"
+            return emit_value_ts(ctx, sub_type, value)
+
+    elif isinstance(stype, builder.SpecTypeDefnStringEnum):
+        return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
+
+    raise Exception("invalid constant type", value, stype)
+
+
+def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
+    if not isinstance(stype, builder.SpecTypeDefn):
+        return
+
+    if stype.is_base or stype.is_predefined:
+        return
+
+    ctx.out.write("\n")
+    ctx.out.write(MODIFY_NOTICE)
+
+    if isinstance(stype, builder.SpecTypeDefnExternal):
+        assert not stype.is_exported, "expecting private names"
+        ctx.out.write(stype.external_map["ts"])
+        ctx.out.write("\n")
+        return
+
+    assert stype.is_exported, "expecting exported names"
+    if isinstance(stype, builder.SpecTypeDefnAlias):
+        ctx.out.write(f"export type {stype.name} = {refer_to(ctx, stype.alias)}\n")
+        return
+
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.out.write(
+            f"export type {stype.name} = {refer_to(ctx, stype.get_backing_type())}\n"
+        )
+        return
+
+    if isinstance(stype, builder.SpecTypeDefnStringEnum):
+        ctx.out.write(f"export enum {stype.name} {{\n")
+        assert stype.values
+        for name, entry in stype.values.items():
+            ctx.out.write(
+                f'{INDENT}{ts_enum_name(name, stype.name_case)} = "{entry.value}",\n'
+            )
+        ctx.out.write("}\n")
+        return
+
+    assert isinstance(stype, builder.SpecTypeDefnObject)
+    assert stype.base is not None
+
+    base_type = ""
+    if not stype.base.is_base:
+        base_type = f"{refer_to(ctx, stype.base)} & "
+
+    if stype.properties is None and base_type == "":
+        ctx.out.write(f"export type {stype.name} = TEmpty\n")
+    elif stype.properties is None:
+        ctx.out.write(f"export type {stype.name} = {base_type}{{}}\n")
+    else:
+        if isinstance(stype, builder.SpecTypeDefnObject) and len(stype.parameters) > 0:
+            full_type_name = f'{stype.name}<{", ".join(stype.parameters)}>'
+        else:
+            full_type_name = stype.name
+        ctx.out.write(f"export type {full_type_name} = {base_type}{{")
+        ctx.out.write("\n")
+        for prop in stype.properties.values():
+            ref_type = refer_to(ctx, prop.spec_type)
+            prop_name = ts_name(prop.name, prop.name_case)
+            if prop.has_default and not prop.parse_require:
+                # For now, we'll assume the generated types with defaults are meant as
+                # arguments, thus treat like extant==missing
+                # IMPROVE: if we can decide they are meant as output instead, then
+                # they should be marked as required
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
+            elif prop.extant == builder.PropertyExtant.missing:
+                # Unlike optional below, missing does not imply null is possible. They
+                # treated distinctly.
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
+            elif prop.extant == builder.PropertyExtant.optional:
+                # Need to add in |null since Python side can produce null's right now
+                # IMPROVE: It would be better if the serializer could instead omit the None's
+                # Dropping the null should be forward compatible
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type} | null")
+            else:
+                ctx.out.write(f"{INDENT}{prop_name}: {ref_type}")
+            ctx.out.write("\n")
+        ctx.out.write("}\n")
+
+
+def refer_to(ctx: EmitTypescriptContext, stype: builder.SpecType) -> str:
+    return refer_to_impl(ctx, stype)[0]
+
+
+def refer_to_impl(
+    ctx: EmitTypescriptContext, stype: builder.SpecType
+) -> tuple[str, bool]:
+    """
+    @return (string-specific, multiple-types)
+    """
+    if isinstance(stype, builder.SpecTypeInstance):
+        if stype.defn_type.name == builder.BaseTypeName.s_list:
+            spec, multi = refer_to_impl(ctx, stype.parameters[0])
+            return f"({spec})[]" if multi else f"{spec}[]", False
+        if stype.defn_type.name == builder.BaseTypeName.s_readonly_array:
+            spec, multi = refer_to_impl(ctx, stype.parameters[0])
+            return f"readonly ({spec})[]" if multi else f"readonly {spec}[]", False
+        if stype.defn_type.name == builder.BaseTypeName.s_union:
+            return (
+                f'({" | ".join([refer_to(ctx, p) for p in stype.parameters])})',
+                False,
+            )
+        if stype.defn_type.name == builder.BaseTypeName.s_literal:
+            parts = []
+            for parameter in stype.parameters:
+                assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
+                parts.append(refer_to(ctx, parameter))
+            return f'({" | ".join(parts)})', False
+        if stype.defn_type.name == builder.BaseTypeName.s_optional:
+            return f"{refer_to(ctx, stype.parameters[0])} | null", True
+        if stype.defn_type.name == builder.BaseTypeName.s_tuple:
+            return f"[{", ".join([refer_to(ctx, p) for p in stype.parameters])}]", False
+        params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
+        return f"{refer_to(ctx, stype.defn_type)}<{params}>", False
+
+    if isinstance(stype, builder.SpecTypeLiteralWrapper):
+        return emit_value_ts(ctx, stype.value_type, stype.value), False
+
+    if isinstance(stype, builder.SpecTypeGenericParameter):
+        return stype.name, False
+
+    assert isinstance(stype, builder.SpecTypeDefn)
+    if stype.is_base:  # assume correct namespace
+        if stype.name == builder.BaseTypeName.s_list:
+            return "any[]", False  # TODO: generic type
+        return base_name_map[builder.BaseTypeName(stype.name)], False
+
+    if stype.namespace == ctx.namespace:
+        return stype.name, False
+
+    ctx.namespaces.add(stype.namespace)
+    return f"{resolve_namespace_ref(stype.namespace)}.{stype.name}", False
+
+
+def ts_enum_name(name: str, name_case: builder.NameCase) -> str:
+    if name_case == builder.NameCase.js_upper:
+        return name.upper()
+    return ts_name(name, name_case)
+
+
+def resolve_namespace_name(namespace: builder.SpecNamespace) -> str:
+    return namespace.name
+
+
+def emit_namespace_imports_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    current_namespace: builder.SpecNamespace,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        import_path = (
+            "./"
+            if len(current_namespace.path) == 1
+            else "../" * (len(current_namespace.path) - 1)
+        )
+        import_from = f"{import_path}{resolve_namespace_name(ns)}"
+        out.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501

uncountable/core/environment.py

@@ -2,6 +2,8 @@ import functools
 import os
 from importlib.metadata import PackageNotFoundError, version
 
+from uncountable.types import integration_server_t
+
 
 @functools.cache
 def get_version() -> str:
@@ -12,8 +14,8 @@ def get_version() -> str:
     return version_str
 
 
-def get_integration_env() -> str | None:
-    return os.environ.get("UNC_INTEGRATION_ENV")
+def get_server_env() -> str | None:
+    return os.environ.get("UNC_SERVER_ENV")
 
 
 def get_webhook_server_port() -> int:
@@ -26,3 +28,14 @@ def get_local_admin_server_port() -> int:
 
 def get_otel_enabled() -> bool:
     return os.environ.get("UNC_OTEL_ENABLED") == "true"
+
+
+def get_profiles_module() -> str:
+    return os.environ["UNC_PROFILES_MODULE"]
+
+
+def get_integration_envs() -> list[integration_server_t.IntegrationEnvironment]:
+    return [
+        integration_server_t.IntegrationEnvironment(env)
+        for env in os.environ.get("UNC_INTEGRATION_ENVS", "prod").split(",")
+    ]

uncountable/integration/construct_client.py

@@ -3,22 +3,21 @@ from uncountable.core.client import ClientConfig
 from uncountable.core.types import AuthDetailsAll, AuthDetailsOAuth
 from uncountable.integration.secret_retrieval.retrieve_secret import retrieve_secret
 from uncountable.integration.telemetry import JobLogger
+from uncountable.types import auth_retrieval_t
 from uncountable.types.job_definition_t import (
-    AuthRetrievalBasic,
-    AuthRetrievalOAuth,
     ProfileMetadata,
 )
 
 
 def _construct_auth_details(profile_meta: ProfileMetadata) -> AuthDetailsAll:
     match profile_meta.auth_retrieval:
-        case AuthRetrievalOAuth():
+        case auth_retrieval_t.AuthRetrievalOAuth():
             refresh_token = retrieve_secret(
                 profile_meta.auth_retrieval.refresh_token_secret,
                 profile_metadata=profile_meta,
             )
             return AuthDetailsOAuth(refresh_token=refresh_token)
-        case AuthRetrievalBasic():
+        case auth_retrieval_t.AuthRetrievalBasic():
             api_id = retrieve_secret(
                 profile_meta.auth_retrieval.api_id_secret, profile_metadata=profile_meta
             )

uncountable/integration/queue_runner/job_scheduler.py

@@ -55,7 +55,7 @@ def _start_workers(
     job_worker_lookup: dict[str, Worker] = {}
     job_definition_lookup: dict[str, job_definition_t.JobDefinition] = {}
     for profile in profiles:
-        for job_definition in profile.definition.jobs:
+        for job_definition in profile.jobs:
             job_definition_lookup[job_definition.id] = job_definition
             job_worker_key = _get_job_worker_key(job_definition, profile.name)
             if job_worker_key not in job_queue_worker_lookup:

uncountable/integration/queue_runner/worker.py

@@ -51,16 +51,11 @@ class RegisteredJobDetails:
 
 def get_registered_job_details(job_ref_name: str) -> RegisteredJobDetails:
     profiles = load_profiles()
-    for profile in profiles:
-        for job_definition in profile.definition.jobs:
+    for profile_metadata in profiles:
+        for job_definition in profile_metadata.jobs:
             if job_definition.id == job_ref_name:
                 return RegisteredJobDetails(
-                    profile_metadata=job_definition_t.ProfileMetadata(
-                        name=profile.name,
-                        base_url=profile.definition.base_url,
-                        auth_retrieval=profile.definition.auth_retrieval,
-                        client_options=profile.definition.client_options,
-                    ),
+                    profile_metadata=profile_metadata,
                     job_definition=job_definition,
                 )
     raise Exception(f"profile not found for job {job_ref_name}")
@@ -86,23 +81,23 @@ def run_queued_job(
             profile_metadata=job_details.profile_metadata,
             job_definition=job_details.job_definition,
         )
-        client = construct_uncountable_client(
-            profile_meta=job_details.profile_metadata, job_logger=job_logger
-        )
-        batch_processor = AsyncBatchProcessor(client=client)
+        try:
+            client = construct_uncountable_client(
+                profile_meta=job_details.profile_metadata, job_logger=job_logger
+            )
+            batch_processor = AsyncBatchProcessor(client=client)
 
-        payload = _resolve_queued_job_payload(queued_job)
+            payload = _resolve_queued_job_payload(queued_job)
 
-        args = JobArguments(
-            job_definition=job_details.job_definition,
-            client=client,
-            batch_processor=batch_processor,
-            profile_metadata=job_details.profile_metadata,
-            logger=job_logger,
-            payload=payload,
-        )
+            args = JobArguments(
+                job_definition=job_details.job_definition,
+                client=client,
+                batch_processor=batch_processor,
+                profile_metadata=job_details.profile_metadata,
+                logger=job_logger,
+                payload=payload,
+            )
 
-        try:
             return execute_job(
                 args=args,
                 profile_metadata=job_details.profile_metadata,

uncountable/integration/scan_profiles.py

@@ -1,27 +1,26 @@
 import functools
-import os
-from dataclasses import dataclass
 from importlib import resources
 
 from pkgs.argument_parser import CachedParser
-from uncountable.types import job_definition_t
+from uncountable.core import environment
+from uncountable.types import integration_server_t, job_definition_t
 
 profile_parser = CachedParser(job_definition_t.ProfileDefinition)
 
-
-@dataclass(kw_only=True)
-class ProfileDetails:
-    name: str
-    definition: job_definition_t.ProfileDefinition
+_DEFAULT_PROFILE_ENV = integration_server_t.IntegrationEnvironment.PROD
+_IGNORED_PROFILE_FOLDERS = ["__pycache__"]
 
 
 @functools.cache
-def load_profiles() -> list[ProfileDetails]:
-    profiles_module = os.environ["UNC_PROFILES_MODULE"]
+def load_profiles() -> list[job_definition_t.ProfileMetadata]:
+    profiles_module = environment.get_profiles_module()
+    integration_envs = environment.get_integration_envs()
     profiles = [
-        entry for entry in resources.files(profiles_module).iterdir() if entry.is_dir()
+        entry
+        for entry in resources.files(profiles_module).iterdir()
+        if entry.is_dir() and entry.name not in _IGNORED_PROFILE_FOLDERS
     ]
-    profile_details: list[ProfileDetails] = []
+    profile_details: list[job_definition_t.ProfileMetadata] = []
     seen_job_ids: set[str] = set()
     for profile_file in profiles:
         profile_name = profile_file.name
@@ -34,9 +33,34 @@ def load_profiles() -> list[ProfileDetails]:
                 if job.id in seen_job_ids:
                     raise Exception(f"multiple jobs with id {job.id}")
                 seen_job_ids.add(job.id)
-            profile_details.append(
-                ProfileDetails(name=profile_name, definition=definition)
-            )
+
+            if definition.environments is not None:
+                for integration_env in integration_envs:
+                    environment_config = definition.environments.get(integration_env)
+                    if environment_config is not None:
+                        profile_details.append(
+                            job_definition_t.ProfileMetadata(
+                                name=profile_name,
+                                jobs=definition.jobs,
+                                base_url=environment_config.base_url,
+                                auth_retrieval=environment_config.auth_retrieval,
+                                client_options=environment_config.client_options,
+                            )
+                        )
+            elif _DEFAULT_PROFILE_ENV in integration_envs:
+                assert (
+                    definition.base_url is not None
+                    and definition.auth_retrieval is not None
+                ), f"define environments in profile.yaml for {profile_name}"
+                profile_details.append(
+                    job_definition_t.ProfileMetadata(
+                        name=profile_name,
+                        jobs=definition.jobs,
+                        base_url=definition.base_url,
+                        auth_retrieval=definition.auth_retrieval,
+                        client_options=definition.client_options,
+                    )
+                )
         except FileNotFoundError as e:
             print(f"WARN: profile.yaml not found for {profile_name}", e)
             continue

uncountable/integration/server.py

@@ -12,12 +12,10 @@ from opentelemetry.trace import get_current_span
 from sqlalchemy.engine.base import Engine
 
 from uncountable.integration.cron import CronJobArgs, cron_job_executor
-from uncountable.integration.scan_profiles import ProfileDetails
 from uncountable.integration.telemetry import Logger
-from uncountable.types import base_t
+from uncountable.types import base_t, job_definition_t
 from uncountable.types.job_definition_t import (
     CronJobDefinition,
-    ProfileMetadata,
     WebhookJobDefinition,
 )
 
@@ -38,17 +36,11 @@ class IntegrationServer:
         )
         self._server_logger = Logger(get_current_span())
 
-    def register_jobs(self, profiles: list[ProfileDetails]) -> None:
+    def register_jobs(self, profiles: list[job_definition_t.ProfileMetadata]) -> None:
         valid_job_ids = []
-        for profile in profiles:
-            for job_defn in profile.definition.jobs:
+        for profile_metadata in profiles:
+            for job_defn in profile_metadata.jobs:
                 valid_job_ids.append(job_defn.id)
-                profile_metadata = ProfileMetadata(
-                    name=profile.name,
-                    auth_retrieval=profile.definition.auth_retrieval,
-                    base_url=profile.definition.base_url,
-                    client_options=profile.definition.client_options,
-                )
                 match job_defn:
                     case CronJobDefinition():
                         # Add to ap scheduler

uncountable/integration/telemetry.py

@@ -21,8 +21,8 @@ from opentelemetry.sdk.trace.export import (
 from opentelemetry.trace import DEFAULT_TRACE_OPTIONS, Span, Tracer
 
 from uncountable.core.environment import (
-    get_integration_env,
     get_otel_enabled,
+    get_server_env,
     get_version,
 )
 from uncountable.types import base_t, job_definition_t
@@ -41,7 +41,7 @@ def get_otel_resource() -> Resource:
     unc_version = os.environ.get("UNC_VERSION")
     if unc_version is not None:
         attributes["service.version"] = unc_version
-    unc_env = get_integration_env()
+    unc_env = get_server_env()
     if unc_env is not None:
         attributes["deployment.environment"] = unc_env
     resource = Resource.create(attributes=_cast_attributes(attributes))

uncountable/integration/webhook_server/entrypoint.py

@@ -8,8 +8,8 @@ from flask.typing import ResponseReturnValue
 from flask.wrappers import Response
 from opentelemetry.trace import get_current_span
 from uncountable.core.environment import (
-    get_integration_env,
     get_local_admin_server_port,
+    get_server_env,
     get_webhook_server_port,
 )
 from uncountable.integration.queue_runner.command_server.command_client import (
@@ -143,15 +143,9 @@ def register_route(
 
 def main() -> None:
     profiles = load_profiles()
-    for profile in profiles:
+    for profile_metadata in profiles:
         server_logger = Logger(get_current_span())
-        profile_metadata = job_definition_t.ProfileMetadata(
-            name=profile.name,
-            auth_retrieval=profile.definition.auth_retrieval,
-            base_url=profile.definition.base_url,
-            client_options=profile.definition.client_options,
-        )
-        for job in profile.definition.jobs:
+        for job in profile_metadata.jobs:
             if isinstance(job, job_definition_t.WebhookJobDefinition):
                 register_route(
                     server_logger=server_logger, profile_meta=profile_metadata, job=job
@@ -165,6 +159,6 @@ if __name__ == "__main__":
     app.run(
         host="0.0.0.0",
         port=get_webhook_server_port(),
-        debug=get_integration_env() == "playground",
+        debug=get_server_env() == "playground",
         exclude_patterns=[],
     )

uncountable/types/__init__.py

@@ -9,6 +9,7 @@ from .api.equipment import associate_equipment_input as associate_equipment_inpu
 from .api.recipes import associate_recipe_as_input as associate_recipe_as_input_t
 from .api.recipes import associate_recipe_as_lot as associate_recipe_as_lot_t
 from . import async_batch_t as async_batch_t
+from . import auth_retrieval_t as auth_retrieval_t
 from . import base_t as base_t
 from . import calculations_t as calculations_t
 from . import chemical_structure_t as chemical_structure_t
@@ -31,6 +32,7 @@ from . import experiment_groups_t as experiment_groups_t
 from . import field_values_t as field_values_t
 from . import fields_t as fields_t
 from . import generic_upload_t as generic_upload_t
+from .api.recipes import get_column_calculation_values as get_column_calculation_values_t
 from .api.recipes import get_curve as get_curve_t
 from .api.entity import get_entities_data as get_entities_data_t
 from .api.inputs import get_input_data as get_input_data_t
@@ -47,10 +49,12 @@ from .api.recipe_metadata import get_recipe_metadata_data as get_recipe_metadata
 from .api.recipes import get_recipe_names as get_recipe_names_t
 from .api.recipes import get_recipe_output_metadata as get_recipe_output_metadata_t
 from .api.recipes import get_recipes_data as get_recipes_data_t
+from .api.entity import grant_entity_permissions as grant_entity_permissions_t
 from . import id_source_t as id_source_t
 from . import identifier_t as identifier_t
 from . import input_attributes_t as input_attributes_t
 from . import inputs_t as inputs_t
+from . import integration_server_t as integration_server_t
 from .api.uploader import invoke_uploader as invoke_uploader_t
 from . import job_definition_t as job_definition_t
 from .api.entity import list_entities as list_entities_t
@@ -110,6 +114,7 @@ __all__: list[str] = [
     "associate_recipe_as_input_t",
     "associate_recipe_as_lot_t",
     "async_batch_t",
+    "auth_retrieval_t",
     "base_t",
     "calculations_t",
     "chemical_structure_t",
@@ -132,6 +137,7 @@ __all__: list[str] = [
     "field_values_t",
     "fields_t",
     "generic_upload_t",
+    "get_column_calculation_values_t",
     "get_curve_t",
     "get_entities_data_t",
     "get_input_data_t",
@@ -148,10 +154,12 @@ __all__: list[str] = [
     "get_recipe_names_t",
     "get_recipe_output_metadata_t",
     "get_recipes_data_t",
+    "grant_entity_permissions_t",
     "id_source_t",
     "identifier_t",
     "input_attributes_t",
     "inputs_t",
+    "integration_server_t",
     "invoke_uploader_t",
     "job_definition_t",
     "list_entities_t",

uncountable/types/api/entity/create_entities.py

@@ -12,6 +12,7 @@ from pkgs.serialization import serial_class
 from ... import base_t
 from ... import entity_t
 from ... import field_values_t
+from ... import identifier_t
 
 __all__: list[str] = [
     "Arguments",
@@ -40,9 +41,10 @@ class EntityToCreate:
 )
 @dataclasses.dataclass(kw_only=True)
 class Arguments:
-    definition_id: base_t.ObjectId
-    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]]
+    entity_type: entity_t.LimitedEntityType
     entities_to_create: list[EntityToCreate]
+    definition_id: typing.Optional[base_t.ObjectId] = None
+    definition_key: typing.Optional[identifier_t.IdentifierKey] = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/entity/create_entity.py

@@ -12,6 +12,7 @@ from pkgs.serialization import serial_class
 from ... import base_t
 from ... import entity_t
 from ... import field_values_t
+from ... import identifier_t
 
 __all__: list[str] = [
     "Arguments",
@@ -43,8 +44,9 @@ class EntityFieldInitialValue:
 )
 @dataclasses.dataclass(kw_only=True)
 class Arguments:
-    definition_id: base_t.ObjectId
-    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]]
+    entity_type: entity_t.LimitedEntityType
+    definition_id: typing.Optional[base_t.ObjectId] = None
+    definition_key: typing.Optional[identifier_t.IdentifierKey] = None
     field_values: typing.Optional[typing.Optional[list[field_values_t.FieldRefNameValue]]] = None