UncountablePythonSDK 0.0.30__py3-none-any.whl → 0.0.33__py3-none-any.whl

pkgs/serialization_util/serialization_helpers.py

@@ -5,16 +5,16 @@ from decimal import Decimal
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
+    ClassVar,
+    Protocol,
     TypeVar,
     Union,
+    overload,
 )
 
-from pkgs.argument_parser import camel_to_snake_case, snake_to_camel_case
+from pkgs.argument_parser import snake_to_camel_case
 from pkgs.serialization import (
     MISSING_SENTRY,
-    MissingSentryType,
-    MissingType,
     OpaqueKey,
     get_serial_class_data,
 )
@@ -28,52 +28,60 @@ if TYPE_CHECKING:
 else:
     JsonValue = Union[JsonScalar, dict[str, Any], list[Any]]
 
+T = TypeVar("T")
+
+
+class Dataclass(Protocol):
+    __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
+
 
-def key_convert_to_camelcase(o: Any) -> Any:
+def identity(x: T) -> T:
+    return x
+
+
+def key_convert_to_camelcase(o: Any) -> str:
     if isinstance(o, OpaqueKey):
         return o
     if isinstance(o, enum.Enum):
-        return o.value
+        return o.value  # type: ignore[no-any-return]
     if isinstance(o, str):
         return snake_to_camel_case(o)
-    return o
+    return o  # type: ignore[no-any-return]
 
 
-def _convert_dict(d: Any) -> Any:
+def _convert_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {
-        key_convert_to_camelcase(k): convert_to_camelcase(v)
+        key_convert_to_camelcase(k): serialize_for_api(v)
         for k, v in d.items()
         if v != MISSING_SENTRY
     }
 
 
-def _serialize_dict(d: Any) -> dict[str, Any]:
-    return {k: serialize(v) for k, v in d.items() if v != MISSING_SENTRY}
+def _serialize_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
+    return {k: serialize_for_storage(v) for k, v in d.items() if v != MISSING_SENTRY}
 
 
-def _convert_dataclass(d: Any) -> Any:
+def _convert_dataclass(d: Dataclass) -> dict[str, JsonValue]:
     dct = type(d)
     scd = get_serial_class_data(dct)
 
-    def key_convert(key: Any) -> Any:
+    def key_convert(key: str) -> str:
         if scd.has_unconverted_key(key):
             return key
         return key_convert_to_camelcase(key)
 
-    def value_convert(key: Any, value: Any) -> Any:
-        if value is None:
-            return None
+    def value_convert(key: str, value: Any) -> JsonValue:
         if scd.has_to_string_value(key):
             # Limit to types we know we need to support to avoid surprises
             # Generics, like List/Dict would need to be per-value stringified
             assert isinstance(value, (Decimal, int))
             return str(value)
         if scd.has_unconverted_value(key):
-            return value
-        return convert_to_camelcase(value)
+            return value  # type: ignore[no-any-return]
+        return serialize_for_api(value)  # type: ignore[no-any-return,unused-ignore]
 
     return {
-        key_convert(k): value_convert(k, v)
+        key_convert(k): (value_convert(k, v) if v is not None else None)
         for k, v in d.__dict__.items()
         if v != MISSING_SENTRY
     }
@@ -83,24 +91,35 @@ _SERIALIZATION_FUNCS_STANDARD = {
     SerializationType.ENUM: lambda x: str(x.value),
     SerializationType.DATE: lambda x: x.isoformat(),
     SerializationType.TIMEDELTA: lambda x: x.total_seconds(),
-    SerializationType.UNKNOWN: lambda x: x,
+    SerializationType.UNKNOWN: identity,
 }
 
