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

opentrons/protocol_engine/execution/labware_movement.py

@@ -1,7 +1,9 @@
 """Labware movement command handling."""
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, overload
+
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
 from opentrons.types import Point
 
@@ -79,24 +81,64 @@ class LabwareMovementHandler:
             )
         )
 
+    @overload
     async def move_labware_with_gripper(
         self,
+        *,
         labware_id: str,
         current_location: OnDeckLabwareLocation,
         new_location: OnDeckLabwareLocation,
         user_offset_data: LabwareMovementOffsetData,
         post_drop_slide_offset: Optional[Point],
     ) -> None:
-        """Move a loaded labware from one location to another using gripper."""
+        ...
+
+    @overload
+    async def move_labware_with_gripper(
+        self,
+        *,
+        labware_definition: LabwareDefinition,
+        current_location: OnDeckLabwareLocation,
+        new_location: OnDeckLabwareLocation,
+        user_offset_data: LabwareMovementOffsetData,
+        post_drop_slide_offset: Optional[Point],
+    ) -> 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_offset_data: LabwareMovementOffsetData,
+        post_drop_slide_offset: Optional[Point],
+    ) -> 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)
+
         if use_virtual_gripper:
-            # During Analysis we will pass in hard coded estimates for certain positions only accessible during execution
-            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,
-            )
+            # 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(
@@ -119,14 +161,16 @@ class LabwareMovementHandler:
         await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
         gripper_homed_position = await ot3api.gantry_position(mount=gripper_mount)
 
-        # Verify that no tip collisions will occur during the move
-        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,
-        )
+        # 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,
+            )
 
-        current_labware = self._state_store.labware.get_definition(labware_id)
         async with self._thermocycler_plate_lifter.lift_plate_for_labware_movement(
             labware_location=current_location
         ):
@@ -135,14 +179,14 @@ class LabwareMovementHandler:
                     from_location=current_location,
                     to_location=new_location,
                     additional_offset_vector=user_offset_data,
-                    current_labware=current_labware,
+                    current_labware=labware_definition,
                 )
             )
             from_labware_center = self._state_store.geometry.get_labware_grip_point(
-                labware_id=labware_id, location=current_location
+                labware_definition=labware_definition, location=current_location
             )
             to_labware_center = self._state_store.geometry.get_labware_grip_point(
-                labware_id=labware_id, location=new_location
+                labware_definition=labware_definition, location=new_location
             )
             movement_waypoints = get_gripper_labware_movement_waypoints(
                 from_labware_center=from_labware_center,
@@ -151,7 +195,9 @@ class LabwareMovementHandler:
                 offset_data=final_offsets,
                 post_drop_slide_offset=post_drop_slide_offset,
             )
-            labware_grip_force = self._state_store.labware.get_grip_force(labware_id)
+            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:
@@ -174,9 +220,11 @@ class LabwareMovementHandler:
                     # should be holding labware
                     if holding_labware:
                         labware_bbox = self._state_store.labware.get_dimensions(
-                            labware_id
+                            labware_definition=labware_definition
+                        )
+                        well_bbox = self._state_store.labware.get_well_bbox(
+                            labware_definition=labware_definition
                         )
-                        well_bbox = self._state_store.labware.get_well_bbox(labware_id)
                         # 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.

opentrons/protocol_engine/execution/movement.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 import logging
 from typing import Optional, List, Union
 
-from opentrons.types import Point, MountType
+from opentrons.types import Point, MountType, StagingSlotName
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons_shared_data.errors.exceptions import PositionUnknownError
+from opentrons.protocol_engine.errors import LocationIsStagingSlotError
 
 from ..types import (
     WellLocation,
@@ -93,9 +94,13 @@ class MovementHandler:
             self._state_store.modules.get_heater_shaker_movement_restrictors()
         )
 
-        dest_slot_int = self._state_store.geometry.get_ancestor_slot_name(
-            labware_id
-        ).as_int()
+        ancestor = self._state_store.geometry.get_ancestor_slot_name(labware_id)
+        if isinstance(ancestor, StagingSlotName):
+            raise LocationIsStagingSlotError(
+                "Cannot move to well on labware in Staging Area Slot."
+            )
+
+        dest_slot_int = ancestor.as_int()
 
         self._hs_movement_flagger.raise_if_movement_restricted(
             hs_movement_restrictors=hs_movement_restrictors,

opentrons/protocol_engine/protocol_engine.py

@@ -59,7 +59,6 @@ from .actions import (
     HardwareStoppedAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
-    AddAbsorbanceReaderLidAction,
 )
 
 
@@ -577,12 +576,6 @@ class ProtocolEngine:
             AddAddressableAreaAction(addressable_area=area)
         )
 
-    def add_absorbance_reader_lid(self, module_id: str, lid_id: str) -> None:
-        """Add an absorbance reader lid to the module state."""
-        self._action_dispatcher.dispatch(
-            AddAbsorbanceReaderLidAction(module_id=module_id, lid_id=lid_id)
-        )
-
     def reset_tips(self, labware_id: str) -> None:
         """Reset the tip state of a given labware."""
         # TODO(mm, 2023-03-10): Safely raise an error if the given labware isn't a

opentrons/protocol_engine/resources/deck_data_provider.py

@@ -17,11 +17,9 @@ from ..types import (
     DeckSlotLocation,
     DeckType,
     LabwareLocation,
-    AddressableAreaLocation,
     DeckConfigurationType,
 )
 from .labware_data_provider import LabwareDataProvider
-from ..resources import deck_configuration_provider
 
 
 @final
@@ -71,43 +69,6 @@ class DeckDataProvider:
             slot = cast(Optional[str], fixture.get("slot"))
 
             if (
-                deck_configuration is not None
-                and load_name is not None
-                and slot is not None
-                and slot not in DeckSlotName._value2member_map_
-            ):
-                # The provided slot is likely to be an addressable area for Module-required labware Eg: Plate Reader Lid
-                for (
-                    cutout_id,
-                    cutout_fixture_id,
-                    opentrons_module_serial_number,
-                ) in deck_configuration:
-                    provided_addressable_areas = (
-                        deck_configuration_provider.get_provided_addressable_area_names(
-                            cutout_fixture_id=cutout_fixture_id,
-                            cutout_id=cutout_id,
-                            deck_definition=deck_definition,
-                        )
-                    )
-                    if slot in provided_addressable_areas:
-                        addressable_area_location = AddressableAreaLocation(
-                            addressableAreaName=slot
-                        )
-                        definition = await self._labware_data.get_labware_definition(
-                            load_name=load_name,
-                            namespace="opentrons",
-                            version=1,
-                        )
-
-                        labware.append(
-                            DeckFixedLabware(
-                                labware_id=labware_id,
-                                definition=definition,
-                                location=addressable_area_location,
-                            )
-                        )
-
-            elif (
                 load_fixed_trash
                 and load_name is not None
                 and slot is not None

opentrons/protocol_engine/resources/file_provider.py

@@ -66,7 +66,7 @@ class PlateReaderData(BaseModel):
                 row.append(str(measurement.data[f"{plate_alpharows[i]}{j+1}"]))
             rows.append(row)
         for i in range(3):
-            rows.append([""])
+            rows.append([])
         rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
         for i in range(8):
             row = [plate_alpharows[i]]
@@ -74,7 +74,7 @@ class PlateReaderData(BaseModel):
                 row.append("")
             rows.append(row)
         for i in range(3):
-            rows.append([""])
+            rows.append([])
         rows.append(
             [
                 "",
@@ -86,7 +86,7 @@ class PlateReaderData(BaseModel):
             ]
         )
         for i in range(3):
-            rows.append([""])
+            rows.append([])
         rows.append(
             [
                 "",
@@ -100,7 +100,7 @@ class PlateReaderData(BaseModel):
         )
         rows.append(["1", "Sample 1", "", "", "", "1", "", "", "", "", "", ""])
         for i in range(3):
-            rows.append([""])
+            rows.append([])
 
         # end of file metadata
         rows.append(["Protocol"])
@@ -109,13 +109,17 @@ class PlateReaderData(BaseModel):
         if self.reference_wavelength is not None:
             rows.append(["Reference Wavelength (nm)", str(self.reference_wavelength)])
         rows.append(["Serial No.", self.serial_number])
-        rows.append(["Measurement started at", str(self.start_time)])
-        rows.append(["Measurement finished at", str(self.finish_time)])
+        rows.append(
+            ["Measurement started at", self.start_time.strftime("%m %d %H:%M:%S %Y")]
+        )
+        rows.append(
+            ["Measurement finished at", self.finish_time.strftime("%m %d %H:%M:%S %Y")]
+        )
 
         # Ensure the filename adheres to ruleset contains the wavelength for a given measurement
         if filename.endswith(".csv"):
             filename = filename[:-4]
-        filename = filename + "_" + str(measurement.wavelength) + ".csv"
+        filename = filename + str(measurement.wavelength) + "nm.csv"
 
         return GenericCsvTransform.build(
             filename=filename,

opentrons/protocol_engine/resources/fixture_validation.py

@@ -29,7 +29,12 @@ def is_drop_tip_waste_chute(addressable_area_name: str) -> bool:
 
 def is_trash(addressable_area_name: str) -> bool:
     """Check if an addressable area is a trash bin."""
-    return addressable_area_name in {"movableTrash", "fixedTrash", "shortFixedTrash"}
+    return any(
+        [
+            s in addressable_area_name
+            for s in {"movableTrash", "fixedTrash", "shortFixedTrash"}
+        ]
+    )
 
 
 def is_staging_slot(addressable_area_name: str) -> bool:

opentrons/protocol_engine/state/geometry.py

@@ -262,32 +262,33 @@ class GeometryView:
         return min_travel_z
 
     def get_labware_parent_nominal_position(self, labware_id: str) -> Point:
-        """Get the position of the labware's uncalibrated parent slot (deck, module, or another labware)."""
+        """Get the position of the labware's uncalibrated parent (deck slot, module, or another labware)."""
         try:
             addressable_area_name = self.get_ancestor_slot_name(labware_id).id
         except errors.LocationIsStagingSlotError:
             addressable_area_name = self._get_staging_slot_name(labware_id)
         except errors.LocationIsLidDockSlotError:
             addressable_area_name = self._get_lid_dock_slot_name(labware_id)
-        slot_pos = self._addressable_areas.get_addressable_area_position(
+        parent_pos = self._addressable_areas.get_addressable_area_position(
             addressable_area_name
         )
-        labware_data = self._labware.get(labware_id)
 
-        offset = self._get_labware_position_offset(labware_id, labware_data.location)
+        offset_from_parent = self._get_offset_from_parent(
+            child_definition=self._labware.get_definition(labware_id),
+            parent=self._labware.get(labware_id).location,
+        )
 
         return Point(
-            slot_pos.x + offset.x,
-            slot_pos.y + offset.y,
-            slot_pos.z + offset.z,
+            parent_pos.x + offset_from_parent.x,
+            parent_pos.y + offset_from_parent.y,
+            parent_pos.z + offset_from_parent.z,
         )
 
-    def _get_labware_position_offset(
-        self, labware_id: str, labware_location: LabwareLocation
+    def _get_offset_from_parent(
+        self, child_definition: LabwareDefinition, parent: LabwareLocation
     ) -> LabwareOffsetVector:
-        """Gets the offset vector of a labware on the given location.
+        """Gets the offset vector of a labware placed on the given location.
 
-        NOTE: Not to be confused with LPC offset.
         - For labware on Deck Slot: returns an offset of (0, 0, 0)
         - For labware on a Module: returns the nominal offset for the labware's position
           when placed on the specified module (using slot-transformed labwareOffset
@@ -298,40 +299,42 @@ class GeometryView:
           on modules as well as stacking overlaps.
           Does not include module calibration offset or LPC offset.
         """
-        if isinstance(labware_location, (AddressableAreaLocation, DeckSlotLocation)):
+        if isinstance(parent, (AddressableAreaLocation, DeckSlotLocation)):
             return LabwareOffsetVector(x=0, y=0, z=0)
-        elif isinstance(labware_location, ModuleLocation):
-            module_id = labware_location.moduleId
-            module_offset = self._modules.get_nominal_module_offset(
+        elif isinstance(parent, ModuleLocation):
+            module_id = parent.moduleId
+            module_to_child = self._modules.get_nominal_offset_to_child(
                 module_id=module_id, addressable_areas=self._addressable_areas
             )
             module_model = self._modules.get_connected_model(module_id)
             stacking_overlap = self._labware.get_module_overlap_offsets(
-                labware_id, module_model
+                child_definition, module_model
             )
             return LabwareOffsetVector(
-                x=module_offset.x - stacking_overlap.x,
-                y=module_offset.y - stacking_overlap.y,
-                z=module_offset.z - stacking_overlap.z,
+                x=module_to_child.x - stacking_overlap.x,
+                y=module_to_child.y - stacking_overlap.y,
+                z=module_to_child.z - stacking_overlap.z,
+            )
+        elif isinstance(parent, OnLabwareLocation):
+            on_labware = self._labware.get(parent.labwareId)
+            on_labware_dimensions = self._labware.get_dimensions(
+                labware_id=on_labware.id
             )
-        elif isinstance(labware_location, OnLabwareLocation):
-            on_labware = self._labware.get(labware_location.labwareId)
-            on_labware_dimensions = self._labware.get_dimensions(on_labware.id)
             stacking_overlap = self._labware.get_labware_overlap_offsets(
-                labware_id=labware_id, below_labware_name=on_labware.loadName
+                definition=child_definition, below_labware_name=on_labware.loadName
             )
             labware_offset = LabwareOffsetVector(
                 x=stacking_overlap.x,
                 y=stacking_overlap.y,
                 z=on_labware_dimensions.z - stacking_overlap.z,
             )
-            return labware_offset + self._get_labware_position_offset(
-                on_labware.id, on_labware.location
+            return labware_offset + self._get_offset_from_parent(
+                self._labware.get_definition(on_labware.id), on_labware.location
             )
         else:
             raise errors.LabwareNotOnDeckError(
-                f"Cannot access labware {labware_id} since it is not on the deck. "
-                f"Either it has been loaded off-deck or its been moved off-deck."
+                "Cannot access labware since it is not on the deck. "
+                "Either it has been loaded off-deck or its been moved off-deck."
             )
 
     def _normalize_module_calibration_offset(
@@ -709,10 +712,12 @@ class GeometryView:
         assert isinstance(labware_location, AddressableAreaLocation)
         return labware_location.addressableAreaName
 
-    def get_ancestor_slot_name(self, labware_id: str) -> DeckSlotName:
+    def get_ancestor_slot_name(
+        self, labware_id: str
+    ) -> Union[DeckSlotName, StagingSlotName]:
         """Get the slot name of the labware or the module that the labware is on."""
         labware = self._labware.get(labware_id)
-        slot_name: DeckSlotName
+        slot_name: Union[DeckSlotName, StagingSlotName]
 
         if isinstance(labware.location, DeckSlotLocation):
             slot_name = labware.location.slotName
@@ -724,18 +729,14 @@ class GeometryView:
             slot_name = self.get_ancestor_slot_name(below_labware_id)
         elif isinstance(labware.location, AddressableAreaLocation):
             area_name = labware.location.addressableAreaName
-            # TODO we might want to eventually return some sort of staging slot name when we're ready to work through
-            #   the linting nightmare it will create
             if self._labware.is_absorbance_reader_lid(labware_id):
                 raise errors.LocationIsLidDockSlotError(
                     "Cannot get ancestor slot name for labware on lid dock slot."
                 )
-            if fixture_validation.is_staging_slot(area_name):
-                raise errors.LocationIsStagingSlotError(
-                    "Cannot get ancestor slot name for labware on staging slot."
-                )
-                raise errors.LocationIs
-            slot_name = DeckSlotName.from_primitive(area_name)
+            elif fixture_validation.is_staging_slot(area_name):
+                slot_name = StagingSlotName.from_primitive(area_name)
+            else:
+                slot_name = DeckSlotName.from_primitive(area_name)
         elif labware.location == OFF_DECK_LOCATION:
             raise errors.LabwareNotOnDeckError(
                 f"Labware {labware_id} does not have a slot associated with it"
@@ -768,7 +769,7 @@ class GeometryView:
 
     def get_labware_grip_point(
         self,
-        labware_id: str,
+        labware_definition: LabwareDefinition,
         location: Union[
             DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
         ],
@@ -784,7 +785,7 @@ class GeometryView:
         z-position of labware bottom + grip height from labware bottom.
         """
         grip_height_from_labware_bottom = (
-            self._labware.get_grip_height_from_labware_bottom(labware_id)
+            self._labware.get_grip_height_from_labware_bottom(labware_definition)
         )
         location_name: str
 
@@ -810,7 +811,9 @@ class GeometryView:
                 ).slotName.id
             else:  # OnLabwareLocation
                 location_name = self.get_ancestor_slot_name(location.labwareId).id
-            labware_offset = self._get_labware_position_offset(labware_id, location)
+            labware_offset = self._get_offset_from_parent(
+                child_definition=labware_definition, parent=location
+            )
             # Get the calibrated offset if the on labware location is on top of a module, otherwise return empty one
             cal_offset = self._get_calibrated_module_offset(location)
             offset = LabwareOffsetVector(
@@ -829,7 +832,9 @@ class GeometryView:
         )
 
     def get_extra_waypoints(
-        self, location: Optional[CurrentPipetteLocation], to_slot: DeckSlotName
+        self,
+        location: Optional[CurrentPipetteLocation],
+        to_slot: Union[DeckSlotName, StagingSlotName],
     ) -> List[Tuple[float, float]]:
         """Get extra waypoints for movement if thermocycler needs to be dodged."""
         if location is not None:
@@ -888,8 +893,10 @@ class GeometryView:
         return maybe_labware or maybe_module or maybe_fixture or None
 
     @staticmethod
-    def get_slot_column(slot_name: DeckSlotName) -> int:
+    def get_slot_column(slot_name: Union[DeckSlotName, StagingSlotName]) -> int:
         """Get the column number for the specified slot."""
+        if isinstance(slot_name, StagingSlotName):
+            return 4
         row_col_name = slot_name.to_ot3_equivalent()
         slot_name_match = WELL_NAME_PATTERN.match(row_col_name.value)
         assert (
@@ -1170,7 +1177,13 @@ class GeometryView:
                         )
 
                 assert isinstance(
-                    ancestor, (DeckSlotLocation, ModuleLocation, OnLabwareLocation)
+                    ancestor,
+                    (
+                        DeckSlotLocation,
+                        ModuleLocation,
+                        OnLabwareLocation,
+                        AddressableAreaLocation,
+                    ),
                 ), "No gripper offsets for off-deck labware"
                 return (
                     direct_parent_offset.pickUpOffset
@@ -1195,6 +1208,7 @@ class GeometryView:
                 extra_offset = LabwareOffsetVector(x=0, y=0, z=0)
                 if (
                     isinstance(ancestor, ModuleLocation)
+                    # todo(mm, 2024-11-06): Do not access private module state; only use public ModuleView methods.
                     and self._modules._state.requested_model_by_id[ancestor.moduleId]
                     == ModuleModel.THERMOCYCLER_MODULE_V2
                     and labware_validation.validate_definition_is_lid(current_labware)
@@ -1217,7 +1231,13 @@ class GeometryView:
                         )
 
                 assert isinstance(
-                    ancestor, (DeckSlotLocation, ModuleLocation, OnLabwareLocation)
+                    ancestor,
+                    (
+                        DeckSlotLocation,
+                        ModuleLocation,
+                        OnLabwareLocation,
+                        AddressableAreaLocation,
+                    ),
                 ), "No gripper offsets for off-deck labware"
                 return (
                     direct_parent_offset.dropOffset
@@ -1227,6 +1247,23 @@ class GeometryView:
                     + extra_offset
                 )
 
+    # todo(mm, 2024-11-05): This may be incorrect because it does not take the following
+    # offsets into account, which *are* taken into account for the actual gripper movement:
+    #
+    # * The pickup offset in the definition of the parent of the gripped labware.
+    # * The "additional offset" or "user offset", e.g. the `pickUpOffset` and `dropOffset`
+    #   params in the `moveLabware` command.
+    #
+    # And this *does* take these extra offsets into account:
+    #
+    # * The labware's Labware Position Check offset
+    #
+    # For robustness, we should combine this with `get_gripper_labware_movement_waypoints()`.
+    #
+    # We should also be more explicit about which offsets act to move the gripper paddles
+    # relative to the gripped labware, and which offsets act to change how the gripped
+    # labware sits atop its parent. Those have different effects on how far the gripped
+    # labware juts beyond the paddles while it's in transit.
     def check_gripper_labware_tip_collision(
         self,
         gripper_homed_position_z: float,
@@ -1234,18 +1271,22 @@ class GeometryView:
         current_location: OnDeckLabwareLocation,
     ) -> None:
         """Check for potential collision of tips against labware to be lifted."""
-        # TODO(cb, 2024-01-22): Remove the 1 and 8 channel special case once we are doing X axis validation
+        labware_definition = self._labware.get_definition(labware_id)
         pipettes = self._pipettes.get_all()
         for pipette in pipettes:
+            # TODO(cb, 2024-01-22): Remove the 1 and 8 channel special case once we are doing X axis validation
             if self._pipettes.get_channels(pipette.id) in [1, 8]:
                 return
 
             tip = self._pipettes.get_attached_tip(pipette.id)
             if tip:
+                # NOTE: This call to get_labware_highest_z() uses the labware's LPC offset,
+                # which is an inconsistency between this and the actual gripper movement.
+                # See the todo comment above this function.
                 labware_top_z_when_gripped = gripper_homed_position_z + (
                     self.get_labware_highest_z(labware_id=labware_id)
                     - self.get_labware_grip_point(
-                        labware_id=labware_id, location=current_location
+                        labware_definition=labware_definition, location=current_location
                     ).z
                 )
                 # TODO(cb, 2024-01-18): Utilizing the nozzle map and labware X coordinates verify if collisions will occur on the X axis (analysis will use hard coded data to measure from the gripper critical point to the pipette mount)
@@ -1253,7 +1294,7 @@ class GeometryView:
                     _PIPETTE_HOMED_POSITION_Z - tip.length
                 ) < labware_top_z_when_gripped:
                     raise LabwareMovementNotAllowedError(
-                        f"Cannot move labware '{self._labware.get(labware_id).loadName}' when {int(tip.volume)} µL tips are attached."
+                        f"Cannot move labware '{labware_definition.parameters.loadName}' when {int(tip.volume)} µL tips are attached."
                     )
         return
 
@@ -1293,6 +1334,7 @@ class GeometryView:
                 DeckSlotLocation,
                 ModuleLocation,
                 AddressableAreaLocation,
+                OnLabwareLocation,
             ),
         ), "No gripper offsets for off-deck labware"
 
@@ -1306,11 +1348,11 @@ class GeometryView:
             module_loc = self._modules.get_location(parent_location.moduleId)
             slot_name = module_loc.slotName
 
-        slot_based_offset = self._labware.get_labware_gripper_offsets(
+        slot_based_offset = self._labware.get_child_gripper_offsets(
             labware_id=labware_id, slot_name=slot_name.to_ot3_equivalent()
         )
 
-        return slot_based_offset or self._labware.get_labware_gripper_offsets(
+        return slot_based_offset or self._labware.get_child_gripper_offsets(
             labware_id=labware_id, slot_name=None
         )