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

opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.6.0a12'
-__version_tuple__ = version_tuple = (8, 6, 0, 'a12')
+__version__ = version = '8.7.0a1'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a1')
 
 __commit_id__ = commit_id = None

opentrons/hardware_control/backends/ot3controller.py

@@ -686,9 +686,9 @@ class OT3Controller(FlexBackend):
         return (
             MoveGroupRunner(
                 move_groups=[move_group],
-                ignore_stalls=True
-                if not self._feature_flags.stall_detection_enabled
-                else False,
+                ignore_stalls=(
+                    True if not self._feature_flags.stall_detection_enabled else False
+                ),
             ),
             False,
         )
@@ -712,9 +712,9 @@ class OT3Controller(FlexBackend):
         return (
             MoveGroupRunner(
                 move_groups=[tip_motor_move_group],
-                ignore_stalls=True
-                if not self._feature_flags.stall_detection_enabled
-                else False,
+                ignore_stalls=(
+                    True if not self._feature_flags.stall_detection_enabled else False
+                ),
             ),
             True,
         )
@@ -939,9 +939,9 @@ class OT3Controller(FlexBackend):
 
         runner = MoveGroupRunner(
             move_groups=[move_group],
-            ignore_stalls=True
-            if not self._feature_flags.stall_detection_enabled
-            else False,
+            ignore_stalls=(
+                True if not self._feature_flags.stall_detection_enabled else False
+            ),
         )
         try:
             positions = await runner.run(can_messenger=self._messenger)
@@ -976,9 +976,9 @@ class OT3Controller(FlexBackend):
         move_group = self._build_tip_action_group(origin, targets)
         runner = MoveGroupRunner(
             move_groups=[move_group],
-            ignore_stalls=True
-            if not self._feature_flags.stall_detection_enabled
-            else False,
+            ignore_stalls=(
+                True if not self._feature_flags.stall_detection_enabled else False
+            ),
         )
         try:
             positions = await runner.run(can_messenger=self._messenger)
@@ -1777,7 +1777,16 @@ class OT3Controller(FlexBackend):
             expected_grip_width + grip_width_uncertainty_wider
         )
         current_gripper_position = jaw_width
