opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/thermocycler/wait_for_lid_temperature.py

@@ -0,0 +1,89 @@
+"""Command models to wait for heating a Thermocycler's lid."""
+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
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+
+WaitForLidTemperatureCommandType = Literal["thermocycler/waitForLidTemperature"]
+
+
+class WaitForLidTemperatureParams(BaseModel):
+    """Input parameters to wait for Thermocycler's lid temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler Module.")
+
+
+class WaitForLidTemperatureResult(BaseModel):
+    """Result data from wait for Thermocycler's lid temperature."""
+
+
+class WaitForLidTemperatureImpl(
+    AbstractCommandImpl[
+        WaitForLidTemperatureParams, SuccessData[WaitForLidTemperatureResult]
+    ]
+):
+    """Execution implementation of Thermocycler's wait for lid temperature command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self,
+        params: WaitForLidTemperatureParams,
+    ) -> SuccessData[WaitForLidTemperatureResult]:
+        """Wait for a Thermocycler's lid temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+
+        # Raises error if no target temperature
+        thermocycler_state.get_target_lid_temperature()
+
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.wait_for_lid_target()
+
+        return SuccessData(
+            public=WaitForLidTemperatureResult(),
+        )
+
+
+class WaitForLidTemperature(
+    BaseCommand[
+        WaitForLidTemperatureParams, WaitForLidTemperatureResult, ErrorOccurrence
+    ]
+):
+    """A command to wait for a Thermocycler's lid temperature."""
+
+    commandType: WaitForLidTemperatureCommandType = "thermocycler/waitForLidTemperature"
+    params: WaitForLidTemperatureParams
+    result: Optional[WaitForLidTemperatureResult] = None
+
+    _ImplementationCls: Type[WaitForLidTemperatureImpl] = WaitForLidTemperatureImpl
+
+
+class WaitForLidTemperatureCreate(BaseCommandCreate[WaitForLidTemperatureParams]):
+    """A request to create Thermocycler's wait for lid temperature command."""
+
+    commandType: WaitForLidTemperatureCommandType = "thermocycler/waitForLidTemperature"
+    params: WaitForLidTemperatureParams
+
+    _CommandCls: Type[WaitForLidTemperature] = WaitForLidTemperature

opentrons/protocol_engine/commands/touch_tip.py

@@ -0,0 +1,189 @@
+"""Touch tip command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from typing_extensions import Literal
+from pydantic import Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.types import Point
+
+from ..errors import (
+    TouchTipDisabledError,
+    TouchTipIncompatibleArgumentsError,
+    LabwareIsTipRackError,
+)
+from ..types import DeckPoint
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from .pipetting_common import (
+    PipetteIdMixin,
+)
+from .movement_common import (
+    WellLocationMixin,
+    DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
+)
+
+if TYPE_CHECKING:
+    from ..execution import MovementHandler, GantryMover
+    from ..state.state import StateView
+    from ..resources.model_utils import ModelUtils
+
+
+TouchTipCommandType = Literal["touchTip"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class TouchTipParams(PipetteIdMixin, WellLocationMixin):
+    """Payload needed to touch a pipette tip the sides of a specific well."""
+
+    radius: float = Field(
+        1.0,
+        description=(
+            "The proportion of the target well's radius the pipette tip will move towards."
+        ),
+    )
+
+    mmFromEdge: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Offset away from the the well edge, in millimeters."
+        "Incompatible when a radius is included as a non 1.0 value.",
+        json_schema_extra=_remove_default,
+    )
+
+    speed: float | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "Override the travel speed in mm/s."
+            " This controls the straight linear speed of motion."
+        ),
+        json_schema_extra=_remove_default,
+    )
+
+
+class TouchTipResult(DestinationPositionResult):
+    """Result data from the execution of a TouchTip."""
+
+    pass
+
+
+class TouchTipImplementation(
+    AbstractCommandImpl[
+        TouchTipParams,
+        SuccessData[TouchTipResult] | DefinedErrorData[StallOrCollisionError],
+    ]
+):
+    """Touch tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        movement: MovementHandler,
+        gantry_mover: GantryMover,
+        model_utils: ModelUtils,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._movement = movement
+        self._gantry_mover = gantry_mover
+        self._model_utils = model_utils
+
+    async def execute(
+        self, params: TouchTipParams
+    ) -> SuccessData[TouchTipResult] | DefinedErrorData[StallOrCollisionError]:
+        """Touch tip to sides of a well using the requested pipette."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        if params.radius != 1.0 and params.mmFromEdge is not None:
+            raise TouchTipIncompatibleArgumentsError(
+                "Cannot use mmFromEdge with a radius that is not 1.0"
+            )
+
+        if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
+            raise TouchTipDisabledError(
+                f"Touch tip not allowed on labware {labware_id}"
+            )
+
+        if self._state_view.labware.is_tiprack(labware_id):
+            raise LabwareIsTipRackError("Cannot touch tip on tip rack")
+
+        center_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=params.wellLocation,
+        )
+        if isinstance(center_result, DefinedErrorData):
+            return center_result
+
+        touch_speed = self._state_view.pipettes.get_movement_speed(
+            pipette_id, params.speed
+        )
+
+        mm_from_edge = params.mmFromEdge if params.mmFromEdge is not None else 0
+        touch_waypoints = self._state_view.motion.get_touch_tip_waypoints(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            radius=params.radius,
+            mm_from_edge=mm_from_edge,
+            center_point=Point(
+                center_result.public.position.x,
+                center_result.public.position.y,
+                center_result.public.position.z,
+            ),
+        )
+
+        final_point = await self._gantry_mover.move_to(
+            pipette_id=pipette_id,
+            waypoints=touch_waypoints,
+            speed=touch_speed,
+        )
+        final_deck_point = DeckPoint.model_construct(
+            x=final_point.x, y=final_point.y, z=final_point.z
+        )
+        state_update = center_result.state_update.set_pipette_location(
+            pipette_id=pipette_id,
+            new_labware_id=labware_id,
+            new_well_name=well_name,
+            new_deck_point=final_deck_point,
+        )
+
+        return SuccessData(
+            public=TouchTipResult(position=final_deck_point),
+            state_update=state_update,
+        )
+
+
+class TouchTip(BaseCommand[TouchTipParams, TouchTipResult, StallOrCollisionError]):
+    """Touch up tip command model."""
+
+    commandType: TouchTipCommandType = "touchTip"
+    params: TouchTipParams
+    result: Optional[TouchTipResult] = None
+
+    _ImplementationCls: Type[TouchTipImplementation] = TouchTipImplementation
+
+
+class TouchTipCreate(BaseCommandCreate[TouchTipParams]):
+    """Touch tip command creation request model."""
+
+    commandType: TouchTipCommandType = "touchTip"
+    params: TouchTipParams
+
+    _CommandCls: Type[TouchTip] = TouchTip

opentrons/protocol_engine/commands/unsafe/__init__.py

@@ -0,0 +1,161 @@
+"""Commands that are "unsafe".
+
+"Unsafe" means that they can cause inaccuracy or incorrect behavior. They should
+therefore never be used in protocols, and should only be used otherwise as a last
+resort.
+
+These exist as a necessary evil for implementing things like error recovery.
+Even in those narrow contexts, these commands must be used with care.
+e.g. after an `UpdatePositionEstimators` command, there must be a `Home` command,
+or positioning will be subtly wrong. Each unsafe command should document its intended
+use case and its caveats.
+
+Because we don't expect unsafe commands to be used in any protocols whose behavior we
+must preserve, we may change the commands' semantics over time. We may also change
+their shapes if we're confident that it won't break something in robot-server's
+persistent storage.
+"""
+
+
+from .unsafe_blow_out_in_place import (
+    UnsafeBlowOutInPlaceCommandType,
+    UnsafeBlowOutInPlaceParams,
+    UnsafeBlowOutInPlaceResult,
+    UnsafeBlowOutInPlace,
+    UnsafeBlowOutInPlaceCreate,
+)
+from .unsafe_drop_tip_in_place import (
+    UnsafeDropTipInPlaceCommandType,
+    UnsafeDropTipInPlaceParams,
+    UnsafeDropTipInPlaceResult,
+    UnsafeDropTipInPlace,
+    UnsafeDropTipInPlaceCreate,
+)
+
+from .update_position_estimators import (
+    UpdatePositionEstimatorsCommandType,
+    UpdatePositionEstimatorsParams,
+    UpdatePositionEstimatorsResult,
+    UpdatePositionEstimators,
+    UpdatePositionEstimatorsCreate,
+)
+
+from .unsafe_engage_axes import (
+    UnsafeEngageAxesCommandType,
+    UnsafeEngageAxesParams,
+    UnsafeEngageAxesResult,
+    UnsafeEngageAxes,
+    UnsafeEngageAxesCreate,
+)
+
+from .unsafe_ungrip_labware import (
+    UnsafeUngripLabwareCommandType,
+    UnsafeUngripLabwareParams,
+    UnsafeUngripLabwareResult,
+    UnsafeUngripLabware,
+    UnsafeUngripLabwareCreate,
+)
+
+
+from .unsafe_place_labware import (
+    UnsafePlaceLabwareCommandType,
+    UnsafePlaceLabwareParams,
+    UnsafePlaceLabwareResult,
+    UnsafePlaceLabware,
+    UnsafePlaceLabwareCreate,
+)
+
+from .unsafe_stacker_manual_retrieve import (
+    UnsafeFlexStackerManualRetrieveCommandType,
+    UnsafeFlexStackerManualRetrieveParams,
+    UnsafeFlexStackerManualRetrieveResult,
+    UnsafeFlexStackerManualRetrieve,
+    UnsafeFlexStackerManualRetrieveCreate,
+)
+
+from .unsafe_stacker_close_latch import (
+    UnsafeFlexStackerCloseLatchCommandType,
+    UnsafeFlexStackerCloseLatchParams,
+    UnsafeFlexStackerCloseLatchResult,
+    UnsafeFlexStackerCloseLatch,
+    UnsafeFlexStackerCloseLatchCreate,
+)
+
+from .unsafe_stacker_open_latch import (
+    UnsafeFlexStackerOpenLatchCommandType,
+    UnsafeFlexStackerOpenLatchParams,
+    UnsafeFlexStackerOpenLatchResult,
+    UnsafeFlexStackerOpenLatch,
+    UnsafeFlexStackerOpenLatchCreate,
+)
+
+from .unsafe_stacker_prepare_shuttle import (
+    UnsafeFlexStackerPrepareShuttleCommandType,
+    UnsafeFlexStackerPrepareShuttleParams,
+    UnsafeFlexStackerPrepareShuttleResult,
+    UnsafeFlexStackerPrepareShuttle,
+    UnsafeFlexStackerPrepareShuttleCreate,
+)
+
+__all__ = [
+    # Unsafe blow-out-in-place command models
+    "UnsafeBlowOutInPlaceCommandType",
+    "UnsafeBlowOutInPlaceParams",
+    "UnsafeBlowOutInPlaceResult",
+    "UnsafeBlowOutInPlace",
+    "UnsafeBlowOutInPlaceCreate",
+    # Unsafe drop-tip command models
+    "UnsafeDropTipInPlaceCommandType",
+    "UnsafeDropTipInPlaceParams",
+    "UnsafeDropTipInPlaceResult",
+    "UnsafeDropTipInPlace",
+    "UnsafeDropTipInPlaceCreate",
+    # Update position estimate command models
+    "UpdatePositionEstimatorsCommandType",
+    "UpdatePositionEstimatorsParams",
+    "UpdatePositionEstimatorsResult",
+    "UpdatePositionEstimators",
+    "UpdatePositionEstimatorsCreate",
+    # Unsafe engage axes
+    "UnsafeEngageAxesCommandType",
+    "UnsafeEngageAxesParams",
+    "UnsafeEngageAxesResult",
+    "UnsafeEngageAxes",
+    "UnsafeEngageAxesCreate",
+    # Unsafe ungrip labware
+    "UnsafeUngripLabwareCommandType",
+    "UnsafeUngripLabwareParams",
+    "UnsafeUngripLabwareResult",
+    "UnsafeUngripLabware",
+    "UnsafeUngripLabwareCreate",
+    # Unsafe place labware
+    "UnsafePlaceLabwareCommandType",
+    "UnsafePlaceLabwareParams",
+    "UnsafePlaceLabwareResult",
+    "UnsafePlaceLabware",
+    "UnsafePlaceLabwareCreate",
+    # Unsafe manual retrieve
+    "UnsafeFlexStackerManualRetrieveCommandType",
+    "UnsafeFlexStackerManualRetrieveParams",
+    "UnsafeFlexStackerManualRetrieveResult",
+    "UnsafeFlexStackerManualRetrieve",
+    "UnsafeFlexStackerManualRetrieveCreate",
+    # Unsafe flex stacker close latch
+    "UnsafeFlexStackerCloseLatchCommandType",
+    "UnsafeFlexStackerCloseLatchParams",
+    "UnsafeFlexStackerCloseLatchResult",
+    "UnsafeFlexStackerCloseLatch",
+    "UnsafeFlexStackerCloseLatchCreate",
+    # Unsafe flex stacker open latch
+    "UnsafeFlexStackerOpenLatchCommandType",
+    "UnsafeFlexStackerOpenLatchParams",
+    "UnsafeFlexStackerOpenLatchResult",
+    "UnsafeFlexStackerOpenLatch",
+    "UnsafeFlexStackerOpenLatchCreate",
+    # Unsafe flex stacker prepare shuttle
+    "UnsafeFlexStackerPrepareShuttleCommandType",
+    "UnsafeFlexStackerPrepareShuttleParams",
+    "UnsafeFlexStackerPrepareShuttleResult",
+    "UnsafeFlexStackerPrepareShuttle",
+    "UnsafeFlexStackerPrepareShuttleCreate",
+]

opentrons/protocol_engine/commands/unsafe/unsafe_blow_out_in_place.py

@@ -0,0 +1,100 @@
+"""Command models to blow out in place while plunger positions are unknown."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type
+from typing_extensions import Literal
+
+from pydantic import BaseModel
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..pipetting_common import PipetteIdMixin, FlowRateMixin
+from ...resources import ensure_ot3_hardware
+from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.types import Axis
+
+if TYPE_CHECKING:
+    from ...execution import PipettingHandler
+    from ...state.state import StateView
+
+
+UnsafeBlowOutInPlaceCommandType = Literal["unsafe/blowOutInPlace"]
+
+
+class UnsafeBlowOutInPlaceParams(PipetteIdMixin, FlowRateMixin):
+    """Payload required to blow-out in place while position is unknown."""
+
+    pass
+
+
+class UnsafeBlowOutInPlaceResult(BaseModel):
+    """Result data from an UnsafeBlowOutInPlace command."""
+
+    pass
+
+
+class UnsafeBlowOutInPlaceImplementation(
+    AbstractCommandImpl[
+        UnsafeBlowOutInPlaceParams, SuccessData[UnsafeBlowOutInPlaceResult]
+    ]
+):
+    """UnsafeBlowOutInPlace command implementation."""
+
+    def __init__(
+        self,
+        pipetting: PipettingHandler,
+        state_view: StateView,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._pipetting = pipetting
+        self._state_view = state_view
+        self._hardware_api = hardware_api
+
+    async def execute(
+        self, params: UnsafeBlowOutInPlaceParams
+    ) -> SuccessData[UnsafeBlowOutInPlaceResult]:
+        """Blow-out without moving the pipette even when position is unknown."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        pipette_location = self._state_view.motion.get_pipette_location(
+            params.pipetteId
+        )
+        await ot3_hardware_api.update_axis_position_estimations(
+            [Axis.of_main_tool_actuator(pipette_location.mount.to_hw_mount())]
+        )
+        await self._pipetting.blow_out_in_place(
+            pipette_id=params.pipetteId, flow_rate=params.flowRate
+        )
+        state_update = update_types.StateUpdate()
+        state_update.set_fluid_empty(pipette_id=params.pipetteId)
+        state_update.set_pipette_ready_to_aspirate(
+            pipette_id=params.pipetteId, ready_to_aspirate=False
+        )
+        return SuccessData(
+            public=UnsafeBlowOutInPlaceResult(), state_update=state_update
+        )
+
+
+class UnsafeBlowOutInPlace(
+    BaseCommand[UnsafeBlowOutInPlaceParams, UnsafeBlowOutInPlaceResult, ErrorOccurrence]
+):
+    """UnsafeBlowOutInPlace command model."""
+
+    commandType: UnsafeBlowOutInPlaceCommandType = "unsafe/blowOutInPlace"
+    params: UnsafeBlowOutInPlaceParams
+    result: Optional[UnsafeBlowOutInPlaceResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeBlowOutInPlaceImplementation
+    ] = UnsafeBlowOutInPlaceImplementation
+
+
+class UnsafeBlowOutInPlaceCreate(BaseCommandCreate[UnsafeBlowOutInPlaceParams]):
+    """UnsafeBlowOutInPlace command request model."""
+
+    commandType: UnsafeBlowOutInPlaceCommandType = "unsafe/blowOutInPlace"
+    params: UnsafeBlowOutInPlaceParams
+
+    _CommandCls: Type[UnsafeBlowOutInPlace] = UnsafeBlowOutInPlace

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -0,0 +1,121 @@
+"""Command models to drop tip in place while plunger positions are unknown."""
+
+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 opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.types import Axis
+
+from opentrons.protocol_engine.state.update_types import StateUpdate
+from ..pipetting_common import PipetteIdMixin
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+
+if TYPE_CHECKING:
+    from ...execution import TipHandler
+    from ...state.state import StateView
+
+
+UnsafeDropTipInPlaceCommandType = Literal["unsafe/dropTipInPlace"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class UnsafeDropTipInPlaceParams(PipetteIdMixin):
+    """Payload required to drop a tip in place even if the plunger position is not known."""
+
+    homeAfter: bool | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "Whether to home this pipette's plunger after dropping the tip."
+            " You should normally leave this unspecified to let the robot choose"
+            " a safe default depending on its hardware."
+        ),
+        json_schema_extra=_remove_default,
+    )
+
+
+class UnsafeDropTipInPlaceResult(BaseModel):
+    """Result data from the execution of an UnsafeDropTipInPlace command."""
+
+    pass
+
+
+class UnsafeDropTipInPlaceImplementation(
+    AbstractCommandImpl[
+        UnsafeDropTipInPlaceParams, SuccessData[UnsafeDropTipInPlaceResult]
+    ]
+):
+    """Unsafe drop tip in place command implementation."""
+
+    def __init__(
+        self,
+        tip_handler: TipHandler,
+        state_view: StateView,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._tip_handler = tip_handler
+        self._hardware_api = hardware_api
+
+    async def execute(
+        self, params: UnsafeDropTipInPlaceParams
+    ) -> SuccessData[UnsafeDropTipInPlaceResult]:
+        """Drop a tip using the requested pipette, even if the plunger position is not known."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+        pipette_location = self._state_view.motion.get_pipette_location(
+            params.pipetteId
+        )
+        await ot3_hardware_api.update_axis_position_estimations(
+            [Axis.of_main_tool_actuator(pipette_location.mount.to_hw_mount())]
+        )
+        await self._tip_handler.drop_tip(
+            pipette_id=params.pipetteId,
+            home_after=params.homeAfter,
+            ignore_plunger=(
+                self._state_view.pipettes.get_active_channels(params.pipetteId) == 96
+            ),
+        )
+
+        state_update = StateUpdate()
+        state_update.update_pipette_tip_state(
+            pipette_id=params.pipetteId,
+            tip_geometry=None,
+            tip_source=None,
+        )
+        state_update.set_fluid_unknown(pipette_id=params.pipetteId)
+
+        return SuccessData(
+            public=UnsafeDropTipInPlaceResult(), state_update=state_update
+        )
+
+
+class UnsafeDropTipInPlace(
+    BaseCommand[UnsafeDropTipInPlaceParams, UnsafeDropTipInPlaceResult, ErrorOccurrence]
+):
+    """Drop tip in place command model."""
+
+    commandType: UnsafeDropTipInPlaceCommandType = "unsafe/dropTipInPlace"
+    params: UnsafeDropTipInPlaceParams
+    result: Optional[UnsafeDropTipInPlaceResult] = None
+
+    _ImplementationCls: Type[
+        UnsafeDropTipInPlaceImplementation
+    ] = UnsafeDropTipInPlaceImplementation
+
+
+class UnsafeDropTipInPlaceCreate(BaseCommandCreate[UnsafeDropTipInPlaceParams]):
+    """Drop tip in place command creation request model."""
+
+    commandType: UnsafeDropTipInPlaceCommandType = "unsafe/dropTipInPlace"
+    params: UnsafeDropTipInPlaceParams
+
+    _CommandCls: Type[UnsafeDropTipInPlace] = UnsafeDropTipInPlace