UncountablePythonSDK 0.0.164__py3-none-any.whl → 0.0.166__py3-none-any.whl

pkgs/serialization_util/__init__.py

@@ -3,12 +3,14 @@ from .dataclasses import dict_fields as dict_fields
 from .dataclasses import iterate_fields as iterate_fields
 from .serialization_helpers import (
     JsonValue,
+    convert_decimals_to_strings,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
 )
 
 __all__: list[str] = [
+    "convert_decimals_to_strings",
     "convert_dict_to_snake_case",
     "serialize_for_api",
     "serialize_for_storage",

pkgs/serialization_util/serialization_helpers.py

@@ -14,6 +14,7 @@ from typing import (
     Protocol,
     TypeVar,
     Union,
+    assert_never,
     overload,
 )
 
@@ -37,6 +38,30 @@ else:
 T = TypeVar("T")
 
 
+# IMPROVE: this match should be exhaustive over JsonValue, but mypy can't verify
+# that Mapping()/Sequence() fully narrow the TYPE_CHECKING definition of JsonValue.
+def convert_decimals_to_strings(obj: JsonValue) -> JsonValue:
+    match obj:
+        case Decimal():
+            return str(obj)
+        case (
+            str()
+            | int()
+            | float()
+            | bool()
+            | None
+            | datetime.datetime()
+            | datetime.date()
+        ):
+            return obj
+        case Mapping():
+            return {k: convert_decimals_to_strings(v) for k, v in obj.items()}
+        case Sequence():
+            return [convert_decimals_to_strings(v) for v in obj]
+        case _ as unreachable:
+            assert_never(unreachable)
+
+
 class Dataclass(Protocol):
     __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
 

pkgs/type_spec/type_info/emit_type_info.py

@@ -144,11 +144,10 @@ def asdict_for_yaml_dump(dataclass_instance: Any) -> Any:
 def emit_type_info_python(build: builder.SpecBuilder, output: str) -> None:
     type_map = _build_map_all(build, python=True)
 
-    stripped = _dict_null_strip(asdict_for_yaml_dump(type_map))
-    serialized = serialize_for_storage(stripped)
-
-    yaml_content = yaml.dump(serialized, default_flow_style=False, sort_keys=True)
-    util.rewrite_file(f"{output}/type_map.yaml", yaml_content)
+    for namespace, data in type_map.namespaces.items():
+        serial = serialize_for_storage(asdict_for_yaml_dump(data))
+        yaml_content = yaml.dump(serial, default_flow_style=False, sort_keys=True)
+        util.rewrite_file(f"{output}/namespace_{namespace}.yaml", yaml_content)
 
 
 @dataclasses.dataclass

uncountable/integration/queue_runner/worker.py

@@ -1,4 +1,6 @@
 import asyncio
+import logging
+import pathlib
 import sys
 import typing
 from concurrent.futures import ProcessPoolExecutor
@@ -105,14 +107,48 @@ def _resolve_queued_job_request_context(
             return None
 
 
+_CGROUP_V2_MEMORY_MAX = pathlib.Path("/sys/fs/cgroup/memory.max")
+_CGROUP_V1_MEMORY_LIMIT = pathlib.Path("/sys/fs/cgroup/memory/memory.limit_in_bytes")
+
+_MEMORY_LIMIT_FRACTION_CGROUP = 0.75
+_MEMORY_LIMIT_FRACTION_HOST = 0.9
+
+_logger = logging.getLogger(__name__)
+
+
+def _get_cgroup_memory_limit_bytes() -> int | None:
+    for cgroup_path in (_CGROUP_V2_MEMORY_MAX, _CGROUP_V1_MEMORY_LIMIT):
+        if not cgroup_path.exists():
+            continue
+        raw = cgroup_path.read_text().strip()
+        if raw == "max":
+            # cgroups v2 "max" means no limit is set
+            return None
+        value = int(raw)
+        # cgroups v1 uses a very large sentinel for "no limit"
+        if value >= 2**63 - 1:
+            return None
+        return value
+    return None
+
+
 def run_queued_job(
     queued_job: queued_job_t.QueuedJob,
 ) -> job_definition_t.JobResult:
     with get_otel_tracer().start_as_current_span(name="run_queued_job") as span:
         if resource is not None:
-            total_mem = psutil.virtual_memory().total
-            limit_bytes = int(total_mem * 0.9)
+            cgroup_limit = _get_cgroup_memory_limit_bytes()
+            if cgroup_limit is not None:
+                limit_bytes = int(cgroup_limit * _MEMORY_LIMIT_FRACTION_CGROUP)
+            else:
+                total_mem = psutil.virtual_memory().total
+                limit_bytes = int(total_mem * _MEMORY_LIMIT_FRACTION_HOST)
             resource.setrlimit(resource.RLIMIT_AS, (limit_bytes, limit_bytes))
+            _logger.info(
+                "RLIMIT_AS set to %.2f GiB (source: %s)",
+                limit_bytes / (1024**3),
+                "cgroup" if cgroup_limit is not None else "host",
+            )
 
         job_details = get_registered_job_details(queued_job.job_ref_name)
         job_logger = JobLogger(

uncountable/integration/telemetry.py

@@ -220,9 +220,15 @@ class Logger:
 
 
 class PerJobResourceTracker:
-    def __init__(self, logger: "JobLogger", sample_interval: float = 0.5) -> None:
+    def __init__(
+        self,
+        logger: "JobLogger",
+        sample_interval: float = 0.5,
+        log_interval: float = 30.0,
+    ) -> None:
         self.logger = logger
         self.sample_interval = sample_interval
+        self.log_interval = log_interval
         self._process = psutil.Process(os.getpid())
         self._stop_event = threading.Event()
         self._thread: threading.Thread | None = None
@@ -233,15 +239,40 @@ class PerJobResourceTracker:
         self.start_wall_time: float | None = None
         self.end_wall_time: float | None = None
 
+    def _current_stats(self) -> Attributes:
+        assert self.start_cpu_times is not None
+        assert self.start_wall_time is not None
+        current_cpu_times = self._process.cpu_times()
+        cpu_user = current_cpu_times.user - self.start_cpu_times.user
+        cpu_sys = current_cpu_times.system - self.start_cpu_times.system
+        cpu_total = cpu_user + cpu_sys
+        elapsed = time.monotonic() - self.start_wall_time
+        return {
+            "cpu_user_s": round(cpu_user, 3),
+            "cpu_system_s": round(cpu_sys, 3),
+            "cpu_total_s": round(cpu_total, 3),
+            "wall_time_s": round(elapsed, 3),
+            "current_rss_mb": round(self._process.memory_info().rss / (1024 * 1024), 2),
+            "peak_rss_mb": round(self.max_rss / (1024 * 1024), 2),
+        }
+
     def start(self) -> None:
         self.start_cpu_times = self._process.cpu_times()
         self.start_wall_time = time.monotonic()
 
         def _monitor() -> None:
+            last_log_time = time.monotonic()
             try:
                 while not self._stop_event.is_set():
                     rss = self._process.memory_info().rss
                     self.max_rss = max(self.max_rss, rss)
+                    now = time.monotonic()
+                    if now - last_log_time >= self.log_interval:
+                        self.logger.log_info(
+                            "Job resource usage (periodic)",
+                            attributes=self._current_stats(),
+                        )
+                        last_log_time = now
                     time.sleep(self.sample_interval)
             except Exception:
                 self._stop_event.set()

uncountable/integration/webhook_server/entrypoint.py

@@ -24,8 +24,22 @@ def register_route(
     job: job_definition_t.HttpJobDefinitionBase,
 ) -> None:
     route = f"/{profile_meta.name}/{job.id}"
+    log_attributes = {
+        "profile.name": profile_meta.name,
+        "profile.base_url": profile_meta.base_url,
+        "job.name": job.name,
+        "job.id": job.id,
+        "http.route": route,
+    }
 
     def handle_request() -> ResponseReturnValue:
+        method = flask.request.method
+        url = flask.request.url
+        request_attributes = {
+            **log_attributes,
+            "http.method": method,
+            "http.url": url,
+        }
         with server_logger.push_scope(route):
             try:
                 if not isinstance(job.executor, job_definition_t.JobExecutorScript):
@@ -56,10 +70,18 @@ def register_route(
                     http_response.headers,
                 )
             except HttpException as e:
-                server_logger.log_exception(e)
+                server_logger.log_exception(
+                    e,
+                    message=f"HTTP error on {method} {url}",
+                    attributes=request_attributes,
+                )
                 return e.make_error_response()
             except Exception as e:
-                server_logger.log_exception(e)
+                server_logger.log_exception(
+                    e,
+                    message=f"Unexpected error on {method} {url}",
+                    attributes=request_attributes,
+                )
                 return HttpException.unknown_error().make_error_response()
 
     app.add_url_rule(
@@ -69,7 +91,9 @@ def register_route(
         methods=["POST"],
     )
 
-    server_logger.log_info(f"job {job.id} webhook registered at: {route}")
+    server_logger.log_info(
+        f"job {job.id} webhook registered at: {route}", attributes=log_attributes
+    )
 
 
 def main() -> None:

uncountable/types/__init__.py

@@ -135,6 +135,7 @@ from .api.entity import set_values as set_values_t
 from . import sockets_t as sockets_t
 from . import specs_t as specs_t
 from . import step_relationships_t as step_relationships_t
+from .api.output_parameters import swap_output_condition_parameters as swap_output_condition_parameters_t
 from .api.entity import transition_entity_phase as transition_entity_phase_t
 from .api.recipes import unarchive_recipes as unarchive_recipes_t
 from . import units_t as units_t
@@ -286,6 +287,7 @@ __all__: list[str] = [
     "sockets_t",
     "specs_t",
     "step_relationships_t",
+    "swap_output_condition_parameters_t",
     "transition_entity_phase_t",
     "unarchive_recipes_t",
     "units_t",

uncountable/types/api/output_parameters/__init__.py

@@ -0,0 +1 @@
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/output_parameters/swap_output_condition_parameters.py

@@ -0,0 +1,150 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+from enum import StrEnum
+import dataclasses
+from pkgs.serialization import serial_class
+from pkgs.serialization import serial_union_annotation
+from ... import async_batch_t
+from ... import base_t
+from ... import identifier_t
+
+__all__: list[str] = [
+    "AllInProjectSwapScope",
+    "Arguments",
+    "ConditionParameterDefinition",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+    "NewOutputCondition",
+    "NewOutputConditionExisting",
+    "NewOutputConditionFromDefinition",
+    "NewOutputConditionType",
+    "SwapScope",
+    "SwapScopeType",
+    "TargetedSwapScope",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/output_parameters/swap_output_condition_parameters"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.ConditionParameterDefinition",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class ConditionParameterDefinition:
+    condition_parameter_key: identifier_t.IdentifierKey
+    value_numeric: Decimal | None = None
+    value_text: str | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class NewOutputConditionType(StrEnum):
+    EXISTING = "existing"
+    DEFINITION = "definition"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputConditionExisting",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class NewOutputConditionExisting:
+    type: typing.Literal[NewOutputConditionType.EXISTING] = NewOutputConditionType.EXISTING
+    condition_key: identifier_t.IdentifierKey
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputConditionFromDefinition",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class NewOutputConditionFromDefinition:
+    type: typing.Literal[NewOutputConditionType.DEFINITION] = NewOutputConditionType.DEFINITION
+    parameters: list[ConditionParameterDefinition]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+NewOutputCondition = typing.Annotated[
+    NewOutputConditionExisting | NewOutputConditionFromDefinition,
+    serial_union_annotation(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.NewOutputCondition",
+        discriminator="type",
+        discriminator_map={
+            "existing": NewOutputConditionExisting,
+            "definition": NewOutputConditionFromDefinition,
+        },
+    ),
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+class SwapScopeType(StrEnum):
+    TARGETED = "targeted"
+    ALL_IN_PROJECT = "all_in_project"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.TargetedSwapScope",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class TargetedSwapScope:
+    type: typing.Literal[SwapScopeType.TARGETED] = SwapScopeType.TARGETED
+    recipe_keys: list[identifier_t.IdentifierKey]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.AllInProjectSwapScope",
+    parse_require={"type"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class AllInProjectSwapScope:
+    type: typing.Literal[SwapScopeType.ALL_IN_PROJECT] = SwapScopeType.ALL_IN_PROJECT
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+SwapScope = typing.Annotated[
+    TargetedSwapScope | AllInProjectSwapScope,
+    serial_union_annotation(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.SwapScope",
+        discriminator="type",
+        discriminator_map={
+            "targeted": TargetedSwapScope,
+            "all_in_project": AllInProjectSwapScope,
+        },
+    ),
+]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.Arguments",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Arguments:
+    scope: SwapScope
+    output_key: identifier_t.IdentifierKey
+    new_condition: NewOutputCondition
+    old_condition_key: identifier_t.IdentifierKey | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.output_parameters.swap_output_condition_parameters.Data",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Data(async_batch_t.AsyncBatchActionReturn):
+    pass
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/async_batch_processor.py

@@ -40,6 +40,7 @@ import uncountable.types.api.triggers.run_trigger as run_trigger_t
 import uncountable.types.api.entity.set_barcode as set_barcode_t
 import uncountable.types.api.entity.set_entity_field_values as set_entity_field_values_t
 import uncountable.types.api.recipes.set_recipe_metadata as set_recipe_metadata_t
+import uncountable.types.api.output_parameters.swap_output_condition_parameters as swap_output_condition_parameters_t
 import uncountable.types.api.entity.transition_entity_phase as transition_entity_phase_t
 import uncountable.types.api.entity.unlock_entity as unlock_entity_t
 import uncountable.types.api.recipes.unlock_recipes as unlock_recipes_t
@@ -69,7 +70,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Create or return the input association for equipment
+        """Create or return an input association for a piece of equipment within specified material families. The equipment is resolved via identifier key. Supports both direct invocation and async batch execution. Returns modification_made and result_id of the association.
 
         :param equipment_key: Identifier of the equipment to associate
         :param material_family_ids: The list of material families to add the input to. This must be non-empty
@@ -106,7 +107,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Create or return the input association for a recipe
+        """Associates a recipe as an input (ingredient). When no existing input is specified, creates a new input or returns the existing association if one already exists. When an existing input is specified, associates it with the recipe; fails if that input is already associated with a different recipe. Use `disassociate_recipe_as_input` to remove an existing association first. Returns the input ID and whether a modification was made.
 
         :param recipe_key: Identifier for the recipe
         :param input_key: Identifier for an input to use for the association.  Optionally supplied.  If not supplied, one is created
@@ -144,7 +145,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Create a new lot association for the provided recipe with the provided ingredient
+        """Creates a lot association between a recipe and an ingredient. The recipe becomes a lot for the specified ingredient. Returns whether a modification was made.
 
         :param recipe_key: Identifier for the recipe
         :param ingredient_key: Identifier for the ingredient
@@ -179,7 +180,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Clears all output values & output metadata for a given recipe
+        """Clears all output values and output metadata for a given recipe identified by key. Returns whether a modification was made.
 
         :param recipe_key: The identifier of the recipe
         :param depends_on: A list of batch reference keys to process before processing this request
@@ -215,7 +216,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Parses uploaded files asynchronously
+        """Completes the asynchronous parsing step of a file upload workflow. Accepts either inline parsed_file_data or a file_id referencing a JSON file containing the parsed data (exactly one must be provided). Resolves the async job by its identifier key and applies the parsed data to the upload destination. Updates the async job status to COMPLETED upon success. Supports async batch execution.
 
         :param parsed_file_data: Inline parsed data. Provide either parsed_file_data or file_id, not both.
         :param file_id: File ID containing parsed data. Provide either file_id or parsed_file_data, not both.
@@ -253,7 +254,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Processes an file id with a given async job id to be uploaded asynchronously
+        """Completes an asynchronous runsheet export by processing an uploaded file and placing it in the job owner's export downloads folder. Sends an export-complete notification to the job owner on completion. Supports async batch execution.
 
         :param depends_on: A list of batch reference keys to process before processing this request
         """
@@ -287,7 +288,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Creates mix order on a recipe workflow step
+        """Creates a mix order on a recipe workflow step. The recipe and workflow step are identified by their respective keys. Returns whether a modification was made.
 
         :param depends_on: A list of batch reference keys to process before processing this request
         """
@@ -369,7 +370,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Returns the id of the recipe being created.
+        """Creates a single recipe in the specified material family and workflow. If a matching recipe already exists, no new recipe is created and the existing recipe ID is returned. Returns the recipe ID.
 
         :param name: The name for the recipe
         :param material_family_id: The material family for the recipe
@@ -420,7 +421,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Clear, update, or add inputs on a recipe
+        """Applies a list of edits to inputs on a specific recipe workflow step. Supported edit types include clearing all inputs, upserting or adding inputs, updating annotations, setting lots, setting propagated percentages, changing basis, adding instructions, setting roles, and managing placeholders.
 
         :param recipe_key: Identifier for the recipe
         :param depends_on: A list of batch reference keys to process before processing this request
@@ -500,7 +501,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Runs a file through an uploader. Non-SDK users: use file_upload/external_create_file_record to upload files. SDK users: use client.upload_files() helper method.
+        """Processes one or more uploaded files through a configured uploader, parsing and writing the extracted data to a recipe destination. Resolves the uploader by its identifier key and requires READ_ALL permission on the uploader entity. The file_ids parameter is preferred; file_id is deprecated. Non-SDK users should use file_upload/external_create_file_record to upload files first. SDK users can use the client.upload_files() helper method. Supports async batch execution.
 
         :param file_id: DEPRECATED: use file_ids
         :param depends_on: A list of batch reference keys to process before processing this request
@@ -578,7 +579,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Lock experiments. Experiments will require unlocking to be editable. Edits to the experiments are blocked while they are locked.
+        """Locks experiments to prevent editing. Supports locking all data (inputs and measurements) or inputs only. Returns whether a modification was made.
 
         :param type: The type of lock to set.
     All = both inputs and measurements are locked.
@@ -661,7 +662,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Push a notification to a user or user group
+        """Send a notification to one or more users or user groups. Supports specifying a subject, message body, and optional entity link. Can optionally display as an in-app notice with custom configuration. Supports both direct invocation and async batch execution.
 
         :param depends_on: A list of batch reference keys to process before processing this request
         """
@@ -700,7 +701,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Runs a trigger.  Requires admin access
+        """Executes a trigger script identified by ref name, optionally on a specific entity, and returns only after the trigger has fully completed. Requires admin user access; non-admin users receive a 403 error. Accepts either entity_identifier (preferred) or entity (deprecated) to specify the target entity, but not both. Returns whether any entities were modified by the trigger execution.
 
         :param entity_identifier: Identifier of the entity to run the trigger on.
         :param entity: [Deprecated: use entity_identifier] Entity to run the trigger on.
@@ -807,7 +808,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Set metadata values on a recipe
+        """Sets metadata values on a recipe identified by key. Accepts a list of metadata field-value pairs to populate on the recipe. Fails if any of the metadata fields are read-only.
 
         :param recipe_key: Identifier for the recipe
         :param recipe_metadata: Metadata values to populate the recipe with
@@ -835,6 +836,48 @@ class AsyncBatchProcessorBase(ABC):
             batch_reference=req.batch_reference,
         )
 
+    def swap_output_condition_parameters(
+        self,
+        *,
+        scope: swap_output_condition_parameters_t.SwapScope,
+        output_key: identifier_t.IdentifierKey,
+        new_condition: swap_output_condition_parameters_t.NewOutputCondition,
+        old_condition_key: identifier_t.IdentifierKey | None = None,
+        depends_on: list[str] | None = None,
+        _request_options: client_config_t.RequestOptions | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Swap output condition parameters on recipes. Either specify recipe keys for targeted swaps or set swap_all to swap across all recipes in the project.
+
+        :param scope: Which recipes to apply the swap to. See SwapScope variants for options.
+        :param output_key: Identifier for the output on which to swap conditions.
+        :param old_condition_key: Identifier for the old condition to replace. If omitted, recipes without a condition on the output are targeted.
+        :param new_condition: The new output condition to swap to. See NewOutputCondition variants for options.
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = swap_output_condition_parameters_t.Arguments(
+            scope=scope,
+            output_key=output_key,
+            old_condition_key=old_condition_key,
+            new_condition=new_condition,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.SWAP_OUTPUT_CONDITION_PARAMETERS,
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return async_batch_t.QueuedAsyncBatchRequest(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )
+
     def transition_entity_phase(
         self,
         *,
@@ -918,7 +961,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Unlock experiments. Experiments will edtiable after unlocking if they are currently locked.
+        """Unlocks previously locked experiments, making them editable again. Returns whether a modification was made.
 
         :param type: The method to unlock recipes. Default is standard.
         :param recipes: The recipes to unlock, a maximum of 100 can be sent
@@ -959,7 +1002,7 @@ class AsyncBatchProcessorBase(ABC):
         depends_on: list[str] | None = None,
         _request_options: client_config_t.RequestOptions | None = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
-        """Creates or updates condition match
+        """Creates or updates a condition match record. Condition matches are used to set goals on outputs. Each call creates a new condition match — there is no idempotent behavior, so the same inputs will produce a new condition match with each invocation. Returns modification_made and result_id of the created or updated condition match.
 
         :param depends_on: A list of batch reference keys to process before processing this request
         """

uncountable/types/async_batch_t.py

@@ -55,6 +55,7 @@ class AsyncBatchRequestPath(StrEnum):
     RUN_TRIGGER = "triggers/run_trigger"
     UPSERT_STEP_RELATIONSHIPS = "recipes/upsert_step_relationships"
     UPSERT_RECIPE_WORKFLOW_STEP = "recipes/upsert_recipe_workflow_step"
+    SWAP_OUTPUT_CONDITION_PARAMETERS = "output_parameters/swap_output_condition_parameters"
 
 
 # DO NOT MODIFY -- This file is generated by type_spec