opentrons 8.6.0a12__py3-none-any.whl → 8.7.0__py3-none-any.whl

opentrons/protocol_api/protocol_context.py

@@ -405,7 +405,7 @@ class ProtocolContext(CommandPublisher):
         )
 
     @requires_version(2, 0)
-    def load_labware(
+    def load_labware(  # noqa: C901
         self,
         load_name: str,
         location: Union[DeckLocation, OffDeckType],
@@ -414,6 +414,11 @@ class ProtocolContext(CommandPublisher):
         version: Optional[int] = None,
         adapter: Optional[str] = None,
         lid: Optional[str] = None,
+        *,
+        adapter_namespace: Optional[str] = None,
+        adapter_version: Optional[int] = None,
+        lid_namespace: Optional[str] = None,
+        lid_version: Optional[int] = None,
     ) -> Labware:
         """Load a labware onto a location.
 
@@ -454,18 +459,52 @@ class ProtocolContext(CommandPublisher):
         :param version: The version of the labware definition. You should normally
             leave this unspecified to let ``load_labware()`` choose a version
             automatically.
-        :param adapter: An adapter to load the labware on top of. Accepts the same
-            values as the ``load_name`` parameter of :py:meth:`.load_adapter`. The
-            adapter will use the same namespace as the labware, and the API will
-            choose the adapter's version automatically.
 
-                        .. versionadded:: 2.15
+        :param adapter: The load name of an adapter to load the labware on top of. Accepts
+            the same values as the ``load_name`` parameter of :py:meth:`.load_adapter`.
+
+            .. versionadded:: 2.15
+
+        :param adapter_namespace: The namespace of the adapter being loaded.
+            Applies to ``adapter`` the same way that ``namespace`` applies to ``load_name``.
+
+            .. versionchanged:: 2.26
+               ``adapter_namespace`` may now be specified explicitly.
+               Also, when you've specified ``namespace`` but not ``adapter_namespace``,
+               ``adapter_namespace`` will now independently follow the same search rules
+               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+
+        :param adapter_version: The version of the adapter being loaded.
+            Applies to ``adapter`` the same way that ``version`` applies to ``load_name``.
+
+            .. versionchanged:: 2.26
+               ``adapter_version`` may now be specified explicitly. Also, when it's unspecified,
+               the algorithm to select a version automatically has improved to avoid
+               selecting versions that do not exist.
+
         :param lid: A lid to load on the top of the main labware. Accepts the same
             values as the ``load_name`` parameter of :py:meth:`.load_lid_stack`. The
             lid will use the same namespace as the labware, and the API will
             choose the lid's version automatically.
 
-                        .. versionadded:: 2.23
+            .. versionadded:: 2.23
+
+        :param lid_namespace: The namespace of the lid being loaded.
+            Applies to ``lid`` the same way that ``namespace`` applies to ``load_name``.
+
+            .. versionchanged:: 2.26
+               ``lid_namespace`` may now be specified explicitly.
+               Also, when you've specified ``namespace`` but not ``lid_namespace``,
+               ``lid_namespace`` will now independently follow the same search rules
+               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+
+        :param lid_version: The version of the adapter being loaded.
+            Applies to ``lid`` the same way that ``version`` applies to ``load_name``.
+
+            .. versionchanged:: 2.26
+               ``lid_version`` may now be specified explicitly. Also, when it's unspecified,
+               the algorithm to select a version automatically has improved to avoid
+               selecting versions that do not exist.
         """
 
         if isinstance(location, OffDeckType) and self._api_version < APIVersion(2, 15):
@@ -475,6 +514,40 @@ class ProtocolContext(CommandPublisher):
                 current_version=f"{self._api_version}",
             )
 
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            if adapter_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if adapter_version is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `lid_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_version is not None:
+                raise APIVersionError(
+                    api_element="The `lid_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+
         load_name = validation.ensure_lowercase_name(load_name)
         load_location: Union[OffDeckType, DeckSlotName, StagingSlotName, LabwareCore]
         if adapter is not None:
@@ -484,10 +557,22 @@ class ProtocolContext(CommandPublisher):
                     until_version="2.15",
                     current_version=f"{self._api_version}",
                 )
+
+            if (
+                self._api_version
+                < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+            ):
+                checked_adapter_namespace = namespace
+                checked_adapter_version = None
+            else:
+                checked_adapter_namespace = adapter_namespace
+                checked_adapter_version = adapter_version
+
             loaded_adapter = self.load_adapter(
                 load_name=adapter,
                 location=location,
-                namespace=namespace,
+                namespace=checked_adapter_namespace,
+                version=checked_adapter_version,
             )
             load_location = loaded_adapter._core
         elif isinstance(location, OffDeckType):
@@ -512,11 +597,22 @@ class ProtocolContext(CommandPublisher):
                     until_version=f"{validation.LID_STACK_VERSION_GATE}",
                     current_version=f"{self._api_version}",
                 )
+
+            if (
+                self._api_version
+                < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+            ):
+                checked_lid_namespace = namespace
+                checked_lid_version = version
+            else:
+                checked_lid_namespace = lid_namespace
+                checked_lid_version = lid_version
+
             self._core.load_lid(
                 load_name=lid,
                 location=labware_core,
-                namespace=namespace,
-                version=version,
+                namespace=checked_lid_namespace,
+                version=checked_lid_version,
             )
 
         labware = Labware(
@@ -1377,6 +1473,7 @@ class ProtocolContext(CommandPublisher):
     def get_liquid_class(
         self,
         name: str,
+        version: Optional[int] = None,
     ) -> LiquidClass:
         """
         Get an instance of an Opentrons-verified liquid class for use in a Flex protocol.
@@ -1386,12 +1483,14 @@ class ProtocolContext(CommandPublisher):
             - ``"water"``: an Opentrons-verified liquid class based on deionized water.
             - ``"glycerol_50"``: an Opentrons-verified liquid class for viscous liquid. Based on 50% glycerol.
             - ``"ethanol_80"``: an Opentrons-verified liquid class for volatile liquid. Based on 80% ethanol.
+        :param version: The version of the liquid class to retrieve. If left unspecified, the latest definition for the
+            protocol's API version will be loaded.
 
         :raises: ``LiquidClassDefinitionDoesNotExist``: if the specified liquid class does not exist.
 
         :returns: A new LiquidClass object.
         """
-        return self._core.get_liquid_class(name=name, version=DEFAULT_LC_VERSION)
+        return self._core.get_liquid_class(name=name, version=version)
 
     @requires_version(2, 24)
     def define_liquid_class(
@@ -1461,6 +1560,9 @@ class ProtocolContext(CommandPublisher):
         adapter: Optional[str] = None,
         namespace: Optional[str] = None,
         version: Optional[int] = None,
+        *,
+        adapter_namespace: Optional[str] = None,
+        adapter_version: Optional[int] = None,
     ) -> Labware:
         """
         Load a stack of Opentrons Tough Auto-Sealing Lids onto a valid deck location or adapter.
@@ -1468,13 +1570,17 @@ class ProtocolContext(CommandPublisher):
         :param str load_name: A string to use for looking up a lid definition.
             You can find the ``load_name`` for any compatible lid on the Opentrons
             `Labware Library <https://labware.opentrons.com>`_.
+
         :param location: Either a :ref:`deck slot <deck-slots>`,
             like ``1``, ``"1"``, or ``"D1"``, or a valid Opentrons Adapter.
+
         :param int quantity: The quantity of lids to be loaded in the stack.
+
         :param adapter: An adapter to load the lid stack on top of. Accepts the same
             values as the ``load_name`` parameter of :py:meth:`.load_adapter`. The
             adapter will use the same namespace as the lid labware, and the API will
             choose the adapter's version automatically.
+
         :param str namespace: The namespace that the lid labware definition belongs to.
             If unspecified, the API will automatically search two namespaces:
 
@@ -1490,6 +1596,21 @@ class ProtocolContext(CommandPublisher):
             leave this unspecified to let ``load_lid_stack()`` choose a version
             automatically.
 
+        :param adapter_namespace: The namespace of the adapter being loaded.
+            Applies to ``adapter`` the same way that ``namespace`` applies to ``load_name``.
+
+            .. versionchanged:: 2.26
+               ``adapter_namespace`` may now be specified explicitly.
+               Also, when you've specified ``namespace`` but not ``adapter_namespace``,
+               ``adapter_namespace`` will now independently follow the same search rules
+               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+
+        :param adapter_version: The version of the adapter being loaded.
+            Applies to ``adapter`` the same way that ``version`` applies to ``load_name``.
+
+            .. versionadded:: 2.26
+               ``adapter_version`` may now be specified explicitly.
+
         :return:  The initialized and loaded labware object representing the lid stack.
 
         .. versionadded:: 2.23
@@ -1502,6 +1623,24 @@ class ProtocolContext(CommandPublisher):
                 current_version=f"{self._api_version}",
             )
 
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            if adapter_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if adapter_version is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+
         load_location: Union[DeckSlotName, StagingSlotName, LabwareCore]
         if isinstance(location, Labware):
             load_location = location._core
@@ -1514,10 +1653,21 @@ class ProtocolContext(CommandPublisher):
             if isinstance(load_location, DeckSlotName) or isinstance(
                 load_location, StagingSlotName
             ):
+                if (
+                    self._api_version
+                    < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                ):
+                    checked_adapter_namespace = namespace
+                    checked_adapter_version = None
+                else:
+                    checked_adapter_namespace = adapter_namespace
+                    checked_adapter_version = adapter_version
+
                 loaded_adapter = self.load_adapter(
                     load_name=adapter,
                     location=load_location.value,
-                    namespace=namespace,
+                    namespace=checked_adapter_namespace,
+                    version=checked_adapter_version,
                 )
                 load_location = loaded_adapter._core
             else:

opentrons/protocol_api/validation.py

@@ -62,6 +62,10 @@ LID_STACK_VERSION_GATE = APIVersion(2, 23)
 # The first APIVersion where Python protocols can use the Flex Stacker module.
 FLEX_STACKER_VERSION_GATE = APIVersion(2, 23)
 
+# The first APIVersion where various "multi labware load" methods allow you to specify
+# the namespace and version of adapters and lids separately from the main labware.
+NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE = APIVersion(2, 26)
+
 
 class InvalidPipetteMountError(ValueError):
     """An error raised when attempting to load pipettes on an invalid mount."""

opentrons/protocol_engine/commands/command_unions.py

@@ -20,6 +20,7 @@ from .flex_stacker.common import (
     FlexStackerHopperError,
     FlexStackerLabwareRetrieveError,
     FlexStackerShuttleOccupiedError,
+    FlexStackerLabwareStoreError,
 )
 
 from . import absorbance_reader
@@ -948,6 +949,7 @@ CommandDefinedErrorData = Union[
     DefinedErrorData[FlexStackerHopperError],
     DefinedErrorData[FlexStackerLabwareRetrieveError],
     DefinedErrorData[FlexStackerShuttleOccupiedError],
+    DefinedErrorData[FlexStackerLabwareStoreError],
 ]
 
 

opentrons/protocol_engine/commands/flex_stacker/common.py

@@ -148,6 +148,19 @@ class FlexStackerLabwareRetrieveError(ErrorOccurrence):
     errorInfo: FailedLabware
 
 
+class FlexStackerLabwareStoreError(ErrorOccurrence):
+    """Returned when the labware was not able to get to the shuttle."""
+
+    isDefined: bool = True
+    errorType: Literal[
+        "flexStackerLabwareStoreFailed"
+    ] = "flexStackerLabwareStoreFailed"
+
+    errorCode: str = ErrorCodes.STACKER_SHUTTLE_LABWARE_FAILED.value.code
+    detail: str = ErrorCodes.STACKER_SHUTTLE_LABWARE_FAILED.value.detail
+    errorInfo: FailedLabware
+
+
 class FlexStackerShuttleOccupiedError(ErrorOccurrence):
     """Returned when the Flex Stacker Shuttle is occupied when it shouldn't be."""
 

opentrons/protocol_engine/commands/flex_stacker/store.py

@@ -10,6 +10,7 @@ from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.errors.exceptions import (
     FlexStackerStallError,
     FlexStackerShuttleMissingError,
+    FlexStackerShuttleLabwareError,
 )
 
 from ..command import (
@@ -22,6 +23,7 @@ from ..command import (
 from ..flex_stacker.common import (
     FlexStackerStallOrCollisionError,
     FlexStackerShuttleError,
+    FlexStackerLabwareStoreError,
     labware_locations_for_group,
     labware_location_base_sequence,
     primary_location_sequence,
@@ -115,7 +117,8 @@ class StoreResult(BaseModel):
 _ExecuteReturn = Union[
     SuccessData[StoreResult],
     DefinedErrorData[FlexStackerStallOrCollisionError]
-    | DefinedErrorData[FlexStackerShuttleError],
+    | DefinedErrorData[FlexStackerShuttleError]
+    | DefinedErrorData[FlexStackerLabwareStoreError],
 ]
 
 
@@ -180,7 +183,7 @@ class StoreImpl(AbstractCommandImpl[StoreParams, _ExecuteReturn]):
                 )
             return labware_ids[0], None, lid_id
 
-    async def execute(self, params: StoreParams) -> _ExecuteReturn:
+    async def execute(self, params: StoreParams) -> _ExecuteReturn:  # noqa: C901
         """Execute the labware storage command."""
         stacker_state = self._state_view.modules.get_flex_stacker_substate(
             params.moduleId
@@ -250,6 +253,21 @@ class StoreImpl(AbstractCommandImpl[StoreParams, _ExecuteReturn]):
                         errorInfo={"labwareId": primary_id},
                     ),
                 )
+            except FlexStackerShuttleLabwareError as e:
+                return DefinedErrorData(
+                    public=FlexStackerLabwareStoreError(
+                        id=self._model_utils.generate_id(),
+                        createdAt=self._model_utils.get_timestamp(),
+                        wrappedErrors=[
+                            ErrorOccurrence.from_failed(
+                                id=self._model_utils.generate_id(),
+                                createdAt=self._model_utils.get_timestamp(),
+                                error=e,
+                            )
+                        ],
+                        errorInfo={"labwareId": primary_id},
+                    ),
+                )
 
         id_list = [
             id for id in (primary_id, maybe_adapter_id, maybe_lid_id) if id is not None

opentrons/protocol_engine/execution/labware_movement.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Optional, TYPE_CHECKING, overload
 
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition, Quirks
 
 from opentrons.types import Point
 
@@ -234,23 +234,25 @@ class LabwareMovementHandler:
                     # we only want to check position after the gripper has opened and
                     # should be holding labware
                     if holding_labware:
-                        labware_bbox = self._state_store.labware.get_dimensions(
-                            labware_definition=labware_definition
-                        )
-                        well_bbox = self._state_store.labware.get_well_bbox(
+                        grip_specs = self._state_store.labware.get_gripper_width_specs(
                             labware_definition=labware_definition
                         )
+
+                        disable_geometry_grip_check = False
+                        if labware_definition.parameters.quirks is not None:
+                            disable_geometry_grip_check = (
+                                Quirks.disableGeometryBasedGripCheck.value
+                                in labware_definition.parameters.quirks
+                            )
+
                         # 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.
                         ot3api.raise_error_if_gripper_pickup_failed(
-                            expected_grip_width=labware_bbox.y,
-                            grip_width_uncertainty_wider=abs(
-                                max(well_bbox.y - labware_bbox.y, 0)
-                            ),
-                            grip_width_uncertainty_narrower=abs(
-                                min(well_bbox.y - labware_bbox.y, 0)
-                            ),
+                            expected_grip_width=grip_specs.targetY,
+                            grip_width_uncertainty_wider=grip_specs.uncertaintyWider,
+                            grip_width_uncertainty_narrower=grip_specs.uncertaintyNarrower,
+                            disable_geometry_grip_check=disable_geometry_grip_check,
                         )
                 await ot3api.move_to(
                     mount=gripper_mount, abs_position=waypoint_data.position

opentrons/protocol_engine/resources/pipette_data_provider.py

@@ -70,6 +70,7 @@ class LoadedStaticPipetteData:
     plunger_positions: Dict[str, float]
     shaft_ul_per_mm: float
     available_sensors: pipette_definition.AvailableSensorDefinition
+    volume_mode: pip_types.LiquidClasses  # pip_types Liquid Classes refers to volume modes
 
 
 class VirtualPipetteDataProvider:
@@ -298,6 +299,7 @@ class VirtualPipetteDataProvider:
             shaft_ul_per_mm=config.shaft_ul_per_mm,
             available_sensors=config.available_sensors
             or pipette_definition.AvailableSensorDefinition(sensors=[]),
+            volume_mode=liquid_class,
         )
 
     def get_virtual_pipette_static_config(
@@ -353,6 +355,7 @@ def get_pipette_static_config(
         plunger_positions=pipette_dict["plunger_positions"],
         shaft_ul_per_mm=pipette_dict["shaft_ul_per_mm"],
         available_sensors=available_sensors,
+        volume_mode=pipette_dict["volume_mode"],
     )
 
 

opentrons/protocol_engine/state/geometry.py

@@ -274,12 +274,20 @@ class GeometryView:
             try:
                 labware_id = self._labware.get_id_by_module(module_id=module_id)
             except LabwareNotLoadedOnModuleError:
-                return self._modules.get_module_highest_z(
-                    module_id=module_id,
-                    addressable_areas=self._addressable_areas,
-                )
+                # For the time being we will ignore column 4 modules in this check to avoid conflating results
+                if self._modules.is_column_4_module(slot_item.model) is False:
+                    return self._modules.get_module_highest_z(
+                        module_id=module_id,
+                        addressable_areas=self._addressable_areas,
+                    )
             else:
-                return self.get_highest_z_of_labware_stack(labware_id)
+                # For the time being we will ignore column 4 modules in this check to avoid conflating results
+                if self._modules.is_column_4_module(slot_item.model) is False:
+                    return self.get_highest_z_of_labware_stack(labware_id)
+            # todo (cb, 2025-09-15): For now we skip column 4 modules and handle them seperately in
+            # get_highest_z_of_column_4_module, so this will return 0. In the future we may want to consolidate
+            # this to make it more apparently at this point in the query process.
+            return 0
         elif isinstance(slot_item, LoadedLabware):
             # get stacked heights of all labware in the slot
             return self.get_highest_z_of_labware_stack(slot_item.id)
@@ -301,6 +309,26 @@ class GeometryView:
             return self.get_labware_highest_z(labware_id)
         return self.get_highest_z_of_labware_stack(stacked_labware_id)
 
+    def get_highest_z_of_column_4_module(self, module: LoadedModule) -> float:
+        """Get the highest Z-point of the topmost labware in the stack of labware on the given column 4 module.
+
+        If there is no labware on the given module, returns highest z of the module.
+        """
+        if self._modules.is_column_4_module(module.model):
+            try:
+                labware_id = self._labware.get_id_by_module(module_id=module.id)
+            except LabwareNotLoadedOnModuleError:
+                return self._modules.get_module_highest_z(
+                    module_id=module.id,
+                    addressable_areas=self._addressable_areas,
+                )
+            else:
+                return self.get_highest_z_of_labware_stack(labware_id)
+        else:
+            raise ValueError(
+                "Module must be a Column 4 Module to determine maximum z height."
+            )
+
     def get_min_travel_z(
         self,
         pipette_id: str,

opentrons/protocol_engine/state/labware.py

@@ -46,6 +46,7 @@ from ..types import (
     AddressableAreaLocation,
     NonStackedLocation,
     Dimensions,
+    GripSpecs,
     LabwareOffset,
     LabwareOffsetVector,
     LabwareOffsetLocationSequence,
@@ -1430,3 +1431,68 @@ class LabwareView:
         ):
             return Dimensions(0, 0, 0)
         return Dimensions(max_x - min_x, max_y - min_y, max_z)
+
+    def _gripper_uncertainty_narrower(
+        self, labware_bbox: Dimensions, well_bbox: Dimensions, target_grip_width: float
+    ) -> float:
+        """Most narrower the gripper can be than the target while still likely gripping successfully.
+
+        This number can't just be the 0, because that is not going to be accurate if the labware is
+        skirted - the dimensions are a full bounding box including the skirt, and the labware is
+        narrower than that at the point where it is gripped. The general heuristic is that we can't
+        get to the wells; but some labware don't have wells, so we need alternate values.
+
+        The number will be interpreted relative to the target width, which is (for now) the labware
+        outer bounding box.
+
+        TODO: This should be a number looked up from the definition.
+        """
+        if well_bbox.y == 0:
+            # This labware has no wells; use a fixed minimum
+            return 5
+        if well_bbox.y > labware_bbox.y:
+            # This labware has a very odd definition with wells outside its dimensions.
+            # Return the smaller value.
+            return 0
+        # An ok heuristic for successful grip is if we don't get all the way to the wells.
+        return target_grip_width - well_bbox.y
+
+    def _gripper_uncertainty_wider(
+        self, labware_bbox: Dimensions, well_bbox: Dimensions, target_grip_width: float
+    ) -> float:
+        """Most wider the gripper can be than the target while still likely gripping successfully.
+
+        This can be a lot closer to 0, since the bounding box of the labware will certainly be the
+        widest point (if it's defined without error), but since there might be error in the
+        definition we allow some slop.
+
+        The number will be interpreted relative to the target width, which is (for now) the labware
+        outer bounding box.
+
+        TODO: This should be a number looked up from the definition.
+        """
+        # This will be 0 unless the wells are wider than the labware
+        return max(well_bbox.y - target_grip_width, 0)
+
+    def get_gripper_width_specs(
+        self, labware_definition: LabwareDefinition
+    ) -> GripSpecs:
+        """Get the target and bounds for a successful grip of this labware."""
+        outer_bounds = self.get_dimensions(labware_definition=labware_definition)
+        well_bounds = self.get_well_bbox(labware_definition=labware_definition)
+        narrower = self._gripper_uncertainty_narrower(
+            labware_bbox=outer_bounds,
+            well_bbox=well_bounds,
+            target_grip_width=outer_bounds.y,
+        )
+        wider = self._gripper_uncertainty_wider(
+            labware_bbox=outer_bounds,
+            well_bbox=well_bounds,
+            target_grip_width=outer_bounds.y,
+        )
+        return GripSpecs(
+            # TODO: This should be a number looked up from the definition.
+            targetY=outer_bounds.y,
+            uncertaintyNarrower=narrower,
+            uncertaintyWider=wider,
+        )

opentrons/protocol_engine/state/modules.py

@@ -1330,6 +1330,12 @@ class ModuleView:
                     f"Module {module.model} is already present at {location}."
                 )
 
+    def is_column_4_module(self, model: ModuleModel) -> bool:
+        """Determine whether or not a module is a Column 4 Module."""
+        if model in _COLUMN_4_MODULES:
+            return True
+        return False
+
     def get_default_gripper_offsets(
         self, module_id: str
     ) -> Optional[LabwareMovementOffsetData]:

opentrons/protocol_engine/state/pipettes.py

@@ -17,7 +17,10 @@ from typing_extensions import assert_never
 
 from opentrons_shared_data.pipette import pipette_definition
 from opentrons_shared_data.pipette.ul_per_mm import calculate_ul_per_mm
-from opentrons_shared_data.pipette.types import UlPerMmAction
+from opentrons_shared_data.pipette.types import (
+    UlPerMmAction,
+    LiquidClasses as VolumeModes,
+)
 
 from opentrons.config.defaults_ot2 import Z_RETRACT_DISTANCE
 from opentrons.hardware_control.dev_types import PipetteDict
@@ -107,6 +110,7 @@ class StaticPipetteConfig:
     plunger_positions: Dict[str, float]
     shaft_ul_per_mm: float
     available_sensors: pipette_definition.AvailableSensorDefinition
+    volume_mode: VolumeModes
 
 
 @dataclasses.dataclass
@@ -212,7 +216,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                         # we identify tip classes - looking things up by volume is not enough.
                         tip_configuration = list(
                             static_config.tip_configuration_lookup_table.values()
-                        )[0]
+                        )[-1]
                     self._state.flow_rates_by_id[pipette_id] = FlowRates(
                         default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
                         default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
@@ -230,7 +234,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                     # TODO(seth,9/11/2023): bad way to do defaulting, see above.
                     tip_configuration = list(
                         static_config.tip_configuration_lookup_table.values()
-                    )[0]
+                    )[-1]
                     self._state.flow_rates_by_id[pipette_id] = FlowRates(
                         default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
                         default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
@@ -313,6 +317,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 plunger_positions=config.plunger_positions,
                 shaft_ul_per_mm=config.shaft_ul_per_mm,
                 available_sensors=config.available_sensors,
+                volume_mode=config.volume_mode,
             )
             self._state.flow_rates_by_id[
                 state_update.pipette_config.pipette_id
@@ -867,6 +872,10 @@ class PipetteView:
             return False
         return True
 
+    def get_is_low_volume_mode(self, pipette_id: str) -> bool:
+        """Determine if the pipette is currently in low volume mode."""
+        return self.get_config(pipette_id).volume_mode == VolumeModes.lowVolumeDefault
+
     def lookup_volume_to_mm_conversion(
         self, pipette_id: str, volume: float, action: str
     ) -> float: