opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/commands/robot/move_axes_to.py

@@ -0,0 +1,100 @@
+"""Command models for moving any robot axis to an absolute position."""
+from __future__ import annotations
+from typing import Literal, Optional, Type, TYPE_CHECKING, Any
+
+from pydantic import Field, BaseModel
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.protocol_engine.resources import ensure_ot3_hardware
+
+from .common import MotorAxisMapType, DestinationRobotPositionResult
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from ...errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.execution import GantryMover
+
+
+MoveAxesToCommandType = Literal["robot/moveAxesTo"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class MoveAxesToParams(BaseModel):
+    """Payload required to move axes to absolute position."""
+
+    axis_map: MotorAxisMapType = Field(
+        ..., description="The specified axes to move to an absolute deck position with."
+    )
+    critical_point: MotorAxisMapType | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The critical point to move the mount with.",
+        json_schema_extra=_remove_default,
+    )
+    speed: float | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The max velocity to move the axes at. Will fall to hardware defaults if none provided.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class MoveAxesToResult(DestinationRobotPositionResult):
+    """Result data from the execution of a MoveAxesTo command."""
+
+    pass
+
+
+class MoveAxesToImplementation(
+    AbstractCommandImpl[MoveAxesToParams, SuccessData[MoveAxesToResult]]
+):
+    """MoveAxesTo command implementation."""
+
+    def __init__(
+        self,
+        gantry_mover: GantryMover,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._gantry_mover = gantry_mover
+        self._hardware_api = hardware_api
+
+    async def execute(self, params: MoveAxesToParams) -> SuccessData[MoveAxesToResult]:
+        """Move the axes on a flex an absolute distance."""
+        # TODO (lc 08-16-2024) implement `move_axes` for OT 2 hardware controller
+        # and then we can remove this validation.
+        ensure_ot3_hardware(self._hardware_api)
+        current_position = await self._gantry_mover.move_axes(
+            axis_map=params.axis_map,
+            speed=params.speed,
+            critical_point=params.critical_point,
+        )
+        return SuccessData(
+            public=MoveAxesToResult(position=current_position),
+        )
+
+
+class MoveAxesTo(BaseCommand[MoveAxesToParams, MoveAxesToResult, ErrorOccurrence]):
+    """MoveAxesTo command model."""
+
+    commandType: MoveAxesToCommandType = "robot/moveAxesTo"
+    params: MoveAxesToParams
+    result: Optional[MoveAxesToResult] = None
+
+    _ImplementationCls: Type[MoveAxesToImplementation] = MoveAxesToImplementation
+
+
+class MoveAxesToCreate(BaseCommandCreate[MoveAxesToParams]):
+    """MoveAxesTo command request model."""
+
+    commandType: MoveAxesToCommandType = "robot/moveAxesTo"
+    params: MoveAxesToParams
+
+    _CommandCls: Type[MoveAxesTo] = MoveAxesTo

opentrons/protocol_engine/commands/robot/move_to.py

@@ -0,0 +1,94 @@
+"""Command models for moving any robot mount to a destination point."""
+from __future__ import annotations
+from typing import Literal, Type, Optional, TYPE_CHECKING, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.types import MountType
+
+from ..movement_common import DestinationPositionResult
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from opentrons.protocol_engine.types import DeckPoint
+from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
+
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.execution import MovementHandler
+
+
+MoveToCommandType = Literal["robot/moveTo"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class MoveToParams(BaseModel):
+    """Payload required to move to a destination position."""
+
+    mount: MountType = Field(
+        ...,
+        description="The mount to move to the destination point.",
+    )
+    destination: DeckPoint = Field(
+        ...,
+        description="X, Y and Z coordinates in mm from deck's origin location (left-front-bottom corner of work space)",
+    )
+    speed: float | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The max velocity to move the axes at. Will fall to hardware defaults if none provided.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class MoveToResult(DestinationPositionResult):
+    """Result data from the execution of a MoveTo command."""
+
+    pass
+
+
+class MoveToImplementation(
+    AbstractCommandImpl[MoveToParams, SuccessData[MoveToResult]]
+):
+    """MoveTo command implementation."""
+
+    def __init__(
+        self,
+        movement: MovementHandler,
+        **kwargs: object,
+    ) -> None:
+        self._movement = movement
+
+    async def execute(self, params: MoveToParams) -> SuccessData[MoveToResult]:
+        """Move to a given destination on a flex."""
+        x, y, z = await self._movement.move_mount_to(
+            mount=params.mount, destination=params.destination, speed=params.speed
+        )
+        return SuccessData(
+            public=MoveToResult(position=DeckPoint(x=x, y=y, z=z)),
+        )
+
+
+class MoveTo(BaseCommand[MoveToParams, MoveToResult, ErrorOccurrence]):
+    """MoveTo command model."""
+
+    commandType: MoveToCommandType = "robot/moveTo"
+    params: MoveToParams
+    result: Optional[MoveToResult] = None
+
+    _ImplementationCls: Type[MoveToImplementation] = MoveToImplementation
+
+
+class MoveToCreate(BaseCommandCreate[MoveToParams]):
+    """MoveTo command request model."""
+
+    commandType: MoveToCommandType = "robot/moveTo"
+    params: MoveToParams
+
+    _CommandCls: Type[MoveTo] = MoveTo

opentrons/protocol_engine/commands/robot/open_gripper_jaw.py

@@ -0,0 +1,86 @@
+"""Command models for opening a gripper jaw."""
+
+from __future__ import annotations
+from typing import Literal, Type, Optional, TYPE_CHECKING
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.protocol_engine.resources import ensure_ot3_hardware
+
+from pydantic import BaseModel
+
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+
+
+OpenGripperJawCommandType = Literal["robot/openGripperJaw"]
+
+
+class OpenGripperJawParams(BaseModel):
+    """Payload required to release a gripper."""
+
+    pass
+
+
+class OpenGripperJawResult(BaseModel):
+    """Result data from the execution of a openGripperJaw command."""
+
+    pass
+
+
+class OpenGripperJawImplementation(
+    AbstractCommandImpl[OpenGripperJawParams, SuccessData[OpenGripperJawResult]]
+):
+    """openGripperJaw command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+        self._state_view = state_view
+
+    async def execute(
+        self, params: OpenGripperJawParams
+    ) -> SuccessData[OpenGripperJawResult]:
+        """Release the gripper."""
+        if self._state_view.config.use_virtual_gripper:
+            return SuccessData(public=OpenGripperJawResult())
+
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+
+        await ot3_hardware_api.home_gripper_jaw()
+        return SuccessData(
+            public=OpenGripperJawResult(),
+        )
+
+
+class OpenGripperJaw(
+    BaseCommand[OpenGripperJawParams, OpenGripperJawResult, ErrorOccurrence]
+):
+    """openGripperJaw command model."""
+
+    commandType: OpenGripperJawCommandType = "robot/openGripperJaw"
+    params: OpenGripperJawParams
+    result: Optional[OpenGripperJawResult] = None
+
+    _ImplementationCls: Type[
+        OpenGripperJawImplementation
+    ] = OpenGripperJawImplementation
+
+
+class OpenGripperJawCreate(BaseCommandCreate[OpenGripperJawParams]):
+    """openGripperJaw command request model."""
+
+    commandType: OpenGripperJawCommandType = "robot/openGripperJaw"
+    params: OpenGripperJawParams
+
+    _CommandCls: Type[OpenGripperJaw] = OpenGripperJaw

opentrons/protocol_engine/commands/save_position.py

@@ -0,0 +1,109 @@
+"""Save pipette position command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+from typing_extensions import Literal
+
+from ..types import DeckPoint
+from ..resources import ModelUtils
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ..execution import GantryMover
+
+SavePositionCommandType = Literal["savePosition"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class SavePositionParams(BaseModel):
+    """Payload needed to save a pipette's current position."""
+
+    pipetteId: str = Field(
+        ..., description="Unique identifier of the pipette in question."
+    )
+    positionId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="An optional ID to assign to this command instance. "
+        "Auto-assigned if not defined.",
+        json_schema_extra=_remove_default,
+    )
+    failOnNotHomed: bool | SkipJsonSchema[None] = Field(
+        True,
+        description="Require all axes to be homed before saving position.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class SavePositionResult(BaseModel):
+    """Result data from executing a savePosition."""
+
+    positionId: str = Field(
+        ..., description="An ID to reference this position in subsequent requests."
+    )
+    position: DeckPoint = Field(
+        ...,
+        description="The (x,y,z) coordinates of the pipette's critical point "
+        "in deck space.",
+    )
+
+
+class SavePositionImplementation(
+    AbstractCommandImpl[SavePositionParams, SuccessData[SavePositionResult]]
+):
+    """Save position command implementation."""
+
+    def __init__(
+        self,
+        gantry_mover: GantryMover,
+        model_utils: ModelUtils,
+        **kwargs: object,
+    ) -> None:
+        self._gantry_mover = gantry_mover
+        self._model_utils = model_utils
+
+    async def execute(
+        self, params: SavePositionParams
+    ) -> SuccessData[SavePositionResult]:
+        """Check the requested pipette's current position."""
+        position_id = self._model_utils.ensure_id(params.positionId)
+        fail_on_not_homed = (
+            params.failOnNotHomed if params.failOnNotHomed is not None else True
+        )
+        x, y, z = await self._gantry_mover.get_position(
+            pipette_id=params.pipetteId, fail_on_not_homed=fail_on_not_homed
+        )
+
+        return SuccessData(
+            public=SavePositionResult(
+                positionId=position_id,
+                position=DeckPoint(x=x, y=y, z=z),
+            ),
+        )
+
+
+class SavePosition(
+    BaseCommand[SavePositionParams, SavePositionResult, ErrorOccurrence]
+):
+    """Save Position command model."""
+
+    commandType: SavePositionCommandType = "savePosition"
+    params: SavePositionParams
+    result: Optional[SavePositionResult] = None
+
+    _ImplementationCls: Type[SavePositionImplementation] = SavePositionImplementation
+
+
+class SavePositionCreate(BaseCommandCreate[SavePositionParams]):
+    """Save position command creation request model."""
+
+    commandType: SavePositionCommandType = "savePosition"
+    params: SavePositionParams
+
+    _CommandCls: Type[SavePosition] = SavePosition