opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__py3-none-any.whl

opentrons/protocol_engine/state/labware.py

@@ -56,6 +56,7 @@ from ..types import (
     LoadedLabware,
     ModuleLocation,
     OverlapOffset,
+    LabwareMovementOffsetData,
     OnDeckLabwareLocation,
     OFF_DECK_LOCATION,
 )
@@ -400,7 +401,7 @@ class LabwareView:
             return self._state.labware_by_id[labware_id]
         except KeyError as e:
             raise errors.LabwareNotLoadedError(
-                f"Labware with id {labware_id} not found."
+                f"Labware {labware_id} not found."
             ) from e
 
     def known(self, labware_id: str) -> bool:
@@ -429,7 +430,7 @@ class LabwareView:
             ):
                 return labware.id
         raise errors.exceptions.LabwareNotLoadedOnLabwareError(
-            f"There is not labware loaded onto labware {self.get_display_name(labware_id)}"
+            f"There is not labware loaded onto labware {labware_id}"
         )
 
     def raise_if_labware_has_non_lid_labware_on_top(self, labware_id: str) -> None:
@@ -442,8 +443,7 @@ class LabwareView:
                 and candidate_id != lid_id
             ):
                 raise errors.LabwareIsInStackError(
-                    f"Cannot access labware {self.get_display_name(labware_id)} because it has"
-                    " a non-lid labware stacked on top."
+                    f"Cannot access labware {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,29 +454,9 @@ class LabwareView:
                 and labware.location.labwareId == labware_id
             ):
                 raise errors.LabwareIsInStackError(
-                    f"Cannot access labware {self.get_display_name(labware_id)} because it has"
-                    " another labware stacked on top."
+                    f"Cannot access labware {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],
@@ -683,14 +663,6 @@ 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,
@@ -709,7 +681,7 @@ class LabwareView:
             return definition.wells[well_name]
         except KeyError as e:
             raise errors.WellDoesNotExistError(
-                f"{well_name} does not exist in {self.get_display_name(labware_id)}."
+                f"{well_name} does not exist in {labware_id}."
             ) from e
 
     def get_well_geometry(
@@ -719,21 +691,19 @@ 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 {self.get_display_name(labware_id)}."
+                message=f"No innerLabwareGeometry found in labware definition for labware_id: {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}"
-                f" for {self.get_display_name(labware_id)}"
+                message=f"No geometryDefinitionId found in well definition for well: {well_name} in labware_id: {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 geometry id {geometry_id}"
-                    f" for {self.get_display_name(labware_id)}"
+                    message=f"No innerLabwareGeometry found in labware definition for well_id: {geometry_id} in labware_id: {labware_id}"
                 )
             return well_geometry
 
@@ -802,15 +772,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 {self.get_display_name(labware_id)} is a tip rack. Can not load liquid."
+                f"Given labware: {labware_id} is a tiprack. Can not load liquid."
             )
         if LabwareRole.adapter in labware_definition.allowedRoles:
             raise errors.LabwareIsAdapterError(
-                f"Given labware {self.get_display_name(labware_id)} is an adapter. Can not load liquid."
+                f"Given labware: {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 labware {self.get_display_name(labware_id)}."
+                f"Some of the supplied wells do not match the labwareId: {labware_id}."
             )
         return list(wells)
 
@@ -819,7 +789,7 @@ class LabwareView:
         definition = self.get_definition(labware_id)
         if definition.parameters.tipLength is None:
             raise errors.LabwareIsNotTipRackError(
-                f"Labware {self.get_display_name(labware_id)} has no tip length defined."
+                f"Labware {labware_id} has no tip length defined."
             )
 
         return definition.parameters.tipLength - overlap
@@ -1125,9 +1095,7 @@ class LabwareView:
                 raise errors.LabwareCannotBeStackedError(
                     f"Labware {lid_labware_definition.parameters.loadName} cannot be used as a lid in the Flex Stacker."
                 )
