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

opentrons/protocol_api/core/engine/tasks.py

@@ -1,48 +0,0 @@
-from datetime import datetime
-from ..tasks import AbstractTaskCore
-from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
-from opentrons.protocol_engine.errors.exceptions import NoTaskFoundError
-
-
-class EngineTaskCore(AbstractTaskCore):
-    def __init__(
-        self, task_id: str | None, engine_client: ProtocolEngineClient
-    ) -> None:
-        self._id = task_id
-        self._engine_client = engine_client
-
-    def get_created_at_timestamp(self) -> datetime:
-        if self._id is None:
-            raise NoTaskFoundError
-        try:
-            task = self._engine_client.state.tasks.get(self._id)
-            return task.createdAt
-        except NoTaskFoundError:
-            raise NoTaskFoundError
-
-    def is_done(self) -> bool:
-        if self._id is None:
-            raise NoTaskFoundError
-        try:
-            self._engine_client.state.tasks.get_finished(self._id)
-            return True
-        except NoTaskFoundError:
-            return False
-
-    def is_started(self) -> bool:
-        if self._id is None:
-            raise NoTaskFoundError
-        try:
-            self._engine_client.state.tasks.get_current(self._id)
-            return True
-        except NoTaskFoundError:
-            return self.is_done()
-
-    def get_finished_at_timestamp(self) -> datetime | None:
-        if self._id is None:
-            raise NoTaskFoundError
-        try:
-            finished_task = self._engine_client.state.tasks.get_finished(self._id)
-            return finished_task.finishedAt
-        except NoTaskFoundError:
-            return None

opentrons/protocol_api/core/legacy/tasks.py

@@ -1,19 +0,0 @@
-from ..tasks import AbstractTaskCore
-from datetime import datetime
-
-
-class LegacyTaskCore(AbstractTaskCore):
-    def __init__(self) -> None:
-        pass
-
-    def get_created_at_timestamp(self) -> datetime:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def is_done(self) -> bool:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def is_started(self) -> bool:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def get_finished_at_timestamp(self) -> datetime | None:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")

opentrons/protocol_api/core/legacy_simulator/tasks.py

@@ -1,19 +0,0 @@
-from ..tasks import AbstractTaskCore
-from datetime import datetime
-
-
-class LegacyTaskCore(AbstractTaskCore):
-    def __init__(self, created_at: datetime) -> None:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def get_created_at_timestamp(self) -> datetime:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def is_done(self) -> bool:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def is_started(self) -> bool:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")
-
-    def get_finished_at_timestamp(self) -> datetime | None:
-        raise NotImplementedError("Legacy protocols do not implement tasks.")

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/heater_shaker/common.py

@@ -1,20 +0,0 @@
-"""Common heatershaker base models."""
-from opentrons.protocol_engine.state.module_substates.heater_shaker_module_substate import (
-    HeaterShakerModuleSubState,
-)
-
-
-async def get_heatershaker_ready_to_shake(
-    hs_module_substate: HeaterShakerModuleSubState,
-    rpm: float,
-) -> int:
-    """Check heatershaker state to confirm if it is ready to shake.
-
-    This includes
-    - Checking latch closure
-    - Validating target speed
-    """
-    hs_module_substate.raise_if_labware_latch_not_closed()
-    # Verify speed from hs module view
-    validated_speed = hs_module_substate.validate_target_speed(rpm)
-    return validated_speed

opentrons/protocol_engine/commands/heater_shaker/set_shake_speed.py

