opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__py3-none-any.whl

opentrons/protocol_engine/commands/thermocycler/start_run_extended_profile.py

@@ -1,191 +0,0 @@
-"""StartRunProfile command request, result, and implementation models."""
-
-from __future__ import annotations
-from pydantic import BaseModel, Field
-from typing import List, Optional, TYPE_CHECKING, overload, Union, Any
-from typing_extensions import Literal, Type
-from pydantic.json_schema import SkipJsonSchema
-
-from opentrons.hardware_control.modules.types import ThermocyclerStep, ThermocyclerCycle
-
-from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ...errors.error_occurrence import ErrorOccurrence
-from .run_extended_profile import ProfileStep, ProfileCycle
-
-if TYPE_CHECKING:
-    from opentrons.protocol_engine.state.state import StateView
-    from opentrons.protocol_engine.execution import (
-        TaskHandler,
-        EquipmentHandler,
-    )
-    from opentrons.protocol_engine.state.module_substates.thermocycler_module_substate import (
-        ThermocyclerModuleSubState,
-    )
-
-StartRunExtendedProfileCommandType = Literal["thermocycler/startRunExtendedProfile"]
-
-
-def _remove_default(s: dict[str, Any]) -> None:
-    s.pop("default", None)
-
-
-class StartRunExtendedProfileStepParams(BaseModel):
-    """Input parameters for an individual Thermocycler profile step."""
-
-    celsius: float = Field(..., description="Target temperature in °C.")
-    holdSeconds: float = Field(
-        ..., description="Time to hold target temperature at in seconds."
-    )
-    rampRate: float | SkipJsonSchema[None] = Field(
-        None,
-        description="How quickly to change temperature in °C/second.",
-        json_schema_extra=_remove_default,
-    )
-
-
-class StartRunExtendedProfileParams(BaseModel):
-    """Input parameters to run a Thermocycler profile."""
-
-    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
-    profileElements: List[Union[ProfileStep, ProfileCycle]] = Field(
-        ...,
-        description="Elements of the profile. Each can be either a step or a cycle.",
-    )
-    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
-        None,
-        description="Amount of liquid in uL of the most-full well"
-        " in labware loaded onto the thermocycler.",
-        json_schema_extra=_remove_default,
-    )
-    taskId: str | None = Field(None, description="The id of the profile task")
-
-
-class StartRunExtendedProfileResult(BaseModel):
-    """Result data from running a Thermocycler profile."""
-
-    taskId: str = Field(..., description="The id of the profile task")
-
-
-def _transform_profile_step(
-    step: ProfileStep, thermocycler_state: ThermocyclerModuleSubState
-) -> ThermocyclerStep:
-    return ThermocyclerStep(
-        temperature=thermocycler_state.validate_target_block_temperature(step.celsius),
-        hold_time_seconds=step.holdSeconds,
-        ramp_rate=thermocycler_state.validate_ramp_rate(step.rampRate, step.celsius),
-    )
-
-
-@overload
-def _transform_profile_element(
-    element: ProfileStep, thermocycler_state: ThermocyclerModuleSubState
-) -> ThermocyclerStep:
-    ...
-
-
-@overload
-def _transform_profile_element(
-    element: ProfileCycle, thermocycler_state: ThermocyclerModuleSubState
-) -> ThermocyclerCycle:
-    ...
-
-
-def _transform_profile_element(
-    element: Union[ProfileStep, ProfileCycle],
-    thermocycler_state: ThermocyclerModuleSubState,
-) -> Union[ThermocyclerStep, ThermocyclerCycle]:
-    if isinstance(element, ProfileStep):
-        return _transform_profile_step(element, thermocycler_state)
-    else:
-        return ThermocyclerCycle(
-            steps=[
-                _transform_profile_step(step, thermocycler_state)
-                for step in element.steps
-            ],
-            repetitions=element.repetitions,
-        )
-
-
-class StartRunExtendedProfileImpl(
-    AbstractCommandImpl[
-        StartRunExtendedProfileParams, SuccessData[StartRunExtendedProfileResult]
-    ]
-):
-    """Execution implementation of a Thermocycler's run profile command."""
-
-    def __init__(
-        self,
-        state_view: StateView,
-        equipment: EquipmentHandler,
-        task_handler: TaskHandler,
-        **unused_dependencies: object,
-    ) -> None:
-        self._state_view = state_view
-        self._equipment = equipment
-        self._task_handler = task_handler
-
-    async def execute(
-        self, params: StartRunExtendedProfileParams
-    ) -> SuccessData[StartRunExtendedProfileResult]:
-        """Run a Thermocycler profile."""
-        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
-            params.moduleId
-        )
-        thermocycler_hardware = self._equipment.get_module_hardware_api(
-            thermocycler_state.module_id
-        )
-
-        profile = [
-            _transform_profile_element(element, thermocycler_state)
-            for element in params.profileElements
-        ]
-        target_volume: Optional[float]
-        if params.blockMaxVolumeUl is not None:
-            target_volume = thermocycler_state.validate_max_block_volume(
-                params.blockMaxVolumeUl
-            )
-        else:
-            target_volume = None
-
-        async def start_run_profile(task_handler: TaskHandler) -> None:
-            if thermocycler_hardware is not None:
-                async with task_handler.synchronize_cancel_latest(
-                    thermocycler_state.module_id
-                ):
-                    await thermocycler_hardware.execute_profile(
-                        profile=profile, volume=target_volume
-                    )
-
-        task = await self._task_handler.create_task(
-            task_function=start_run_profile, id=params.taskId
-        )
-
-        return SuccessData(
-            public=StartRunExtendedProfileResult(taskId=task.id),
-        )
-
-
-class StartRunExtendedProfile(
-    BaseCommand[
-        StartRunExtendedProfileParams, StartRunExtendedProfileResult, ErrorOccurrence
-    ]
-):
-    """A command to start the execution of a Thermocycler profile run without waiting for its completion."""
-
-    commandType: StartRunExtendedProfileCommandType = (
-        "thermocycler/startRunExtendedProfile"
-    )
-    params: StartRunExtendedProfileParams
-
-    _ImplementationCls: Type[StartRunExtendedProfileImpl] = StartRunExtendedProfileImpl
-
-
-class StartRunExtendedProfileCreate(BaseCommandCreate[StartRunExtendedProfileParams]):
-    """A request to execute a Thermocycler profile run."""
-
-    commandType: StartRunExtendedProfileCommandType = (
-        "thermocycler/startRunExtendedProfile"
-    )
-    params: StartRunExtendedProfileParams
-
-    _CommandCls: Type[StartRunExtendedProfile] = StartRunExtendedProfile

opentrons/protocol_engine/commands/wait_for_tasks.py

@@ -1,98 +0,0 @@
-"""WaitForTasks command request, result, and implementation models."""
-from __future__ import annotations
-from pydantic import BaseModel, Field
-from typing import Optional, Type, TYPE_CHECKING
-from typing_extensions import Literal
-
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
-from ..errors.exceptions import TaskFailedError
-
-if TYPE_CHECKING:
-    from ..execution import TaskHandler, RunControlHandler
-    from ..state.state import StateView
-
-
-WaitForTasksCommandType = Literal["waitForTasks"]
-
-
-class WaitForTasksParams(BaseModel):
-    """Payload required to annotate execution with a WaitForTasks."""
-
-    task_ids: list[str] = Field(
-        ...,
-        description="The list of task ids to wait for.",
-    )
-
-
-class WaitForTasksResult(BaseModel):
-    """Result data from the execution of a WaitForTasks command."""
-
-    task_ids: list[str] = Field(
-        ...,
-        description="The list of completed task ids.",
-    )
-
-
-class WaitForTasksImplementation(
-    AbstractCommandImpl[WaitForTasksParams, SuccessData[WaitForTasksResult]]
-):
-    """WaitForTasks command implementation."""
-
-    def __init__(
-        self,
-        task_handler: TaskHandler,
-        run_control: RunControlHandler,
-        state_view: StateView,
-        **kwargs: object,
-    ) -> None:
-        self._task_handler = task_handler
-        self._run_control = run_control
-        self._state_view = state_view
-
-    async def execute(
-        self, params: WaitForTasksParams
-    ) -> SuccessData[WaitForTasksResult]:
-        """Checks for existance of task id and then asynchronously waits for the valid, specified tasks to finish."""
-        # Raises the exception if we don't have a valid task id.
-        for task_id in params.task_ids:
-            _ = self._state_view.tasks.get(task_id)
-
-        await self._run_control.wait_for_tasks(params.task_ids)
-
-        failed_tasks = self._state_view.tasks.get_failed_tasks(params.task_ids)
-        if failed_tasks:
-            raise TaskFailedError(
-                message=f"{len(failed_tasks)} tasks failed.",
-                details={"failed_task_ids": failed_tasks},
-                wrapping=[
-                    ProtocolCommandFailedError(
-                        original_error=self._state_view.tasks.get_finished(
-                            task_id
-                        ).error
-                    )
-                    for task_id in failed_tasks
-                ],
-            )
-        return SuccessData(public=WaitForTasksResult(task_ids=params.task_ids))
-
-
-class WaitForTasks(
-    BaseCommand[WaitForTasksParams, WaitForTasksResult, ErrorOccurrence]
-):
-    """WaitForTasks command model."""
-
-    commandType: WaitForTasksCommandType = "waitForTasks"
-    params: WaitForTasksParams
-    result: Optional[WaitForTasksResult] = None
-
-    _ImplementationCls: Type[WaitForTasksImplementation] = WaitForTasksImplementation
-
-
-class WaitForTasksCreate(BaseCommandCreate[WaitForTasksParams]):
-    """WaitForTasks command request model."""
-
-    commandType: WaitForTasksCommandType = "waitForTasks"
-    params: WaitForTasksParams
-
-    _CommandCls: Type[WaitForTasks] = WaitForTasks

opentrons/protocol_engine/execution/task_handler.py

@@ -1,157 +0,0 @@
-"""Task handling."""
-
-from __future__ import annotations
-import logging
-from typing import Protocol, AsyncIterator
-from ..state.state import StateStore
-from ..resources import ModelUtils, ConcurrencyProvider
-from ..types import Task
-import asyncio
-import contextlib
-from ..actions import ActionDispatcher, FinishTaskAction, StartTaskAction
-from ..errors import ErrorOccurrence
-from opentrons_shared_data.errors.exceptions import EnumeratedError, PythonException
-
-log = logging.getLogger(__name__)
-
-
-class TaskFunction(Protocol):
-    """The function run inside a task protocol."""
-
-    async def __call__(self, task_handler: TaskHandler) -> None:
-        """The function called inside a task."""
-        ...
-
-
-class TaskHandler:
-    """Implementation logic for fast concurrency."""
-
-    _state_store: StateStore
-    _model_utils: ModelUtils
-    _concurrency_provider: ConcurrencyProvider
-
-    def __init__(
-        self,
-        state_store: StateStore,
-        action_dispatcher: ActionDispatcher,
-        model_utils: ModelUtils | None = None,
-        concurrency_provider: ConcurrencyProvider | None = None,
-    ) -> None:
-        """Initialize a TaskHandler instance."""
-        self._state_store = state_store
-        self._model_utils = model_utils or ModelUtils()
-        self._concurrency_provider = concurrency_provider or ConcurrencyProvider()
-        self._action_dispatcher = action_dispatcher
-
-    async def create_task(
-        self, task_function: TaskFunction, id: str | None = None
-    ) -> Task:
-        """Create a task and immediately schedules it."""
-        task_id = self._model_utils.ensure_id(id)
-        asyncio_task = asyncio.create_task(
-            task_function(task_handler=self), name=f"engine-task-{task_id}"
-        )
-
-        def _done_callback(task: asyncio.Task[None]) -> None:
-            try:
-                maybe_exception = task.exception()
-            except asyncio.CancelledError as e:
-                maybe_exception = e
-            if isinstance(maybe_exception, EnumeratedError):
-                occurence: ErrorOccurrence | None = ErrorOccurrence.from_failed(
-                    id=self._model_utils.generate_id(),
-                    createdAt=self._model_utils.get_timestamp(),
-                    error=maybe_exception,
-                )
-            elif isinstance(maybe_exception, BaseException):
-                occurence = ErrorOccurrence.from_failed(
-                    id=self._model_utils.generate_id(),
-                    createdAt=self._model_utils.get_timestamp(),
-                    error=PythonException(maybe_exception),
-                )
-            else:
-                occurence = None
-            try:
-                self._action_dispatcher.dispatch(
-                    FinishTaskAction(
-                        task_id=task_id,
-                        finished_at=self._model_utils.get_timestamp(),
-                        error=occurence,
-                    ),
-                )
-            except BaseException:
-                log.exception("Exception in task finish dispatch.")
-
-        asyncio_task.add_done_callback(_done_callback)
-        task = Task(
-            id=task_id,
-            createdAt=self._model_utils.get_timestamp(),
-            asyncioTask=asyncio_task,
-        )
-        self._action_dispatcher.dispatch(StartTaskAction(task))
-        return task
-
-    @staticmethod
-    def _empty_queue(
-        queue: "asyncio.Queue[asyncio.Task[None]]", this_task: asyncio.Task[None]
-    ) -> None:
-        """Empties the queue."""
-        try:
-            while True:
-                task = queue.get_nowait()
-                if task is this_task:
-                    break
-        except asyncio.QueueEmpty:
-            pass
-
-    @contextlib.asynccontextmanager
-    async def synchronize_cancel_latest(self, group_id: str) -> AsyncIterator[None]:
-        """Cancel current task."""
-        lock = self._concurrency_provider.lock_for_group(group_id)
-        if lock.locked():
-            raise asyncio.CancelledError()
-        async with lock:
-            yield
-
-    @contextlib.asynccontextmanager
-    async def synchronize_cancel_previous(self, group_id: str) -> AsyncIterator[None]:
-        """Cancel previous run."""
-        queue = self._concurrency_provider.queue_for_group(group_id)
-        while not queue.empty():
-            task = queue.get_nowait()
-            task.cancel()
-        this_task = asyncio.current_task()
-        assert this_task is not None
-        queue.put_nowait(this_task)
-        try:
-            yield
-        except asyncio.CancelledError:
-            raise
-        except BaseException:
-            self._empty_queue(queue, this_task)
-            raise
-        else:
-            self._empty_queue(queue, this_task)
-
-    @contextlib.asynccontextmanager
-    async def synchronize_sequential(self, group_id: str) -> AsyncIterator[None]:
-        """Run tasks one after the other."""
-        lock = self._concurrency_provider.lock_for_group(group_id)
-        async with lock:
-            yield
-
-    @contextlib.asynccontextmanager
-    async def synchronize_concurrent(self, group_id: str) -> AsyncIterator[None]:
-        """Run a list of tasks at the same time."""
-        yield
-
-    def cancel_all(self, message: str | None = None) -> None:
-        """Cancel all asyncio tasks immediately.
-
-        Do not call this more than once synchronously because
-        that could lead to tasks cancelling more than once.
-        It can be called if there are no current tasks. In that case
-        nothing will happen.
-        """
-        for task in self._state_store.tasks.get_all_current():
-            task.asyncioTask.cancel(msg=message)

opentrons/protocol_engine/resources/concurrency_provider.py

@@ -1,27 +0,0 @@
-"""Concurrency primitives providers."""
-import asyncio
-
-
-class ConcurrencyProvider:
-    """Concurrency primitives for engine tasks."""
-
-    def __init__(self) -> None:
-        """Build a concurrency provider."""
-        self._locks: dict[str, asyncio.Lock] = {}
-        self._queues: dict[str, "asyncio.Queue[asyncio.Task[None]]"] = {}
-
-    def lock_for_group(self, group_id: str) -> asyncio.Lock:
-        """Returns the lock for specified group id."""
-        try:
-            return self._locks[group_id]
-        except KeyError:
-            self._locks[group_id] = asyncio.Lock()
-            return self._locks[group_id]
-
-    def queue_for_group(self, group_id: str) -> "asyncio.Queue[asyncio.Task[None]]":
-        """Returns the queue for specified group id."""
-        try:
-            return self._queues[group_id]
-        except KeyError:
-            self._queues[group_id] = asyncio.Queue()
-            return self._queues[group_id]

opentrons/protocol_engine/state/labware_origin_math/errors.py

@@ -1,94 +0,0 @@
-"""Labware origin math errors."""
-
-from typing import Any, Dict, Optional, Sequence
-
-from opentrons.protocol_engine.errors import ProtocolEngineError
-from opentrons_shared_data.errors import ErrorCodes
-from opentrons_shared_data.errors.exceptions import EnumeratedError
-
-
-class LabwareLocatingFeatureError(ProtocolEngineError):
-    """Base class for errors related to labware locating features."""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a LabwareLocatingFeatureError."""
-        super().__init__(
-            ErrorCodes.LABWARE_LOCATING_FEATURE_ERROR, message, details, wrapping
-        )
-
-
-class MissingLocatingFeatureError(LabwareLocatingFeatureError):
-    """Raised when a labware definition is missing a required locating feature."""
-
-    def __init__(
-        self,
-        labware_name: str,
-        required_feature: str,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a MissingLocatingFeatureError."""
-        if message is None:
-            message = f"Expected {labware_name} to have {required_feature} feature"
-
-        if details is None:
-            details = {
-                "labware_name": labware_name,
-                "required_feature": required_feature,
-            }
-
-        super().__init__(message, details, wrapping)
-
-
-class InvalidLabwarePlacementError(LabwareLocatingFeatureError):
-    """Raised when a labware cannot be placed in the specified location due to locating feature constraints."""
-
-    def __init__(
-        self,
-        feature_name: str,
-        invalid_placement: str,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build an InvalidLabwarePlacementError."""
-        if message is None:
-            message = f"{feature_name} feature does not support placement: {invalid_placement}"
-
-        if details is None:
-            details = {
-                "feature_name": feature_name,
-                "invalid_placement": invalid_placement,
-            }
-
-        super().__init__(message, details, wrapping)
-
-
-class IncompatibleLocatingFeatureError(LabwareLocatingFeatureError):
-    """Raised when parent and child labware have incompatible locating features."""
-
-    def __init__(
-        self,
-        parent_feature: str,
-        child_feature: str,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build an IncompatibleLocatingFeatureError."""
-        if message is None:
-            message = f"Incompatible labware features: parent {parent_feature}, child {child_feature}"
-
-        if details is None:
-            details = {
-                "parent_feature": parent_feature,
-                "child_feature": child_feature,
-            }
-
-        super().__init__(message, details, wrapping)