-            if isinstance(
-                lid_labware_definition, LabwareDefinition2
-            ) and not labware_validation.validate_legacy_labware_can_be_stacked(
+            if not labware_validation.validate_labware_can_be_stacked(
                 lid_labware_definition, primary_labware_definition.parameters.loadName
             ):
                 raise errors.LabwareCannotBeStackedError(
@@ -1140,9 +1108,7 @@ class LabwareView:
                 raise errors.LabwareCannotBeStackedError(
                     f"Labware {adapter_labware_definition.parameters.loadName} cannot be used as an adapter in the Flex Stacker."
                 )
-            if isinstance(
-                primary_labware_definition, LabwareDefinition2
-            ) and not labware_validation.validate_legacy_labware_can_be_stacked(
+            if not labware_validation.validate_labware_can_be_stacked(
                 primary_labware_definition,
                 adapter_labware_definition.parameters.loadName,
             ):
@@ -1196,9 +1162,9 @@ class LabwareView:
         below_labware = self.get(bottom_labware_id)
         if isinstance(
             top_labware_definition, LabwareDefinition2
-        ) and not labware_validation.validate_legacy_labware_can_be_stacked(
-            child_labware_definition=top_labware_definition,
-            parent_labware_load_name=below_labware.loadName,
+        ) and not labware_validation.validate_labware_can_be_stacked(
+            top_labware_definition=top_labware_definition,
+            below_labware_load_name=below_labware.loadName,
         ):
             raise errors.LabwareCannotBeStackedError(
                 f"Labware {top_labware_definition.parameters.loadName} cannot be loaded onto labware {below_labware.loadName}"
@@ -1259,6 +1225,28 @@ 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.
 
@@ -1269,6 +1257,68 @@ 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/module_substates/thermocycler_module_substate.py

@@ -5,7 +5,6 @@ from typing import NewType, Optional
 from opentrons.protocol_engine.errors import (
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
-    InvalidRampRateError,
     NoTargetTemperatureSetError,
     InvalidHoldTimeError,
 )
@@ -24,10 +23,6 @@ from opentrons.hardware_control.modules import ModuleData, ModuleDataValidator
 
 ThermocyclerModuleId = NewType("ThermocyclerModuleId", str)
 
-# These are our published numbers, and from testing they are good bounds
-MAX_HEATING_RATE = 4.25
-MAX_COOLING_RATE = 2.0
-
 
 @dataclass(frozen=True)
 class ThermocyclerModuleSubState:
@@ -148,38 +143,6 @@ class ThermocyclerModuleSubState:
             )
         return target
 
-    def validate_ramp_rate(
-        self, ramp_rate: Optional[float], target_temp: float
-    ) -> Optional[float]:
-        """Validate a given temperature ramp rate.
-
-        Args:
-            ramp_rate: The requested ramp rate in °C/second.
-            target_temp:  The requested block temperature.
-
-        Raises:
-            InvalidRampRateError: The given ramp_rate is invalid
-
-        Returns:
-            The validated ramp rate in °C/second
-        """
-        if ramp_rate is None:
-            return ramp_rate
-
-        heating = target_temp > self.get_target_block_temperature()
-        if (heating and ramp_rate > MAX_HEATING_RATE) or (
-            not heating and ramp_rate > MAX_COOLING_RATE
-        ):
-            raise InvalidRampRateError(
-                f"Thermocycler ramp rate cannot exceed {MAX_HEATING_RATE}°C/s"
-                f" while heating or {MAX_COOLING_RATE}°C/s when cooling."
-            )
-        if ramp_rate <= 0:
-            raise InvalidRampRateError(
-                f"Thermocycler ramp rate cannot be less than or equal to 0, got {ramp_rate}"
-            )
-        return ramp_rate
-
     @classmethod
     def from_live_data(
         cls, module_id: ThermocyclerModuleId, data: ModuleData | None

opentrons/protocol_engine/state/modules.py

@@ -56,6 +56,7 @@ from ..types import (
     HeaterShakerLatchStatus,
     HeaterShakerMovementRestrictors,
     DeckType,
+    LabwareMovementOffsetData,
     AddressableAreaLocation,
     StackerStoredLabwareGroup,
 )
@@ -1335,6 +1336,13 @@ class ModuleView:
             return True
         return False
 
+    def get_default_gripper_offsets(
+        self, module_id: str
+    ) -> Optional[LabwareMovementOffsetData]:
+        """Get the deck's default gripper offsets."""
+        offsets = self.get_definition(module_id).gripperOffsets
+        return offsets.get("default") if offsets else None
+
     def get_overflowed_module_in_slot(
         self, slot_name: DeckSlotName
     ) -> Optional[LoadedModule]:
@@ -1511,24 +1519,3 @@ class ModuleView:
                 f"Provided overlap offset {overlap_offset} does not match "
                 f"configured {configured}."
             )
-
-    def get_has_module_probably_matching_hardware_details(
-        self, module_model: ModuleModel, module_serial: str | None
-    ) -> bool:
-        """Get the ID of a model that possibly matches the provided details.
-
-        If the provided serial is not None, return True if there is a module with the same serial or
-        False if there is not.
-        If the provided serial is None, return True if there is a module with the same model or False if
-        there is not.
-
-        This is intended to provide a good probability that a module matching the provided details
-        is or is not present in the state store. It is used to drive whether the engine cancels a protocol
-        in response to an asynchronous module error or not.
-        """
-        for module_id, module in self._state.hardware_by_module_id.items():
-            if module_serial is not None and module_serial == module.serial_number:
-                return True
-            if module_serial is None and module.definition.model == module_model:
-                return True
-        return False

opentrons/protocol_engine/state/motion.py

@@ -1,7 +1,6 @@
 """Motion state store and getters."""
 from dataclasses import dataclass
 from typing import List, Optional, Union
-import logging
 
 from opentrons.types import MountType, Point, StagingSlotName
 from opentrons.hardware_control.types import CriticalPoint
@@ -29,8 +28,6 @@ from .geometry import GeometryView
 from .modules import ModuleView
 from .module_substates import HeaterShakerModuleId
 
-log = logging.getLogger(__name__)
-
 
 @dataclass(frozen=True)
 class PipetteLocationData:
@@ -88,42 +85,6 @@ class MotionView:
                 critical_point = CriticalPoint.XY_CENTER
         return PipetteLocationData(mount=mount, critical_point=critical_point)
 
-    def _get_pipette_offset_for_reservoirs(
-        self, labware_id: str, well_name: str, pipette_id: str
-    ) -> Point:
-        #   8 rows, 12 columns
-        subwells_96 = self._labware.get_has_96_subwells(labware_id)
-        #   1 row, 12 columns
-        subwells_12 = self._labware.get_has_12_subwells(labware_id)
-        if subwells_12 and subwells_96:
-            log.warning(
-                f"{self._labware.get_display_name(labware_id)} has both offsetPipetteFor96GridSubwells and"
-                " offsetPipetteFor12GridSubwells quirks."
-            )
-
-        pipette_rows = self._pipettes.get_nozzle_configuration(pipette_id).rows
-        pipette_cols = self._pipettes.get_nozzle_configuration(pipette_id).columns
-
-        even_labware_rows = subwells_96
-        even_labware_columns = subwells_96 or subwells_12
-        odd_pipette_rows = len(pipette_rows) % 2 == 1
-        odd_pipette_cols = len(pipette_cols) % 2 == 1
-
-        well_x_dim, well_y_dim, well_z_dim = self._labware.get_well_size(
-            labware_id=labware_id, well_name=well_name
-        )
-        x_offset = 0.0
-        y_offset = 0.0
-        if even_labware_rows and odd_pipette_rows:
-            # need to move up half a row
-            # there's 8 rows, so move 1/16 of reservoir length
-            y_offset = well_y_dim / 16
-        if even_labware_columns and odd_pipette_cols:
-            # need to move left half a column
-            # there's 12 columns, so move 1/24 of reservoir width
-            x_offset = -1 * well_x_dim / 24
-        return Point(x=x_offset, y=y_offset)
-
     def get_movement_waypoints_to_well(
         self,
         pipette_id: str,
@@ -137,7 +98,6 @@ class MotionView:
         force_direct: bool = False,
         minimum_z_height: Optional[float] = None,
         operation_volume: Optional[float] = None,
-        offset_pipette_for_reservoir_subwells: bool = False,
     ) -> List[motion_planning.Waypoint]:
         """Calculate waypoints to a destination that's specified as a well."""
         location = current_well or self._pipettes.get_current_location()
@@ -155,10 +115,6 @@ class MotionView:
             operation_volume=operation_volume,
             pipette_id=pipette_id,
         )
-        if offset_pipette_for_reservoir_subwells:
-            destination += self._get_pipette_offset_for_reservoirs(
-                labware_id=labware_id, well_name=well_name, pipette_id=pipette_id
-            )
 
         move_type = _move_types.get_move_type_to_well(
             pipette_id, labware_id, well_name, location, force_direct

opentrons/protocol_engine/state/state.py

@@ -34,7 +34,6 @@ from .files import FileView, FileState, FileStore
 from .config import Config
 from .state_summary import StateSummary
 from ..types import DeckConfigurationType
-from .tasks import TaskState, TaskView, TaskStore
 
 
 _ParamsT = ParamSpec("_ParamsT")
@@ -55,7 +54,6 @@ class State:
     tips: TipState
     wells: WellState
     files: FileState
-    tasks: TaskState
 
 
 class StateView(HasState[State]):
@@ -75,7 +73,6 @@ class StateView(HasState[State]):
     _motion: MotionView
     _files: FileView
     _config: Config
-    _tasks: TaskView
 
     @property
     def commands(self) -> CommandView:
@@ -142,11 +139,6 @@ class StateView(HasState[State]):
         """Get ProtocolEngine configuration."""
         return self._config
 
-    @property
-    def tasks(self) -> TaskView:
-        """Get state view selectors for task state."""
-        return self._tasks
-
     def get_summary(self) -> StateSummary:
         """Get protocol run data."""
         error = self._commands.get_error()
@@ -170,7 +162,6 @@ class StateView(HasState[State]):
                 )
                 for liquid_class_id, liquid_class_record in self._liquid_classes.get_all().items()
             ],
-            tasks=self._tasks.get_summary(),
         )
 
 
@@ -240,7 +231,6 @@ class StateStore(StateView, ActionHandler):
         self._tip_store = TipStore()
         self._well_store = WellStore()
         self._file_store = FileStore()
-        self._task_store = TaskStore()
 
         self._substores: List[HandlesActions] = [
             self._command_store,
@@ -253,7 +243,6 @@ class StateStore(StateView, ActionHandler):
             self._tip_store,
             self._well_store,
             self._file_store,
-            self._task_store,
         ]
         self._config = config
         self._change_notifier = change_notifier or ChangeNotifier()
@@ -377,7 +366,6 @@ class StateStore(StateView, ActionHandler):
             tips=self._tip_store.state,
             wells=self._well_store.state,
             files=self._file_store.state,
-            tasks=self._task_store.state,
         )
 
     def _initialize_state(self) -> None:
@@ -396,7 +384,6 @@ class StateStore(StateView, ActionHandler):
         self._tips = TipView(state.tips)
         self._wells = WellView(state.wells)
         self._files = FileView(state.files)
-        self._tasks = TaskView(state.tasks)
 
         # Derived states
         self._geometry = GeometryView(
@@ -429,7 +416,6 @@ class StateStore(StateView, ActionHandler):
         self._liquid_classes._state = next_state.liquid_classes
         self._tips._state = next_state.tips
         self._wells._state = next_state.wells
-        self._tasks._state = next_state.tasks
         self._change_notifier.notify()
         if self._notify_robot_server is not None:
             self._notify_robot_server()

opentrons/protocol_engine/state/state_summary.py

@@ -13,7 +13,6 @@ from ..types import (
     Liquid,
     LiquidClassRecordWithId,
     WellInfoSummary,
-    TaskSummary,
 )
 
 
@@ -35,4 +34,3 @@ class StateSummary(BaseModel):
     wells: List[WellInfoSummary] = Field(default_factory=list)
     files: List[str] = Field(default_factory=list)
     liquidClasses: List[LiquidClassRecordWithId] = Field(default_factory=list)
-    tasks: List[TaskSummary] = Field(default_factory=list)