UncountablePythonSDK 0.0.126__py3-none-any.whl → 0.0.128__py3-none-any.whl

uncountable/integration/queue_runner/job_scheduler.py

@@ -10,8 +10,13 @@ from uncountable.integration.queue_runner.command_server import (
     CommandEnqueueJob,
     CommandEnqueueJobResponse,
     CommandQueue,
+    CommandRetryJob,
+    CommandRetryJobResponse,
     CommandTask,
 )
+from uncountable.integration.queue_runner.command_server.types import (
+    CommandVaccuumQueuedJobs,
+)
 from uncountable.integration.queue_runner.datastore import DatastoreSqlite
 from uncountable.integration.queue_runner.datastore.interface import Datastore
 from uncountable.integration.queue_runner.worker import Worker
@@ -99,7 +104,9 @@ async def start_scheduler(
                 worker = job_worker_lookup[queued_job.job_ref_name]
             except KeyError as e:
                 logger.log_exception(e)
-                datastore.remove_job_from_queue(queued_job.queued_job_uuid)
+                datastore.update_job_status(
+                    queued_job.queued_job_uuid, queued_job_t.JobStatus.FAILED
+                )
                 return
             await worker.listen_queue.put(queued_job)
 
@@ -135,6 +142,25 @@ async def start_scheduler(
                 CommandEnqueueJobResponse(queued_job_uuid=queued_job_uuid)
             )
 
+        async def _handle_retry_job_command(command: CommandRetryJob) -> None:
+            queued_job = datastore.retry_job(command.queued_job_uuid)
+            if queued_job is None:
+                await command.response_queue.put(
+                    CommandRetryJobResponse(queued_job_uuid=None)
+                )
+                return
+
+            await enqueue_queued_job(queued_job)
+            await command.response_queue.put(
+                CommandRetryJobResponse(queued_job_uuid=queued_job.queued_job_uuid)
+            )
+
+        def _handle_vaccuum_queued_jobs_command(
+            command: CommandVaccuumQueuedJobs,
+        ) -> None:
+            logger.log_info("Vaccuuming queued jobs...")
+            datastore.vaccuum_queued_jobs()
+
         for queued_job in queued_jobs:
             await enqueue_queued_job(queued_job)
 
@@ -151,10 +177,24 @@ async def start_scheduler(
                     match command:
                         case CommandEnqueueJob():
                             await _handle_enqueue_job_command(command=command)
+                        case CommandRetryJob():
+                            await _handle_retry_job_command(command=command)
+                        case CommandVaccuumQueuedJobs():
+                            _handle_vaccuum_queued_jobs_command(command=command)
                         case _:
                             typing.assert_never(command)
                     command_task = asyncio.create_task(command_queue.get())
                 elif task == result_task:
                     queued_job_result = result_task.result()
-                    datastore.remove_job_from_queue(queued_job_result.queued_job_uuid)
+                    match queued_job_result.job_result.success:
+                        case True:
+                            datastore.update_job_status(
+                                queued_job_result.queued_job_uuid,
+                                queued_job_t.JobStatus.SUCCESS,
+                            )
+                        case False:
+                            datastore.update_job_status(
+                                queued_job_result.queued_job_uuid,
+                                queued_job_t.JobStatus.FAILED,
+                            )
                     result_task = asyncio.create_task(result_queue.get())

uncountable/integration/queue_runner/worker.py

@@ -103,13 +103,13 @@ def run_queued_job(
                 profile_metadata=job_details.profile_metadata,
                 logger=job_logger,
                 payload=payload,
+                job_uuid=queued_job.queued_job_uuid,
             )
 
             return execute_job(
                 args=args,
                 profile_metadata=job_details.profile_metadata,
                 job_definition=job_details.job_definition,
-                job_uuid=queued_job.queued_job_uuid,
             )
         except BaseException as e:
             job_logger.log_exception(e)

uncountable/integration/server.py

@@ -11,7 +11,11 @@ from apscheduler.triggers.cron import CronTrigger
 from opentelemetry.trace import get_current_span
 from sqlalchemy.engine.base import Engine
 
+from uncountable.core.environment import get_local_admin_server_port
 from uncountable.integration.cron import CronJobArgs, cron_job_executor
+from uncountable.integration.queue_runner.command_server.command_client import (
+    send_vaccuum_queued_jobs_message,
+)
 from uncountable.integration.telemetry import Logger
 from uncountable.types import base_t, job_definition_t
 from uncountable.types.job_definition_t import (
@@ -21,6 +25,14 @@ from uncountable.types.job_definition_t import (
 
 _MAX_APSCHEDULER_CONCURRENT_JOBS = 1
 
+VACCUUM_QUEUED_JOBS_JOB_ID = "vacuum_queued_jobs"
+
+STATIC_JOB_IDS = {VACCUUM_QUEUED_JOBS_JOB_ID}
+
+
+def vaccuum_queued_jobs() -> None:
+    send_vaccuum_queued_jobs_message(port=get_local_admin_server_port())
+
 
 class IntegrationServer:
     _scheduler: BaseScheduler
@@ -36,11 +48,27 @@ class IntegrationServer:
         )
         self._server_logger = Logger(get_current_span())
 
+    def _register_static_jobs(self) -> None:
+        all_job_ids = {job.id for job in self._scheduler.get_jobs()}
+        if VACCUUM_QUEUED_JOBS_JOB_ID in all_job_ids:
+            self._scheduler.remove_job(VACCUUM_QUEUED_JOBS_JOB_ID)
+
+        self._scheduler.add_job(
+            vaccuum_queued_jobs,
+            max_instances=1,
+            coalesce=True,
+            trigger=CronTrigger.from_crontab("5 4 * * 4"),
+            name="Vaccuum queued jobs",
+            id=VACCUUM_QUEUED_JOBS_JOB_ID,
+            kwargs={},
+            misfire_grace_time=None,
+        )
+
     def register_jobs(self, profiles: list[job_definition_t.ProfileMetadata]) -> None:
-        valid_job_ids = []
+        valid_job_ids: set[str] = set()
         for profile_metadata in profiles:
             for job_defn in profile_metadata.jobs:
-                valid_job_ids.append(job_defn.id)
+                valid_job_ids.add(job_defn.id)
                 match job_defn:
                     case CronJobDefinition():
                         # Add to ap scheduler
@@ -90,10 +118,11 @@ class IntegrationServer:
                         pass
                     case _:
                         assert_never(job_defn)
-        all_jobs = self._scheduler.get_jobs()
-        for job in all_jobs:
-            if job.id not in valid_job_ids:
-                self._scheduler.remove_job(job.id)
+        all_job_ids = {job.id for job in self._scheduler.get_jobs()}
+        invalid_job_ids = all_job_ids.difference(valid_job_ids.union(STATIC_JOB_IDS))
+
+        for job_id in invalid_job_ids:
+            self._scheduler.remove_job(job_id)
 
     def serve_forever(self) -> None:
         signal.pause()
@@ -106,6 +135,7 @@ class IntegrationServer:
 
     def __enter__(self) -> "IntegrationServer":
         self._start_apscheduler()
+        self._register_static_jobs()
         return self
 
     def __exit__(

uncountable/integration/telemetry.py

@@ -12,7 +12,10 @@ from opentelemetry import _logs, trace
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import Logger as OTELLogger
-from opentelemetry.sdk._logs import LoggerProvider, LogRecord
+from opentelemetry.sdk._logs import (
+    LoggerProvider,
+    LogRecord,
+)
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, ConsoleLogExporter
 from opentelemetry.sdk.resources import Attributes, Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -95,8 +98,27 @@ class Logger:
     def current_trace_id(self) -> int | None:
         return self.current_span.get_span_context().trace_id
 
-    def _patch_attributes(self, attributes: Attributes | None) -> Attributes:
-        return attributes or {}
+    def _patch_attributes(
+        self,
+        attributes: Attributes | None,
+        *,
+        message: str | None = None,
+        severity: LogSeverity | None = None,
+    ) -> Attributes:
+        patched_attributes = {**(attributes if attributes is not None else {})}
+        if message is not None:
+            patched_attributes["message"] = message
+        elif "body" in patched_attributes:
+            patched_attributes["message"] = patched_attributes["body"]
+
+        if severity is not None:
+            patched_attributes["status"] = severity.lower()
+        elif "severity_text" in patched_attributes and isinstance(
+            patched_attributes["severity_text"], str
+        ):
+            patched_attributes["status"] = patched_attributes["severity_text"].lower()
+
+        return patched_attributes
 
     def _emit_log(
         self, message: str, *, severity: LogSeverity, attributes: Attributes | None
@@ -106,7 +128,9 @@ class Logger:
             body=message,
             severity_text=severity,
             timestamp=time.time_ns(),
-            attributes=self._patch_attributes(attributes),
+            attributes=self._patch_attributes(
+                message=message, severity=severity, attributes=attributes
+            ),
             span_id=self.current_span_id,
             trace_id=self.current_trace_id,
             trace_flags=DEFAULT_TRACE_OPTIONS,
@@ -140,7 +164,9 @@ class Logger:
         attributes: Attributes | None = None,
     ) -> None:
         traceback_str = "".join(traceback.format_exception(exception))
-        patched_attributes = self._patch_attributes(attributes)
+        patched_attributes = self._patch_attributes(
+            message=message, severity=LogSeverity.ERROR, attributes=attributes
+        )
         self.current_span.record_exception(
             exception=exception, attributes=patched_attributes
         )
@@ -171,9 +197,17 @@ class JobLogger(Logger):
         self.job_definition = job_definition
         super().__init__(base_span)
 
-    def _patch_attributes(self, attributes: Attributes | None) -> Attributes:
+    def _patch_attributes(
+        self,
+        attributes: Attributes | None,
+        *,
+        message: str | None = None,
+        severity: LogSeverity | None = None,
+    ) -> Attributes:
         patched_attributes: dict[str, base_t.JsonValue] = {
-            **(attributes if attributes is not None else {})
+            **super()._patch_attributes(
+                attributes=attributes, message=message, severity=severity
+            )
         }
         patched_attributes["profile.name"] = self.profile_metadata.name
         patched_attributes["profile.base_url"] = self.profile_metadata.base_url

uncountable/types/__init__.py

@@ -93,6 +93,7 @@ from . import recipe_output_metadata_t as recipe_output_metadata_t
 from . import recipe_tags_t as recipe_tags_t
 from . import recipe_workflow_steps_t as recipe_workflow_steps_t
 from . import recipes_t as recipes_t
+from .api.integrations import register_sockets_token as register_sockets_token_t
 from .api.recipes import remove_recipe_from_project as remove_recipe_from_project_t
 from .api.recipe_links import remove_recipe_link as remove_recipe_link_t
 from .api.entity import resolve_entity_ids as resolve_entity_ids_t
@@ -112,6 +113,7 @@ from .api.recipes import set_recipe_output_annotations as set_recipe_output_anno
 from .api.recipes import set_recipe_output_file as set_recipe_output_file_t
 from .api.recipes import set_recipe_outputs as set_recipe_outputs_t
 from .api.recipes import set_recipe_tags as set_recipe_tags_t
+from .api.recipes import set_recipe_total as set_recipe_total_t
 from .api.entity import set_values as set_values_t
 from . import sockets_t as sockets_t
 from .api.entity import transition_entity_phase as transition_entity_phase_t
@@ -220,6 +222,7 @@ __all__: list[str] = [
     "recipe_tags_t",
     "recipe_workflow_steps_t",
     "recipes_t",
+    "register_sockets_token_t",
     "remove_recipe_from_project_t",
     "remove_recipe_link_t",
     "resolve_entity_ids_t",
@@ -239,6 +242,7 @@ __all__: list[str] = [
     "set_recipe_output_file_t",
     "set_recipe_outputs_t",
     "set_recipe_tags_t",
+    "set_recipe_total_t",
     "set_values_t",
     "sockets_t",
     "transition_entity_phase_t",

uncountable/types/api/integrations/register_sockets_token.py

@@ -0,0 +1,41 @@
+# 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
+import dataclasses
+from pkgs.serialization import serial_class
+from ... import base_t
+from ... import sockets_t
+
+__all__: list[str] = [
+    "Arguments",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/integrations/register_sockets_token"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.integrations.register_sockets_token.Arguments",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Arguments:
+    socket_request: sockets_t.SocketTokenRequest
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.integrations.register_sockets_token.Data",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Data:
+    response: sockets_t.SocketTokenResponse
+# DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/recipes/edit_recipe_inputs.py

@@ -93,7 +93,7 @@ class RecipeInputEditClearInputs(RecipeInputEditBase):
 @dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
 class RecipeInputEditInputBase(RecipeInputEditBase):
     ingredient_key: identifier_t.IdentifierKey
-    quantity_basis: recipe_inputs_t.QuantityBasis = recipe_inputs_t.QuantityBasis.MASS
+    quantity_basis: recipe_inputs_t.QuantityBasis | None = recipe_inputs_t.QuantityBasis.MASS
     input_value_type: recipe_inputs_t.InputValueType = recipe_inputs_t.InputValueType.VALUE
     value_numeric: Decimal | None = None
     value_str: str | None = None

uncountable/types/api/recipes/get_recipes_data.py

@@ -6,8 +6,10 @@ 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_string_enum
 from ... import base_t
 from ... import experiment_groups_t
 from ... import inputs_t
@@ -25,6 +27,7 @@ __all__: list[str] = [
     "Recipe",
     "RecipeInput",
     "RecipeOutput",
+    "RecipeOutputInclusion",
     "RecipeStep",
     "RecipeStepGroup",
     "RecipeStepRelationship",
@@ -46,6 +49,19 @@ class Arguments:
     project_id: base_t.ObjectId | None = None
     offset: int | None = None
     limit: int | None = None
+    empty_output_behavior: RecipeOutputInclusion | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_string_enum(
+    labels={
+        "include_null": "Include Outputs without values",
+        "exclude_null": "Exclude Outputs without values",
+    },
+)
+class RecipeOutputInclusion(StrEnum):
+    INCLUDE_NULL = "include_null"
+    EXCLUDE_NULL = "exclude_null"
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/recipes/lock_recipes.py

@@ -9,6 +9,7 @@ from decimal import Decimal  # noqa: F401
 from enum import StrEnum
 import dataclasses
 from pkgs.serialization import serial_class
+from ... import async_batch_t
 from ... import base_t
 from ... import identifier_t
 
@@ -58,6 +59,6 @@ class Arguments:
     named_type_path="sdk.api.recipes.lock_recipes.Data",
 )
 @dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
-class Data:
+class Data(async_batch_t.AsyncBatchActionReturn):
     pass
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/recipes/set_recipe_total.py

@@ -0,0 +1,59 @@
+# 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
+import dataclasses
+from pkgs.serialization import serial_class
+from ... import async_batch_t
+from ... import base_t
+from ... import identifier_t
+from ... import recipe_inputs_t
+from ... import recipe_workflow_steps_t
+
+__all__: list[str] = [
+    "Arguments",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+    "ValueNumeric",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/recipes/set_recipe_total"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.recipes.set_recipe_total.ValueNumeric",
+    to_string_values={"value"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class ValueNumeric:
+    value: Decimal
+    quantity_basis: recipe_inputs_t.QuantityBasis
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.recipes.set_recipe_total.Arguments",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Arguments:
+    recipe_key: identifier_t.IdentifierKey
+    value: ValueNumeric
+    recipe_workflow_step_identifier: recipe_workflow_steps_t.RecipeWorkflowStepIdentifier | None = None
+    calculation_key: identifier_t.IdentifierKey | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.recipes.set_recipe_total.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/api/recipes/unlock_recipes.py

@@ -9,6 +9,7 @@ from decimal import Decimal  # noqa: F401
 from enum import StrEnum
 import dataclasses
 from pkgs.serialization import serial_class
+from ... import async_batch_t
 from ... import base_t
 from ... import identifier_t
 
@@ -45,6 +46,6 @@ class Arguments:
     named_type_path="sdk.api.recipes.unlock_recipes.Data",
 )
 @dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
-class Data:
+class Data(async_batch_t.AsyncBatchActionReturn):
     pass
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/uploader/complete_async_parse.py

@@ -10,6 +10,8 @@ import dataclasses
 from pkgs.serialization import serial_class
 from ... import async_batch_t
 from ... import base_t
+from ... import generic_upload_t
+from ... import identifier_t
 from ... import uploader_t
 
 __all__: list[str] = [
@@ -30,6 +32,8 @@ ENDPOINT_PATH = "api/external/uploader/complete_async_parse"
 @dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
 class Arguments:
     parsed_file_data: list[uploader_t.ParsedFileData]
+    async_job_key: identifier_t.IdentifierKey
+    upload_destination: generic_upload_t.UploadDestinationRecipe
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/async_batch_processor.py

@@ -13,6 +13,7 @@ import uncountable.types.api.recipes.associate_recipe_as_lot as associate_recipe
 from uncountable.types import async_batch_t
 from uncountable.types import base_t
 import uncountable.types.api.recipes.clear_recipe_outputs as clear_recipe_outputs_t
+import uncountable.types.api.uploader.complete_async_parse as complete_async_parse_t
 import uncountable.types.api.runsheet.complete_async_upload as complete_async_upload_t
 import uncountable.types.api.recipes.create_mix_order as create_mix_order_t
 import uncountable.types.api.entity.create_or_update_entity as create_or_update_entity_t
@@ -24,6 +25,7 @@ from uncountable.types import generic_upload_t
 import uncountable.types.api.entity.grant_entity_permissions as grant_entity_permissions_t
 from uncountable.types import identifier_t
 import uncountable.types.api.uploader.invoke_uploader as invoke_uploader_t
+import uncountable.types.api.recipes.lock_recipes as lock_recipes_t
 import uncountable.types.api.entity.lookup_entity as lookup_entity_t
 from uncountable.types import notifications_t
 import uncountable.types.api.integrations.push_notification as push_notification_t
@@ -32,6 +34,8 @@ from uncountable.types import recipe_metadata_t
 from uncountable.types import recipe_workflow_steps_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.recipes.unlock_recipes as unlock_recipes_t
+from uncountable.types import uploader_t
 import uncountable.types.api.condition_parameters.upsert_condition_match as upsert_condition_match_t
 import uuid
 from abc import ABC, abstractmethod
@@ -187,6 +191,41 @@ class AsyncBatchProcessorBase(ABC):
             batch_reference=req.batch_reference,
         )
 
+    def complete_async_parse(
+        self,
+        *,
+        parsed_file_data: list[uploader_t.ParsedFileData],
+        async_job_key: identifier_t.IdentifierKey,
+        upload_destination: generic_upload_t.UploadDestinationRecipe,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Parses uploaded files asynchronously
+
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = complete_async_parse_t.Arguments(
+            parsed_file_data=parsed_file_data,
+            async_job_key=async_job_key,
+            upload_destination=upload_destination,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.COMPLETE_ASYNC_PARSE,
+            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 complete_async_upload(
         self,
         *,
@@ -461,6 +500,53 @@ class AsyncBatchProcessorBase(ABC):
             batch_reference=req.batch_reference,
         )
 
+    def lock_recipes(
+        self,
+        *,
+        type: lock_recipes_t.RecipeLockType = lock_recipes_t.RecipeLockType.ALL,
+        recipes: list[identifier_t.IdentifierKey],
+        globally_removable: bool,
+        lock_samples: bool | None = None,
+        comments: str | None = None,
+        depends_on: list[str] | 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.
+
+        :param type: The type of lock to set.
+    All = both inputs and measurements are locked.
+    Inputs Only = only inputs are locked from editing.
+
+        :param recipes: The recipes to lock, a maximum of 100 can be sent
+        :param globally_removable: If true any user can unlock the experiment. If false the locking user is the only user that can unlock.
+        :param lock_samples: Should associated experiment test samples also be locked.
+        :param comments: Optional comment describing the purpose of locking
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = lock_recipes_t.Arguments(
+            type=type,
+            recipes=recipes,
+            globally_removable=globally_removable,
+            lock_samples=lock_samples,
+            comments=comments,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.LOCK_RECIPES,
+            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 lookup_entity(
         self,
         *,
@@ -603,6 +689,44 @@ class AsyncBatchProcessorBase(ABC):
             batch_reference=req.batch_reference,
         )
 
+    def unlock_recipes(
+        self,
+        *,
+        type: unlock_recipes_t.RecipeUnlockType = unlock_recipes_t.RecipeUnlockType.STANDARD,
+        recipes: list[identifier_t.IdentifierKey],
+        unlock_samples: bool | None = None,
+        depends_on: list[str] | None = None,
+    ) -> async_batch_t.QueuedAsyncBatchRequest:
+        """Unlock experiments. Experiments will edtiable after unlocking if they are currently locked.
+
+        :param type: The method to unlock recipes. Default is standard.
+        :param recipes: The recipes to unlock, a maximum of 100 can be sent
+        :param unlock_samples: Should associated experiment test samples also be unlocked.
+        :param depends_on: A list of batch reference keys to process before processing this request
+        """
+        args = unlock_recipes_t.Arguments(
+            type=type,
+            recipes=recipes,
+            unlock_samples=unlock_samples,
+        )
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = async_batch_t.AsyncBatchRequest(
+            path=async_batch_t.AsyncBatchRequestPath.UNLOCK_RECIPES,
+            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 upsert_condition_match(
         self,
         *,

uncountable/types/async_batch_t.py

@@ -46,6 +46,8 @@ class AsyncBatchRequestPath(StrEnum):
     COMPLETE_ASYNC_UPLOAD = "runsheet/complete_async_upload"
     CREATE_MIX_ORDER = "recipes/create_mix_order"
     PUSH_NOTIFICATION = "integrations/push_notification"
+    COMPLETE_ASYNC_PARSE = "uploader/complete_async_parse"
+    SET_RECIPE_TOTAL = "recipes/set_recipe_total"
 
 
 # DO NOT MODIFY -- This file is generated by type_spec