UncountablePythonSDK 0.0.20__py3-none-any.whl → 0.0.21__py3-none-any.whl

pkgs/type_spec/emit_python.py

@@ -21,6 +21,17 @@ __all__: list[str] = [
 """
 END_ALL_EXPORTS = "]\n"
 
+ASYNC_BATCH_TYPE_NAMESPACE = builder.SpecNamespace(name="uncountable.types.async_batch")
+ASYNC_BATCH_REQUEST_PATH_STYPE = builder.SpecTypeDefnStringEnum(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="AsyncBatchRequestPath"
+)
+ASYNC_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="AsyncBatchRequest"
+)
+QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedBatchRequest"
+)
+
 
 @dataclass(kw_only=True)
 class TrackingContext:
@@ -194,6 +205,7 @@ def emit_python(builder: builder.SpecBuilder, *, config: PythonConfig) -> None:
     _emit_api_stubs(builder=builder, config=config)
     _emit_api_argument_lookup(builder=builder, config=config)
     _emit_client_class(spec_builder=builder, config=config)
+    _emit_async_batch_processor(spec_builder=builder, config=config)
 
 
 def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
@@ -353,11 +365,9 @@ def _validate_supports_handler_generation(
 def _emit_endpoint_invocation_docstring(
     ctx: Context,
     endpoint: builder.SpecEndpoint,
-    arguments_type: builder.SpecTypeDefnObject,
+    properties: list[builder.SpecProperty],
 ) -> None:
-    has_argument_desc = arguments_type.properties is not None and any(
-        prop.desc is not None for prop in arguments_type.properties.values()
-    )
+    has_argument_desc = any(prop.desc is not None for prop in properties)
     has_endpoint_desc = endpoint.desc
     if not has_argument_desc and not has_endpoint_desc:
         return
@@ -370,55 +380,39 @@ def _emit_endpoint_invocation_docstring(
         ctx.out.write(f"{endpoint.desc}\n")
         ctx.out.write("\n")
 
-    if arguments_type.properties is not None and has_argument_desc:
-        for prop in arguments_type.properties.values():
+    if has_argument_desc:
+        for prop in properties:
             if prop.desc:
                 ctx.out.write(f"{FULL_INDENT}:param {prop.name}: {prop.desc}\n")
 
     ctx.out.write(f'{FULL_INDENT}"""\n')
 
 
-def _emit_endpoint_invocation_function(
-    ctx: Context, namespace: builder.SpecNamespace
+def _emit_endpoint_invocation_function_signature(
+    ctx: Context,
+    endpoint: builder.SpecEndpoint,
+    arguments_type: builder.SpecTypeDefnObject,
+    data_type: builder.SpecTypeDefnObject,
+    extra_params: list[builder.SpecProperty] | None = None,
 ) -> None:
-    endpoint = namespace.endpoint
-    if endpoint is None:
-        return
-    if not endpoint.is_sdk:
-        return
-
-    arguments_type = namespace.types["Arguments"]
-    data_type = namespace.types["Data"]
+    all_arguments = (
+        list(arguments_type.properties.values())
+        if arguments_type.properties is not None
+        else []
+    ) + (extra_params if extra_params is not None else [])
 
-    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
-    data_type = _validate_supports_handler_generation(
-        data_type, "response", supports_inheritance=True
-    )
-
-    endpoint_method_stype = builder.SpecTypeDefnObject(
-        namespace=arguments_type.namespace, name=ENDPOINT_METHOD
-    )
-    endpoint_path_stype = builder.SpecTypeDefnObject(
-        namespace=arguments_type.namespace, name=ENDPOINT_PATH
-    )
-
-    has_arguments = (
-        arguments_type.properties is not None
-        and len(arguments_type.properties.values()) > 0
-    )
     assert endpoint.function is not None
     function_name = endpoint.function.split(".")[-1]
-    ctx.out.write("\n")
     ctx.out.write(
         f"""
     def {function_name}(
         self,\n"""
     )
-    if has_arguments:
+    if len(all_arguments) > 0:
         ctx.out.write(f"{INDENT}{INDENT}*,\n")
-        _emit_type_properties(
+        _emit_properties(
             ctx=ctx,
-            stype=arguments_type,
+            properties=all_arguments,
             num_indent=2,
             separator=",\n",
             class_out=ctx.out,
@@ -426,23 +420,143 @@ def _emit_endpoint_invocation_function(
     ctx.out.write(f"{INDENT}) -> {refer_to(ctx=ctx, stype=data_type)}:")
     ctx.out.write("\n")
 
-    _emit_endpoint_invocation_docstring(
-        ctx=ctx,
-        endpoint=endpoint,
-        arguments_type=arguments_type,
-    )
+    if len(all_arguments) > 0:
+        _emit_endpoint_invocation_docstring(
+            ctx=ctx, endpoint=endpoint, properties=all_arguments
+        )
+
 
-    ctx.out.write(f"{INDENT}{INDENT}args = {refer_to(ctx=ctx, stype=arguments_type)}(")
-    if has_arguments:
-        assert arguments_type.properties is not None
+def _emit_instantiate_type_from_locals(
+    ctx: Context, variable_name: str, variable_type: builder.SpecTypeDefnObject
+) -> None:
+    ctx.out.write(
+        f"{INDENT}{INDENT}{variable_name} = {refer_to(ctx=ctx, stype=variable_type)}("
+    )
+    if variable_type.properties is not None and len(variable_type.properties) > 0:
         ctx.out.write("\n")
-        for prop in arguments_type.properties.values():
+        for prop in variable_type.properties.values():
             ctx.out.write(f"{INDENT}{INDENT}{INDENT}{prop.name}={prop.name},")
             ctx.out.write("\n")
         ctx.out.write(f"{INDENT}{INDENT})")
     else:
         ctx.out.write(")")
 
+
+def _emit_async_batch_invocation_function(
+    ctx: Context, namespace: builder.SpecNamespace
+) -> None:
+    endpoint = namespace.endpoint
+    if endpoint is None:
+        return
+    if endpoint.async_batch_path is None or not endpoint.is_sdk:
+        return
+
+    ctx.out.write("\n")
+    arguments_type = namespace.types["Arguments"]
+    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
+    data_type = QUEUED_BATCH_REQUEST_STYPE
+
+    list_str_params: list[builder.SpecType] = []
+    list_str_params.append(
+        builder.SpecTypeGenericParameter(
+            name="str",
+            spec_type_definition=builder.SpecTypeDefnObject(
+                namespace=namespace, name=builder.BaseTypeName.s_string, is_base=True
+            ),
+        )
+    )
+
+    _emit_endpoint_invocation_function_signature(
+        ctx=ctx,
+        endpoint=endpoint,
+        arguments_type=arguments_type,
+        data_type=data_type,
+        extra_params=[
+            builder.SpecProperty(
+                name="depends_on",
+                extant=builder.PropertyExtant.optional,
+                convert_value=builder.PropertyConvertValue.auto,
+                name_case=builder.NameCase.convert,
+                label="depends_on",
+                desc="A list of batch reference keys to process before processing this request",
+                spec_type=builder.SpecTypeInstance(
+                    defn_type=builder.SpecTypeDefnObject(
+                        name=builder.BaseTypeName.s_list,
+                        is_base=True,
+                        namespace=namespace,
+                    ),
+                    parameters=list_str_params,
+                ),
+            )
+        ],
+    )
+
+    # Emit function body
+    _emit_instantiate_type_from_locals(
+        ctx=ctx, variable_name="args", variable_type=arguments_type
+    )
+
+    path = _emit_value(
+        ctx=ctx,
+        stype=ASYNC_BATCH_REQUEST_PATH_STYPE,
+        value=endpoint.async_batch_path,
+    )
+
+    ctx.out.write(
+        f"""
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = {refer_to(ctx=ctx, stype=ASYNC_BATCH_REQUEST_STYPE)}(
+            path={path},
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return {refer_to(ctx=ctx, stype=data_type)}(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )"""
+    )
+
+
+def _emit_endpoint_invocation_function(
+    ctx: Context, namespace: builder.SpecNamespace
+) -> None:
+    endpoint = namespace.endpoint
+    if endpoint is None:
+        return
+    if not endpoint.is_sdk or endpoint.is_beta:
+        return
+
+    ctx.out.write("\n")
+    arguments_type = namespace.types["Arguments"]
+    data_type = namespace.types["Data"]
+    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
+    data_type = _validate_supports_handler_generation(
+        data_type, "response", supports_inheritance=True
+    )
+
+    _emit_endpoint_invocation_function_signature(
+        ctx=ctx, endpoint=endpoint, arguments_type=arguments_type, data_type=data_type
+    )
+
+    endpoint_method_stype = builder.SpecTypeDefnObject(
+        namespace=arguments_type.namespace, name=ENDPOINT_METHOD
+    )
+    endpoint_path_stype = builder.SpecTypeDefnObject(
+        namespace=arguments_type.namespace, name=ENDPOINT_PATH
+    )
+
+    # Emit function body
+    _emit_instantiate_type_from_locals(
+        ctx=ctx, variable_name="args", variable_type=arguments_type
+    )
+
     ctx.out.write(
         f"""
         api_request = APIRequest(
@@ -452,7 +566,6 @@ def _emit_endpoint_invocation_function(
         )
         return self.do_request(api_request=api_request, return_type={refer_to(ctx=ctx, stype=data_type)})"""
     )
-    ctx.out.write("\n")
 
 
 def _emit_string_enum(ctx: Context, stype: builder.SpecTypeDefnStringEnum) -> None:
@@ -516,17 +629,32 @@ def _emit_type_properties(
     stype: builder.SpecTypeDefnObject,
     num_indent: int = 1,
     separator: str = "\n",
+) -> EmittedPropertiesMetadata:
+    return _emit_properties(
+        ctx=ctx,
+        class_out=class_out,
+        properties=list((stype.properties or {}).values()),
+        num_indent=num_indent,
+        separator=separator,
+    )
+
+
+def _emit_properties(
+    *,
+    ctx: Context,
+    class_out: io.StringIO,
+    properties: list[builder.SpecProperty],
+    num_indent: int = 1,
+    separator: str = "\n",
 ) -> EmittedPropertiesMetadata:
     unconverted_keys: set[str] = set()
     unconverted_values: set[str] = set()
     to_string_values: set[str] = set()
     parse_require: set[str] = set()
 
-    if stype.properties is not None and len(stype.properties) > 0:
+    if len(properties) > 0:
 
         def write_field(prop: builder.SpecProperty) -> None:
-            # Checked in outer function, MyPy doens't track the check inside here
-            assert isinstance(stype, builder.SpecTypeDefn)
             if prop.name_case == builder.NameCase.preserve:
                 unconverted_keys.add(prop.name)
             py_name = python_field_name(prop.name, prop.name_case)
@@ -559,10 +687,10 @@ def _emit_type_properties(
                 class_out.write(f" = {default}")
             class_out.write(separator)
 
-        for prop in stype.properties.values():
+        for prop in properties:
             if prop.extant == builder.PropertyExtant.required:
                 write_field(prop)
-        for prop in stype.properties.values():
+        for prop in properties:
             if prop.extant != builder.PropertyExtant.required:
                 write_field(prop)
     else:
@@ -1014,6 +1142,64 @@ CLIENT_CLASS_IMPORTS = [
     "from abc import ABC, abstractmethod",
     "from dataclasses import dataclass",
 ]
+ASYNC_BATCH_PROCESSOR_FILENAME = "async_batch_processor"
+ASYNC_BATCH_PROCESSOR_IMPORTS = [
+    "import uuid",
+    "from abc import ABC, abstractmethod",
+    "from dataclasses import dataclass",
+    "from pkgs.serialization_util.serialization_helpers import serialize_for_api",
+]
+
+
+def _emit_async_batch_processor(
+    *, spec_builder: builder.SpecBuilder, config: PythonConfig
+) -> None:
+    if not config.emit_async_batch_processor:
+        return
+
+    async_batch_processor_out = io.StringIO()
+    ctx = Context(
+        out=io.StringIO(), namespace=builder.SpecNamespace("async_batch_processor")
+    )
+
+    for namespace in sorted(
+        spec_builder.namespaces.values(),
+        key=lambda ns: _resolve_namespace_name(ns),
+    ):
+        _emit_async_batch_invocation_function(ctx=ctx, namespace=namespace)
+
+    async_batch_processor_out.write(MODIFY_NOTICE)
+    async_batch_processor_out.write(LINT_HEADER)
+    async_batch_processor_out.write("# ruff: noqa: PLR0904\n")
+
+    _emit_types_imports(out=async_batch_processor_out, ctx=ctx)
+    _emit_namespace_imports(
+        out=async_batch_processor_out,
+        namespaces=ctx.namespaces,
+        from_namespace=None,
+        config=config,
+    )
+
+    async_batch_processor_out.write(
+        f"""{LINE_BREAK.join(ASYNC_BATCH_PROCESSOR_IMPORTS)}
+
+
+class AsyncBatchProcessorBase(ABC):
+    @abstractmethod
+    def _enqueue(self, req: {refer_to(ctx=ctx, stype=ASYNC_BATCH_REQUEST_STYPE)}) -> None:
+        ...
+
+    @abstractmethod
+    def send(self) -> base_t.ObjectId:
+        ..."""
+    )
+    async_batch_processor_out.write(ctx.out.getvalue())
+    async_batch_processor_out.write("\n")
+
+    util.rewrite_file(
+        f"{config.types_output}/{ASYNC_BATCH_PROCESSOR_FILENAME}.py",
+        async_batch_processor_out.getvalue(),
+    )
 
 
 def _emit_client_class(
@@ -1023,7 +1209,7 @@ def _emit_client_class(
         return
 
     client_base_out = io.StringIO()
-    ctx = Context(out=io.StringIO(), namespace=builder.SpecNamespace("client_class"))
+    ctx = Context(out=io.StringIO(), namespace=builder.SpecNamespace("client_base"))
     for namespace in sorted(
         spec_builder.namespaces.values(),
         key=lambda ns: _resolve_namespace_name(ns),
@@ -1038,7 +1224,7 @@ def _emit_client_class(
     _emit_namespace_imports(
         out=client_base_out,
         namespaces=ctx.namespaces,
-        from_namespace=builder.SpecNamespace("client_base"),
+        from_namespace=None,
         config=config,
     )
 
@@ -1059,10 +1245,10 @@ class ClientMethods(ABC):
 
     @abstractmethod
     def do_request(self, *, api_request: APIRequest, return_type: type[DT]) -> DT:
-        ...
-"""
+        ..."""
     )
     client_base_out.write(ctx.out.getvalue())
+    client_base_out.write("\n")
 
     util.rewrite_file(
         f"{config.types_output}/{CLIENT_CLASS_FILENAME}.py", client_base_out.getvalue()

pkgs/type_spec/type_info/emit_type_info.py

@@ -23,7 +23,7 @@ def type_path_of(stype: builder.SpecType) -> object:  # NamePath
     extended scopes, generics, and enum literal values.
     - Scoped Type: [ (namespace-string)..., type-string ]
     - Instance Type: [ "$instance", Scoped-Type-Base, [TypePath-Parameters...] ]
-    - Literal Type: [ "$literal", [ "$value", value ]... ]
+    - Literal Type: [ "$literal", [ "$value", value, value-type-string ]... ]
 
     @return (string-specific, multiple-types)
     """
@@ -34,11 +34,15 @@ def type_path_of(stype: builder.SpecType) -> object:  # NamePath
 
     if isinstance(stype, builder.SpecTypeInstance):
         if stype.defn_type.name == builder.BaseTypeName.s_literal:
-            parts: list[str | list[str | bool]] = ["$literal"]
+            parts: list[object] = ["$literal"]
             for parameter in stype.parameters:
                 assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
                 # This allows expansion to enum literal values later
-                parts.append(["$value", parameter.value])
+                parts.append([
+                    "$value",
+                    parameter.value,
+                    type_path_of(parameter.value_type),
+                ])
             return parts
 
         return [
@@ -148,6 +152,114 @@ def _build_map_all(build: builder.SpecBuilder) -> MapAll:
     return map_all
 
 
+@dataclasses.dataclass(kw_only=True)
+class InheritablePropertyParts:
+    """This uses only the "soft" information for now, things that aren't relevant
+    to the language emitted types. There are some fields that should be inherited
+    at that level, but that needs to be done in builder. When that is done, the
+    "label" and "desc" could probably be removed from this list."""
+
+    label: Optional[str] = None
+    desc: Optional[str] = None
+    ext_info: Optional[data_t.ExtInfo] = None
+
+
+def _extract_inheritable_property_parts(
+    stype: builder.SpecTypeDefnObject,
+    prop: builder.SpecProperty,
+) -> InheritablePropertyParts:
+    if not stype.is_base and isinstance(stype.base, builder.SpecTypeDefn):
+        base_prop = (stype.base.properties or {}).get(prop.name)
+        if base_prop is None:
+            base_parts = InheritablePropertyParts()
+        else:
+            base_parts = _extract_inheritable_property_parts(stype.base, base_prop)
+            # Layout should not be inherited, as it'd end up hiding properties in the derived type
+            if base_parts.ext_info is not None:
+                base_parts.ext_info.layout = None
+    else:
+        base_parts = InheritablePropertyParts()
+
+    label = prop.label or base_parts.label
+    desc = prop.desc or base_parts.desc
+    local_ext_info = _parse_ext_info(prop.ext_info)
+    if local_ext_info is None:
+        ext_info = base_parts.ext_info
+    elif base_parts.ext_info is None:
+        ext_info = local_ext_info
+    else:
+        ext_info = data_t.ExtInfo(
+            **(local_ext_info.__dict__ | base_parts.ext_info.__dict__)
+        )
+
+    return InheritablePropertyParts(label=label, desc=desc, ext_info=ext_info)
+
+
+ExtInfoLayout = dict[str, set[str]]
+ALL_FIELDS_GROUP = "*all_fields"
+
+
+def _extract_and_validate_layout(
+    stype: builder.SpecTypeDefnObject,
+    ext_info: data_t.ExtInfo,
+    base_layout: ExtInfoLayout | None,
+) -> ExtInfoLayout:
+    """
+    Produce a map of groups to fields, for validation.
+    """
+    if ext_info.layout is None:
+        return {}
+    assert stype.properties is not None
+
+    all_fields_group: set[str] = set()
+    layout: ExtInfoLayout = {ALL_FIELDS_GROUP: all_fields_group}
+
+    for group in ext_info.layout.groups:
+        fields = set(group.fields or [])
+        for field in fields:
+            assert field in stype.properties, f"layout-refers-to-missing-field:{field}"
+
+        local_ref_name = None
+        if group.ref_name is not None:
+            assert (
+                base_layout is None or base_layout.get(group.ref_name) is None
+            ), f"group-name-duplicate-in-base:{group.ref_name}"
+            local_ref_name = group.ref_name
+
+        if group.extends:
+            assert base_layout is not None, "missing-base-layout"
+            base_group = base_layout.get(group.extends)
+            assert base_group is not None, f"missing-base-group:{group.extends}"
+            fields.update(base_group)
+            local_ref_name = group.extends
+
+        assert local_ref_name not in layout, f"duplicate-group:{local_ref_name}"
+        if local_ref_name is not None:
+            layout[local_ref_name] = fields
+        all_fields_group.update(fields)
+
+    for group_ref_name in base_layout or {}:
+        assert group_ref_name in layout, f"missing-base-group:{group_ref_name}"
+
+    for prop_ref_name in stype.properties:
+        assert prop_ref_name in all_fields_group, f"layout-missing-field:{prop_ref_name}"
+
+    return layout
+
+
+def _validate_type_ext_info(stype: builder.SpecTypeDefnObject) -> ExtInfoLayout | None:
+    ext_info = _parse_ext_info(stype.ext_info)
+    if ext_info is None:
+        return None
+
+    if not stype.is_base and isinstance(stype.base, builder.SpecTypeDefnObject):
+        base_layout = _validate_type_ext_info(stype.base)
+    else:
+        base_layout = None
+
+    return _extract_and_validate_layout(stype, ext_info, base_layout)
+
+
 def _build_map_type(
     build: builder.SpecBuilder, stype: builder.SpecTypeDefn
 ) -> MapType | None:
@@ -158,6 +270,8 @@ def _build_map_type(
         and not stype.is_base
         and stype.base is not None
     ):
+        _validate_type_ext_info(stype)
+
         properties: dict[str, MapProperty] = {}
         map_type = MapTypeObject(
             type_name=stype.name,
@@ -170,14 +284,17 @@ def _build_map_type(
 
         if stype.properties is not None:
             for prop in stype.properties.values():
+                parts = _extract_inheritable_property_parts(stype, prop)
+                # Propertis can't have layouts
+                assert parts.ext_info is None or parts.ext_info.layout is None
                 map_property = MapProperty(
                     type_name=prop.name,
-                    label=prop.label,
+                    label=parts.label,
                     api_name=ts_name(prop.name, prop.name_case),
                     extant=prop.extant,
                     type_path=type_path_of(prop.spec_type),
-                    ext_info=_convert_ext_info(prop.ext_info),
-                    desc=prop.desc,
+                    ext_info=serialize_for_api(parts.ext_info),
+                    desc=parts.desc,
                     default=prop.default,
                 )
                 map_type.properties[prop.name] = map_property
@@ -211,7 +328,7 @@ def _build_map_type(
     return None
 
 
-def _convert_ext_info(in_ext: Any) -> Optional[PureJsonValue]:
+def _parse_ext_info(in_ext: Any) -> Optional[data_t.ExtInfo]:
     if in_ext is None:
         return None
     assert isinstance(in_ext, dict)
@@ -229,6 +346,10 @@ def _convert_ext_info(in_ext: Any) -> Optional[PureJsonValue]:
             df["result_type"] = serialize_for_storage(converted)
             mod_ext["data_format"] = df
 
-    parsed = ext_info_parser.parse_storage(mod_ext)
+    return ext_info_parser.parse_storage(mod_ext)
+
+
+def _convert_ext_info(in_ext: Any) -> Optional[PureJsonValue]:
     # we need to convert this to API storage since it'll be used as-is in the UI
+    parsed = _parse_ext_info(in_ext)
     return cast(PureJsonValue, serialize_for_api(parsed))

type_spec/external/api/entity/create_entities.yaml

@@ -19,7 +19,18 @@ Arguments:
             type: ObjectId
             desc: "Definition id for the entities to create"
         entity_type:
-            type: Union<Literal<entity.EntityType.lab_request>, Literal<entity.EntityType.approval>, Literal<entity.EntityType.custom_entity>, Literal<entity.EntityType.task>, Literal<entity.EntityType.project>, Literal<entity.EntityType.equipment>, Literal<entity.EntityType.inv_local_locations>>
+            type: |
+                Union<
+                    Literal<entity.EntityType.lab_request>,
+                    Literal<entity.EntityType.approval>,
+                    Literal<entity.EntityType.custom_entity>,
+                    Literal<entity.EntityType.task>,
+                    Literal<entity.EntityType.project>,
+                    Literal<entity.EntityType.equipment>,
+                    Literal<entity.EntityType.inv_local_locations>,
+                    Literal<entity.EntityType.field_option_set>,
+                    Literal<entity.EntityType.webhook>
+                >
             desc: "The type of the entities to create"
         entities_to_create:
             type: List<EntityToCreate>

type_spec/external/api/entity/create_entity.yaml

@@ -26,7 +26,18 @@ Arguments:
             type: ObjectId
             desc: "Definition id of the entity to create"
         entity_type:
-            type: Union<Literal<entity.EntityType.lab_request>, Literal<entity.EntityType.approval>, Literal<entity.EntityType.custom_entity>, Literal<entity.EntityType.task>, Literal<entity.EntityType.project>, Literal<entity.EntityType.equipment>, Literal<entity.EntityType.inv_local_locations>>
+            type: |
+                Union<
+                    Literal<entity.EntityType.lab_request>,
+                    Literal<entity.EntityType.approval>,
+                    Literal<entity.EntityType.custom_entity>,
+                    Literal<entity.EntityType.task>,
+                    Literal<entity.EntityType.project>,
+                    Literal<entity.EntityType.equipment>,
+                    Literal<entity.EntityType.inv_local_locations>,
+                    Literal<entity.EntityType.field_option_set>,
+                    Literal<entity.EntityType.webhook>
+                >
             desc: "The type of the entities requested"
         field_values?:
             type: Optional<List<field_values.FieldRefNameValue>>

type_spec/external/api/entity/transition_entity_phase.yaml

@@ -0,0 +1,44 @@
+$endpoint:
+    is_sdk: true
+    method: post
+    path: ${external}/entity/transition_entity_phase
+    function: main.site.app.external.entity.transition_entity_phase.transition_entity_phase
+    desc: "Transitions an entity from one phase to another"
+
+
+TransitionIdentifierPhases:
+    type: Object
+    properties:
+        type:
+            type: Literal<'phases'>
+        phase_from_key:
+            type: identifier.IdentifierKey
+        phase_to_key:
+            type: identifier.IdentifierKey
+
+TransitionIdentifierTransition:
+    type: Object
+    properties:
+        type:
+            type: Literal<'transition'>
+        transition_key:
+            type: identifier.IdentifierKey
+
+
+TransitionIdentifier:
+    type: Alias
+    alias: |
+        Union<TransitionIdentifierPhases, TransitionIdentifierTransition>
+
+
+Arguments:
+    type: Object
+    properties:
+        entity:
+            type: entity.Entity
+        transition:
+            type: TransitionIdentifier
+
+Data:
+    type: response.Response
+    properties: