opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/execution/hardware_stopper.py

@@ -0,0 +1,147 @@
+"""Post-protocol hardware stopper."""
+import logging
+from typing import Optional
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.types import PipetteNotAttachedError as HwPipetteNotAttachedError
+
+from ..resources.ot3_validation import ensure_ot3_hardware
+from ..state.state import StateStore
+from ..types import MotorAxis, PostRunHardwareState
+from ..errors import HardwareNotSupportedError
+
+from .movement import MovementHandler
+from .gantry_mover import HardwareGantryMover
+from .tip_handler import TipHandler, HardwareTipHandler
+from ...hardware_control.types import OT3Mount
+
+from opentrons.protocol_engine.types import AddressableOffsetVector
+
+log = logging.getLogger(__name__)
+
+# TODO(mc, 2022-03-07): this constant dup'd from opentrons.protocols.geometry.deck
+# to avoid a circular dependency that needs to be figured out.
+FIXED_TRASH_ID = "fixedTrash"
+
+
+class HardwareStopper:
+    """Class to implement hardware stopping."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        state_store: StateStore,
+        movement: Optional[MovementHandler] = None,
+        tip_handler: Optional[TipHandler] = None,
+    ) -> None:
+        """Hardware stopper initializer."""
+        self._hardware_api = hardware_api
+        self._state_store = state_store
+        self._movement_handler = movement or MovementHandler(
+            hardware_api=hardware_api,
+            state_store=state_store,
+            gantry_mover=HardwareGantryMover(
+                hardware_api=hardware_api,
+                state_view=state_store,
+            ),
+        )
+        self._tip_handler = tip_handler or HardwareTipHandler(
+            hardware_api=hardware_api,
+            state_view=state_store,
+        )
+
+    async def _home_everything_except_plungers(self) -> None:
+        # TODO: Update this once gripper MotorAxis is available in engine.
+        try:
+            ot3api = ensure_ot3_hardware(hardware_api=self._hardware_api)
+            if (
+                not self._state_store.config.use_virtual_gripper
+                and ot3api.has_gripper()
+            ):
+                await ot3api.home_z(mount=OT3Mount.GRIPPER)
+        except HardwareNotSupportedError:
+            pass
+        await self._movement_handler.home(
+            axes=[MotorAxis.X, MotorAxis.Y, MotorAxis.LEFT_Z, MotorAxis.RIGHT_Z]
+        )
+
+    async def _try_to_drop_tips(self) -> None:
+        """Drop currently attached tip, if any, into trash after a run cancel."""
+        attached_tips = self._state_store.pipettes.get_all_attached_tips()
+
+        if attached_tips:
+            await self._hardware_api.stop(home_after=False)
+
+            await self._home_everything_except_plungers()
+
+            for pipette_id, tip in attached_tips:
+                try:
+                    if self._state_store.labware.get_fixed_trash_id() == FIXED_TRASH_ID:
+                        # OT-2 and Flex 2.15 protocols will default to the Fixed Trash Labware
+                        self._tip_handler.cache_tip(pipette_id=pipette_id, tip=tip)
+                        await self._movement_handler.move_to_well(
+                            pipette_id=pipette_id,
+                            labware_id=FIXED_TRASH_ID,
+                            well_name="A1",
+                        )
+                        await self._tip_handler.drop_tip(
+                            pipette_id=pipette_id,
+                            home_after=False,
+                        )
+                    elif self._state_store.config.robot_type == "OT-2 Standard":
+                        # API 2.16 and above OT2 protocols use addressable areas
+                        self._tip_handler.cache_tip(pipette_id=pipette_id, tip=tip)
+                        await self._movement_handler.move_to_addressable_area(
+                            pipette_id=pipette_id,
+                            addressable_area_name="fixedTrash",
+                            offset=AddressableOffsetVector(x=0, y=0, z=0),
+                            force_direct=False,
+                            speed=None,
+                            minimum_z_height=None,
+                        )
+                        await self._tip_handler.drop_tip(
+                            pipette_id=pipette_id,
+                            home_after=False,
+                        )
+                    else:
+                        log.debug(
+                            "Flex Protocols API Version 2.16 and beyond do not support automatic tip dropping at this time."
+                        )
+
+                except HwPipetteNotAttachedError:
+                    # this will happen normally during protocol analysis, but
+                    # should not happen during an actual run
+                    log.debug(f"Pipette ID {pipette_id} no longer attached.")
+
+    async def do_halt(self, disengage_before_stopping: bool = False) -> None:
+        """Issue a halt signal to the hardware API.
+
+        After issuing a halt, you must call do_stop_and_recover after
+        anything using the HardwareAPI has settled.
+        """
+        await self._hardware_api.halt(
+            disengage_before_stopping=disengage_before_stopping
+        )
+
+    async def do_stop_and_recover(
+        self,
+        post_run_hardware_state: PostRunHardwareState,
+        drop_tips_after_run: bool = False,
+    ) -> None:
+        """Stop and reset the HardwareAPI, homing and dropping tips independently if specified. If modules are attached that require recovery handle them."""
+        home_after_stop = post_run_hardware_state in (
+            PostRunHardwareState.HOME_AND_STAY_ENGAGED,
+            PostRunHardwareState.HOME_THEN_DISENGAGE,
+        )
+        try:
+            if drop_tips_after_run:
+                await self._try_to_drop_tips()
+
+            await self._hardware_api.stop(home_after=False)
+
+            if home_after_stop:
+                await self._home_everything_except_plungers()
+        finally:
+            # Ensure module state recovery is handled
+            for module in self._hardware_api.attached_modules:
+                module.cleanup_persistent()

opentrons/protocol_engine/execution/heater_shaker_movement_flagger.py

@@ -0,0 +1,207 @@
+"""Helpers for flagging unsafe movements around a Heater-Shaker Module."""
+
+from typing import List, Optional
+
+from opentrons.motion_planning.adjacent_slots_getters import (
+    get_east_west_slots,
+    get_north_south_slots,
+)
+
+from ..errors import (
+    PipetteMovementRestrictedByHeaterShakerError,
+    HeaterShakerLabwareLatchNotOpenError,
+    HeaterShakerLabwareLatchStatusUnknown,
+    WrongModuleTypeError,
+)
+from ..state.state import StateStore
+from ..state.module_substates import HeaterShakerModuleSubState
+from ..types import (
+    HeaterShakerMovementRestrictors,
+    HeaterShakerLatchStatus,
+    LabwareLocation,
+    ModuleLocation,
+)
+from ...hardware_control import HardwareControlAPI
+from ...hardware_control.modules import HeaterShaker as HardwareHeaterShaker
+from ...drivers.types import (
+    HeaterShakerLabwareLatchStatus as HeaterShakerHardwareLatchStatus,
+)
+
+
+class HeaterShakerMovementFlagger:
+    """A helper for flagging unsafe movements to a Heater-Shaker."""
+
+    def __init__(
+        self, state_store: StateStore, hardware_api: HardwareControlAPI
+    ) -> None:
+        self._state_store = state_store
+        self._hardware_api = hardware_api
+
+    async def raise_if_labware_latched_on_heater_shaker(
+        self, labware_parent: LabwareLocation
+    ) -> None:
+        """Flag unsafe movements to a heater-shaker.
+
+        If the given labware is on a heater-shaker, and that heater-shaker's labware
+        latch is not open according to the engine's h/s state as well as the
+        hardware API (for non-virtual modules), raises HeaterShakerLabwareLatchNotOpenError.
+        If it is a virtual module, checks only for heater-shaker latch state in engine.
+
+        Otherwise, no-ops.
+        """
+        if isinstance(labware_parent, ModuleLocation):
+            module_id = labware_parent.moduleId
+        else:
+            return  # Labware not on a module.
+        try:
+            hs_substate = self._state_store.modules.get_heater_shaker_module_substate(
+                module_id=module_id
+            )
+        except WrongModuleTypeError:
+            return  # Labware on a module, but not a Heater-Shaker.
+
+        if hs_substate.labware_latch_status == HeaterShakerLatchStatus.CLOSED:
+            raise HeaterShakerLabwareLatchNotOpenError(
+                "Heater-Shaker labware latch must be open when moving labware to/from it."
+            )
+        elif hs_substate.labware_latch_status == HeaterShakerLatchStatus.UNKNOWN:
+            raise HeaterShakerLabwareLatchStatusUnknown(
+                "Heater-Shaker labware latch must be opened before moving labware to/from it."
+            )
+
+        # There is a chance that the engine might not have the latest latch status;
+        # do a hardware state check to be sure that the latch is truly open
+        if not self._state_store.config.use_virtual_modules:
+            await self._check_hardware_module_latch_status(hs_substate)
+
+    async def _check_hardware_module_latch_status(
+        self, hs_substate: HeaterShakerModuleSubState
+    ) -> None:
+        try:
+            hs_latch_status = await self._get_hardware_heater_shaker_latch_status(
+                module_id=hs_substate.module_id
+            )
+        except self._HardwareHeaterShakerMissingError as e:
+            raise HeaterShakerLabwareLatchNotOpenError(
+                "Heater-Shaker labware latch must be open when moving labware to/from it,"
+                " but the latch status is unknown."
+            ) from e
+
+        if hs_latch_status != HeaterShakerHardwareLatchStatus.IDLE_OPEN:
+            raise HeaterShakerLabwareLatchNotOpenError(
+                f"Heater-Shaker labware latch must be open when moving labware to/from it,"
+                f" but the latch is currently {hs_latch_status}"
+            )
+
+    async def _get_hardware_heater_shaker_latch_status(
+        self,
+        module_id: str,
+    ) -> HeaterShakerHardwareLatchStatus:
+        """Get latch status of the hardware H/S corresponding with the module ID.
+
+        Returns:
+            Latch status of the requested attached heater-shaker.
+
+        Raises:
+            _HardwareHeaterShakerMissingError: If we can't find that H/S in
+                the hardware API, so we can't fetch its current latch status.
+                It's unclear if this can happen in practice...
+                maybe if the module disconnects between when it was loaded into
+                Protocol Engine and when this function is called?
+        """
+        hs_serial = self._state_store.modules.get_serial_number(module_id=module_id)
+        heater_shaker = await self._find_heater_shaker_by_serial(
+            serial_number=hs_serial
+        )
+        if heater_shaker is None:
+            raise self._HardwareHeaterShakerMissingError(
+                f"No Heater-Shaker found with serial number {hs_serial}"
+            )
+
+        latch_status = heater_shaker.labware_latch_status
+        # An attached H/S should always have latch status unless it's in error or
+        # it was just connected and hasn't been polled for status yet.
+        assert latch_status is not None, (
+            "Did not receive a valid latch status from heater-shaker. "
+            "Cannot verify safe labware movement."
+        )
+        return latch_status
+
+    async def _find_heater_shaker_by_serial(
+        self, serial_number: str
+    ) -> Optional[HardwareHeaterShaker]:
+        """Find the hardware H/S with the given serial number.
+
+        Returns:
+            The matching hardware H/S, or None if none was found.
+        """
+        for module in self._hardware_api.attached_modules:
+            # Different module types have different keys under .device_info.
+            # Heater-Shaker should always have .device_info["serial"].
+            if (
+                isinstance(module, HardwareHeaterShaker)
+                and module.device_info["serial"] == serial_number
+            ):
+                return module
+        return None
+
+    def raise_if_movement_restricted(
+        self,
+        hs_movement_restrictors: List[HeaterShakerMovementRestrictors],
+        destination_slot: int,
+        is_multi_channel: bool,
+        destination_is_tip_rack: bool,
+    ) -> None:
+        """Flag restricted movement around/to a Heater-Shaker."""
+        for hs_movement_restrictor in hs_movement_restrictors:
+            dest_east_west = destination_slot in get_east_west_slots(
+                hs_movement_restrictor.deck_slot
+            )
+            dest_north_south = destination_slot in get_north_south_slots(
+                hs_movement_restrictor.deck_slot
+            )
+            dest_heater_shaker = destination_slot == hs_movement_restrictor.deck_slot
+
+            # If Heater-Shaker is running, can't move to or around it
+            if (
+                any([dest_east_west, dest_north_south, dest_heater_shaker])
+                and hs_movement_restrictor.plate_shaking
+            ):
+                raise PipetteMovementRestrictedByHeaterShakerError(
+                    "Cannot move pipette to Heater-Shaker or adjacent slot while module is shaking"
+                )
+
+            # If Heater-Shaker's latch is open, can't move to it or east and west of it
+            elif hs_movement_restrictor.latch_status != HeaterShakerLatchStatus.CLOSED:
+                if dest_heater_shaker:
+                    raise PipetteMovementRestrictedByHeaterShakerError(
+                        f"Cannot move pipette to Heater-Shaker while labware latch"
+                        f" {'has not been closed' if hs_movement_restrictor.latch_status == HeaterShakerLatchStatus.UNKNOWN else 'is open'}."
+                    )
+                if (
+                    dest_east_west
+                    and self._state_store.config.robot_type == "OT-2 Standard"
+                ):
+                    raise PipetteMovementRestrictedByHeaterShakerError(
+                        "Cannot move pipette to left or right of Heater-Shaker while labware latch "
+                        f" {'has not been closed' if hs_movement_restrictor.latch_status == HeaterShakerLatchStatus.UNKNOWN else 'is open'}."
+                    )
+
+            elif (
+                is_multi_channel
+                and self._state_store.config.robot_type == "OT-2 Standard"
+            ):
+                # Can't go to east/west slot under any circumstances on OT-2
+                # if pipette is multi-channel
+                if dest_east_west:
+                    raise PipetteMovementRestrictedByHeaterShakerError(
+                        "Cannot move 8-Channel pipette to slot adjacent to the left or right of Heater-Shaker"
+                    )
+                # Can only go north/south if the labware is a tip rack
+                elif dest_north_south and not destination_is_tip_rack:
+                    raise PipetteMovementRestrictedByHeaterShakerError(
+                        "Cannot move 8-Channel pipette to non-tip-rack labware directly in front of or behind a Heater-Shaker"
+                    )
+
+    class _HardwareHeaterShakerMissingError(Exception):
+        pass

opentrons/protocol_engine/execution/labware_movement.py

@@ -0,0 +1,297 @@
+"""Labware movement command handling."""
+
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING, overload
+
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+from opentrons.types import Point
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.types import OT3Mount, Axis
+from opentrons.motion_planning import get_gripper_labware_movement_waypoints
+
+from opentrons.protocol_engine.state.state import StateStore
+from opentrons.protocol_engine.resources.ot3_validation import ensure_ot3_hardware
+
+from .thermocycler_movement_flagger import ThermocyclerMovementFlagger
+from .heater_shaker_movement_flagger import HeaterShakerMovementFlagger
+from .thermocycler_plate_lifter import ThermocyclerPlateLifter
+
+from ..errors import (
+    GripperNotAttachedError,
+    LabwareMovementNotAllowedError,
+    ThermocyclerNotOpenError,
+    HeaterShakerLabwareLatchNotOpenError,
+    CannotPerformGripperAction,
+)
+
+from ..types import (
+    OnLabwareLocation,
+    LabwareLocation,
+    OnDeckLabwareLocation,
+)
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
+
+_GRIPPER_HOMED_POSITION_Z = 166.125  # Height of the center of the gripper critical point from the deck when homed
+
+
+class LabwareMovementHandler:
+    """Implementation logic for labware movement."""
+
+    _hardware_api: HardwareControlAPI
+    _state_store: StateStore
+    _movement: MovementHandler
+    _equipment: EquipmentHandler
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        state_store: StateStore,
+        equipment: EquipmentHandler,
+        movement: MovementHandler,
+        thermocycler_plate_lifter: Optional[ThermocyclerPlateLifter] = None,
+        thermocycler_movement_flagger: Optional[ThermocyclerMovementFlagger] = None,
+        heater_shaker_movement_flagger: Optional[HeaterShakerMovementFlagger] = None,
+    ) -> None:
+        """Initialize a LabwareMovementHandler instance."""
+        self._hardware_api = hardware_api
+        self._state_store = state_store
+        self._equipment = equipment
+        self._thermocycler_plate_lifter = (
+            thermocycler_plate_lifter
+            or ThermocyclerPlateLifter(
+                state_store=self._state_store,
+                equipment=equipment,
+                movement=movement,
+            )
+        )
+        self._tc_movement_flagger = (
+            thermocycler_movement_flagger
+            or ThermocyclerMovementFlagger(
+                state_store=self._state_store,
+                hardware_api=self._hardware_api,
+                equipment=self._equipment
+                or EquipmentHandler(
+                    hardware_api=self._hardware_api,
+                    state_store=self._state_store,
+                ),
+            )
+        )
+        self._hs_movement_flagger = (
+            heater_shaker_movement_flagger
+            or HeaterShakerMovementFlagger(
+                state_store=self._state_store, hardware_api=self._hardware_api
+            )
+        )
+
+    @overload
+    async def move_labware_with_gripper(
+        self,
+        *,
+        labware_id: str,
+        current_location: OnDeckLabwareLocation,
+        new_location: OnDeckLabwareLocation,
+        user_pick_up_offset: Point,
+        user_drop_offset: Point,
+        post_drop_slide_offset: Optional[Point],
+    ) -> None:
+        ...
+
+    @overload
+    async def move_labware_with_gripper(
+        self,
+        *,
+        labware_definition: LabwareDefinition,
+        current_location: OnDeckLabwareLocation,
+        new_location: OnDeckLabwareLocation,
+        user_pick_up_offset: Point,
+        user_drop_offset: Point,
+        post_drop_slide_offset: Optional[Point],
+        gripper_z_offset: Optional[float],
+    ) -> None:
+        ...
+
+    async def move_labware_with_gripper(  # noqa: C901
+        self,
+        *,
+        labware_id: str | None = None,
+        labware_definition: LabwareDefinition | None = None,
+        current_location: OnDeckLabwareLocation,
+        new_location: OnDeckLabwareLocation,
+        user_pick_up_offset: Point,
+        user_drop_offset: Point,
+        post_drop_slide_offset: Optional[Point],
+        gripper_z_offset: Optional[float] = None,
+    ) -> None:
+        """Physically move a labware from one location to another using the gripper.
+
+        Generally, provide the `labware_id` of a loaded labware, and this method will
+        automatically look up its labware definition. If you're physically moving
+        something that has not been loaded as a labware (this is not common),
+        provide the `labware_definition` yourself instead.
+        """
+        use_virtual_gripper = self._state_store.config.use_virtual_gripper
+
+        if labware_definition is None:
+            assert labware_id is not None  # From this method's @typing.overloads.
+            labware_definition = self._state_store.labware.get_definition(labware_id)
+
+        from_labware_center = self._state_store.geometry.get_labware_grip_point(
+            labware_definition=labware_definition, location=current_location
+        )
+        to_labware_center = self._state_store.geometry.get_labware_grip_point(
+            labware_definition=labware_definition, location=new_location
+        )
+
+        if use_virtual_gripper:
+            # todo(mm, 2024-11-07): We should do this collision checking even when we
+            # only have a `labware_definition`, not a `labware_id`. Resolve when
+            # `check_gripper_labware_tip_collision()` can be made independent of `labware_id`.
+            if labware_id is not None:
+                self._state_store.geometry.check_gripper_labware_tip_collision(
+                    # During Analysis we will pass in hard coded estimates for certain positions only accessible during execution
+                    gripper_homed_position_z=_GRIPPER_HOMED_POSITION_Z,
+                    labware_id=labware_id,
+                    current_location=current_location,
+                )
+            return
+
+        ot3api = ensure_ot3_hardware(
+            hardware_api=self._hardware_api,
+            error_msg="Gripper is only available on Opentrons Flex",
+        )
+
+        if not ot3api.has_gripper():
+            raise GripperNotAttachedError(
+                "No gripper found for performing labware movements."
+            )
+        if not ot3api.gripper_jaw_can_home():
+            raise CannotPerformGripperAction(
+                "Cannot pick up labware when gripper is already gripping."
+            )
+
+        gripper_mount = OT3Mount.GRIPPER
+
+        # Retract all mounts
+        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
+        gripper_homed_position = await ot3api.gantry_position(mount=gripper_mount)
+
+        # todo(mm, 2024-11-07): We should do this collision checking even when we
+        # only have a `labware_definition`, not a `labware_id`. Resolve when
+        # `check_gripper_labware_tip_collision()` can be made independent of `labware_id`.
+        if labware_id is not None:
+            self._state_store.geometry.check_gripper_labware_tip_collision(
+                gripper_homed_position_z=gripper_homed_position.z,
+                labware_id=labware_id,
+                current_location=current_location,
+            )
+
+        async with self._thermocycler_plate_lifter.lift_plate_for_labware_movement(
+            labware_location=current_location
+        ):
+            final_offsets = (
+                self._state_store.geometry.get_final_labware_movement_offset_vectors(
+                    from_location=current_location,
+                    to_location=new_location,
+                    additional_pick_up_offset=user_pick_up_offset,
+                    additional_drop_offset=user_drop_offset,
+                    current_labware=labware_definition,
+                )
+            )
+            movement_waypoints = get_gripper_labware_movement_waypoints(
+                from_labware_center=from_labware_center,
+                to_labware_center=to_labware_center,
+                gripper_home_z=gripper_homed_position.z,
+                offset_data=final_offsets,
+                post_drop_slide_offset=post_drop_slide_offset,
+                gripper_home_z_offset=gripper_z_offset,
+            )
+            labware_grip_force = self._state_store.labware.get_grip_force(
+                labware_definition
+            )
+            holding_labware = False
+            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()
+                    holding_labware = True
+                    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)
+                else:
+                    await ot3api.grip(force_newtons=labware_grip_force)
+                    # we only want to check position after the gripper has opened and
+                    # should be holding labware
+                    if holding_labware:
+                        labware_bbox = self._state_store.labware.get_dimensions(
+                            labware_definition=labware_definition
+                        )
+                        well_bbox = self._state_store.labware.get_well_bbox(
+                            labware_definition=labware_definition
+                        )
+                        # todo(mm, 2024-09-26): This currently raises a lower-level 2015 FailedGripperPickupError.
+                        # Convert this to a higher-level 3001 LabwareDroppedError or 3002 LabwareNotPickedUpError,
+                        # depending on what waypoint we're at, to propagate a more specific error code to users.
+                        ot3api.raise_error_if_gripper_pickup_failed(
+                            expected_grip_width=labware_bbox.y,
+                            grip_width_uncertainty_wider=abs(
+                                max(well_bbox.y - labware_bbox.y, 0)
+                            ),
+                            grip_width_uncertainty_narrower=abs(
+                                min(well_bbox.y - labware_bbox.y, 0)
+                            ),
+                        )
+                await ot3api.move_to(
+                    mount=gripper_mount, abs_position=waypoint_data.position
+                )
+
+            # this makes sure gripper jaw is closed between two move labware calls
+            await ot3api.idle_gripper()
+
+    async def ensure_movement_not_obstructed_by_module(
+        self, labware_id: str, new_location: LabwareLocation
+    ) -> None:
+        """Ensure that the labware movement is not obstructed by a parent module.
+
+        Raises: LabwareMovementNotAllowedError if either current location or
+        new location is a module that is in a state that prevents the labware from
+        being moved (either manually or using gripper).
+        """
+        current_parent = self._state_store.labware.get_parent_location(
+            labware_id=labware_id
+        )
+        if isinstance(new_location, OnLabwareLocation):
+            new_location = self._state_store.labware.get_parent_location(
+                labware_id=new_location.labwareId
+            )
+        for parent in (current_parent, new_location):
+            try:
+                await self._tc_movement_flagger.ensure_labware_in_open_thermocycler(
+                    labware_parent=parent
+                )
+                if not self._state_store.labware.is_lid(labware_id):
+                    # Lid placement is actually improved by holding the labware latched on the H/S
+                    # So, we skip this check for lids.
+                    await self._hs_movement_flagger.raise_if_labware_latched_on_heater_shaker(
+                        labware_parent=parent
+                    )
+            except ThermocyclerNotOpenError:
+                raise LabwareMovementNotAllowedError(
+                    "Cannot move labware to or from a Thermocycler with its lid closed."
+                )
+            except HeaterShakerLabwareLatchNotOpenError:
+                raise LabwareMovementNotAllowedError(
+                    "Cannot move labware to or from a Heater-Shaker"
+                    " with its labware latch closed."
+                )