opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/touch_tip.py

@@ -4,6 +4,8 @@ from pydantic import Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.state import update_types
+
 from ..errors import TouchTipDisabledError, LabwareIsTipRackError
 from ..types import DeckPoint
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
@@ -16,7 +18,7 @@ from .pipetting_common import (
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, GantryMover
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 TouchTipCommandType = Literal["touchTip"]
@@ -48,7 +50,7 @@ class TouchTipResult(DestinationPositionResult):
 
 
 class TouchTipImplementation(
-    AbstractCommandImpl[TouchTipParams, SuccessData[TouchTipResult, None]]
+    AbstractCommandImpl[TouchTipParams, SuccessData[TouchTipResult]]
 ):
     """Touch tip command implementation."""
 
@@ -63,14 +65,14 @@ class TouchTipImplementation(
         self._movement = movement
         self._gantry_mover = gantry_mover
 
-    async def execute(
-        self, params: TouchTipParams
-    ) -> SuccessData[TouchTipResult, None]:
+    async def execute(self, params: TouchTipParams) -> SuccessData[TouchTipResult]:
         """Touch tip to sides of a well using the requested pipette."""
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
 
+        state_update = update_types.StateUpdate()
+
         if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
             raise TouchTipDisabledError(
                 f"Touch tip not allowed on labware {labware_id}"
@@ -98,14 +100,24 @@ class TouchTipImplementation(
             center_point=center_point,
         )
 
-        x, y, z = await self._gantry_mover.move_to(
+        final_point = await self._gantry_mover.move_to(
             pipette_id=pipette_id,
             waypoints=touch_waypoints,
             speed=touch_speed,
         )
+        final_deck_point = DeckPoint.construct(
+            x=final_point.x, y=final_point.y, z=final_point.z
+        )
+        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=DeckPoint(x=x, y=y, z=z)), private=None
+            public=TouchTipResult(position=final_deck_point),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/unsafe/__init__.py

@@ -31,6 +31,24 @@ from .unsafe_engage_axes import (
     UnsafeEngageAxesCreate,
 )
 
+from .unsafe_ungrip_labware import (
+    UnsafeUngripLabwareCommandType,
+    UnsafeUngripLabwareParams,
+    UnsafeUngripLabwareResult,
+    UnsafeUngripLabware,
+    UnsafeUngripLabwareCreate,
+)
+
+
+from .unsafe_place_labware import (
+    UnsafePlaceLabwareCommandType,
+    UnsafePlaceLabwareParams,
+    UnsafePlaceLabwareResult,
+    UnsafePlaceLabware,
+    UnsafePlaceLabwareCreate,
+)
+
+
 __all__ = [
     # Unsafe blow-out-in-place command models
     "UnsafeBlowOutInPlaceCommandType",
@@ -56,4 +74,16 @@ __all__ = [
     "UnsafeEngageAxesResult",
     "UnsafeEngageAxes",
     "UnsafeEngageAxesCreate",
+    # Unsafe ungrip labware
+    "UnsafeUngripLabwareCommandType",
+    "UnsafeUngripLabwareParams",
+    "UnsafeUngripLabwareResult",
+    "UnsafeUngripLabware",
+    "UnsafeUngripLabwareCreate",
+    # Unsafe place labware
+    "UnsafePlaceLabwareCommandType",
+    "UnsafePlaceLabwareParams",
+    "UnsafePlaceLabwareResult",
+    "UnsafePlaceLabware",
+    "UnsafePlaceLabwareCreate",
 ]

opentrons/protocol_engine/commands/unsafe/unsafe_blow_out_in_place.py

@@ -16,7 +16,7 @@ from opentrons.hardware_control.types import Axis
 
 if TYPE_CHECKING:
     from ...execution import PipettingHandler
-    from ...state import StateView
+    from ...state.state import StateView
 
 
 UnsafeBlowOutInPlaceCommandType = Literal["unsafe/blowOutInPlace"]
@@ -36,7 +36,7 @@ class UnsafeBlowOutInPlaceResult(BaseModel):
 
 class UnsafeBlowOutInPlaceImplementation(
     AbstractCommandImpl[
-        UnsafeBlowOutInPlaceParams, SuccessData[UnsafeBlowOutInPlaceResult, None]
+        UnsafeBlowOutInPlaceParams, SuccessData[UnsafeBlowOutInPlaceResult]
     ]
 ):
     """UnsafeBlowOutInPlace command implementation."""
@@ -54,7 +54,7 @@ class UnsafeBlowOutInPlaceImplementation(
 
     async def execute(
         self, params: UnsafeBlowOutInPlaceParams
-    ) -> SuccessData[UnsafeBlowOutInPlaceResult, None]:
+    ) -> 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(
@@ -67,7 +67,9 @@ class UnsafeBlowOutInPlaceImplementation(
             pipette_id=params.pipetteId, flow_rate=params.flowRate
         )
 
-        return SuccessData(public=UnsafeBlowOutInPlaceResult(), private=None)
+        return SuccessData(
+            public=UnsafeBlowOutInPlaceResult(),
+        )
 
 
 class UnsafeBlowOutInPlace(

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -1,5 +1,6 @@
 """Command models to drop tip in place while plunger positions are unknown."""
 from __future__ import annotations
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from pydantic import Field, BaseModel
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
@@ -14,7 +15,7 @@ from ...resources import ensure_ot3_hardware
 
 if TYPE_CHECKING:
     from ...execution import TipHandler
-    from ...state import StateView
+    from ...state.state import StateView
 
 
 UnsafeDropTipInPlaceCommandType = Literal["unsafe/dropTipInPlace"]
@@ -41,7 +42,7 @@ class UnsafeDropTipInPlaceResult(BaseModel):
 
 class UnsafeDropTipInPlaceImplementation(
     AbstractCommandImpl[
-        UnsafeDropTipInPlaceParams, SuccessData[UnsafeDropTipInPlaceResult, None]
+        UnsafeDropTipInPlaceParams, SuccessData[UnsafeDropTipInPlaceResult]
     ]
 ):
     """Unsafe drop tip in place command implementation."""
@@ -59,7 +60,7 @@ class UnsafeDropTipInPlaceImplementation(
 
     async def execute(
         self, params: UnsafeDropTipInPlaceParams
-    ) -> SuccessData[UnsafeDropTipInPlaceResult, None]:
+    ) -> 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(
@@ -72,7 +73,14 @@ class UnsafeDropTipInPlaceImplementation(
             pipette_id=params.pipetteId, home_after=params.homeAfter
         )
 
-        return SuccessData(public=UnsafeDropTipInPlaceResult(), private=None)
+        state_update = StateUpdate()
+        state_update.update_pipette_tip_state(
+            pipette_id=params.pipetteId, tip_geometry=None
+        )
+
+        return SuccessData(
+            public=UnsafeDropTipInPlaceResult(), state_update=state_update
+        )
 
 
 class UnsafeDropTipInPlace(

opentrons/protocol_engine/commands/unsafe/unsafe_engage_axes.py

@@ -32,7 +32,7 @@ class UnsafeEngageAxesResult(BaseModel):
 class UnsafeEngageAxesImplementation(
     AbstractCommandImpl[
         UnsafeEngageAxesParams,
-        SuccessData[UnsafeEngageAxesResult, None],
+        SuccessData[UnsafeEngageAxesResult],
     ]
 ):
     """Enable axes command implementation."""
@@ -48,7 +48,7 @@ class UnsafeEngageAxesImplementation(
 
     async def execute(
         self, params: UnsafeEngageAxesParams
-    ) -> SuccessData[UnsafeEngageAxesResult, None]:
+    ) -> SuccessData[UnsafeEngageAxesResult]:
         """Enable exes."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.engage_axes(
@@ -57,7 +57,9 @@ class UnsafeEngageAxesImplementation(
                 for axis in params.axes
             ]
         )
-        return SuccessData(public=UnsafeEngageAxesResult(), private=None)
+        return SuccessData(
+            public=UnsafeEngageAxesResult(),
+        )
 
 
 class UnsafeEngageAxes(

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -0,0 +1,194 @@
+"""Place labware payload, result, and implementaiton."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, Type, cast
+from typing_extensions import Literal
+
+from opentrons.hardware_control.types import Axis, OT3Mount
+from opentrons.motion_planning.waypoints import get_gripper_labware_placement_waypoints
+from opentrons.protocol_engine.errors.exceptions import (
+    CannotPerformGripperAction,
+    GripperNotAttachedError,
+)
+from opentrons.types import Point
+
+from ...types import DeckSlotLocation, ModuleModel, OnDeckLabwareLocation
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...resources import ensure_ot3_hardware
+from ...state.update_types import StateUpdate
+
+from opentrons.hardware_control import HardwareControlAPI, OT3HardwareControlAPI
+
+if TYPE_CHECKING:
+    from ...state.state import StateView
+    from ...execution.equipment import EquipmentHandler
+
+
+UnsafePlaceLabwareCommandType = Literal["unsafe/placeLabware"]
+
+
+class UnsafePlaceLabwareParams(BaseModel):
+    """Payload required for an UnsafePlaceLabware command."""
+
+    labwareId: str = Field(..., description="The id of the labware to place.")
+    location: OnDeckLabwareLocation = Field(
+        ..., description="Where to place the labware."
+    )
+
+
+class UnsafePlaceLabwareResult(BaseModel):
+    """Result data from the execution of an UnsafePlaceLabware command."""
+
+
+class UnsafePlaceLabwareImplementation(
+    AbstractCommandImpl[
+        UnsafePlaceLabwareParams,
+        SuccessData[UnsafePlaceLabwareResult],
+    ]
+):
+    """The UnsafePlaceLabware command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: UnsafePlaceLabwareParams
+    ) -> SuccessData[UnsafePlaceLabwareResult]:
+        """Place Labware.
+
+        This command is used only when the gripper is in the middle of moving
+        labware but is interrupted before completing the move. (i.e., the e-stop
+        is pressed, get into error recovery, etc).
+
+        Unlike the `moveLabware` command, where you pick a source and destination
+        location, this command takes the labwareId to be moved and location to
+        move it to.
+
+        """
+        ot3api = ensure_ot3_hardware(self._hardware_api)
+        if not ot3api.has_gripper():
+            raise GripperNotAttachedError("No gripper found to perform labware place.")
+
+        if ot3api.gripper_jaw_can_home():
+            raise CannotPerformGripperAction(
+                "Cannot place labware when gripper is not gripping."
+            )
+
+        # Allow propagation of LabwareNotLoadedError.
+        labware_id = params.labwareId
+        definition_uri = self._state_view.labware.get(labware_id).definitionUri
+        final_offsets = self._state_view.labware.get_labware_gripper_offsets(
+            labware_id, None
+        )
+        drop_offset = cast(Point, final_offsets.dropOffset) if final_offsets else None
+
+        if isinstance(params.location, DeckSlotLocation):
+            self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
+                params.location.slotName.id
+            )
+
+        location = self._state_view.geometry.ensure_valid_gripper_location(
+            params.location,
+        )
+
+        # This is an absorbance reader, move the lid to its dock (staging area).
+        if isinstance(location, DeckSlotLocation):
+            module = self._state_view.modules.get_by_slot(location.slotName)
+            if module and module.model == ModuleModel.ABSORBANCE_READER_V1:
+                location = self._state_view.modules.absorbance_reader_dock_location(
+                    module.id
+                )
+
+        new_offset_id = self._equipment.find_applicable_labware_offset_id(
+            labware_definition_uri=definition_uri,
+            labware_location=location,
+        )
+
+        # NOTE: When the estop is pressed, the gantry loses position,
+        # so the robot needs to home x, y to sync.
+        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G, Axis.X, Axis.Y])
+        state_update = StateUpdate()
+
+        # Place the labware down
+        await self._start_movement(ot3api, labware_id, location, drop_offset)
+
+        state_update.set_labware_location(
+            labware_id=labware_id,
+            new_location=location,
+            new_offset_id=new_offset_id,
+        )
+        return SuccessData(public=UnsafePlaceLabwareResult(), state_update=state_update)
+
+    async def _start_movement(
+        self,
+        ot3api: OT3HardwareControlAPI,
+        labware_id: str,
+        location: OnDeckLabwareLocation,
+        drop_offset: Optional[Point],
+    ) -> None:
+        gripper_homed_position = await ot3api.gantry_position(
+            mount=OT3Mount.GRIPPER,
+            refresh=True,
+        )
+
+        to_labware_center = self._state_view.geometry.get_labware_grip_point(
+            labware_id=labware_id, location=location
+        )
+
+        movement_waypoints = get_gripper_labware_placement_waypoints(
+            to_labware_center=to_labware_center,
+            gripper_home_z=gripper_homed_position.z,
+            drop_offset=drop_offset,
+        )
+
+        # start movement
+        for waypoint_data in movement_waypoints:
+            if waypoint_data.jaw_open:
+                if waypoint_data.dropping:
+                    # This `disengage_axes` step is important in order to engage
+                    # the electronic brake on the Z axis of the gripper. The brake
+                    # has a stronger holding force on the axis than the hold current,
+                    # and prevents the axis from spuriously dropping when  e.g. the notch
+                    # on the side of a falling tiprack catches the jaw.
+                    await ot3api.disengage_axes([Axis.Z_G])
+                await ot3api.ungrip()
+                if waypoint_data.dropping:
+                    # We lost the position estimation after disengaging the axis, so
+                    # it is necessary to home it next
+                    await ot3api.home_z(OT3Mount.GRIPPER)
+            await ot3api.move_to(
+                mount=OT3Mount.GRIPPER, abs_position=waypoint_data.position
+            )
+
+
+class UnsafePlaceLabware(
+    BaseCommand[UnsafePlaceLabwareParams, UnsafePlaceLabwareResult, ErrorOccurrence]
+):
+    """UnsafePlaceLabware command model."""
+
+    commandType: UnsafePlaceLabwareCommandType = "unsafe/placeLabware"
+    params: UnsafePlaceLabwareParams
+    result: Optional[UnsafePlaceLabwareResult]
+
+    _ImplementationCls: Type[
+        UnsafePlaceLabwareImplementation
+    ] = UnsafePlaceLabwareImplementation
+
+
+class UnsafePlaceLabwareCreate(BaseCommandCreate[UnsafePlaceLabwareParams]):
+    """UnsafePlaceLabware command request model."""
+
+    commandType: UnsafePlaceLabwareCommandType = "unsafe/placeLabware"
+    params: UnsafePlaceLabwareParams
+
+    _CommandCls: Type[UnsafePlaceLabware] = UnsafePlaceLabware

opentrons/protocol_engine/commands/unsafe/unsafe_ungrip_labware.py

@@ -0,0 +1,75 @@
+"""Ungrip labware payload, result, and implementaiton."""
+
+from __future__ import annotations
+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.ungrip()
+        return SuccessData(
+            public=UnsafeUngripLabwareResult(),
+        )
+
+
+class UnsafeUngripLabware(
+    BaseCommand[UnsafeUngripLabwareParams, UnsafeUngripLabwareResult, ErrorOccurrence]
+):
+    """UnsafeUngripLabware command model."""
+
+    commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
+    params: UnsafeUngripLabwareParams
+    result: Optional[UnsafeUngripLabwareResult]
+
+    _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

@@ -34,7 +34,7 @@ class UpdatePositionEstimatorsResult(BaseModel):
 class UpdatePositionEstimatorsImplementation(
     AbstractCommandImpl[
         UpdatePositionEstimatorsParams,
-        SuccessData[UpdatePositionEstimatorsResult, None],
+        SuccessData[UpdatePositionEstimatorsResult],
     ]
 ):
     """Update position estimators command implementation."""
@@ -50,7 +50,7 @@ class UpdatePositionEstimatorsImplementation(
 
     async def execute(
         self, params: UpdatePositionEstimatorsParams
-    ) -> SuccessData[UpdatePositionEstimatorsResult, None]:
+    ) -> 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(
@@ -59,7 +59,9 @@ class UpdatePositionEstimatorsImplementation(
                 for axis in params.axes
             ]
         )
-        return SuccessData(public=UpdatePositionEstimatorsResult(), private=None)
+        return SuccessData(
+            public=UpdatePositionEstimatorsResult(),
+        )
 
 
 class UpdatePositionEstimators(

opentrons/protocol_engine/commands/verify_tip_presence.py

@@ -36,9 +36,7 @@ class VerifyTipPresenceResult(BaseModel):
 
 
 class VerifyTipPresenceImplementation(
-    AbstractCommandImpl[
-        VerifyTipPresenceParams, SuccessData[VerifyTipPresenceResult, None]
-    ]
+    AbstractCommandImpl[VerifyTipPresenceParams, SuccessData[VerifyTipPresenceResult]]
 ):
     """VerifyTipPresence command implementation."""
 
@@ -51,7 +49,7 @@ class VerifyTipPresenceImplementation(
 
     async def execute(
         self, params: VerifyTipPresenceParams
-    ) -> SuccessData[VerifyTipPresenceResult, None]:
+    ) -> SuccessData[VerifyTipPresenceResult]:
         """Verify if tip presence is as expected for the requested pipette."""
         pipette_id = params.pipetteId
         expected_state = params.expectedState
@@ -67,7 +65,9 @@ class VerifyTipPresenceImplementation(
             follow_singular_sensor=follow_singular_sensor,
         )
 
-        return SuccessData(public=VerifyTipPresenceResult(), private=None)
+        return SuccessData(
+            public=VerifyTipPresenceResult(),
+        )
 
 
 class VerifyTipPresence(

opentrons/protocol_engine/commands/wait_for_duration.py

@@ -29,7 +29,7 @@ class WaitForDurationResult(BaseModel):
 
 
 class WaitForDurationImplementation(
-    AbstractCommandImpl[WaitForDurationParams, SuccessData[WaitForDurationResult, None]]
+    AbstractCommandImpl[WaitForDurationParams, SuccessData[WaitForDurationResult]]
 ):
     """Wait for duration command implementation."""
 
@@ -38,10 +38,12 @@ class WaitForDurationImplementation(
 
     async def execute(
         self, params: WaitForDurationParams
-    ) -> SuccessData[WaitForDurationResult, None]:
+    ) -> SuccessData[WaitForDurationResult]:
         """Wait for a duration of time."""
         await self._run_control.wait_for_duration(params.seconds)
-        return SuccessData(public=WaitForDurationResult(), private=None)
+        return SuccessData(
+            public=WaitForDurationResult(),
+        )
 
 
 class WaitForDuration(

opentrons/protocol_engine/commands/wait_for_resume.py

@@ -30,7 +30,7 @@ class WaitForResumeResult(BaseModel):
 
 
 class WaitForResumeImplementation(
-    AbstractCommandImpl[WaitForResumeParams, SuccessData[WaitForResumeResult, None]]
+    AbstractCommandImpl[WaitForResumeParams, SuccessData[WaitForResumeResult]]
 ):
     """Wait for resume command implementation."""
 
@@ -39,10 +39,12 @@ class WaitForResumeImplementation(
 
     async def execute(
         self, params: WaitForResumeParams
-    ) -> SuccessData[WaitForResumeResult, None]:
+    ) -> SuccessData[WaitForResumeResult]:
         """Dispatch a PauseAction to the store to pause the protocol."""
         await self._run_control.wait_for_resume()
-        return SuccessData(public=WaitForResumeResult(), private=None)
+        return SuccessData(
+            public=WaitForResumeResult(),
+        )
 
 
 class WaitForResume(