opentrons 8.7.0a2__py3-none-any.whl → 8.7.0a4__py3-none-any.whl

opentrons/protocol_api/core/tasks.py

@@ -1,31 +0,0 @@
-from abc import abstractmethod, ABC
-from datetime import datetime
-from typing import TypeVar
-
-
-class AbstractTaskCore(ABC):
-    @abstractmethod
-    def get_created_at_timestamp(self) -> datetime:
-        """Get the createdAt timestamp of the task."""
-        ...
-
-    @abstractmethod
-    def is_done(self) -> bool:
-        """Returns ``True`` if the task is done."""
-        ...
-
-    @abstractmethod
-    def is_started(self) -> bool:
-        """Returns ``True`` if the task has started."""
-        ...
-
-    @abstractmethod
-    def get_finished_at_timestamp(self) -> datetime | None:
-        """The timestamp of the when the task finished.
-
-        Returns ``None`` if the task hasn't finished yet.
-        """
-        ...
-
-
-TaskCoreType = TypeVar("TaskCoreType", bound=AbstractTaskCore)

opentrons/protocol_api/tasks.py

@@ -1,48 +0,0 @@
-"""Data for concurrent protocol tasks."""
-from typing import TYPE_CHECKING
-from datetime import datetime
-from opentrons.protocols.api_support.util import requires_version
-from opentrons.protocols.api_support.types import APIVersion
-
-if TYPE_CHECKING:
-    from .core.common import TaskCore
-
-
-class Task:
-    """A concurrent protocol task created by a protocol API function.
-
-    .. versionadded:: 2.27
-    """
-
-    def __init__(self, core: "TaskCore", api_version: APIVersion) -> None:
-        """Initialize a Task."""
-        self._core = core
-        self._api_version = api_version
-
-    @property
-    @requires_version(2, 27)
-    def created_at(self) -> datetime:
-        """The timestamp of when the task was created."""
-        return self._core.get_created_at_timestamp()
-
-    @property
-    @requires_version(2, 27)
-    def done(self) -> bool:
-        """Returns ``True`` if the task is done."""
-        return self._core.is_done()
-
-    @property
-    @requires_version(2, 27)
-    def started(self) -> bool:
-        """Returns ``True`` if the task has started."""
-        return self._core.is_started()
-        ...
-
-    @property
-    @requires_version(2, 27)
-    def finished_at(self) -> datetime | None:
-        """The timestamp of the when the task finished.
-
-        Returns ``None`` if the task hasn't finished yet.
-        """
-        return self._core.get_finished_at_timestamp()

opentrons/protocol_engine/commands/create_timer.py

@@ -1,83 +0,0 @@
-"""CreateTimer 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
-
-if TYPE_CHECKING:
-    from ..execution import TaskHandler, RunControlHandler
-
-
-CreateTimerCommandType = Literal["createTimer"]
-
-
-class CreateTimerParams(BaseModel):
-    """Payload required to annotate execution with a CreateTimer."""
-
-    time: float = Field(
-        ...,
-        description="The time before the timer should elapse in seconds. This is the minimum time before the timer elapses; it may in practice take longer than this.",
-    )
-    task_id: str | None = Field(
-        None,
-        description="The id of the timer task",
-    )
-
-
-class CreateTimerResult(BaseModel):
-    """Result data from the execution of a CreateTimer command."""
-
-    task_id: str = Field(..., description="The id of the timer task")
-    time: float = Field(..., description="The same time as the parameter.")
-
-
-class CreateTimerImplementation(
-    AbstractCommandImpl[CreateTimerParams, SuccessData[CreateTimerResult]]
-):
-    """CreateTimer command implementation."""
-
-    def __init__(
-        self,
-        task_handler: TaskHandler,
-        run_control: RunControlHandler,
-        **kwargs: object,
-    ) -> None:
-        self._task_handler = task_handler
-        self._run_control = run_control
-
-    async def execute(
-        self, params: CreateTimerParams
-    ) -> SuccessData[CreateTimerResult]:
-        """No operation taken other than capturing message in command."""
-
-        async def timer(task_handler: TaskHandler) -> None:
-            async with task_handler.synchronize_concurrent("createTimer"):
-                await self._run_control.wait_for_duration(params.time)
-
-        task = await self._task_handler.create_task(timer, params.task_id)
-        return SuccessData(
-            public=CreateTimerResult(task_id=task.id, time=params.time),
-        )
-
-
-class CreateTimer(BaseCommand[CreateTimerParams, CreateTimerResult, ErrorOccurrence]):
-    """CreateTimer command model."""
-
-    commandType: CreateTimerCommandType = "createTimer"
-    params: CreateTimerParams
-    result: Optional[CreateTimerResult] = None
-
-    _ImplementationCls: Type[CreateTimerImplementation] = CreateTimerImplementation
-
-
-class CreateTimerCreate(BaseCommandCreate[CreateTimerParams]):
-    """CreateTimer command request model."""
-
-    commandType: CreateTimerCommandType = "createTimer"
-    params: CreateTimerParams
-
-    _CommandCls: Type[CreateTimer] = CreateTimer

opentrons/protocol_engine/commands/set_tip_state.py

@@ -1,97 +0,0 @@
-"""Set tip state command request, result, and implementation models."""
-
-from __future__ import annotations
-from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type, List
-from typing_extensions import Literal
-
-from ..errors.error_occurrence import ErrorOccurrence
-from ..state.update_types import StateUpdate
-from ..types import TipRackWellState
-
-
-from .command import (
-    AbstractCommandImpl,
-    BaseCommand,
-    BaseCommandCreate,
-    SuccessData,
-)
-
-if TYPE_CHECKING:
-    from ..state.state import StateView
-
-
-SetTipStateCommandType = Literal["setTipState"]
-
-
-class SetTipStateParams(BaseModel):
-    """Payload needed to set tip wells of a tip rack to the requested state."""
-
-    labwareId: str = Field(
-        ..., description="Identifier of tip rack labware to set tip wells in."
-    )
-    wellNames: List[str] = Field(
-        ..., description="Names of the well to set tip well state for."
-    )
-    tipWellState: TipRackWellState = Field(
-        ..., description="State to set tip wells to."
-    )
-
-
-class SetTipStateResult(BaseModel):
-    """Result data from the execution of a setTipState command."""
-
-    pass
-
-
-class SetTipStateImplementation(
-    AbstractCommandImpl[SetTipStateParams, SuccessData[SetTipStateResult]]
-):
-    """Set tip state command implementation."""
-
-    def __init__(
-        self,
-        state_view: StateView,
-        **kwargs: object,
-    ) -> None:
-        self._state_view = state_view
-
-    async def execute(
-        self, params: SetTipStateParams
-    ) -> SuccessData[SetTipStateResult]:
-        """Set the tip rack wells to the requested state."""
-        labware_id = params.labwareId
-        well_names = params.wellNames
-
-        self._state_view.labware.raise_if_not_tip_rack(labware_id=labware_id)
-        self._state_view.labware.raise_if_wells_are_invalid(
-            labware_id=labware_id, well_names=well_names
-        )
-
-        return SuccessData(
-            public=SetTipStateResult(),
-            state_update=StateUpdate().update_tip_rack_well_state(
-                tip_state=params.tipWellState,
-                labware_id=labware_id,
-                well_names=well_names,
-            ),
-        )
-
-
-class SetTipState(BaseCommand[SetTipStateParams, SetTipStateResult, ErrorOccurrence]):
-    """Set tip state command model."""
-
-    commandType: SetTipStateCommandType = "setTipState"
-    params: SetTipStateParams
-    result: Optional[SetTipStateResult] = None
-
-    _ImplementationCls: Type[SetTipStateImplementation] = SetTipStateImplementation
-
-
-class SetTipStateCreate(BaseCommandCreate[SetTipStateParams]):
-    """Set tip state command creation request model."""
-
-    commandType: SetTipStateCommandType = "setTipState"
-    params: SetTipStateParams
-
-    _CommandCls: Type[SetTipState] = SetTipState

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)