-        if isclose(current_gripper_position, hard_limit_lower):
+        log.info(
+            f"Checking gripper position: current {jaw_width}; max error {max_allowed_grip_error}; hard limits {hard_limit_lower}, {hard_limit_upper}; expected {expected_gripper_position_min}, {expected_grip_width}, {expected_gripper_position_max}; uncertainty {grip_width_uncertainty_narrower}, {grip_width_uncertainty_wider}"
+        )
+        if (
+            isclose(current_gripper_position, hard_limit_lower)
+            # this odd check handles internal backlash that can lead the position to read as if
+            # the gripper has overshot its lower bound; this is physically impossible and an
+            # artifact of the gearing, so it always indicates a hard stop
+            or current_gripper_position < hard_limit_lower
+        ):
             raise FailedGripperPickupError(
                 message="Failed to grip: jaws all the way closed",
                 details={

opentrons/hardware_control/backends/ot3simulator.py

@@ -781,7 +781,7 @@ class OT3Simulator(FlexBackend):
                 next_fw_version=1,
                 fw_update_needed=False,
                 current_fw_sha="simulated",
-                pcba_revision="A1",
+                pcba_revision="A1.0",
                 update_state=None,
             )
             for axis in self._present_axes

opentrons/hardware_control/ot3api.py

@@ -1480,8 +1480,8 @@ class OT3API(
             grip_width_uncertainty_narrower,
             gripper.jaw_width,
             gripper.max_allowed_grip_error,
-            gripper.max_jaw_width,
             gripper.min_jaw_width,
+            gripper.max_jaw_width,
         )
 
     def gripper_jaw_can_home(self) -> bool:

opentrons/protocol_api/core/engine/_default_liquid_class_versions.py

@@ -0,0 +1,56 @@
+"""The versions of standard liquid classes that the Protocol API should load by default."""
+
+from typing import TypeAlias
+from opentrons.protocols.api_support.types import APIVersion
+
+
+DefaultLiquidClassVersions: TypeAlias = dict[APIVersion, dict[str, int]]
+
+
+# This:
+#
+# {
+#     APIVersion(2, 100): {
+#         "foo_liquid": 3,
+#     },
+#     APIVersion(2, 105): {
+#         "foo_liquid": 7
+#     }
+# }
+#
+# Means this:
+#
+# apiLevels        name              Default liquid class version
+# ---------------------------------------------------------------
+# <2.100           foo_liquid        1
+# >=2.100,<2.105   foo_liquid        3
+# >=2.105          foo_liquid        7
+# [any]            [anything else]   1
+DEFAULT_LIQUID_CLASS_VERSIONS: DefaultLiquidClassVersions = {
+    APIVersion(2, 26): {
+        "ethanol_80": 2,
+        "glycerol_50": 2,
+        "water": 2,
+    },
+}
+
+
+def get_liquid_class_version(
+    api_version: APIVersion,
+    liquid_class_name: str,
+) -> int:
+    """Return what version of a liquid class the Protocol API should load by default."""
+    default_lc_versions_newest_to_oldest = sorted(
+        DEFAULT_LIQUID_CLASS_VERSIONS.items(), key=lambda kv: kv[0], reverse=True
+    )
+    for (
+        breakpoint_api_version,
+        breakpoint_liquid_class_versions,
+    ) in default_lc_versions_newest_to_oldest:
+        if (
+            api_version >= breakpoint_api_version
+            and liquid_class_name in breakpoint_liquid_class_versions
+        ):
+            return breakpoint_liquid_class_versions[liquid_class_name]
+
+    return 1

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -21,7 +21,11 @@ from opentrons.protocol_engine import (
     OnLabwareLocation,
     DropTipWellLocation,
 )
-from opentrons.protocol_engine.types import StagingSlotLocation, WellLocationType
+from opentrons.protocol_engine.types import (
+    StagingSlotLocation,
+    WellLocationType,
+    LoadedModule,
+)
 from opentrons.types import DeckSlotName, StagingSlotName, Point
 from . import point_calculations
 
@@ -136,22 +140,47 @@ def check_safe_for_pipette_movement(  # noqa: C901
             f" will result in collision with thermocycler lid in deck slot A1."
         )
 
+    def _check_for_column_4_module_collision(slot: DeckSlotName) -> None:
+        slot_module = engine_state.modules.get_by_slot(slot)
+        if (
+            slot_module
+            and engine_state.modules.is_column_4_module(slot_module.model)
+            and _slot_has_potential_colliding_object(
+                engine_state=engine_state,
+                pipette_bounds=pipette_bounds_at_well_location,
+                surrounding_location=slot_module,
+            )
+        ):
+            raise PartialTipMovementNotAllowedError(
+                f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
+                f" {slot} with {primary_nozzle} nozzle partial configuration will"
+                f" result in collision with items on {slot_module.model} mounted in {slot}."
+            )
+
+    # We check the labware slot for a module that is mounted in the same cutout
+    # as the labwares slot but does not occupy the same heirarchy (like the stacker).
+    _check_for_column_4_module_collision(labware_slot)
+
     for regular_slot in surrounding_slots.regular_slots:
         if _slot_has_potential_colliding_object(
             engine_state=engine_state,
             pipette_bounds=pipette_bounds_at_well_location,
-            surrounding_slot=regular_slot,
+            surrounding_location=regular_slot,
         ):
             raise PartialTipMovementNotAllowedError(
                 f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
                 f" {labware_slot} with {primary_nozzle} nozzle partial configuration"
                 f" will result in collision with items in deck slot {regular_slot}."
             )
+
+        # Check for Column 4 Modules that may be descendants of a given surrounding slot
+        _check_for_column_4_module_collision(regular_slot)
+
     for staging_slot in surrounding_slots.staging_slots:
         if _slot_has_potential_colliding_object(
             engine_state=engine_state,
             pipette_bounds=pipette_bounds_at_well_location,
-            surrounding_slot=staging_slot,
+            surrounding_location=staging_slot,
         ):
             raise PartialTipMovementNotAllowedError(
                 f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
@@ -178,18 +207,45 @@ def _get_critical_point_to_use(
 def _slot_has_potential_colliding_object(
     engine_state: StateView,
     pipette_bounds: Tuple[Point, Point, Point, Point],
-    surrounding_slot: Union[DeckSlotName, StagingSlotName],
+    surrounding_location: Union[DeckSlotName, StagingSlotName, LoadedModule],
 ) -> bool:
-    """Return the slot, if any, that has an item that the pipette might collide into."""
-    # Check if slot overlaps with pipette position
-    slot_pos = engine_state.addressable_areas.get_addressable_area_position(
-        addressable_area_name=surrounding_slot.id,
-        do_compatibility_check=False,
-    )
-    slot_bounds = engine_state.addressable_areas.get_addressable_area_bounding_box(
-        addressable_area_name=surrounding_slot.id,
-        do_compatibility_check=False,
-    )
+    """Return the slot, if any, that has an item that the pipette might collide into.
+    Can be provided a Deck Slot, Staging Slot, or Column 4 Module.
+    """
+    if isinstance(surrounding_location, LoadedModule):
+        if (
+            engine_state.modules.is_column_4_module(surrounding_location.model)
+            and surrounding_location.location is not None
+        ):
+            module_area = (
+                engine_state.modules.ensure_and_convert_module_fixture_location(
+                    surrounding_location.location.slotName, surrounding_location.model
+                )
+            )
+            slot_pos = engine_state.addressable_areas.get_addressable_area_position(
+                addressable_area_name=module_area,
+                do_compatibility_check=False,
+            )
+            slot_bounds = (
+                engine_state.addressable_areas.get_addressable_area_bounding_box(
+                    addressable_area_name=module_area,
+                    do_compatibility_check=False,
+                )
+            )
+        else:
+            raise ValueError(
+                f"Error during collision validation, Module {surrounding_location.model} must be in Column 4."
+            )
+    else:
+        # Check if slot overlaps with pipette position
+        slot_pos = engine_state.addressable_areas.get_addressable_area_position(
+            addressable_area_name=surrounding_location.id,
+            do_compatibility_check=False,
+        )
+        slot_bounds = engine_state.addressable_areas.get_addressable_area_bounding_box(
+            addressable_area_name=surrounding_location.id,
+            do_compatibility_check=False,
+        )
     slot_back_left_coords = Point(slot_pos.x, slot_pos.y + slot_bounds.y, slot_pos.z)
     slot_front_right_coords = Point(slot_pos.x + slot_bounds.x, slot_pos.y, slot_pos.z)
 
@@ -199,13 +255,17 @@ def _slot_has_potential_colliding_object(
         rectangle2=(slot_back_left_coords, slot_front_right_coords),
     ):
         # Check z-height of items in overlapping slot
-        if isinstance(surrounding_slot, DeckSlotName):
+        if isinstance(surrounding_location, DeckSlotName):
             slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
-                DeckSlotLocation(slotName=surrounding_slot)
+                DeckSlotLocation(slotName=surrounding_location)
+            )
+        elif isinstance(surrounding_location, LoadedModule):
+            slot_highest_z = engine_state.geometry.get_highest_z_of_column_4_module(
+                surrounding_location
             )
         else:
             slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
-                StagingSlotLocation(slotName=surrounding_slot)
+                StagingSlotLocation(slotName=surrounding_location)
             )
         return slot_highest_z >= pipette_bounds[0].z
     return False

opentrons/protocol_api/core/engine/protocol.py

@@ -78,7 +78,12 @@ from .module_core import (
     FlexStackerCore,
 )
 from .exceptions import InvalidModuleLocationError
-from . import load_labware_params, deck_conflict, overlap_versions
+from . import (
+    load_labware_params,
+    deck_conflict,
+    overlap_versions,
+    _default_liquid_class_versions,
+)
 from opentrons.protocol_engine.resources import labware_validation
 
 if TYPE_CHECKING:
@@ -1068,8 +1073,12 @@ class ProtocolCore(
             display_color=(liquid.displayColor.root if liquid.displayColor else None),
         )
 
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
+        if version is None:
+            version = _default_liquid_class_versions.get_liquid_class_version(
+                self._api_version, name
+            )
         try:
             # Check if we have already loaded this liquid class' definition
             liquid_class_def = self._liquid_class_def_cache[(name, version)]

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -599,7 +599,7 @@ class LegacyProtocolCore(
         """Define a liquid to load into a well."""
         assert False, "define_liquid only supported on engine core"
 
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
         assert False, "define_liquid_class is only supported on engine core"
 

opentrons/protocol_api/core/protocol.py

@@ -297,7 +297,7 @@ class AbstractProtocol(
         """Define a liquid to load into a well."""
 
     @abstractmethod
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
 
     @abstractmethod

opentrons/protocol_api/labware.py

@@ -640,6 +640,9 @@ class Labware:
         lid: Optional[str] = None,
         namespace: Optional[str] = None,
         version: Optional[int] = None,
+        *,
+        lid_namespace: Optional[str] = None,
+        lid_version: Optional[int] = None,
     ) -> Labware:
         """Load a compatible labware onto the labware using its load parameters.
 
@@ -650,6 +653,24 @@ class Labware:
 
         :returns: The initialized and loaded labware object.
         """
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            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),
+                )
+
         labware_core = self._protocol_core.load_labware(
             load_name=name,
             label=label,
@@ -674,11 +695,24 @@ class Labware:
                     until_version="2.23",
                     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:
+                # This is currently impossible to reach because of the
+                # `if self._api_version < validation.validation.LID_STACK_VERSION_GATE`
+                # check above. This is here for now in case that check is removed in
+                # the future, and for symmetry with the other labware load methods.
+                checked_lid_namespace = lid_namespace
+                checked_lid_version = lid_version
             self._protocol_core.load_lid(
                 load_name=lid,
                 location=labware_core,
-                namespace=namespace,
-                version=version,
+                namespace=checked_lid_namespace,
+                version=checked_lid_version,
             )
 
         return labware

opentrons/protocol_api/module_contexts.py

@@ -123,7 +123,7 @@ class ModuleContext(CommandPublisher):
 
         return core.geometry.add_labware(labware)
 
-    def load_labware(
+    def load_labware(  # noqa: C901
         self,
         name: str,
         label: Optional[str] = None,
@@ -131,6 +131,11 @@ class ModuleContext(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 the module using its load parameters.
 
@@ -142,7 +147,11 @@ class ModuleContext(CommandPublisher):
         :returns: The initialized and loaded labware object.
 
         .. versionadded:: 2.1
-            The *label,* *namespace,* and *version* parameters.
+            The ``label``, ``namespace``, and ``version`` parameters.
+
+        .. versionadded:: 2.26
+            The ``adapter_namespace``, ``adapter_version``,
+            ``lid_namespace``, and ``lid_version`` parameters.
         """
         if self._api_version < APIVersion(2, 1) and (
             label is not None or namespace is not None or version != 1
@@ -152,6 +161,40 @@ class ModuleContext(CommandPublisher):
                 "are trying to utilize new load_labware parameters in 2.1"
             )
 
+        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_location: Union[ModuleCore, LabwareCore]
         if adapter is not None:
             if self._api_version < APIVersion(2, 15):
@@ -160,9 +203,21 @@ class ModuleContext(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(
                 name=adapter,
-                namespace=namespace,
+                namespace=checked_adapter_namespace,
+                version=checked_adapter_version,
             )
             load_location = loaded_adapter._core
         else:
@@ -193,11 +248,22 @@ class ModuleContext(CommandPublisher):
                     until_version="2.23",
                     current_version=f"{self._api_version}",
                 )
+
+            if (
+                self._api_version
+                < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+            ):
+                checked_lid_namespace = namespace
+                checked_lid_version = None
+            else:
+                checked_lid_namespace = lid_namespace
+                checked_lid_version = lid_version
+
             self._protocol_core.load_lid(
                 load_name=lid,
                 location=labware_core,
-                namespace=namespace,
-                version=version,
+                namespace=checked_lid_namespace,
+                version=checked_lid_version,
             )
 
         if isinstance(self._core, LegacyModuleCore):
@@ -1330,6 +1396,11 @@ class FlexStackerContext(ModuleContext):
         lid: str | None = None,
         count: int | None = None,
         stacking_offset_z: float | None = None,
+        *,
+        adapter_namespace: str | None = None,
+        adapter_version: int | None = None,
+        lid_namespace: str | None = None,
+        lid_version: int | None = None,
     ) -> None:
         """Configure the type and starting quantity of labware the Flex Stacker will store during a protocol. This is the only type of labware you'll be able to store in the Stacker until it's reconfigured.
 
@@ -1338,6 +1409,7 @@ class FlexStackerContext(ModuleContext):
         :param str load_name: A string to use for looking up a labware definition.
             You can find the ``load_name`` for any Opentrons-verified labware on the
             `Labware Library <https://labware.opentrons.com>`__.
+
         :param str namespace: The namespace that the labware definition belongs to.
             If unspecified, the API will automatically search two namespaces:
 
@@ -1348,19 +1420,34 @@ class FlexStackerContext(ModuleContext):
             You might need to specify an explicit ``namespace`` if you have a custom
             definition whose ``load_name`` is the same as an Opentrons-verified
             definition, and you want to explicitly choose one or the other.
+
         :param version: The version of the labware definition. You should normally
             leave this unspecified to let the method 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.
+            values as the ``load_name`` parameter of :py:meth:`.load_adapter`.
+
+        :param adapter_namespace: Applies to ``adapter`` the same way that ``namespace``
+            applies to ``load_name``.
+
+        :param adapter_version: Applies to ``adapter`` the same way that ``version``
+            applies to ``load_name``.
+
         :param lid: A lid to load the on top of the main labware. Accepts the same
             values as the ``load_name`` parameter of :py:meth:`~.ProtocolContext.load_lid_stack`. The
             lid will use the same namespace as the labware, and the API will
             choose the lid's version automatically.
+
+        :param lid_namespace: Applies to ``lid`` the same way that ``namespace``
+            applies to ``load_name``.
+
+        :param lid_version: Applies to ``lid`` the same way that ``version``
+            applies to ``load_name``.
+
         :param count: The number of labware that the Flex Stacker should store. If not specified, this will be the maximum amount of this kind of
             labware that the Flex Stacker is capable of storing.
+
         :param stacking_offset_z: Stacking ``z`` offset in mm of stored labware. If specified, this overrides the
             calculated value in the labware definition.
 
@@ -1378,18 +1465,18 @@ class FlexStackerContext(ModuleContext):
               - Labware on adapter: the adapter (bottom side) of the upper labware unit overlaps with the top side of the labware below.
               - Labware with lid: the labware (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below.
               - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below.
-
         """
+
         self._core.set_stored_labware(
             main_load_name=load_name,
             main_namespace=namespace,
             main_version=version,
             lid_load_name=lid,
-            lid_namespace=namespace,
-            lid_version=version,
+            lid_namespace=lid_namespace,
+            lid_version=lid_version,
             adapter_load_name=adapter,
-            adapter_namespace=namespace,
-            adapter_version=version,
+            adapter_namespace=adapter_namespace,
+            adapter_version=adapter_version,
             count=count,
             stacking_offset_z=stacking_offset_z,
         )