@@ -1,136 +0,0 @@
-"""Command models to set a shake speed for a Heater-Shaker Module."""
-from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
-from typing_extensions import Literal, Type
-from pydantic import BaseModel, Field
-
-from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ...errors.error_occurrence import ErrorOccurrence
-from ...state import update_types
-from .common import get_heatershaker_ready_to_shake
-
-if TYPE_CHECKING:
-    from opentrons.protocol_engine.state.state import StateView
-    from opentrons.protocol_engine.execution import (
-        EquipmentHandler,
-        MovementHandler,
-        TaskHandler,
-    )
-
-SetShakeSpeedCommandType = Literal["heaterShaker/setShakeSpeed"]
-
-
-class SetShakeSpeedParams(BaseModel):
-    """Input parameters to set a shake speed for a Heater-Shaker Module."""
-
-    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
-    rpm: float = Field(..., description="Target speed in rotations per minute.")
-    taskId: str | None = Field(
-        None,
-        description="Id for the background task that manages the temperature",
-    )
-
-
-class SetShakeSpeedResult(BaseModel):
-    """Result data from setting and waiting for a Heater-Shaker's shake speed."""
-
-    pipetteRetracted: bool = Field(
-        ...,
-        description=(
-            "Whether this command automatically retracted the pipettes"
-            " before starting the shake, to avoid a potential collision."
-        ),
-    )
-    taskId: str = Field(
-        description="The task id for the setTargetTemperature task",
-    )
-
-
-class SetShakeSpeedImpl(
-    AbstractCommandImpl[SetShakeSpeedParams, SuccessData[SetShakeSpeedResult]]
-):
-    """Execution implementation of Heater-Shaker's set shake speed command."""
-
-    def __init__(
-        self,
-        state_view: StateView,
-        equipment: EquipmentHandler,
-        movement: MovementHandler,
-        task_handler: TaskHandler,
-        **unused_dependencies: object,
-    ) -> None:
-        self._state_view = state_view
-        self._equipment = equipment
-        self._movement = movement
-        self._task_handler = task_handler
-
-    async def execute(
-        self,
-        params: SetShakeSpeedParams,
-    ) -> SuccessData[SetShakeSpeedResult]:
-        """Set a Heater-Shaker's target shake speed."""
-        state_update = update_types.StateUpdate()
-
-        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
-        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
-            module_id=params.moduleId
-        )
-
-        validated_speed = await get_heatershaker_ready_to_shake(
-            hs_module_substate, params.rpm
-        )
-        pipette_should_retract = (
-            self._state_view.motion.check_pipette_blocking_hs_shaker(
-                hs_module_substate.module_id
-            )
-        )
-        if pipette_should_retract:
-            # Move pipette away if it is close to the heater-shaker
-            # TODO(jbl 2022-07-28) replace home movement with a retract movement
-            await self._movement.home(
-                axes=self._state_view.motion.get_robot_mount_axes()
-            )
-            state_update.clear_all_pipette_locations()
-
-        # Allow propagation of ModuleNotAttachedError.
-        hs_hardware_module = self._equipment.get_module_hardware_api(
-            hs_module_substate.module_id
-        )
-
-        async def start_shake(task_handler: TaskHandler) -> None:
-            if hs_hardware_module is not None:
-                async with task_handler.synchronize_cancel_previous(
-                    hs_module_substate.module_id
-                ):
-                    await hs_hardware_module.set_speed(rpm=validated_speed)
-
-        task = await self._task_handler.create_task(
-            task_function=start_shake, id=params.taskId
-        )
-        return SuccessData(
-            public=SetShakeSpeedResult(
-                pipetteRetracted=pipette_should_retract, taskId=task.id
-            ),
-            state_update=state_update,
-        )
-
-
-class SetShakeSpeed(
-    BaseCommand[SetShakeSpeedParams, SetShakeSpeedResult, ErrorOccurrence]
-):
-    """A command to set a Heater-Shaker's shake speed."""
-
-    commandType: SetShakeSpeedCommandType = "heaterShaker/setShakeSpeed"
-    params: SetShakeSpeedParams
-    result: Optional[SetShakeSpeedResult] = None
-
-    _ImplementationCls: Type[SetShakeSpeedImpl] = SetShakeSpeedImpl
-
-
-class SetShakeSpeedCreate(BaseCommandCreate[SetShakeSpeedParams]):
-    """A request to create a Heater-Shaker's set shake speed command."""
-
-    commandType: SetShakeSpeedCommandType = "heaterShaker/setShakeSpeed"
-    params: SetShakeSpeedParams
-
-    _CommandCls: Type[SetShakeSpeed] = SetShakeSpeed

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