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

opentrons/protocol_engine/state/geometry.py

@@ -262,33 +262,32 @@ 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 (deck slot, module, or another labware)."""
+        """Get the position of the labware's uncalibrated parent slot (deck, 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)
-        parent_pos = self._addressable_areas.get_addressable_area_position(
+        slot_pos = self._addressable_areas.get_addressable_area_position(
             addressable_area_name
         )
+        labware_data = self._labware.get(labware_id)
 
-        offset_from_parent = self._get_offset_from_parent(
-            child_definition=self._labware.get_definition(labware_id),
-            parent=self._labware.get(labware_id).location,
-        )
+        offset = self._get_labware_position_offset(labware_id, labware_data.location)
 
         return Point(
-            parent_pos.x + offset_from_parent.x,
-            parent_pos.y + offset_from_parent.y,
-            parent_pos.z + offset_from_parent.z,
+            slot_pos.x + offset.x,
+            slot_pos.y + offset.y,
+            slot_pos.z + offset.z,
         )
 
-    def _get_offset_from_parent(
-        self, child_definition: LabwareDefinition, parent: LabwareLocation
+    def _get_labware_position_offset(
+        self, labware_id: str, labware_location: LabwareLocation
     ) -> LabwareOffsetVector:
-        """Gets the offset vector of a labware placed on the given location.
+        """Gets the offset vector of a labware 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
@@ -299,42 +298,40 @@ class GeometryView:
           on modules as well as stacking overlaps.
           Does not include module calibration offset or LPC offset.
         """
-        if isinstance(parent, (AddressableAreaLocation, DeckSlotLocation)):
+        if isinstance(labware_location, (AddressableAreaLocation, DeckSlotLocation)):
             return LabwareOffsetVector(x=0, y=0, z=0)
-        elif isinstance(parent, ModuleLocation):
-            module_id = parent.moduleId
-            module_to_child = self._modules.get_nominal_offset_to_child(
+        elif isinstance(labware_location, ModuleLocation):
+            module_id = labware_location.moduleId
+            module_offset = self._modules.get_nominal_module_offset(
                 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(
-                child_definition, module_model
+                labware_id, module_model
             )
             return LabwareOffsetVector(
-                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
+                x=module_offset.x - stacking_overlap.x,
+                y=module_offset.y - stacking_overlap.y,
+                z=module_offset.z - stacking_overlap.z,
             )
+        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(
-                definition=child_definition, below_labware_name=on_labware.loadName
+                labware_id=labware_id, 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_offset_from_parent(
-                self._labware.get_definition(on_labware.id), on_labware.location
+            return labware_offset + self._get_labware_position_offset(
+                on_labware.id, on_labware.location
             )
         else:
             raise errors.LabwareNotOnDeckError(
-                "Cannot access labware since it is not on the deck. "
-                "Either it has been loaded off-deck or its been moved off-deck."
+                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."
             )
 
     def _normalize_module_calibration_offset(
@@ -712,12 +709,10 @@ class GeometryView:
         assert isinstance(labware_location, AddressableAreaLocation)
         return labware_location.addressableAreaName
 
-    def get_ancestor_slot_name(
-        self, labware_id: str
-    ) -> Union[DeckSlotName, StagingSlotName]:
+    def get_ancestor_slot_name(self, labware_id: str) -> DeckSlotName:
         """Get the slot name of the labware or the module that the labware is on."""
         labware = self._labware.get(labware_id)
-        slot_name: Union[DeckSlotName, StagingSlotName]
+        slot_name: DeckSlotName
 
         if isinstance(labware.location, DeckSlotLocation):
             slot_name = labware.location.slotName
@@ -729,14 +724,18 @@ 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."
                 )
-            elif fixture_validation.is_staging_slot(area_name):
-                slot_name = StagingSlotName.from_primitive(area_name)
-            else:
-                slot_name = DeckSlotName.from_primitive(area_name)
+            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 labware.location == OFF_DECK_LOCATION:
             raise errors.LabwareNotOnDeckError(
                 f"Labware {labware_id} does not have a slot associated with it"
@@ -769,7 +768,7 @@ class GeometryView:
 
     def get_labware_grip_point(
         self,
-        labware_definition: LabwareDefinition,
+        labware_id: str,
         location: Union[
             DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
         ],
@@ -785,7 +784,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_definition)
+            self._labware.get_grip_height_from_labware_bottom(labware_id)
         )
         location_name: str
 
@@ -811,9 +810,7 @@ class GeometryView:
                 ).slotName.id
             else:  # OnLabwareLocation
                 location_name = self.get_ancestor_slot_name(location.labwareId).id
-            labware_offset = self._get_offset_from_parent(
-                child_definition=labware_definition, parent=location
-            )
+            labware_offset = self._get_labware_position_offset(labware_id, 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(
@@ -832,9 +829,7 @@ class GeometryView:
         )
 
     def get_extra_waypoints(
-        self,
-        location: Optional[CurrentPipetteLocation],
-        to_slot: Union[DeckSlotName, StagingSlotName],
+        self, location: Optional[CurrentPipetteLocation], to_slot: DeckSlotName
     ) -> List[Tuple[float, float]]:
         """Get extra waypoints for movement if thermocycler needs to be dodged."""
         if location is not None:
@@ -893,10 +888,8 @@ class GeometryView:
         return maybe_labware or maybe_module or maybe_fixture or None
 
     @staticmethod
-    def get_slot_column(slot_name: Union[DeckSlotName, StagingSlotName]) -> int:
+    def get_slot_column(slot_name: DeckSlotName) -> 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 (
@@ -1177,13 +1170,7 @@ class GeometryView:
                         )
 
                 assert isinstance(
-                    ancestor,
-                    (
-                        DeckSlotLocation,
-                        ModuleLocation,
-                        OnLabwareLocation,
-                        AddressableAreaLocation,
-                    ),
+                    ancestor, (DeckSlotLocation, ModuleLocation, OnLabwareLocation)
                 ), "No gripper offsets for off-deck labware"
                 return (
                     direct_parent_offset.pickUpOffset
@@ -1208,7 +1195,6 @@ 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)
@@ -1231,13 +1217,7 @@ class GeometryView:
                         )
 
                 assert isinstance(
-                    ancestor,
-                    (
-                        DeckSlotLocation,
-                        ModuleLocation,
-                        OnLabwareLocation,
-                        AddressableAreaLocation,
-                    ),
+                    ancestor, (DeckSlotLocation, ModuleLocation, OnLabwareLocation)
                 ), "No gripper offsets for off-deck labware"
                 return (
                     direct_parent_offset.dropOffset
@@ -1247,23 +1227,6 @@ 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,
@@ -1271,22 +1234,18 @@ class GeometryView:
         current_location: OnDeckLabwareLocation,
     ) -> None:
         """Check for potential collision of tips against labware to be lifted."""
-        labware_definition = self._labware.get_definition(labware_id)
+        # TODO(cb, 2024-01-22): Remove the 1 and 8 channel special case once we are doing X axis validation
         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_definition=labware_definition, location=current_location
+                        labware_id=labware_id, 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)
@@ -1294,7 +1253,7 @@ class GeometryView:
                     _PIPETTE_HOMED_POSITION_Z - tip.length
                 ) < labware_top_z_when_gripped:
                     raise LabwareMovementNotAllowedError(
-                        f"Cannot move labware '{labware_definition.parameters.loadName}' when {int(tip.volume)} µL tips are attached."
+                        f"Cannot move labware '{self._labware.get(labware_id).loadName}' when {int(tip.volume)} µL tips are attached."
                     )
         return
 
@@ -1334,7 +1293,6 @@ class GeometryView:
                 DeckSlotLocation,
                 ModuleLocation,
                 AddressableAreaLocation,
-                OnLabwareLocation,
             ),
         ), "No gripper offsets for off-deck labware"
 
@@ -1348,11 +1306,11 @@ class GeometryView:
             module_loc = self._modules.get_location(parent_location.moduleId)
             slot_name = module_loc.slotName
 
-        slot_based_offset = self._labware.get_child_gripper_offsets(
+        slot_based_offset = self._labware.get_labware_gripper_offsets(
             labware_id=labware_id, slot_name=slot_name.to_ot3_equivalent()
         )
 
-        return slot_based_offset or self._labware.get_child_gripper_offsets(
+        return slot_based_offset or self._labware.get_labware_gripper_offsets(
             labware_id=labware_id, slot_name=None
         )
 

opentrons/protocol_engine/state/labware.py

@@ -13,7 +13,6 @@ from typing import (
     NamedTuple,
     cast,
     Union,
-    overload,
 )
 
 from opentrons.protocol_engine.state import update_types
@@ -82,10 +81,6 @@ _RIGHT_SIDE_SLOTS = {
 }
 
 
-# The max height of the labware that can fit in a plate reader
-_PLATE_READER_MAX_LABWARE_Z_MM = 16
-
-
 class LabwareLoadParams(NamedTuple):
     """Parameters required to load a labware in Protocol Engine."""
 
@@ -232,11 +227,10 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
             if labware_location_update.new_location:
                 new_location = labware_location_update.new_location
 
-                if isinstance(new_location, AddressableAreaLocation) and (
-                    fixture_validation.is_gripper_waste_chute(
-                        new_location.addressableAreaName
-                    )
-                    or fixture_validation.is_trash(new_location.addressableAreaName)
+                if isinstance(
+                    new_location, AddressableAreaLocation
+                ) and fixture_validation.is_gripper_waste_chute(
+                    new_location.addressableAreaName
                 ):
                     # If a labware has been moved into a waste chute it's been chuted away and is now technically off deck
                     new_location = OFF_DECK_LOCATION
@@ -631,26 +625,10 @@ class LabwareView(HasState[LabwareState]):
         definition = self.get_definition(labware_id)
         return definition.parameters.loadName
 
-    @overload
-    def get_dimensions(self, *, labware_definition: LabwareDefinition) -> Dimensions:
-        pass
-
-    @overload
-    def get_dimensions(self, *, labware_id: str) -> Dimensions:
-        pass
-
-    def get_dimensions(
-        self,
-        *,
-        labware_definition: LabwareDefinition | None = None,
-        labware_id: str | None = None,
-    ) -> Dimensions:
+    def get_dimensions(self, labware_id: str) -> Dimensions:
         """Get the labware's dimensions."""
-        if labware_definition is None:
-            assert labware_id is not None  # From our @overloads.
-            labware_definition = self.get_definition(labware_id)
-
-        dims = labware_definition.dimensions
+        definition = self.get_definition(labware_id)
+        dims = definition.dimensions
 
         return Dimensions(
             x=dims.xDimension,
@@ -659,9 +637,10 @@ class LabwareView(HasState[LabwareState]):
         )
 
     def get_labware_overlap_offsets(
-        self, definition: LabwareDefinition, below_labware_name: str
+        self, labware_id: str, below_labware_name: str
     ) -> OverlapOffset:
         """Get the labware's overlap with requested labware's load name."""
+        definition = self.get_definition(labware_id)
         if below_labware_name in definition.stackingOffsetWithLabware.keys():
             stacking_overlap = definition.stackingOffsetWithLabware.get(
                 below_labware_name, OverlapOffset(x=0, y=0, z=0)
@@ -675,9 +654,10 @@ class LabwareView(HasState[LabwareState]):
         )
 
     def get_module_overlap_offsets(
-        self, definition: LabwareDefinition, module_model: ModuleModel
+        self, labware_id: str, module_model: ModuleModel
     ) -> OverlapOffset:
         """Get the labware's overlap with requested module model."""
+        definition = self.get_definition(labware_id)
         stacking_overlap = definition.stackingOffsetWithModule.get(
             str(module_model.value)
         )
@@ -837,24 +817,6 @@ class LabwareView(HasState[LabwareState]):
                     f"Labware {labware.loadName} is already present at {location}."
                 )
 
-    def raise_if_labware_incompatible_with_plate_reader(
-        self,
-        labware_definition: LabwareDefinition,
-    ) -> None:
-        """Raise an error if the labware is not compatible with the plate reader."""
-        load_name = labware_definition.parameters.loadName
-        number_of_wells = len(labware_definition.wells)
-        if number_of_wells != 96:
-            raise errors.LabwareMovementNotAllowedError(
-                f"Cannot move '{load_name}' into plate reader because the"
-                f" labware contains {number_of_wells} wells where 96 wells is expected."
-            )
-        elif labware_definition.dimensions.zDimension > _PLATE_READER_MAX_LABWARE_Z_MM:
-            raise errors.LabwareMovementNotAllowedError(
-                f"Cannot move '{load_name}' into plate reader because the"
-                f" maximum allowed labware height is {_PLATE_READER_MAX_LABWARE_Z_MM}mm."
-            )
-
     def raise_if_labware_cannot_be_stacked(  # noqa: C901
         self, top_labware_definition: LabwareDefinition, bottom_labware_id: str
     ) -> None:
@@ -938,60 +900,22 @@ class LabwareView(HasState[LabwareState]):
             else None
         )
 