-_CONVERSION_SERIALIZATION_FUNCS = {
+_CONVERSION_SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     SerializationType.NAMED_TUPLE: lambda x: _convert_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [convert_to_camelcase(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_api(v) for v in x],
     SerializationType.DICT: _convert_dict,
     SerializationType.DATACLASS: _convert_dataclass,
 }
 
 
-def convert_to_camelcase(obj: Any) -> Any:
-    """@DEPRECATED prefer serialize_for_api"""
-    return serialize_for_api(obj)
+@overload
+def serialize_for_api(obj: None) -> None: ...
+
+
+@overload
+def serialize_for_api(obj: dict[str, Any]) -> dict[str, JsonValue]: ...
 
 
-def serialize_for_api(obj: Any) -> Any:
+@overload
+def serialize_for_api(obj: Dataclass) -> dict[str, JsonValue]: ...
+
+
+@overload
+def serialize_for_api(obj: Any) -> JsonValue: ...
+
+
+def serialize_for_api(obj: Any) -> JsonValue:
     """
     Serialize to a parsed-JSON format suitably encoded for API output.
 
@@ -122,15 +141,10 @@ _SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     **_SERIALIZATION_FUNCS_DICT,
     SerializationType.NAMED_TUPLE: lambda x: _serialize_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [serialize(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_storage(v) for v in x],
 }
 
 
-def serialize(obj: Any) -> Any:
-    """@DEPRECATED: prefer serialize_for_storage"""
-    return serialize_for_storage(obj)
-
-
 def serialize_for_storage(obj: Any) -> JsonValue:
     """
     Convert a value into the pseudo-JSON form for
@@ -142,34 +156,9 @@ def serialize_for_storage(obj: Any) -> JsonValue:
     return _SERIALIZATION_FUNCS[serialization_type](obj)
 
 
-def serialize_for_storage_dict(obj: Any) -> dict[str, JsonValue]:
+def serialize_for_storage_dict(obj: dict | Dataclass) -> dict[str, JsonValue]:  # type: ignore[type-arg]
     """
     Same as serialize for storage but guarantees outer object is a dictionary
     """
-    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    serialization_type = get_serialization_type(type(obj))
     return _SERIALIZATION_FUNCS_DICT[serialization_type](obj)
-
-
-def key_convert_to_snake_case(o: Any) -> Any:
-    if isinstance(o, OpaqueKey):
-        return o
-    if isinstance(o, str):
-        return camel_to_snake_case(o)
-    return o
-
-
-def convert_dict_to_snake_case(data: Any) -> Any:
-    return {
-        key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
-        if isinstance(v, dict)
-        else v
-        for k, v in data.items()
-        if v != MISSING_SENTRY
-    }
-
-
-T = TypeVar("T")
-
-
-def resolve_missing_to_none(val: MissingType[T]) -> Optional[T]:
-    return val if not isinstance(val, MissingSentryType) else None

pkgs/type_spec/builder.py

@@ -102,6 +102,8 @@ class DefnTypeName(StrEnum):
     s_string_enum = "StringEnum"
     # a particular literal value
     s_string_literal = "_StringLiteral"
+    # A union of several other types
+    s_union = "Union"
 
 
 base_namespace_name = "base"
@@ -547,13 +549,65 @@ class SpecTypeDefnAlias(SpecTypeDefn):
         super().base_process(builder, data, ["type", "desc", "alias", "discriminator"])
         self.alias = builder.parse_type(self.namespace, data["alias"])
         self.desc = data.get("desc", None)
-        # Should be limited to Union type aliases
         self.discriminator = data.get("discriminator", None)
 
     def get_referenced_types(self) -> list[SpecType]:
         return [self.alias]
 
 
+class SpecTypeDefnUnion(SpecTypeDefn):
+    def __init__(self, namespace: SpecNamespace, name: str) -> None:
+        super().__init__(namespace, name)
+        self.discriminator: str | None = None
+        self.types: list[SpecType] = []
+        self._alias_type: SpecType | None = None
+        self.discriminator_map: dict[str, SpecType] | None = None
+        self.desc: str | None = None
+
+    def process(self, builder: SpecBuilder, data: RawDict) -> None:
+        super().base_process(builder, data, ["type", "desc", "types", "discriminator"])
+
+        self.desc = data.get("desc", None)
+        self.discriminator = data.get("discriminator", None)
+
+        for sub_type_str in data["types"]:
+            sub_type = builder.parse_type(self.namespace, sub_type_str)
+            self.types.append(sub_type)
+
+        base_type = builder.namespaces[base_namespace_name].types[BaseTypeName.s_union]
+        self._backing_type = SpecTypeInstance(base_type, self.types)
+
+        if self.discriminator is not None:
+            self.discriminator_map = {}
+            for sub_type in self.types:
+                builder.push_where(sub_type.name)
+                assert isinstance(
+                    sub_type, SpecTypeDefnObject
+                ), "union-type-must-be-object"
+                assert sub_type.properties is not None
+                discriminator_type = sub_type.properties.get(self.discriminator)
+                assert (
+                    discriminator_type is not None
+                ), f"missing-discriminator-field: {sub_type}"
+                prop_type = unwrap_literal_type(discriminator_type.spec_type)
+                assert prop_type is not None
+                assert prop_type.is_value_to_string()
+                discriminant = str(prop_type.value)
+                assert (
+                    discriminant not in self.discriminator_map
+                ), f"duplicated-discriminant, {discriminant} in {sub_type}"
+                self.discriminator_map[discriminant] = sub_type
+
+                builder.pop_where()
+
+    def get_referenced_types(self) -> list[SpecType]:
+        return self.types
+
+    def get_backing_type(self) -> SpecType:
+        assert self._backing_type is not None
+        return self._backing_type
+
+
 class SpecTypeDefnExternal(SpecTypeDefn):
     external_map: dict[str, str]
 
@@ -1017,6 +1071,8 @@ class SpecNamespace:
             spec_type: SpecTypeDefn
             if defn_type == DefnTypeName.s_alias:
                 spec_type = SpecTypeDefnAlias(self, name)
+            elif defn_type == DefnTypeName.s_union:
+                spec_type = SpecTypeDefnUnion(self, name)
             elif defn_type == DefnTypeName.s_external:
                 spec_type = SpecTypeDefnExternal(self, name)
             elif defn_type == DefnTypeName.s_string_enum:

pkgs/type_spec/emit_open_api.py

@@ -430,6 +430,12 @@ def _emit_type(
         ctx.types[stype.name] = open_api_type(ctx, stype.alias, config=config)
         return
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.types[stype.name] = open_api_type(
+            ctx, stype.get_backing_type(), config=config
+        )
+        return
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         # TODO: check that these are always string enums
         # IMPROVE: reflect the enum names in the description

pkgs/type_spec/emit_python.py

@@ -43,6 +43,7 @@ class TrackingContext:
     use_serial_string_enum: bool = False
     use_dataclass: bool = False
     use_serial_class: bool = False
+    use_serial_union: bool = False
     use_missing: bool = False
     use_opaque_key: bool = False
 
@@ -219,6 +220,8 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
         out.write("from dataclasses import dataclass\n")
     if ctx.use_serial_class:
         out.write("from pkgs.serialization import serial_class\n")
+    if ctx.use_serial_union:
+        out.write("from pkgs.serialization import serial_union_annotation\n")
     if ctx.use_serial_string_enum:
         out.write("from pkgs.serialization import serial_string_enum\n")
     if ctx.use_missing:
@@ -727,6 +730,26 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
         ctx.out.write(f"{stype.name} = {refer_to(ctx, stype.alias)}\n")
         return
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.use_serial_union = True
+        ctx.out.write(f"{stype.name} = typing.Annotated[\n")
+        ctx.out.write(f"{INDENT}{refer_to(ctx, stype.get_backing_type())},\n")
+        ctx.out.write(f"{INDENT}serial_union_annotation(\n")
+        if stype.discriminator is not None:
+            ctx.out.write(
+                f"{INDENT * 2}discriminator={util.encode_common_string(stype.discriminator)},\n"
+            )
+        if stype.discriminator_map is not None:
+            ctx.out.write(f"{INDENT * 2}discriminator_map={{\n")
+            for key, value in stype.discriminator_map.items():
+                ctx.out.write(
+                    f"{INDENT * 3}{util.encode_common_string(key)}: {refer_to(ctx, value)},\n"
+                )
+            ctx.out.write(f"{INDENT * 2}}},\n")
+        ctx.out.write(f"{INDENT}),\n")
+        ctx.out.write("]\n")
+        return
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         return _emit_string_enum(ctx, stype)
 

pkgs/type_spec/emit_typescript.py

@@ -303,6 +303,12 @@ def _emit_type(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
         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

pkgs/type_spec/type_info/emit_type_info.py

@@ -1,5 +1,6 @@
 import copy
 import dataclasses
+import decimal
 import io
 import json
 from typing import Any, Optional, TypeAlias, Union, cast
@@ -7,7 +8,10 @@ from typing import Any, Optional, TypeAlias, Union, cast
 from main.base.types import data_t
 from main.base.types.base import PureJsonValue
 from pkgs.argument_parser import CachedParser
-from pkgs.serialization_util import serialize_for_api, serialize_for_storage
+from pkgs.serialization_util import (
+    serialize_for_api,
+    serialize_for_storage,
+)
 
 from .. import builder, util
 from ..emit_typescript_util import MODIFY_NOTICE, ts_name
@@ -69,12 +73,21 @@ def _dict_null_strip(data: dict[str, object]) -> dict[str, object]:
     }
 
 
+class JsonEncoder(json.JSONEncoder):
+    """We have some defaults of special types that we need to emit"""
+
+    def default(self, obj: object) -> object:
+        if isinstance(obj, decimal.Decimal):
+            return str(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
 def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
     type_map = _build_map_all(build)
 
     # sort for stability, indent for smaller diffs
     stripped = _dict_null_strip(dataclasses.asdict(type_map))
-    serial = json.dumps(stripped, sort_keys=True, indent=2)
+    serial = json.dumps(stripped, sort_keys=True, indent=2, cls=JsonEncoder)
     type_map_out = io.StringIO()
     type_map_out.write(MODIFY_NOTICE)
     type_map_out.write(f"export const TYPE_MAP = {serial}")
@@ -247,17 +260,25 @@ def _extract_and_validate_layout(
     return layout
 
 
-def _validate_type_ext_info(stype: builder.SpecTypeDefnObject) -> ExtInfoLayout | None:
+def _validate_type_ext_info(
+    stype: builder.SpecTypeDefnObject,
+) -> tuple[ExtInfoLayout | None, Optional[data_t.ExtInfo]]:
     ext_info = _parse_ext_info(stype.ext_info)
     if ext_info is None:
-        return None
+        return None, None
+
+    if ext_info.label_fields is not None:
+        assert stype.properties is not None
+        for name in ext_info.label_fields:
+            prop = stype.properties.get(name)
+            assert prop is not None, f"missing-label-field:{name}"
 
     if not stype.is_base and isinstance(stype.base, builder.SpecTypeDefnObject):
-        base_layout = _validate_type_ext_info(stype.base)
+        base_layout, _ = _validate_type_ext_info(stype.base)
     else:
         base_layout = None
 
-    return _extract_and_validate_layout(stype, ext_info, base_layout)
+    return _extract_and_validate_layout(stype, ext_info, base_layout), ext_info
 
 
 def _build_map_type(
@@ -270,7 +291,7 @@ def _build_map_type(
         and not stype.is_base
         and stype.base is not None
     ):
-        _validate_type_ext_info(stype)
+        _, ext_info = _validate_type_ext_info(stype)
 
         properties: dict[str, MapProperty] = {}
         map_type = MapTypeObject(
@@ -279,7 +300,7 @@ def _build_map_type(
             properties=properties,
             desc=stype.desc,
             base_type_path=type_path_of(stype.base),
-            ext_info=_convert_ext_info(stype.ext_info),
+            ext_info=serialize_for_api(ext_info),  # type: ignore[arg-type]
         )
 
         if stype.properties is not None:
@@ -293,7 +314,7 @@ def _build_map_type(
                     api_name=ts_name(prop.name, prop.name_case),
                     extant=prop.extant,
                     type_path=type_path_of(prop.spec_type),
-                    ext_info=serialize_for_api(parts.ext_info),
+                    ext_info=serialize_for_api(parts.ext_info),  # type: ignore[arg-type]
                     desc=parts.desc,
                     default=prop.default,
                 )
@@ -311,6 +332,19 @@ def _build_map_type(
             discriminator=stype.discriminator,
         )
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        # Emit as a basic alias for now, as the front-end supports only those for now
+        # IMPROVE: We should emit a proper union type and support that
+        backing = stype.get_backing_type()
+        return MapTypeAlias(
+            type_name=stype.name,
+            label=stype.label,
+            desc=stype.desc,
+            alias_type_path=type_path_of(backing),
+            ext_info=_convert_ext_info(stype.ext_info),
+            discriminator=stype.discriminator,
+        )
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         return MapStringEnum(
             type_name=stype.name,

uncountable/types/__init__.py

@@ -3,6 +3,7 @@
 # ruff: noqa: E402
 # fmt: off
 # isort: skip_file
+from .api.recipes import add_recipe_to_project as add_recipe_to_project_t
 from .api.recipes import archive_recipes as archive_recipes_t
 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
@@ -61,6 +62,8 @@ from . import recipe_metadata as recipe_metadata_t
 from . import recipe_output_metadata as recipe_output_metadata_t
 from . import recipe_tags as recipe_tags_t
 from . import recipe_workflow_steps as recipe_workflow_steps_t
+from . import recipes as recipes_t
+from .api.recipes import remove_recipe_from_project as remove_recipe_from_project_t
 from .api.entity import resolve_entity_ids as resolve_entity_ids_t
 from .api.outputs import resolve_output_conditions as resolve_output_conditions_t
 from . import response as response_t
@@ -69,6 +72,7 @@ from .api.permissions import set_core_permissions as set_core_permissions_t
 from .api.inputs import set_input_attribute_values as set_input_attribute_values_t
 from .api.inputs import set_input_category as set_input_category_t
 from .api.inputs import set_input_subcategories as set_input_subcategories_t
+from .api.inputs import set_intermediate_type as set_intermediate_type_t
 from .api.recipes import set_recipe_inputs as set_recipe_inputs_t
 from .api.recipes import set_recipe_metadata as set_recipe_metadata_t
 from .api.recipes import set_recipe_outputs as set_recipe_outputs_t
@@ -85,6 +89,7 @@ from . import workflows as workflows_t
 
 
 __all__: list[str] = [
+    "add_recipe_to_project_t",
     "archive_recipes_t",
     "associate_recipe_as_input_t",
     "associate_recipe_as_lot_t",
@@ -143,6 +148,8 @@ __all__: list[str] = [
     "recipe_output_metadata_t",
     "recipe_tags_t",
     "recipe_workflow_steps_t",
+    "recipes_t",
+    "remove_recipe_from_project_t",
     "resolve_entity_ids_t",
     "resolve_output_conditions_t",
     "response_t",
@@ -151,6 +158,7 @@ __all__: list[str] = [
     "set_input_attribute_values_t",
     "set_input_category_t",
     "set_input_subcategories_t",
+    "set_intermediate_type_t",
     "set_recipe_inputs_t",
     "set_recipe_metadata_t",
     "set_recipe_outputs_t",

uncountable/types/api/entity/list_entities.py

@@ -8,6 +8,7 @@ import typing  # noqa: F401
 import datetime  # noqa: F401
 from decimal import Decimal  # noqa: F401
 from dataclasses import dataclass
+from pkgs.serialization import serial_class
 from pkgs.serialization import OpaqueKey
 from ... import base as base_t
 from ... import entity as entity_t
@@ -26,6 +27,9 @@ ENDPOINT_PATH = "api/external/entity/external_list_entities"
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    unconverted_values={"attributes"},
+)
 @dataclass(kw_only=True)
 class Arguments:
     entity_type: entity_t.EntityType
@@ -36,6 +40,9 @@ class Arguments:
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    unconverted_values={"column_values"},
+)
 @dataclass(kw_only=True)
 class EntityResult:
     entity: entity_t.Entity

uncountable/types/api/inputs/set_intermediate_type.py

@@ -0,0 +1,43 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from pkgs.strenum_compat import StrEnum
+from dataclasses import dataclass
+from ... import identifier as identifier_t
+
+__all__: list[str] = [
+    "Arguments",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+    "IntermediateType",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/inputs/set_intermediate_type"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class IntermediateType(StrEnum):
+    FINAL_PRODUCT = "final_product"
+    COMPOUND_AS_INTERMEDIATE = "compound_as_intermediate"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclass(kw_only=True)
+class Arguments:
+    input_key: identifier_t.IdentifierKey
+    intermediate_type: IntermediateType
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclass(kw_only=True)
+class Data:
+    pass
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/recipes/add_recipe_to_project.py

@@ -0,0 +1,35 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from dataclasses import dataclass
+from ... import identifier as identifier_t
+
+__all__: list[str] = [
+    "Arguments",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/recipes/add_recipe_to_project"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclass(kw_only=True)
+class Arguments:
+    recipe_key: identifier_t.IdentifierKey
+    project_key: identifier_t.IdentifierKey
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclass(kw_only=True)
+class Data:
+    pass
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/recipes/associate_recipe_as_input.py

@@ -27,6 +27,7 @@ ENDPOINT_PATH = "api/external/recipes/associate_recipe_as_input"
 class Arguments:
     recipe_key: identifier_t.IdentifierKey
     input_key: typing.Optional[identifier_t.IdentifierKey] = None
+    show_in_listings: typing.Optional[bool] = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec