opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/commands/unsafe/unsafe_stacker_open_latch.py

@@ -0,0 +1,91 @@
+"""Command models to open the latch of a Flex Stacker."""
+
+from __future__ import annotations
+
+from __future__ import annotations
+from typing import Optional, Literal, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors import (
+    ErrorOccurrence,
+)
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+UnsafeFlexStackerOpenLatchCommandType = Literal["unsafe/flexStacker/openLatch"]
+
+
+class UnsafeFlexStackerOpenLatchParams(BaseModel):
+    """The parameters defining how a stacker should open its latch."""
+
+    moduleId: str = Field(..., description="Unique ID of the Flex Stacker")
+
+
+class UnsafeFlexStackerOpenLatchResult(BaseModel):
+    """Result data from a stacker UnsafeFlexStackerOpenLatch command."""
+
+
+class UnsafeFlexStackerOpenLatchImpl(
+    AbstractCommandImpl[
+        UnsafeFlexStackerOpenLatchParams, SuccessData[UnsafeFlexStackerOpenLatchResult]
+    ]
+):
+    """Implementation of a stacker UnsafeFlexStackerOpenLatch command."""
+
+    def __init__(
+        self, state_view: StateView, equipment: EquipmentHandler, **kwargs: object
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: UnsafeFlexStackerOpenLatchParams
+    ) -> SuccessData[UnsafeFlexStackerOpenLatchResult]:
+        """Execute the stacker UnsafeFlexStackerOpenLatch command.
+
+        Opening the latch could result in labware falling down the stacker hopper,
+        resulting in an error state. This command should be used with care, outside of
+        a protocol and followed by a close latch command.
+        """
+        stacker_state = self._state_view.modules.get_flex_stacker_substate(
+            params.moduleId
+        )
+        stacker_hw = self._equipment.get_module_hardware_api(stacker_state.module_id)
+
+        if stacker_hw is not None:
+            await stacker_hw.open_latch()
+        return SuccessData(public=UnsafeFlexStackerOpenLatchResult())
+
+
+class UnsafeFlexStackerOpenLatch(
+    BaseCommand[
+        UnsafeFlexStackerOpenLatchParams,
+        UnsafeFlexStackerOpenLatchResult,
+        ErrorOccurrence,
+    ]
+):
+    """A command to UnsafeFlexStackerOpenLatch the Flex Stacker of labware."""
+
+    commandType: UnsafeFlexStackerOpenLatchCommandType = "unsafe/flexStacker/openLatch"
+    params: UnsafeFlexStackerOpenLatchParams
+    result: Optional[UnsafeFlexStackerOpenLatchResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeFlexStackerOpenLatchImpl
+    ] = UnsafeFlexStackerOpenLatchImpl
+
+
+class UnsafeFlexStackerOpenLatchCreate(
+    BaseCommandCreate[UnsafeFlexStackerOpenLatchParams]
+):
+    """A request to execute a Flex Stacker UnsafeFlexStackerOpenLatch command."""
+
+    commandType: UnsafeFlexStackerOpenLatchCommandType = "unsafe/flexStacker/openLatch"
+    params: UnsafeFlexStackerOpenLatchParams
+
+    _CommandCls: Type[UnsafeFlexStackerOpenLatch] = UnsafeFlexStackerOpenLatch

opentrons/protocol_engine/commands/unsafe/unsafe_stacker_prepare_shuttle.py

@@ -0,0 +1,136 @@
+"""Command models to prepare the stacker shuttle for movement."""
+
+from __future__ import annotations
+
+from __future__ import annotations
+from typing import Literal, Union, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from opentrons_shared_data.errors.exceptions import FlexStackerStallError
+
+from ..flex_stacker.common import FlexStackerStallOrCollisionError
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from ...errors import ErrorOccurrence
+from ...resources import ModelUtils
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+    from ...execution import EquipmentHandler
+
+UnsafeFlexStackerPrepareShuttleCommandType = Literal[
+    "unsafe/flexStacker/prepareShuttle"
+]
+
+
+class UnsafeFlexStackerPrepareShuttleParams(BaseModel):
+    """The parameters for a UnsafeFlexStackerPrepareShuttle command."""
+
+    moduleId: str = Field(..., description="Unique ID of the Flex Stacker")
+    ignoreLatch: bool = Field(
+        default=False, description="Ignore the latch state of the shuttle"
+    )
+
+
+class UnsafeFlexStackerPrepareShuttleResult(BaseModel):
+    """Result data from a stacker UnsafeFlexStackerPrepareShuttle command."""
+
+
+_ExecuteReturn = Union[
+    SuccessData[UnsafeFlexStackerPrepareShuttleResult],
+    DefinedErrorData[FlexStackerStallOrCollisionError],
+]
+
+
+class UnsafeFlexStackerPrepareShuttleImpl(
+    AbstractCommandImpl[UnsafeFlexStackerPrepareShuttleParams, _ExecuteReturn]
+):
+    """Implementation of a stacker prepare shuttle command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        model_utils: ModelUtils,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._model_utils = model_utils
+
+    async def execute(
+        self, params: UnsafeFlexStackerPrepareShuttleParams
+    ) -> _ExecuteReturn:
+        """Execute the stacker prepare shuttle command.
+
+        Moving the shuttle directly affects the state of the flex stacker and
+        could affect its ability to execute the next command. This command
+        should be used with care.
+        """
+        stacker_state = self._state_view.modules.get_flex_stacker_substate(
+            params.moduleId
+        )
+        # Allow propagation of ModuleNotAttachedError.
+        stacker_hw = self._equipment.get_module_hardware_api(stacker_state.module_id)
+
+        try:
+            if stacker_hw is not None:
+                await stacker_hw.home_all(params.ignoreLatch)
+        except FlexStackerStallError as e:
+            return DefinedErrorData(
+                public=FlexStackerStallOrCollisionError(
+                    id=self._model_utils.generate_id(),
+                    createdAt=self._model_utils.get_timestamp(),
+                    wrappedErrors=[
+                        ErrorOccurrence.from_failed(
+                            id=self._model_utils.generate_id(),
+                            createdAt=self._model_utils.get_timestamp(),
+                            error=e,
+                        )
+                    ],
+                    errorInfo={},
+                ),
+            )
+        # TODO we should also add a check for shuttle not detected error
+
+        return SuccessData(public=UnsafeFlexStackerPrepareShuttleResult())
+
+
+class UnsafeFlexStackerPrepareShuttle(
+    BaseCommand[
+        UnsafeFlexStackerPrepareShuttleParams,
+        UnsafeFlexStackerPrepareShuttleResult,
+        ErrorOccurrence,
+    ]
+):
+    """A command to prepare Flex Stacker shuttle."""
+
+    commandType: UnsafeFlexStackerPrepareShuttleCommandType = (
+        "unsafe/flexStacker/prepareShuttle"
+    )
+    params: UnsafeFlexStackerPrepareShuttleParams
+    result: UnsafeFlexStackerPrepareShuttleResult | None = None
+
+    _ImplementationCls: Type[
+        UnsafeFlexStackerPrepareShuttleImpl
+    ] = UnsafeFlexStackerPrepareShuttleImpl
+
+
+class UnsafeFlexStackerPrepareShuttleCreate(
+    BaseCommandCreate[UnsafeFlexStackerPrepareShuttleParams]
+):
+    """A request to execute a Flex Stacker UnsafeFlexStackerPrepareShuttle command."""
+
+    commandType: UnsafeFlexStackerPrepareShuttleCommandType = (
+        "unsafe/flexStacker/prepareShuttle"
+    )
+    params: UnsafeFlexStackerPrepareShuttleParams
+
+    _CommandCls: Type[UnsafeFlexStackerPrepareShuttle] = UnsafeFlexStackerPrepareShuttle

opentrons/protocol_engine/commands/unsafe/unsafe_ungrip_labware.py

@@ -0,0 +1,77 @@
+"""Ungrip labware payload, result, and implementaiton."""
+
+from __future__ import annotations
+
+from opentrons.hardware_control.types import Axis
+from opentrons.protocol_engine.errors.exceptions import GripperNotAttachedError
+from pydantic import BaseModel
+from typing import Optional, Type
+from typing_extensions import Literal
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+
+from opentrons.hardware_control import HardwareControlAPI
+
+
+UnsafeUngripLabwareCommandType = Literal["unsafe/ungripLabware"]
+
+
+class UnsafeUngripLabwareParams(BaseModel):
+    """Payload required for an UngripLabware command."""
+
+
+class UnsafeUngripLabwareResult(BaseModel):
+    """Result data from the execution of an UngripLabware command."""
+
+
+class UnsafeUngripLabwareImplementation(
+    AbstractCommandImpl[
+        UnsafeUngripLabwareParams,
+        SuccessData[UnsafeUngripLabwareResult],
+    ]
+):
+    """Ungrip labware command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+
+    async def execute(
+        self, params: UnsafeUngripLabwareParams
+    ) -> SuccessData[UnsafeUngripLabwareResult]:
+        """Ungrip Labware."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        if not ot3_hardware_api.has_gripper():
+            raise GripperNotAttachedError("No gripper found to perform ungrip.")
+        await ot3_hardware_api.home([Axis.G])
+        return SuccessData(
+            public=UnsafeUngripLabwareResult(),
+        )
+
+
+class UnsafeUngripLabware(
+    BaseCommand[UnsafeUngripLabwareParams, UnsafeUngripLabwareResult, ErrorOccurrence]
+):
+    """UnsafeUngripLabware command model."""
+
+    commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
+    params: UnsafeUngripLabwareParams
+    result: Optional[UnsafeUngripLabwareResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeUngripLabwareImplementation
+    ] = UnsafeUngripLabwareImplementation
+
+
+class UnsafeUngripLabwareCreate(BaseCommandCreate[UnsafeUngripLabwareParams]):
+    """UnsafeEngageAxes command request model."""
+
+    commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
+    params: UnsafeUngripLabwareParams
+
+    _CommandCls: Type[UnsafeUngripLabware] = UnsafeUngripLabware

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -0,0 +1,90 @@
+"""Update position estimators payload, result, and implementaiton."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, List, Type
+from typing_extensions import Literal
+
+from ...types import MotorAxis
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+
+from opentrons.hardware_control import HardwareControlAPI
+
+if TYPE_CHECKING:
+    from ...execution import GantryMover
+
+
+UpdatePositionEstimatorsCommandType = Literal["unsafe/updatePositionEstimators"]
+
+
+class UpdatePositionEstimatorsParams(BaseModel):
+    """Payload required for an UpdatePositionEstimators command."""
+
+    axes: List[MotorAxis] = Field(
+        ...,
+        description=(
+            "The axes for which to update the position estimators."
+            " Any axes that are not physically present will be ignored."
+        ),
+    )
+
+
+class UpdatePositionEstimatorsResult(BaseModel):
+    """Result data from the execution of an UpdatePositionEstimators command."""
+
+
+class UpdatePositionEstimatorsImplementation(
+    AbstractCommandImpl[
+        UpdatePositionEstimatorsParams,
+        SuccessData[UpdatePositionEstimatorsResult],
+    ]
+):
+    """Update position estimators command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        gantry_mover: GantryMover,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+        self._gantry_mover = gantry_mover
+
+    async def execute(
+        self, params: UpdatePositionEstimatorsParams
+    ) -> SuccessData[UpdatePositionEstimatorsResult]:
+        """Update axis position estimators from their encoders."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        await ot3_hardware_api.update_axis_position_estimations(
+            self._gantry_mover.motor_axes_to_present_hardware_axes(params.axes)
+        )
+        return SuccessData(
+            public=UpdatePositionEstimatorsResult(),
+        )
+
+
+class UpdatePositionEstimators(
+    BaseCommand[
+        UpdatePositionEstimatorsParams, UpdatePositionEstimatorsResult, ErrorOccurrence
+    ]
+):
+    """UpdatePositionEstimators command model."""
+
+    commandType: UpdatePositionEstimatorsCommandType = "unsafe/updatePositionEstimators"
+    params: UpdatePositionEstimatorsParams
+    result: Optional[UpdatePositionEstimatorsResult] = None
+
+    _ImplementationCls: Type[
+        UpdatePositionEstimatorsImplementation
+    ] = UpdatePositionEstimatorsImplementation
+
+
+class UpdatePositionEstimatorsCreate(BaseCommandCreate[UpdatePositionEstimatorsParams]):
+    """UpdatePositionEstimators command request model."""
+
+    commandType: UpdatePositionEstimatorsCommandType = "unsafe/updatePositionEstimators"
+    params: UpdatePositionEstimatorsParams
+
+    _CommandCls: Type[UpdatePositionEstimators] = UpdatePositionEstimators

opentrons/protocol_engine/commands/unseal_pipette_from_tip.py

@@ -0,0 +1,153 @@
+"""Unseal tip from pipette command request, result, and implementation models."""
+
+from __future__ import annotations
+
+from pydantic import Field
+from typing import TYPE_CHECKING, Optional, Type, Final
+from typing_extensions import Literal
+
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
+
+from ..types import DropTipWellLocation
+from .pipetting_common import (
+    PipetteIdMixin,
+)
+from .movement_common import (
+    DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from ..execution import MovementHandler, TipHandler, GantryMover
+
+
+UnsealPipetteFromTipCommandType = Literal["unsealPipetteFromTip"]
+
+
+class UnsealPipetteFromTipParams(PipetteIdMixin):
+    """Payload required to drop a tip in a specific well."""
+
+    labwareId: str = Field(..., description="Identifier of labware to use.")
+    wellName: str = Field(..., description="Name of well to use in labware.")
+    wellLocation: DropTipWellLocation = Field(
+        default_factory=DropTipWellLocation,
+        description="Relative well location at which to drop the tip.",
+    )
+
+
+class UnsealPipetteFromTipResult(DestinationPositionResult):
+    """Result data from the execution of a DropTip command."""
+
+    pass
+
+
+_ExecuteReturn = (
+    SuccessData[UnsealPipetteFromTipResult] | DefinedErrorData[StallOrCollisionError]
+)
+
+CUSTOM_TIP_LENGTH_MARGIN: Final = 10
+
+
+class UnsealPipetteFromTipImplementation(
+    AbstractCommandImpl[UnsealPipetteFromTipParams, _ExecuteReturn]
+):
+    """Drop tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        tip_handler: TipHandler,
+        movement: MovementHandler,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._tip_handler = tip_handler
+        self._movement_handler = movement
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
+
+    async def execute(self, params: UnsealPipetteFromTipParams) -> _ExecuteReturn:
+        """Move to and drop a tip using the requested pipette."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        well_location = params.wellLocation
+
+        tip_geometry = self._state_view.geometry.get_nominal_tip_geometry(
+            pipette_id, labware_id, well_name
+        )
+
+        is_partially_configured = self._state_view.pipettes.get_is_partially_configured(
+            pipette_id=pipette_id
+        )
+        tip_drop_location = self._state_view.geometry.get_checked_tip_drop_location(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_location=well_location,
+            partially_configured=is_partially_configured,
+            override_default_offset=-(tip_geometry.length - CUSTOM_TIP_LENGTH_MARGIN),
+        )
+
+        move_result = await move_to_well(
+            movement=self._movement_handler,
+            model_utils=self._model_utils,
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=tip_drop_location,
+        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+
+        await self._tip_handler.drop_tip(
+            pipette_id=pipette_id,
+            home_after=None,
+            do_not_ignore_tip_presence=False,
+            ignore_plunger=True,
+        )
+
+        return SuccessData(
+            public=UnsealPipetteFromTipResult(position=move_result.public.position),
+            state_update=move_result.state_update.set_fluid_unknown(
+                pipette_id=pipette_id
+            ).update_pipette_tip_state(
+                pipette_id=params.pipetteId, tip_geometry=None, tip_source=None
+            ),
+        )
+
+
+class UnsealPipetteFromTip(
+    BaseCommand[
+        UnsealPipetteFromTipParams, UnsealPipetteFromTipResult, StallOrCollisionError
+    ]
+):
+    """Unseal pipette command model."""
+
+    commandType: UnsealPipetteFromTipCommandType = "unsealPipetteFromTip"
+    params: UnsealPipetteFromTipParams
+    result: Optional[UnsealPipetteFromTipResult] = None
+
+    _ImplementationCls: Type[
+        UnsealPipetteFromTipImplementation
+    ] = UnsealPipetteFromTipImplementation
+
+
+class UnsealPipetteFromTipCreate(BaseCommandCreate[UnsealPipetteFromTipParams]):
+    """Unseal pipette command creation request model."""
+
+    commandType: UnsealPipetteFromTipCommandType = "unsealPipetteFromTip"
+    params: UnsealPipetteFromTipParams
+
+    _CommandCls: Type[UnsealPipetteFromTip] = UnsealPipetteFromTip

opentrons/protocol_engine/commands/verify_tip_presence.py

@@ -0,0 +1,100 @@
+"""Verify tip presence command request, result and implementation models."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic import Field, BaseModel
+from pydantic.json_schema import SkipJsonSchema
+from typing_extensions import Literal
+
+from .pipetting_common import PipetteIdMixin
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+from ..types import TipPresenceStatus, InstrumentSensorId
+
+if TYPE_CHECKING:
+    from ..execution import TipHandler
+
+
+VerifyTipPresenceCommandType = Literal["verifyTipPresence"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class VerifyTipPresenceParams(PipetteIdMixin):
+    """Payload required for a VerifyTipPresence command."""
+
+    expectedState: TipPresenceStatus = Field(
+        ..., description="The expected tip presence status on the pipette."
+    )
+    followSingularSensor: InstrumentSensorId | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The sensor id to follow if the other can be ignored.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class VerifyTipPresenceResult(BaseModel):
+    """Result data from the execution of a VerifyTipPresence command."""
+
+    pass
+
+
+class VerifyTipPresenceImplementation(
+    AbstractCommandImpl[VerifyTipPresenceParams, SuccessData[VerifyTipPresenceResult]]
+):
+    """VerifyTipPresence command implementation."""
+
+    def __init__(
+        self,
+        tip_handler: TipHandler,
+        **kwargs: object,
+    ) -> None:
+        self._tip_handler = tip_handler
+
+    async def execute(
+        self, params: VerifyTipPresenceParams
+    ) -> SuccessData[VerifyTipPresenceResult]:
+        """Verify if tip presence is as expected for the requested pipette."""
+        pipette_id = params.pipetteId
+        expected_state = params.expectedState
+        follow_singular_sensor = (
+            InstrumentSensorId.to_instrument_probe_type(params.followSingularSensor)
+            if params.followSingularSensor
+            else None
+        )
+
+        await self._tip_handler.verify_tip_presence(
+            pipette_id=pipette_id,
+            expected=expected_state,
+            follow_singular_sensor=follow_singular_sensor,
+        )
+
+        return SuccessData(
+            public=VerifyTipPresenceResult(),
+        )
+
+
+class VerifyTipPresence(
+    BaseCommand[VerifyTipPresenceParams, VerifyTipPresenceResult, ErrorOccurrence]
+):
+    """VerifyTipPresence command model."""
+
+    commandType: VerifyTipPresenceCommandType = "verifyTipPresence"
+    params: VerifyTipPresenceParams
+    result: Optional[VerifyTipPresenceResult] = None
+
+    _ImplementationCls: Type[
+        VerifyTipPresenceImplementation
+    ] = VerifyTipPresenceImplementation
+
+
+class VerifyTipPresenceCreate(BaseCommandCreate[VerifyTipPresenceParams]):
+    """VerifyTipPresence command creation request model."""
+
+    commandType: VerifyTipPresenceCommandType = "verifyTipPresence"
+    params: VerifyTipPresenceParams
+
+    _CommandCls: Type[VerifyTipPresence] = VerifyTipPresence