-    def get_absorbance_reader_lid_definition(self) -> LabwareDefinition:
-        """Return the special labware definition for the plate reader lid.
-
-        See todo comments in `create_protocol_engine().
-        """
-        # NOTE: This needs to stay in sync with create_protocol_engine().
-        return self._state.definitions_by_uri[
-            "opentrons/opentrons_flex_lid_absorbance_plate_reader_module/1"
-        ]
-
-    @overload
-    def get_child_gripper_offsets(
+    def get_labware_gripper_offsets(
         self,
-        *,
-        labware_definition: LabwareDefinition,
-        slot_name: Optional[DeckSlotName],
-    ) -> Optional[LabwareMovementOffsetData]:
-        pass
-
-    @overload
-    def get_child_gripper_offsets(
-        self, *, labware_id: str, slot_name: Optional[DeckSlotName]
-    ) -> Optional[LabwareMovementOffsetData]:
-        pass
-
-    def get_child_gripper_offsets(
-        self,
-        *,
-        labware_definition: Optional[LabwareDefinition] = None,
-        labware_id: Optional[str] = None,
+        labware_id: str,
         slot_name: Optional[DeckSlotName],
     ) -> Optional[LabwareMovementOffsetData]:
-        """Get the grip offsets that a labware says should be applied to children stacked atop it.
-
-        Params:
-            labware_id: The ID of a parent labware (atop which another labware, the child, will be stacked).
-            slot_name: The ancestor slot that the parent labware is ultimately loaded into,
-                       perhaps after going through a module in the middle.
+        """Get the labware's gripper offsets of the specified type.
 
         Returns:
-            If `slot_name` is provided, returns the gripper offsets that the parent labware definition
+            If `slot_name` is provided, returns the gripper offsets that the labware definition
             specifies just for that slot, or `None` if the labware definition doesn't have an
             exact match.
 
-            If `slot_name` is `None`, returns the gripper offsets that the parent labware
+            If `slot_name` is `None`, returns the gripper offsets that the labware
             definition designates as "default," or `None` if it doesn't designate any as such.
         """
-        if labware_id is not None:
-            labware_definition = self.get_definition(labware_id)
-        else:
-            # Should be ensured by our @overloads.
-            assert labware_definition is not None
-
-        parsed_offsets = labware_definition.gripperOffsets
+        parsed_offsets = self.get_definition(labware_id).gripperOffsets
         offset_key = slot_name.id if slot_name else "default"
 
         if parsed_offsets is None or offset_key not in parsed_offsets:
@@ -1006,22 +930,20 @@ class LabwareView(HasState[LabwareState]):
                 ),
             )
 
-    def get_grip_force(self, labware_definition: LabwareDefinition) -> float:
+    def get_grip_force(self, labware_id: str) -> float:
         """Get the recommended grip force for gripping labware using gripper."""
-        recommended_force = labware_definition.gripForce
+        recommended_force = self.get_definition(labware_id).gripForce
         return (
             recommended_force if recommended_force is not None else LABWARE_GRIP_FORCE
         )
 
-    def get_grip_height_from_labware_bottom(
-        self, labware_definition: LabwareDefinition
-    ) -> float:
+    def get_grip_height_from_labware_bottom(self, labware_id: str) -> float:
         """Get the recommended grip height from labware bottom, if present."""
-        recommended_height = labware_definition.gripHeightFromLabwareBottom
+        recommended_height = self.get_definition(labware_id).gripHeightFromLabwareBottom
         return (
             recommended_height
             if recommended_height is not None
-            else self.get_dimensions(labware_definition=labware_definition).z / 2
+            else self.get_dimensions(labware_id).z / 2
         )
 
     @staticmethod
@@ -1064,7 +986,7 @@ class LabwareView(HasState[LabwareState]):
     def _max_z_of_well(well_defn: WellDefinition) -> float:
         return well_defn.z + well_defn.depth
 
-    def get_well_bbox(self, labware_definition: LabwareDefinition) -> Dimensions:
+    def get_well_bbox(self, labware_id: str) -> Dimensions:
         """Get the bounding box implied by the wells.
 
         The bounding box of the labware that is implied by the wells is that required
@@ -1075,13 +997,14 @@ class LabwareView(HasState[LabwareState]):
         This is used for the specific purpose of finding the reasonable uncertainty bounds of
         where and how a gripper will interact with a labware.
         """
+        defn = self.get_definition(labware_id)
         max_x: Optional[float] = None
         min_x: Optional[float] = None
         max_y: Optional[float] = None
         min_y: Optional[float] = None
         max_z: Optional[float] = None
 
-        for well in labware_definition.wells.values():
+        for well in defn.wells.values():
             well_max_x = self._max_x_of_well(well)
             well_min_x = self._min_x_of_well(well)
             well_max_y = self._max_y_of_well(well)

opentrons/protocol_engine/state/module_substates/absorbance_reader_substate.py

@@ -9,9 +9,6 @@ AbsorbanceReaderLidId = NewType("AbsorbanceReaderLidId", str)
 AbsorbanceReaderMeasureMode = NewType("AbsorbanceReaderMeasureMode", str)
 
 
-# todo(mm, 2024-11-08): frozen=True is getting pretty painful because ModuleStore has
-# no type-safe way to modify just a single attribute. Consider unfreezing this
-# (taking care to ensure that consumers of ModuleView still only get a read-only view).
 @dataclass(frozen=True)
 class AbsorbanceReaderSubState:
     """Absorbance-Plate-Reader-specific state."""
@@ -24,6 +21,7 @@ class AbsorbanceReaderSubState:
     configured_wavelengths: Optional[List[int]]
     measure_mode: Optional[AbsorbanceReaderMeasureMode]
     reference_wavelength: Optional[int]
+    lid_id: Optional[str]
 
     def raise_if_lid_status_not_expected(self, lid_on_expected: bool) -> None:
         """Raise if the lid status is not correct."""