opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0a1__py2.py3-none-any.whl

opentrons/protocol_engine/execution/equipment.py

@@ -1,6 +1,6 @@
 """Equipment command side-effect logic."""
 from dataclasses import dataclass
-from typing import Optional, overload, Union
+from typing import Optional, overload, Union, List
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 
@@ -152,10 +152,6 @@ class EquipmentHandler:
         Returns:
             A LoadedLabwareData object.
         """
-        labware_id = (
-            labware_id if labware_id is not None else self._model_utils.generate_id()
-        )
-
         definition_uri = uri_from_details(
             load_name=load_name,
             namespace=namespace,
@@ -172,6 +168,10 @@ class EquipmentHandler:
                 version=version,
             )
 
+        labware_id = (
+            labware_id if labware_id is not None else self._model_utils.generate_id()
+        )
+
         # Allow propagation of ModuleNotLoadedError.
         offset_id = self.find_applicable_labware_offset_id(
             labware_definition_uri=definition_uri,
@@ -379,6 +379,74 @@ class EquipmentHandler:
             definition=attached_module.definition,
         )
 
+    async def load_lids(
+        self,
+        load_name: str,
+        namespace: str,
+        version: int,
+        location: LabwareLocation,
+        quantity: int,
+    ) -> List[LoadedLabwareData]:
+        """Load one or many lid labware by assigning an identifier and pulling required data.
+
+        Args:
+            load_name: The lid labware's load name.
+            namespace: The lid labware's namespace.
+            version: The lid labware's version.
+            location: The deck location at which lid(s) will be placed.
+            labware_ids: An optional list of identifiers to assign the labware. If None,
+                an identifier will be generated.
+
+        Raises:
+            ModuleNotLoadedError: If `location` references a module ID
+                that doesn't point to a valid loaded module.
+
+        Returns:
+            A list of LoadedLabwareData objects.
+        """
+        definition_uri = uri_from_details(
+            load_name=load_name,
+            namespace=namespace,
+            version=version,
+        )
+        try:
+            # Try to use existing definition in state.
+            definition = self._state_store.labware.get_definition_by_uri(definition_uri)
+        except LabwareDefinitionDoesNotExistError:
+            definition = await self._labware_data_provider.get_labware_definition(
+                load_name=load_name,
+                namespace=namespace,
+                version=version,
+            )
+
+        stack_limit = definition.stackLimit if definition.stackLimit is not None else 1
+        if quantity > stack_limit:
+            raise ValueError(
+                f"Requested quantity {quantity} is greater than the stack limit of {stack_limit} provided by definition for {load_name}."
+            )
+
+        # Allow propagation of ModuleNotLoadedError.
+        if (
+            isinstance(location, DeckSlotLocation)
+            and definition.parameters.isDeckSlotCompatible is not None
+            and not definition.parameters.isDeckSlotCompatible
+        ):
+            raise ValueError(
+                f"Lid Labware {load_name} cannot be loaded onto a Deck Slot."
+            )
+
+        load_labware_data_list = []
+        for i in range(quantity):
+            load_labware_data_list.append(
+                LoadedLabwareData(
+                    labware_id=self._model_utils.generate_id(),
+                    definition=definition,
+                    offsetId=None,
+                )
+            )
+
+        return load_labware_data_list
+
     async def configure_for_volume(
         self, pipette_id: str, volume: float, tip_overlap_version: Optional[str]
     ) -> LoadedConfigureForVolumeData:

opentrons/protocol_engine/execution/gantry_mover.py

@@ -1,11 +1,18 @@
 """Gantry movement wrapper for hardware and simulation based movement."""
-from typing import Optional, List, Dict
+from logging import getLogger
+from opentrons.config.types import OT3Config
+from functools import partial
+from typing import Optional, List, Dict, Tuple
 from typing_extensions import Protocol as TypingProtocol
 
-from opentrons.types import Point, Mount
+from opentrons.types import Point, Mount, MountType
 
 from opentrons.hardware_control import HardwareControlAPI
-from opentrons.hardware_control.types import Axis as HardwareAxis
+from opentrons.hardware_control.types import Axis as HardwareAxis, CriticalPoint
+from opentrons.hardware_control.motion_utilities import (
+    target_axis_map_from_relative,
+    target_axis_map_from_absolute,
+)
 from opentrons_shared_data.errors.exceptions import PositionUnknownError
 
 from opentrons.motion_planning import Waypoint
@@ -14,6 +21,8 @@ from ..state.state import StateView
 from ..types import MotorAxis, CurrentWell
 from ..errors import MustHomeError, InvalidAxisForRobotType
 
+log = getLogger(__name__)
+
 
 _MOTOR_AXIS_TO_HARDWARE_AXIS: Dict[MotorAxis, HardwareAxis] = {
     MotorAxis.X: HardwareAxis.X,
@@ -24,8 +33,38 @@ _MOTOR_AXIS_TO_HARDWARE_AXIS: Dict[MotorAxis, HardwareAxis] = {
     MotorAxis.RIGHT_PLUNGER: HardwareAxis.C,
     MotorAxis.EXTENSION_Z: HardwareAxis.Z_G,
     MotorAxis.EXTENSION_JAW: HardwareAxis.G,
+    MotorAxis.AXIS_96_CHANNEL_CAM: HardwareAxis.Q,
+}
+
+_MOTOR_AXIS_TO_HARDWARE_MOUNT: Dict[MotorAxis, Mount] = {
+    MotorAxis.LEFT_Z: Mount.LEFT,
+    MotorAxis.RIGHT_Z: Mount.RIGHT,
+    MotorAxis.EXTENSION_Z: Mount.EXTENSION,
+}
+
+_HARDWARE_MOUNT_MOTOR_AXIS_TO: Dict[Mount, MotorAxis] = {
+    Mount.LEFT: MotorAxis.LEFT_Z,
+    Mount.RIGHT: MotorAxis.RIGHT_Z,
+    Mount.EXTENSION: MotorAxis.EXTENSION_Z,
+}
+
+_HARDWARE_AXIS_TO_MOTOR_AXIS: Dict[HardwareAxis, MotorAxis] = {
+    HardwareAxis.X: MotorAxis.X,
+    HardwareAxis.Y: MotorAxis.Y,
+    HardwareAxis.Z: MotorAxis.LEFT_Z,
+    HardwareAxis.A: MotorAxis.RIGHT_Z,
+    HardwareAxis.B: MotorAxis.LEFT_PLUNGER,
+    HardwareAxis.C: MotorAxis.RIGHT_PLUNGER,
+    HardwareAxis.P_L: MotorAxis.LEFT_PLUNGER,
+    HardwareAxis.P_R: MotorAxis.RIGHT_PLUNGER,
+    HardwareAxis.Z_L: MotorAxis.LEFT_Z,
+    HardwareAxis.Z_R: MotorAxis.RIGHT_Z,
+    HardwareAxis.Z_G: MotorAxis.EXTENSION_Z,
+    HardwareAxis.G: MotorAxis.EXTENSION_JAW,
+    HardwareAxis.Q: MotorAxis.AXIS_96_CHANNEL_CAM,
 }
 
+
 # The height of the bottom of the pipette nozzle at home position without any tips.
 # We rely on this being the same for every OT-3 pipette.
 #
@@ -36,6 +75,8 @@ _MOTOR_AXIS_TO_HARDWARE_AXIS: Dict[MotorAxis, HardwareAxis] = {
 # That OT3Simulator return value is what Protocol Engine uses for simulation when Protocol Engine
 # is configured to not virtualize pipettes, so this number should match it.
 VIRTUAL_MAX_OT3_HEIGHT = 248.0
+# This number was found by using the longest pipette's P1000V2 default configuration values.
+VIRTUAL_MAX_OT2_HEIGHT = 268.14
 
 
 class GantryMover(TypingProtocol):
@@ -50,16 +91,45 @@ class GantryMover(TypingProtocol):
         """Get the current position of the gantry."""
         ...
 
+    async def get_position_from_mount(
+        self,
+        mount: Mount,
+        critical_point: Optional[CriticalPoint] = None,
+        fail_on_not_homed: bool = False,
+    ) -> Point:
+        """Get the current position of the gantry based on the given mount."""
+        ...
+
     def get_max_travel_z(self, pipette_id: str) -> float:
         """Get the maximum allowed z-height for pipette movement."""
         ...
 
+    def get_max_travel_z_from_mount(self, mount: MountType) -> float:
+        """Get the maximum allowed z-height for mount movement."""
+        ...
+
+    async def move_axes(
+        self,
+        axis_map: Dict[MotorAxis, float],
+        critical_point: Optional[Dict[MotorAxis, float]] = None,
+        speed: Optional[float] = None,
+        relative_move: bool = False,
+    ) -> Dict[MotorAxis, float]:
+        """Move a set of axes a given distance."""
+        ...
+
     async def move_to(
         self, pipette_id: str, waypoints: List[Waypoint], speed: Optional[float]
     ) -> Point:
         """Move the hardware gantry to a waypoint."""
         ...
 
+    async def move_mount_to(
+        self, mount: Mount, waypoints: List[Waypoint], speed: Optional[float]
+    ) -> Point:
+        """Move the provided hardware mount to a waypoint."""
+        ...
+
     async def move_relative(
         self,
         pipette_id: str,
@@ -85,6 +155,16 @@ class GantryMover(TypingProtocol):
         """Transform an engine motor axis into a hardware axis."""
         ...
 
+    def pick_mount_from_axis_map(self, axis_map: Dict[MotorAxis, float]) -> Mount:
+        """Find a mount axis in the axis_map if it exists otherwise default to left mount."""
+        ...
+
+    def motor_axes_to_present_hardware_axes(
+        self, motor_axes: List[MotorAxis]
+    ) -> List[HardwareAxis]:
+        """Transform a list of engine axes into a list of hardware axes, filtering out non-present axes."""
+        ...
+
 
 class HardwareGantryMover(GantryMover):
     """Hardware API based gantry movement handler."""
@@ -93,10 +173,70 @@ class HardwareGantryMover(GantryMover):
         self._hardware_api = hardware_api
         self._state_view = state_view
 
+    def motor_axes_to_present_hardware_axes(
+        self, motor_axes: List[MotorAxis]
+    ) -> List[HardwareAxis]:
+        """Get hardware axes from engine axes while filtering out non-present axes."""
+        return [
+            self.motor_axis_to_hardware_axis(motor_axis)
+            for motor_axis in motor_axes
+            if self._hardware_api.axis_is_present(
+                self.motor_axis_to_hardware_axis(motor_axis)
+            )
+        ]
+
     def motor_axis_to_hardware_axis(self, motor_axis: MotorAxis) -> HardwareAxis:
         """Transform an engine motor axis into a hardware axis."""
         return _MOTOR_AXIS_TO_HARDWARE_AXIS[motor_axis]
 
+    def _hardware_axis_to_motor_axis(self, motor_axis: HardwareAxis) -> MotorAxis:
+        """Transform an hardware axis into a engine motor axis."""
+        return _HARDWARE_AXIS_TO_MOTOR_AXIS[motor_axis]
+
+    def _convert_axis_map_for_hw(
+        self, axis_map: Dict[MotorAxis, float]
+    ) -> Dict[HardwareAxis, float]:
+        """Transform an engine motor axis map to a hardware axis map."""
+        return {_MOTOR_AXIS_TO_HARDWARE_AXIS[ax]: dist for ax, dist in axis_map.items()}
+
+    def _critical_point_for(
+        self, mount: Mount, cp_override: Optional[Dict[MotorAxis, float]] = None
+    ) -> Point:
+        if cp_override:
+            return Point(
+                x=cp_override[MotorAxis.X],
+                y=cp_override[MotorAxis.Y],
+                z=cp_override[_HARDWARE_MOUNT_MOTOR_AXIS_TO[mount]],
+            )
+        else:
+            return self._hardware_api.critical_point_for(mount)
+
+    def _get_gantry_offsets_for_robot_type(
+        self,
+    ) -> Tuple[Point, Point, Optional[Point]]:
+        if isinstance(self._hardware_api.config, OT3Config):
+            return (
+                Point(*self._hardware_api.config.left_mount_offset),
+                Point(*self._hardware_api.config.right_mount_offset),
+                Point(*self._hardware_api.config.gripper_mount_offset),
+            )
+        else:
+            return (
+                Point(*self._hardware_api.config.left_mount_offset),
+                Point(0, 0, 0),
+                None,
+            )
+
+    def pick_mount_from_axis_map(self, axis_map: Dict[MotorAxis, float]) -> Mount:
+        """Find a mount axis in the axis_map if it exists otherwise default to left mount."""
+        found_mount = Mount.LEFT
+        mounts = list(_MOTOR_AXIS_TO_HARDWARE_MOUNT.keys())
+        for k in axis_map.keys():
+            if k in mounts:
+                found_mount = _MOTOR_AXIS_TO_HARDWARE_MOUNT[k]
+                break
+        return found_mount
+
     async def get_position(
         self,
         pipette_id: str,
@@ -114,12 +254,33 @@ class HardwareGantryMover(GantryMover):
             pipette_id=pipette_id,
             current_location=current_well,
         )
+        point = await self.get_position_from_mount(
+            mount=pipette_location.mount.to_hw_mount(),
+            critical_point=pipette_location.critical_point,
+            fail_on_not_homed=fail_on_not_homed,
+        )
+        return point
+
+    async def get_position_from_mount(
+        self,
+        mount: Mount,
+        critical_point: Optional[CriticalPoint] = None,
+        fail_on_not_homed: bool = False,
+    ) -> Point:
+        """Get the current position of the gantry based on the mount.
+
+        Args:
+            mount: The mount to get the position for.
+            critical_point: Optional parameter for getting instrument location data, effects critical point.
+            fail_on_not_homed: Raise PositionUnknownError if gantry position is not known.
+        """
         try:
-            return await self._hardware_api.gantry_position(
-                mount=pipette_location.mount.to_hw_mount(),
-                critical_point=pipette_location.critical_point,
+            point = await self._hardware_api.gantry_position(
+                mount=mount,
+                critical_point=critical_point,
                 fail_on_not_homed=fail_on_not_homed,
             )
+            return point
         except PositionUnknownError as e:
             raise MustHomeError(message=str(e), wrapping=[e])
 
@@ -129,8 +290,16 @@ class HardwareGantryMover(GantryMover):
         Args:
             pipette_id: Pipette ID to get max travel z-height for.
         """
-        hw_mount = self._state_view.pipettes.get_mount(pipette_id).to_hw_mount()
-        return self._hardware_api.get_instrument_max_height(mount=hw_mount)
+        mount = self._state_view.pipettes.get_mount(pipette_id)
+        return self.get_max_travel_z_from_mount(mount=mount)
+
+    def get_max_travel_z_from_mount(self, mount: MountType) -> float:
+        """Get the maximum allowed z-height for any mount movement.
+
+        Args:
+            mount: Mount to get max travel z-height for.
+        """
+        return self._hardware_api.get_instrument_max_height(mount=mount.to_hw_mount())
 
     async def move_to(
         self, pipette_id: str, waypoints: List[Waypoint], speed: Optional[float]
@@ -150,6 +319,88 @@ class HardwareGantryMover(GantryMover):
 
         return waypoints[-1].position
 
+    async def move_mount_to(
+        self, mount: Mount, waypoints: List[Waypoint], speed: Optional[float]
+    ) -> Point:
+        """Move the given hardware mount to a waypoint."""
+        assert len(waypoints) > 0, "Must have at least one waypoint"
+        for waypoint in waypoints:
+            log.info(f"The current waypoint moving is {waypoint}")
+            await self._hardware_api.move_to(
+                mount=mount,
+                abs_position=waypoint.position,
+                critical_point=waypoint.critical_point,
+                speed=speed,
+            )
+
+        return waypoints[-1].position
+
+    async def move_axes(
+        self,
+        axis_map: Dict[MotorAxis, float],
+        critical_point: Optional[Dict[MotorAxis, float]] = None,
+        speed: Optional[float] = None,
+        relative_move: bool = False,
+    ) -> Dict[MotorAxis, float]:
+        """Move a set of axes a given distance.
+
+        Args:
+            axis_map: The mapping of axes to command.
+            critical_point: A critical point override for axes
+            speed: Optional speed parameter for the move.
+            relative_move: Whether the axis map needs to be converted from a relative to absolute move.
+        """
+        try:
+            pos_hw = self._convert_axis_map_for_hw(axis_map)
+            mount = self.pick_mount_from_axis_map(axis_map)
+            if relative_move:
+                current_position = await self._hardware_api.current_position(
+                    mount, refresh=True
+                )
+                log.info(f"The current position of the robot is: {current_position}.")
+                converted_current_position_deck = (
+                    self._hardware_api.get_deck_from_machine(current_position)
+                )
+                log.info(f"The current position of the robot is: {current_position}.")
+
+                pos_hw = target_axis_map_from_relative(pos_hw, current_position)
+                log.info(
+                    f"The absolute position is: {pos_hw} and hw pos map is {pos_hw}."
+                )
+            log.info(f"The calculated move {pos_hw} and {mount}")
+            (
+                left_offset,
+                right_offset,
+                gripper_offset,
+            ) = self._get_gantry_offsets_for_robot_type()
+            absolute_pos = target_axis_map_from_absolute(
+                mount,
+                pos_hw,
+                partial(self._critical_point_for, cp_override=critical_point),
+                left_mount_offset=left_offset,
+                right_mount_offset=right_offset,
+                gripper_mount_offset=gripper_offset,
+            )
+            log.info(f"The prepped abs {absolute_pos}")
+            await self._hardware_api.move_axes(
+                position=absolute_pos,
+                speed=speed,
+            )
+
+        except PositionUnknownError as e:
+            raise MustHomeError(message=str(e), wrapping=[e])
+
+        current_position = await self._hardware_api.current_position(
+            mount, refresh=True
+        )
+        converted_current_position_deck = self._hardware_api.get_deck_from_machine(
+            current_position
+        )
+        return {
+            self._hardware_axis_to_motor_axis(ax): pos
+            for ax, pos in converted_current_position_deck.items()
+        }
+
     async def move_relative(
         self,
         pipette_id: str,
@@ -239,6 +490,16 @@ class VirtualGantryMover(GantryMover):
         """Transform an engine motor axis into a hardware axis."""
         return _MOTOR_AXIS_TO_HARDWARE_AXIS[motor_axis]
 
+    def pick_mount_from_axis_map(self, axis_map: Dict[MotorAxis, float]) -> Mount:
+        """Find a mount axis in the axis_map if it exists otherwise default to left mount."""
+        found_mount = Mount.LEFT
+        mounts = list(_MOTOR_AXIS_TO_HARDWARE_MOUNT.keys())
+        for k in axis_map.keys():
+            if k in mounts:
+                found_mount = _MOTOR_AXIS_TO_HARDWARE_MOUNT[k]
+                break
+        return found_mount
+
     async def get_position(
         self,
         pipette_id: str,
@@ -261,6 +522,31 @@ class VirtualGantryMover(GantryMover):
             origin = Point(x=0, y=0, z=0)
         return origin
 
+    async def get_position_from_mount(
+        self,
+        mount: Mount,
+        critical_point: Optional[CriticalPoint] = None,
+        fail_on_not_homed: bool = False,
+    ) -> Point:
+        """Get the current position of the gantry based on the mount.
+
+        Args:
+            mount: The mount to get the position for.
+            critical_point: Optional parameter for getting instrument location data, effects critical point.
+            fail_on_not_homed: Raise PositionUnknownError if gantry position is not known.
+        """
+        pipette = self._state_view.pipettes.get_by_mount(MountType[mount.name])
+        origin_deck_point = (
+            self._state_view.pipettes.get_deck_point(pipette.id) if pipette else None
+        )
+        if origin_deck_point is not None:
+            origin = Point(
+                x=origin_deck_point.x, y=origin_deck_point.y, z=origin_deck_point.z
+            )
+        else:
+            origin = Point(x=0, y=0, z=0)
+        return origin
+
     def get_max_travel_z(self, pipette_id: str) -> float:
         """Get the maximum allowed z-height for pipette movement.
 
@@ -278,6 +564,68 @@ class VirtualGantryMover(GantryMover):
         tip_length = tip.length if tip is not None else 0
         return instrument_height - tip_length
 
+    def get_max_travel_z_from_mount(self, mount: MountType) -> float:
+        """Get the maximum allowed z-height for mount."""
+        pipette = self._state_view.pipettes.get_by_mount(mount)
+        if self._state_view.config.robot_type == "OT-2 Standard":
+            instrument_height = (
+                self._state_view.pipettes.get_instrument_max_height_ot2(pipette.id)
+                if pipette
+                else VIRTUAL_MAX_OT2_HEIGHT
+            )
+        else:
+            instrument_height = VIRTUAL_MAX_OT3_HEIGHT
+        if pipette:
+            tip = self._state_view.pipettes.get_attached_tip(pipette_id=pipette.id)
+            tip_length = tip.length if tip is not None else 0.0
+        else:
+            tip_length = 0.0
+        return instrument_height - tip_length
+
+    async def move_axes(
+        self,
+        axis_map: Dict[MotorAxis, float],
+        critical_point: Optional[Dict[MotorAxis, float]] = None,
+        speed: Optional[float] = None,
+        relative_move: bool = False,
+    ) -> Dict[MotorAxis, float]:
+        """Move the give axes map. No-op in virtual implementation."""
+        mount = self.pick_mount_from_axis_map(axis_map)
+        current_position = await self.get_position_from_mount(mount)
+        updated_position = {}
+        if relative_move:
+            updated_position[MotorAxis.X] = (
+                axis_map.get(MotorAxis.X, 0.0) + current_position[0]
+            )
+            updated_position[MotorAxis.Y] = (
+                axis_map.get(MotorAxis.Y, 0.0) + current_position[1]
+            )
+            if mount == Mount.RIGHT:
+                updated_position[MotorAxis.RIGHT_Z] = (
+                    axis_map.get(MotorAxis.RIGHT_Z, 0.0) + current_position[2]
+                )
+            elif mount == Mount.EXTENSION:
+                updated_position[MotorAxis.EXTENSION_Z] = (
+                    axis_map.get(MotorAxis.EXTENSION_Z, 0.0) + current_position[2]
+                )
+            else:
+                updated_position[MotorAxis.LEFT_Z] = (
+                    axis_map.get(MotorAxis.LEFT_Z, 0.0) + current_position[2]
+                )
+        else:
+            critical_point = critical_point or {}
+            updated_position = {
+                ax: pos - critical_point.get(ax, 0.0) for ax, pos in axis_map.items()
+            }
+        return updated_position
+
+    async def move_mount_to(
+        self, mount: Mount, waypoints: List[Waypoint], speed: Optional[float]
+    ) -> Point:
+        """Move the hardware mount to a waypoint. No-op in virtual implementation."""
+        assert len(waypoints) > 0, "Must have at least one waypoint"
+        return waypoints[-1].position
+
     async def move_to(
         self, pipette_id: str, waypoints: List[Waypoint], speed: Optional[float]
     ) -> Point:
@@ -313,6 +661,14 @@ class VirtualGantryMover(GantryMover):
         """Retract the 'idle' mount if necessary."""
         pass
 
+    def motor_axes_to_present_hardware_axes(
+        self, motor_axes: List[MotorAxis]
+    ) -> List[HardwareAxis]:
+        """Get present hardware axes from a list of engine axes. In simulation, all axes are present."""
+        return [
+            self.motor_axis_to_hardware_axis(motor_axis) for motor_axis in motor_axes
+        ]
+
 
 def create_gantry_mover(
     state_view: StateView, hardware_api: HardwareControlAPI

opentrons/protocol_engine/execution/movement.py

@@ -149,6 +149,33 @@ class MovementHandler:
 
         return final_point
 
+    async def move_mount_to(
+        self, mount: MountType, destination: DeckPoint, speed: Optional[float] = None
+    ) -> Point:
+        """Move mount to a specific location on the deck."""
+        hw_mount = mount.to_hw_mount()
+        await self._gantry_mover.prepare_for_mount_movement(hw_mount)
+        origin = await self._gantry_mover.get_position_from_mount(mount=hw_mount)
+        max_travel_z = self._gantry_mover.get_max_travel_z_from_mount(mount=mount)
+
+        # calculate the movement's waypoints
+        waypoints = self._state_store.motion.get_movement_waypoints_to_coords(
+            origin=origin,
+            dest=Point(x=destination.x, y=destination.y, z=destination.z),
+            max_travel_z=max_travel_z,
+            direct=False,
+            additional_min_travel_z=None,
+        )
+
+        # move through the waypoints
+        final_point = await self._gantry_mover.move_mount_to(
+            mount=hw_mount,
+            waypoints=waypoints,
+            speed=speed,
+        )
+
+        return final_point
+
     async def move_to_addressable_area(
         self,
         pipette_id: str,

opentrons/protocol_engine/execution/pipetting.py

@@ -91,7 +91,11 @@ class HardwarePipettingHandler(PipettingHandler):
         )
 
     async def prepare_for_aspirate(self, pipette_id: str) -> None:
-        """Prepare for pipette aspiration."""
+        """Prepare for pipette aspiration.
+
+        Raises:
+            PipetteOverpressureError, propagated as-is from the hardware controller.
+        """
         hw_mount = self._state_view.pipettes.get_mount(pipette_id).to_hw_mount()
         await self._hardware_api.prepare_for_aspirate(mount=hw_mount)
 

opentrons/protocol_engine/execution/tip_handler.py

@@ -1,11 +1,12 @@
 """Tip pickup and drop procedures."""
+
 from typing import Optional, Dict
 from typing_extensions import Protocol as TypingProtocol
 
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.hardware_control.types import FailedTipStateCheck, InstrumentProbeType
 from opentrons.protocol_engine.errors.exceptions import PickUpTipTipNotAttachedError
-from opentrons.types import Mount
+from opentrons.types import Mount, NozzleConfigurationType
 
 from opentrons_shared_data.errors.exceptions import (
     CommandPreconditionViolated,
@@ -23,9 +24,6 @@ from ..errors import (
     ProtocolEngineError,
 )
 
-from opentrons.hardware_control.nozzle_manager import NozzleConfigurationType
-
-
 PRIMARY_NOZZLE_TO_ENDING_NOZZLE_MAP = {
     "A1": {"COLUMN": "H1", "ROW": "A12"},
     "H1": {"COLUMN": "A1", "ROW": "H12"},
@@ -326,8 +324,8 @@ class HardwareTipHandler(TipHandler):
         follow_singular_sensor: Optional[InstrumentProbeType] = None,
     ) -> None:
         """See documentation on abstract base class."""
-        nozzle_configuration = (
-            self._state_view.pipettes.state.nozzle_configuration_by_id[pipette_id]
+        nozzle_configuration = self._state_view.pipettes.get_nozzle_configuration(
+            pipette_id=pipette_id
         )
 
         # Configuration metrics by which tip presence checking is ignored

opentrons/protocol_engine/notes/notes.py

@@ -35,7 +35,7 @@ def make_error_recovery_debug_note(type: "ErrorRecoveryType") -> CommandNote:
     This is intended to be read by developers and support people, not computers.
     """
     message = f"Handling this command failure with {type.name}."
-    return CommandNote.construct(
+    return CommandNote.model_construct(
         noteKind="debugErrorRecovery",
         shortMessage=message,
         longMessage=message,