opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_engine/state/labware.py

@@ -52,11 +52,11 @@ from ..types import (
     LabwareOffsetLocationSequence,
     LegacyLabwareOffsetLocation,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
     LabwareLocation,
     LoadedLabware,
     ModuleLocation,
     OverlapOffset,
-    LabwareMovementOffsetData,
     OnDeckLabwareLocation,
     OFF_DECK_LOCATION,
 )
@@ -344,14 +344,18 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
         self, labware_id: str, new_location: LabwareLocation, new_offset_id: str | None
     ) -> None:
         self._state.labware_by_id[labware_id].offsetId = new_offset_id
-
         if isinstance(new_location, AddressableAreaLocation) and (
-            fixture_validation.is_gripper_waste_chute(new_location.addressableAreaName)
-            or fixture_validation.is_trash(new_location.addressableAreaName)
+            fixture_validation.is_trash(new_location.addressableAreaName)
         ):
-            # If a labware has been moved into a waste chute it's been chuted away and is now technically off deck
+            # TODO (RC, 2025-10-07: create a specific trash off deck location)
+            # If a labware has been moved into trash and is now technically off deck
             new_location = OFF_DECK_LOCATION
-
+        elif isinstance(
+            new_location, AddressableAreaLocation
+        ) and fixture_validation.is_gripper_waste_chute(
+            new_location.addressableAreaName
+        ):
+            new_location = WASTE_CHUTE_LOCATION
         self._state.labware_by_id[labware_id].location = new_location
 
     def _set_labware_location(self, state_update: update_types.StateUpdate) -> None:
@@ -401,7 +405,7 @@ class LabwareView:
             return self._state.labware_by_id[labware_id]
         except KeyError as e:
             raise errors.LabwareNotLoadedError(
-                f"Labware {labware_id} not found."
+                f"Labware with id {labware_id} not found."
             ) from e
 
     def known(self, labware_id: str) -> bool:
@@ -430,7 +434,7 @@ class LabwareView:
             ):
                 return labware.id
         raise errors.exceptions.LabwareNotLoadedOnLabwareError(
-            f"There is not labware loaded onto labware {labware_id}"
+            f"There is not labware loaded onto labware {self.get_display_name(labware_id)}"
         )
 
     def raise_if_labware_has_non_lid_labware_on_top(self, labware_id: str) -> None:
@@ -443,7 +447,8 @@ class LabwareView:
                 and candidate_id != lid_id
             ):
                 raise errors.LabwareIsInStackError(
-                    f"Cannot access labware {labware_id} because it has a non-lid labware stacked on top."
+                    f"Cannot access labware {self.get_display_name(labware_id)} because it has"
+                    " a non-lid labware stacked on top."
                 )
 
     def raise_if_labware_has_labware_on_top(self, labware_id: str) -> None:
@@ -454,16 +459,35 @@ class LabwareView:
                 and labware.location.labwareId == labware_id
             ):
                 raise errors.LabwareIsInStackError(
-                    f"Cannot access labware {labware_id} because it has another labware stacked on top."
+                    f"Cannot access labware {self.get_display_name(labware_id)} because it has"
+                    " another labware stacked on top."
                 )
 
+    def raise_if_not_tip_rack(self, labware_id: str) -> None:
+        """Raise if a labware is not a tip rack."""
+        if not self.is_tiprack(labware_id):
+            raise errors.LabwareIsNotTipRackError(
+                f"Labware {self.get_display_name(labware_id)} is not a tip rack and cannot have its well states set."
+            )
+
+    def raise_if_wells_are_invalid(
+        self, labware_id: str, well_names: List[str]
+    ) -> None:
+        """Raise if given wells do not exist with the given labware ID."""
+        non_existent_wells = set(well_names) - set(
+            self.get_definition(labware_id).wells
+        )
+        if non_existent_wells:
+            raise errors.WellDoesNotExistError(
+                f"Tip rack {self.get_display_name(labware_id)} does not have wells: {', '.join(non_existent_wells)}"
+            )
+
     def get_by_slot(
         self,
         slot_name: Union[DeckSlotName, StagingSlotName],
     ) -> Optional[LoadedLabware]:
         """Get the labware located in a given slot, if any."""
         loaded_labware = list(self._state.labware_by_id.values())
-
         for labware in loaded_labware:
             if (
                 isinstance(labware.location, DeckSlotLocation)
@@ -663,6 +687,14 @@ class LabwareView:
             or len(self.get_definition(labware_id).wells) >= 96
         )
 
+    def get_has_96_subwells(self, labware_id: str) -> bool:
+        """True if a labware is a reservoir with a 96-grid of sub-wells."""
+        return self.get_has_quirk(labware_id, "offsetPipetteFor96GridSubwells")
+
+    def get_has_12_subwells(self, labware_id: str) -> bool:
+        """True if a labware is a reservoir with a 12-grid of sub-wells."""
+        return self.get_has_quirk(labware_id, "offsetPipetteFor12GridSubwells")
+
     def get_well_definition(
         self,
         labware_id: str,
@@ -681,7 +713,7 @@ class LabwareView:
             return definition.wells[well_name]
         except KeyError as e:
             raise errors.WellDoesNotExistError(
-                f"{well_name} does not exist in {labware_id}."
+                f"{well_name} does not exist in {self.get_display_name(labware_id)}."
             ) from e
 
     def get_well_geometry(
@@ -691,19 +723,21 @@ class LabwareView:
         labware_def = self.get_definition(labware_id)
         if labware_def.innerLabwareGeometry is None:
             raise errors.IncompleteLabwareDefinitionError(
-                message=f"No innerLabwareGeometry found in labware definition for labware_id: {labware_id}."
+                message=f"No innerLabwareGeometry found in labware definition for {self.get_display_name(labware_id)}."
             )
         well_def = self.get_well_definition(labware_id, well_name)
         geometry_id = well_def.geometryDefinitionId
         if geometry_id is None:
             raise errors.IncompleteWellDefinitionError(
-                message=f"No geometryDefinitionId found in well definition for well: {well_name} in labware_id: {labware_id}"
+                message=f"No geometryDefinitionId found in well definition for well {well_name}"
+                f" for {self.get_display_name(labware_id)}"
             )
         else:
             well_geometry = labware_def.innerLabwareGeometry.get(geometry_id)
             if well_geometry is None:
                 raise errors.IncompleteLabwareDefinitionError(
-                    message=f"No innerLabwareGeometry found in labware definition for well_id: {geometry_id} in labware_id: {labware_id}"
+                    message=f"No innerLabwareGeometry found in labware definition for geometry id {geometry_id}"
+                    f" for {self.get_display_name(labware_id)}"
                 )
             return well_geometry
 
@@ -772,15 +806,15 @@ class LabwareView:
         contains_wells = all(well_name in labware_wells for well_name in iter(wells))
         if labware_definition.parameters.isTiprack:
             raise errors.LabwareIsTipRackError(
-                f"Given labware: {labware_id} is a tiprack. Can not load liquid."
+                f"Given labware {self.get_display_name(labware_id)} is a tip rack. Can not load liquid."
             )
         if LabwareRole.adapter in labware_definition.allowedRoles:
             raise errors.LabwareIsAdapterError(
-                f"Given labware: {labware_id} is an adapter. Can not load liquid."
+                f"Given labware {self.get_display_name(labware_id)} is an adapter. Can not load liquid."
             )
         if not contains_wells:
             raise errors.WellDoesNotExistError(
-                f"Some of the supplied wells do not match the labwareId: {labware_id}."
+                f"Some of the supplied wells do not match the labware {self.get_display_name(labware_id)}."
             )
         return list(wells)
 
@@ -789,7 +823,7 @@ class LabwareView:
         definition = self.get_definition(labware_id)
         if definition.parameters.tipLength is None:
             raise errors.LabwareIsNotTipRackError(
-                f"Labware {labware_id} has no tip length defined."
+                f"Labware {self.get_display_name(labware_id)} has no tip length defined."
             )
 
         return definition.parameters.tipLength - overlap
@@ -1095,7 +1129,9 @@ class LabwareView:
                 raise errors.LabwareCannotBeStackedError(
                     f"Labware {lid_labware_definition.parameters.loadName} cannot be used as a lid in the Flex Stacker."
                 )
-            if not labware_validation.validate_labware_can_be_stacked(
+            if isinstance(
+                lid_labware_definition, LabwareDefinition2
+            ) and not labware_validation.validate_legacy_labware_can_be_stacked(
                 lid_labware_definition, primary_labware_definition.parameters.loadName
             ):
                 raise errors.LabwareCannotBeStackedError(
@@ -1108,7 +1144,9 @@ class LabwareView:
                 raise errors.LabwareCannotBeStackedError(
                     f"Labware {adapter_labware_definition.parameters.loadName} cannot be used as an adapter in the Flex Stacker."
                 )
-            if not labware_validation.validate_labware_can_be_stacked(
+            if isinstance(
+                primary_labware_definition, LabwareDefinition2
+            ) and not labware_validation.validate_legacy_labware_can_be_stacked(
                 primary_labware_definition,
                 adapter_labware_definition.parameters.loadName,
             ):
@@ -1162,9 +1200,9 @@ class LabwareView:
         below_labware = self.get(bottom_labware_id)
         if isinstance(
             top_labware_definition, LabwareDefinition2
-        ) and not labware_validation.validate_labware_can_be_stacked(
-            top_labware_definition=top_labware_definition,
-            below_labware_load_name=below_labware.loadName,
+        ) and not labware_validation.validate_legacy_labware_can_be_stacked(
+            child_labware_definition=top_labware_definition,
+            parent_labware_load_name=below_labware.loadName,
         ):
             raise errors.LabwareCannotBeStackedError(
                 f"Labware {top_labware_definition.parameters.loadName} cannot be loaded onto labware {below_labware.loadName}"
@@ -1225,28 +1263,6 @@ class LabwareView:
         uri = self.get_uri_from_definition(self.get_definition(labware_id))
         return uri in _MAGDECK_HALF_MM_LABWARE
 
-    def get_deck_default_gripper_offsets(self) -> Optional[LabwareMovementOffsetData]:
-        """Get the deck's default gripper offsets."""
-        parsed_offsets = (
-            self.get_deck_definition().get("gripperOffsets", {}).get("default")
-        )
-        return (
-            LabwareMovementOffsetData(
-                pickUpOffset=LabwareOffsetVector(
-                    x=parsed_offsets["pickUpOffset"]["x"],
-                    y=parsed_offsets["pickUpOffset"]["y"],
-                    z=parsed_offsets["pickUpOffset"]["z"],
-                ),
-                dropOffset=LabwareOffsetVector(
-                    x=parsed_offsets["dropOffset"]["x"],
-                    y=parsed_offsets["dropOffset"]["y"],
-                    z=parsed_offsets["dropOffset"]["z"],
-                ),
-            )
-            if parsed_offsets
-            else None
-        )
-
     def get_absorbance_reader_lid_definition(self) -> LabwareDefinition:
         """Return the special labware definition for the plate reader lid.
 
@@ -1257,68 +1273,6 @@ class LabwareView:
             "opentrons/opentrons_flex_lid_absorbance_plate_reader_module/1"
         ]
 
-    @overload
-    def get_child_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,
-        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.
-
-        Returns:
-            If `slot_name` is provided, returns the gripper offsets that the parent 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
-            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
-        offset_key = slot_name.id if slot_name else "default"
-
-        if parsed_offsets is None or offset_key not in parsed_offsets:
-            return None
-        else:
-            return LabwareMovementOffsetData(
-                pickUpOffset=LabwareOffsetVector.model_construct(
-                    x=parsed_offsets[offset_key].pickUpOffset.x,
-                    y=parsed_offsets[offset_key].pickUpOffset.y,
-                    z=parsed_offsets[offset_key].pickUpOffset.z,
-                ),
-                dropOffset=LabwareOffsetVector.model_construct(
-                    x=parsed_offsets[offset_key].dropOffset.x,
-                    y=parsed_offsets[offset_key].dropOffset.y,
-                    z=parsed_offsets[offset_key].dropOffset.z,
-                ),
-            )
-
     def get_grip_force(self, labware_definition: LabwareDefinition) -> float:
         """Get the recommended grip force for gripping labware using gripper."""
         recommended_force = labware_definition.gripForce

opentrons/protocol_engine/state/labware_origin_math/errors.py

@@ -0,0 +1,94 @@
+"""Labware origin math errors."""
+
+from typing import Any, Dict, Optional, Sequence
+
+from opentrons.protocol_engine.errors import ProtocolEngineError
+from opentrons_shared_data.errors import ErrorCodes
+from opentrons_shared_data.errors.exceptions import EnumeratedError
+
+
+class LabwareLocatingFeatureError(ProtocolEngineError):
+    """Base class for errors related to labware locating features."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a LabwareLocatingFeatureError."""
+        super().__init__(
+            ErrorCodes.LABWARE_LOCATING_FEATURE_ERROR, message, details, wrapping
+        )
+
+
+class MissingLocatingFeatureError(LabwareLocatingFeatureError):
+    """Raised when a labware definition is missing a required locating feature."""
+
+    def __init__(
+        self,
+        labware_name: str,
+        required_feature: str,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a MissingLocatingFeatureError."""
+        if message is None:
+            message = f"Expected {labware_name} to have {required_feature} feature"
+
+        if details is None:
+            details = {
+                "labware_name": labware_name,
+                "required_feature": required_feature,
+            }
+
+        super().__init__(message, details, wrapping)
+
+
+class InvalidLabwarePlacementError(LabwareLocatingFeatureError):
+    """Raised when a labware cannot be placed in the specified location due to locating feature constraints."""
+
+    def __init__(
+        self,
+        feature_name: str,
+        invalid_placement: str,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build an InvalidLabwarePlacementError."""
+        if message is None:
+            message = f"{feature_name} feature does not support placement: {invalid_placement}"
+
+        if details is None:
+            details = {
+                "feature_name": feature_name,
+                "invalid_placement": invalid_placement,
+            }
+
+        super().__init__(message, details, wrapping)
+
+
+class IncompatibleLocatingFeatureError(LabwareLocatingFeatureError):
+    """Raised when parent and child labware have incompatible locating features."""
+
+    def __init__(
+        self,
+        parent_feature: str,
+        child_feature: str,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build an IncompatibleLocatingFeatureError."""
+        if message is None:
+            message = f"Incompatible labware features: parent {parent_feature}, child {child_feature}"
+
+        if details is None:
+            details = {
+                "parent_feature": parent_feature,
+                "child_feature": child_feature,
+            }
+
+        super().__init__(message, details, wrapping)