opentrons 8.6.0a12__py3-none-any.whl → 8.7.0a0__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.0a0'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a0')
 
 __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,54 @@
+"""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): {
+        "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/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,
         )

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

@@ -234,23 +234,17 @@ 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
                         )
+
                         # 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,
                         )
                 await ot3api.move_to(
                     mount=gripper_mount, abs_position=waypoint_data.position

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/types/__init__.py

@@ -102,6 +102,7 @@ from .labware import (
     LoadedLabware,
     LabwareParentDefinition,
     LabwareWellId,
+    GripSpecs,
 )
 from .liquid import HexColor, EmptyLiquidId, LiquidId, Liquid, FluidKind, AspiratedFluid
 from .labware_offset_location import (
@@ -257,6 +258,7 @@ __all__ = [
     "LabwareOffsetVector",
     "LabwareParentDefinition",
     "LabwareWellId",
+    "GripSpecs",
     # Liquids
     "HexColor",
     "EmptyLiquidId",

opentrons/protocol_engine/types/labware.py

@@ -23,6 +23,15 @@ from .module import ModuleDefinition
 from .deck_configuration import DeckLocationDefinition
 
 
+@dataclass(frozen=True)
+class GripSpecs:
+    """Data for how a labware should be gripped."""
+
+    uncertaintyWider: float
+    uncertaintyNarrower: float
+    targetY: float
+
+
 class OverlapOffset(Vec3f):
     """Offset representing overlap space of one labware on top of another labware or module."""
 

opentrons/protocols/api_support/definitions.py

@@ -1,6 +1,6 @@
 from .types import APIVersion
 
-MAX_SUPPORTED_VERSION = APIVersion(2, 25)
+MAX_SUPPORTED_VERSION = APIVersion(2, 26)
 """The maximum supported protocol API version in this release."""
 
 MIN_SUPPORTED_VERSION = APIVersion(2, 0)

{opentrons-8.6.0a12.dist-info → opentrons-8.7.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentrons
-Version: 8.6.0a12
+Version: 8.7.0a0
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Project-URL: opentrons.com, https://www.opentrons.com
 Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
@@ -24,7 +24,7 @@ Requires-Dist: click<9,>=8.0.0
 Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
 Requires-Dist: jsonschema<4.18.0,>=3.0.1
 Requires-Dist: numpy<2,>=1.20.0
-Requires-Dist: opentrons-shared-data==8.6.0a12
+Requires-Dist: opentrons-shared-data==8.7.0a0
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2.0.0
@@ -32,6 +32,6 @@ Requires-Dist: pyserial>=3.5
 Requires-Dist: pyusb==1.2.1
 Requires-Dist: typing-extensions<5,>=4.0.0
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex]==8.6.0a12; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex]==8.7.0a0; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware==8.6.0a12; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware==8.7.0a0; extra == 'ot2-hardware'

{opentrons-8.6.0a12.dist-info → opentrons-8.7.0a0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 opentrons/__init__.py,sha256=TQ_Ca_zzAM3iLzAysWKkFkQHG8-imihxDPQbLCYrf-E,4533
-opentrons/_version.py,sha256=Ej-eiQxj2liXf3S-OFMSv77mR8rEtkyJT0yFtbesf_E,714
+opentrons/_version.py,sha256=d3ve2LJJuyjX8J_41fIn96U4XlDfRGAll6nNIi4dBwY,712
 opentrons/execute.py,sha256=Y88qICDiHWQjU0L4Ou7DI5OXXu7zZcdkUvNUYmZqIfc,29282
 opentrons/legacy_broker.py,sha256=XnuEBBlrHCThc31RFW2UR0tGqctqWZ-CZ9vSC4L9whU,1553
 opentrons/ordered_set.py,sha256=g-SB3qA14yxHu9zjGyc2wC7d2TUCBE6fKZlHAtbPzI8,4082
@@ -105,7 +105,7 @@ opentrons/hardware_control/module_control.py,sha256=0mmVH9fiZWNyc33ilCpJHajX1Dfh
 opentrons/hardware_control/motion_utilities.py,sha256=7VG60YQ9MSMAZ0hO-q-kRAdkcebzrx7uIPtc6FMCViE,10311
 opentrons/hardware_control/nozzle_manager.py,sha256=dqD8XlYsOu0PFFyxvmsMypBB52Gi6x-VIwhykV7JhuU,16868
 opentrons/hardware_control/ot3_calibration.py,sha256=vHB17U-FBzytvM8QeEu5kRYPo8lFwAo31ZEpiU4yf_0,45000
-opentrons/hardware_control/ot3api.py,sha256=E8WNL-9Y-tGdkyWeDVysxqHQR_DfK5RAiKulS_365EI,127869
+opentrons/hardware_control/ot3api.py,sha256=1vPsaNPmtjsJI1EJF8JPKOd2Bj2GDJLvmKU8eMKGhi8,127869
 opentrons/hardware_control/pause_manager.py,sha256=wmNmraimE2yZQVqCxX_rtQHUWRzpzyQEaym9fLMgyww,888
 opentrons/hardware_control/poller.py,sha256=rx6Q-UxbUIj3ek69IlYenFh7BFuasszRO-GzzhRPuHQ,3885
 opentrons/hardware_control/robot_calibration.py,sha256=ilszGjZPspKiEk8MQPaHm2B-ljeisAYflKl8UyQ_D0U,7155
@@ -119,8 +119,8 @@ opentrons/hardware_control/backends/controller.py,sha256=MOVMq9s1rY_jHhajHB1hQ1M
 opentrons/hardware_control/backends/errors.py,sha256=ZiVP16exHMTWWOajxffnXEqI6NNfeTw-4RkhXE0EBJA,249
 opentrons/hardware_control/backends/estop_state.py,sha256=_GYjI6OaD3CZNduWV2_RVeOtQ4K_Fg-SP8yU01ENhCY,6554
 opentrons/hardware_control/backends/flex_protocol.py,sha256=3S-OHbAnOSTF5PxzhMxD0TdEfxurLwecBrDkedl2O3s,13185
-opentrons/hardware_control/backends/ot3controller.py,sha256=R_BhVNuycoQyWJngFj4oCoCiOVAkT9yGqjLhP4rcN3g,70641
-opentrons/hardware_control/backends/ot3simulator.py,sha256=lmef2w4KeyHqswGAwsr9RTKO0OclH3h6snq7osEoRik,30385
+opentrons/hardware_control/backends/ot3controller.py,sha256=w0LMGu0WWkGd4cEWaqlhMk1NQFHg1-Di83s5_KrKP3U,71374
+opentrons/hardware_control/backends/ot3simulator.py,sha256=CtYnb7NpqIc1TNK91hI0UaK4OyaIecFDczsb-T7DX_w,30387
 opentrons/hardware_control/backends/ot3utils.py,sha256=HYlIZRGmLqudS1mIt0Io2LxQ1BrLrxVFQCjqudbTUWU,22374
 opentrons/hardware_control/backends/simulator.py,sha256=q_9PQlBdOyCa9sj2gLqYWZ-fG9v4mddDAiScL-yHCXY,17549
 opentrons/hardware_control/backends/status_bar_state.py,sha256=E8z9dCJDI3Nb4qfUA5y2_PrE2jSYzZJQVkk75UqY5ZE,9287
@@ -234,24 +234,25 @@ opentrons/protocol_api/create_protocol_context.py,sha256=wwsZje0L__oDnu1Yrihau32
 opentrons/protocol_api/deck.py,sha256=94vFceg1SC1bAGd7TvC1ZpYwnJR-VlzurEZ6jkacYeg,8910
 opentrons/protocol_api/disposal_locations.py,sha256=NRiSGmDR0LnbyEkWSOM-o64uR2fUoB1NWJG7Y7SsJSs,7920
 opentrons/protocol_api/instrument_context.py,sha256=dOg04iqYnNMJ7XnlHBX3tTGiEahc-7feIuErcevRdwY,141216
-opentrons/protocol_api/labware.py,sha256=ZP4QuGadoDp6xtyToupXVSJFnsx4NfWcskRQAH3iU4Y,61443
-opentrons/protocol_api/module_contexts.py,sha256=HYQ20RV2c-NNwgObQZNxyvVKmy2Ufkf--ILoRmhkcvA,59988
+opentrons/protocol_api/labware.py,sha256=ZGukS0oE6vOltolNx9ZFXj_HFhm5BRaTnS0tJUKxGsE,63061
+opentrons/protocol_api/module_contexts.py,sha256=cPyay45R3SeBckC4fk8txuC7DZoCSeoVSp1ALCMNipQ,63292
 opentrons/protocol_api/module_validation_and_errors.py,sha256=ljst-M_KK78GnyG3pyZ_6yoYkMY3HORS1QyQyWrme-U,2250
-opentrons/protocol_api/protocol_context.py,sha256=Hzgw3FbCRyd4kWmw4RZwZHJhoGZkmn7ug-Q7JZGCcqs,70298
+opentrons/protocol_api/protocol_context.py,sha256=2F-awiZGGNwwdu2xxkjrVDCuemJaV3z4bSIBZoXVVlY,77105
 opentrons/protocol_api/robot_context.py,sha256=D6ZdpFX30VTtVUDHitsVjabJQXD5TxOV9_Z6sik1LvE,11891
-opentrons/protocol_api/validation.py,sha256=73QwpdK5337yu9g8jvpHHizOD0Mf3m6Wr9S8eikrHIc,28993
+opentrons/protocol_api/validation.py,sha256=jFJcw_ixifViupEFaGrjEcuHyNIHG1gvo-n2jSqGnok,29227
 opentrons/protocol_api/core/__init__.py,sha256=-g74o8OtBB0LmmOvwkRvPgrHt7fF7T8FRHDj-x_-Onk,736
 opentrons/protocol_api/core/common.py,sha256=Ne7D4yBC3qywy35jIAC_1xI8HQwYt0HjPRXqIcyP06M,1276
 opentrons/protocol_api/core/core_map.py,sha256=NX06HEDi5Obmaz0Xwwc_dikH0M-bTnZcfnSdMLdQqms,2074
 opentrons/protocol_api/core/instrument.py,sha256=ZlEv60tzH5jxP0Wh9eyTc_28ju75RsllkQufMwYdIio,13985
 opentrons/protocol_api/core/labware.py,sha256=-ZOjkalikXCV3ptehKCNaWGAdKxIdwne8LRFQW9NAm4,4290
 opentrons/protocol_api/core/module.py,sha256=D8d9Xs_AgI53i8POkK2deUiu92V93Wt9-HG4FDKrHnE,15833
-opentrons/protocol_api/core/protocol.py,sha256=3K6D2ClT3-bPySuKJuAPWVwvxD8fTvAKUlQG26I9H4M,8685
+opentrons/protocol_api/core/protocol.py,sha256=Jru2lRuPtgdzpZiuhU6VV6UGN2wbjCSoWm_CAbOVPiU,8695
 opentrons/protocol_api/core/robot.py,sha256=QMAqj5Oqq3_IhTDyUF4jpWI4j2LRPP9crUiaYD_RUv4,1385
 opentrons/protocol_api/core/well.py,sha256=Lf89YYEyq-ahRSRIFJw42vxIP8Fw6kzIUh9K1HEijUQ,3487
 opentrons/protocol_api/core/well_grid.py,sha256=BU28DKaBgEU_JdZ6pEzrwNxmuh6TkO4zlg7Pq1Rf5Xk,1516
 opentrons/protocol_api/core/engine/__init__.py,sha256=B_5T7zgkWDb1mXPg4NbT-wBkQaK-WVokMMnJRNu7xiM,582
 opentrons/protocol_api/core/engine/_default_labware_versions.py,sha256=hLKAp33c_eNLpvT5qUt8AOYy6PHhM_JnkdOXaMl80jA,7541
+opentrons/protocol_api/core/engine/_default_liquid_class_versions.py,sha256=MCPKf-7fAULQ4oPVYxiyKHr4AYRAevwA9uhkdur3-kQ,1513
 opentrons/protocol_api/core/engine/deck_conflict.py,sha256=j3AJ-sYr5e-06UgeGueUldx9B3fn7AhN738kJxZO_vw,14693
 opentrons/protocol_api/core/engine/exceptions.py,sha256=aZgNrmYEeuPZm21nX_KZYtvyjv5h_zPjxxgPkEV7_bw,725
 opentrons/protocol_api/core/engine/instrument.py,sha256=lDrCqOZm7ceu1E50EYiSh7qTDMci5cgw4bM-AvLyMjE,98890
@@ -261,7 +262,7 @@ opentrons/protocol_api/core/engine/module_core.py,sha256=qxxcqpH-A4Zil9hHDxnvh4H
 opentrons/protocol_api/core/engine/overlap_versions.py,sha256=PyGvQtQUg1wzNtkuGZtxwXm019PoIjq7em2JiWaxbXc,675
 opentrons/protocol_api/core/engine/pipette_movement_conflict.py,sha256=x54RIYtkL1rdzvkSp2JgusLY3EEvY8bX3OwipeVKdsE,15511
 opentrons/protocol_api/core/engine/point_calculations.py,sha256=C2eF0fvJQGMqQv3DzNhc1-m8HTAXTyTsHPJEPrEUEmo,2502
-opentrons/protocol_api/core/engine/protocol.py,sha256=uX-qwATcTXiEUXe9gGDmp1cJ1Xd4eQnyy-q_jpiyAYY,46023
+opentrons/protocol_api/core/engine/protocol.py,sha256=MQNMYNII1OxwaQGsKbOgVtmEH54mjDahzD-WHst9MH8,46247
 opentrons/protocol_api/core/engine/robot.py,sha256=bzUt23NG-clD-9-QFsV_6nm3fMgSmvYEG9DyyZI1xgw,5366
 opentrons/protocol_api/core/engine/stringify.py,sha256=GwFgEhFMk-uPfFQhQG_2mkaf4cxaItiY8RW7rZwiooQ,2794
 opentrons/protocol_api/core/engine/transfer_components_executor.py,sha256=mR59C-e6IHSZthlbQEwmRnh5ye8lhr6a0Qp5CNNi9n8,45211
@@ -273,7 +274,7 @@ opentrons/protocol_api/core/legacy/labware_offset_provider.py,sha256=2DLIby9xmUr
 opentrons/protocol_api/core/legacy/legacy_instrument_core.py,sha256=mEX2Kmx8vBag7ndk4pCIssKkH9C-FEk0xphDyogCLGQ,27023
 opentrons/protocol_api/core/legacy/legacy_labware_core.py,sha256=ksal6uzzGcMFEE3Ko2H9cbG8b8u4IprzejkkxdBHwHQ,8579
 opentrons/protocol_api/core/legacy/legacy_module_core.py,sha256=CFCuXN1g5zE2IXD1I09vkngBlOdDzQjuIaNlJ5tVXnQ,23231
-opentrons/protocol_api/core/legacy/legacy_protocol_core.py,sha256=fodiDwsBi1_Yd6Hgf8Kx-iTvky_J6WHmGhwmeRBHqmE,23702
+opentrons/protocol_api/core/legacy/legacy_protocol_core.py,sha256=Owj8Vx3ysQEarPH81PcCpAA0MnVegMkjWXNz5-nRIqg,23712
 opentrons/protocol_api/core/legacy/legacy_well_core.py,sha256=wxeiPBqaS8YQwRpDGwF7ykJ0s2y3bExwVGpNbUZMmFg,5560
 opentrons/protocol_api/core/legacy/load_info.py,sha256=r-WaH5ZJb3TRCp_zvbMMh0P4BhbZM8HsBs1K_pU98dk,1857
 opentrons/protocol_api/core/legacy/module_geometry.py,sha256=lvWFHZ81-JFw-1VZUW1R3yUIb59xpXT6H3jwlRintRo,21082
@@ -305,7 +306,7 @@ opentrons/protocol_engine/commands/aspirate_while_tracking.py,sha256=d8-UBiXmBZ1
 opentrons/protocol_engine/commands/blow_out.py,sha256=3gboq4x5S8fq7j4ZZGNClXFDlOjcdW1v2g58GPdhaPI,4338
 opentrons/protocol_engine/commands/blow_out_in_place.py,sha256=jm2XXyJfIP9-AAFwXhD59_13nX18-i6QqpLGb-lK7sI,3391
 opentrons/protocol_engine/commands/command.py,sha256=1hWH_KWg_WDL4R4VXe1ZH2vO6pYt5SA-ZpuPPF1oV5E,10149
-opentrons/protocol_engine/commands/command_unions.py,sha256=MqZ4Otswq--gzPmkZOk7VLdtaOPvmqu4FiCkOWUPo58,27464
+opentrons/protocol_engine/commands/command_unions.py,sha256=_2iINXrl9yc3H8X-AF8YBhYZQHLU0RHFEfl0MwE2H2w,27550
 opentrons/protocol_engine/commands/comment.py,sha256=-6o07x-MZ6-IvZas84OVFmqF0gAbbKWJZIlGVYThCqM,1638
 opentrons/protocol_engine/commands/configure_for_volume.py,sha256=wLt7-zJfKrRZhz9E0J9Xu_eayDMVPl8utdUYDMwgzFw,3615
 opentrons/protocol_engine/commands/configure_nozzle_layout.py,sha256=M_s5Ee03a7sSnbvkibDHzEqZwkca0y8J7F60EnSEq7A,3849
@@ -364,12 +365,12 @@ opentrons/protocol_engine/commands/calibration/calibrate_module.py,sha256=5QZ5zL
 opentrons/protocol_engine/commands/calibration/calibrate_pipette.py,sha256=YMH2MJ7RI0Nf7xjoXJLPlCuMCs5_Stj8zLj-oHcfnDk,3278
 opentrons/protocol_engine/commands/calibration/move_to_maintenance_position.py,sha256=Y5UI4zcnhhVdfQOYh1N07jkBiVChD0kS_H_ow7_qiCA,5311
 opentrons/protocol_engine/commands/flex_stacker/__init__.py,sha256=IJLskKdZZOGUA1eOm2e3fiP1C9GyTdbTS6uY6Hc4nUk,1369
-opentrons/protocol_engine/commands/flex_stacker/common.py,sha256=MHd3mIGK7JpTvL8NGdKQZFBg5yr20dyY4cJMq4TQqlw,34813
+opentrons/protocol_engine/commands/flex_stacker/common.py,sha256=QHBtKawQxWssm6nSmtIpuJCH6BFlT54k4XQTBNSU8mY,35249
 opentrons/protocol_engine/commands/flex_stacker/empty.py,sha256=1R0AwQtLn_wfuFH0Og2yAngJU8T_XLqf0a__9CqZQy0,11492
 opentrons/protocol_engine/commands/flex_stacker/fill.py,sha256=3qhAQxJfaSp4EAFGIUotkrJVuOvdFrwzmkMCa2v6khA,10866
 opentrons/protocol_engine/commands/flex_stacker/retrieve.py,sha256=kh9Lh-FW-RrXmV4RS8txmTYPfPDKhQhjW0UXr8k0vhc,12763
 opentrons/protocol_engine/commands/flex_stacker/set_stored_labware.py,sha256=5VdqCcBdIHmpWqIJN3rCKeZ6IKwfxAdQTXMTD-KL-5w,12484
-opentrons/protocol_engine/commands/flex_stacker/store.py,sha256=8iS77NRj9CVp12S9uVfCJTl-Q0iaJkCQDcOJWZnSeI0,12770
+opentrons/protocol_engine/commands/flex_stacker/store.py,sha256=Ed49qEUc16wo643PztZLYNPhVuLNZbx0lALSvpRYwDk,13632
 opentrons/protocol_engine/commands/heater_shaker/__init__.py,sha256=ImAPrYSUvP8tI7obvoHmrJbjwLldgGNTnFYRgfXj8hI,2757
 opentrons/protocol_engine/commands/heater_shaker/close_labware_latch.py,sha256=Q7sqFtzUD8wclRLL2PLWjnClIeLtJsiMCobStvzoJKc,2847
 opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py,sha256=UYeGrTmnGtfw22p0agefI2ZnpukKlIgFcmJv9v58Xnc,2755
@@ -426,7 +427,7 @@ opentrons/protocol_engine/execution/error_recovery_hardware_state_synchronizer.p
 opentrons/protocol_engine/execution/gantry_mover.py,sha256=LFTPmzuGRuP6IspgXxIEyJIXV0tHkc4UWDDjWFCClYo,26477
 opentrons/protocol_engine/execution/hardware_stopper.py,sha256=ZlhVYEdFfuKqp5slZBkustXcRPy5fJsw2rmfYzHuJkQ,6127
 opentrons/protocol_engine/execution/heater_shaker_movement_flagger.py,sha256=BSFLzSSeELAYZCrCUfJZx5DdlrwU06Ur92TYd0T-hzM,9084
-opentrons/protocol_engine/execution/labware_movement.py,sha256=Bl-Nx3y5-zMlsxL3fcXV04OyiU1JFyqPJTS1Fir_XkA,12962
+opentrons/protocol_engine/execution/labware_movement.py,sha256=0QnTf98CpYItP1icvNpwUeIa2LUWk4w7yBCUVJw-64g,12656
 opentrons/protocol_engine/execution/movement.py,sha256=ZU4K4OHnzZYCZbk3RwfSOC6C3T2jtBlvYMppJhJSF08,12749
 opentrons/protocol_engine/execution/pipetting.py,sha256=cnJYbLiJ2QD1xziD8dkRm0mZG3xOk00klW8Ff8rgSG4,22199
 opentrons/protocol_engine/execution/queue_worker.py,sha256=LM753TrQzJoKUSIrtcaHDOWLe58zcpx-fUOLVpyDlHM,3302
@@ -463,7 +464,7 @@ opentrons/protocol_engine/state/files.py,sha256=w8xxxg8HY0RqKKEGSfHWfrjV54Gb02O3
 opentrons/protocol_engine/state/fluid_stack.py,sha256=uwkf0qYk1UX5iU52xmk-e3yLPK8OG-TtMCcBqrkVFpM,5932
 opentrons/protocol_engine/state/geometry.py,sha256=o8tefXS_Jekdt82dW4HHVJSnsxCsTFJuG6ogtri2wTY,104065
 opentrons/protocol_engine/state/inner_well_math_utils.py,sha256=UhemsPpcuKwVc-iGXI2-v--miOGNunAnAVznJTVADlQ,20598
-opentrons/protocol_engine/state/labware.py,sha256=bmNOa6vDFXa-Iow4x_1zNa3tIcNkUvu1OCg3ED2E4i4,59936
+opentrons/protocol_engine/state/labware.py,sha256=vwagsqSBAIkVj4eupu0pIK6F3idnqqoRWDjVbp4ZwKQ,62977
 opentrons/protocol_engine/state/liquid_classes.py,sha256=u_z75UYdiFAKG0yB3mr1il4T3qaS0Sotq8sL7KLODP8,2990
 opentrons/protocol_engine/state/liquids.py,sha256=NoesktcQdJUjIVmet1uqqJPf-rzbo4SGemXwQC295W0,2338
 opentrons/protocol_engine/state/modules.py,sha256=SM_6j3YfZV4ZXWTGjwxQIVH-jtHEI-YFuJtoMyPBReo,61599
@@ -482,7 +483,7 @@ opentrons/protocol_engine/state/module_substates/magnetic_block_substate.py,sha2
 opentrons/protocol_engine/state/module_substates/magnetic_module_substate.py,sha256=IJ5zpufz5WSRbJqHOAi-WroDxpsRZz-GvwznIL4v7VQ,2468
 opentrons/protocol_engine/state/module_substates/temperature_module_substate.py,sha256=w9h6EBM1YY8SeUOlUz5-nW1Zoyce8-zua8Z6mX4sDNg,2310
 opentrons/protocol_engine/state/module_substates/thermocycler_module_substate.py,sha256=fLt2jMsbnfe8Q25vAjloxLBGdx8sotqM34VxbwfegpE,5167
-opentrons/protocol_engine/types/__init__.py,sha256=8nOYquZPSvQAqkCz9Jfev86SmQ1Tou-AL5RMMvSz07o,8344
+opentrons/protocol_engine/types/__init__.py,sha256=8zInoWjiYEAir1Frq1ESEdFYj17aBH4zXjxL4odPLR0,8376
 opentrons/protocol_engine/types/automatic_tip_selection.py,sha256=I_B3iWei1Sl7F7IrMKqOn4S12heZXRnfKvtCTUXIMyM,1118
 opentrons/protocol_engine/types/command_annotations.py,sha256=5A4k_R_4A2_nGl0K85SKwNlnKA09fUhEIe_mdU55yro,1843
 opentrons/protocol_engine/types/deck_configuration.py,sha256=3dhkk3Z_PrJvqb26brkEdlyzMAGih_UopoEzu9k6SRk,2422
@@ -490,7 +491,7 @@ opentrons/protocol_engine/types/execution.py,sha256=6g_NvlF4niXjFQwDjkmTgKx-N6I8
 opentrons/protocol_engine/types/hardware_passthrough.py,sha256=tpTE3XHbRjXWQqY0rgosIfcOAGHqMkOpIU3IpIXgdAA,534
 opentrons/protocol_engine/types/instrument.py,sha256=sqiY6OKYgI0ViQ2UsuYMkL9MI6OpvdgLzC1mvclrp2M,984
 opentrons/protocol_engine/types/instrument_sensors.py,sha256=CGcChvuxpRXVJHLZP_wd1ej3XDD9x1S9biugMAnk0tM,1449
-opentrons/protocol_engine/types/labware.py,sha256=Htfoqz5lXCJmdib4hYIyXkETTsPZ67bfkZXrO1gmLtk,4441
+opentrons/protocol_engine/types/labware.py,sha256=huIKtzEmWJcWuyKq5jN_3Ra4QXRDUbaK2Ck0O3vV5zU,4615
 opentrons/protocol_engine/types/labware_movement.py,sha256=BEZIDc-6YhU9LRACi0ozroIxuOIq-tngvrFE22uufjs,577
 opentrons/protocol_engine/types/labware_offset_location.py,sha256=gXOmIHLD1Hk6OhfhmV9Uf2HN0rIKD6syWSPfYehB9QQ,4237
 opentrons/protocol_engine/types/labware_offset_vector.py,sha256=2M_q0vSjOyjujt-0NY9NM0asQS27MHYElcFgoKCAZAY,377
@@ -541,7 +542,7 @@ opentrons/protocols/advanced_control/transfers/transfer_liquid_utils.py,sha256=w
 opentrons/protocols/api_support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opentrons/protocols/api_support/constants.py,sha256=pI_zJ8oORr6FUOaF508ttll3KOIYqRRgcwVFwnqZuqc,262
 opentrons/protocols/api_support/deck_type.py,sha256=cBxm-IQqFyL1QtYTMGtLXOlyuh-67xWgnJSP6rkg8oc,3942
-opentrons/protocols/api_support/definitions.py,sha256=vjt7jgMqtntWL2MvYC6pAXcPWJ066Xf4coi3RwbArv8,727
+opentrons/protocols/api_support/definitions.py,sha256=Sg0LIzkncnqTPz-e6EtLxdPmEVhogKkmDv3lTpGfmdI,727
 opentrons/protocols/api_support/instrument.py,sha256=xbgFKbJU_gL1QjbH_mgGHJx2USQIQisjEkBHiFfYEqA,5712
 opentrons/protocols/api_support/labware_like.py,sha256=JArK3XIYSMzDJTnpsVg9KNcMBEaRLMllmbV4ZtcI02s,7701
 opentrons/protocols/api_support/tip_tracker.py,sha256=ztngh5wGworD77ycKHm3_f9EqjT24VFXIAARAGcCPns,7407
@@ -594,8 +595,8 @@ opentrons/util/linal.py,sha256=IlKAP9HkNBBgULeSf4YVwSKHdx9jnCjSr7nvDvlRALg,5753
 opentrons/util/logging_config.py,sha256=7et4YYuQdWdq_e50U-8vFS_QyNBRgdnqPGAQJm8qrIo,9954
 opentrons/util/logging_queue_handler.py,sha256=ZsSJwy-oV8DXwpYiZisQ1PbYwmK2cOslD46AcyJ1E4I,2484
 opentrons/util/performance_helpers.py,sha256=ew7H8XD20iS6-2TJAzbQeyzStZkkE6PzHt_Adx3wbZQ,5172
-opentrons-8.6.0a12.dist-info/METADATA,sha256=l9QH2vlXU_XB9ZQoxc0ls8JKOmdyxwzStTlW-DmhdUw,1611
-opentrons-8.6.0a12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-opentrons-8.6.0a12.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
-opentrons-8.6.0a12.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-opentrons-8.6.0a12.dist-info/RECORD,,
+opentrons-8.7.0a0.dist-info/METADATA,sha256=U7gGnD5DR1XRNN5e9BqM9v9_NnJFeqsqVZI51jyMnoM,1607
+opentrons-8.7.0a0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentrons-8.7.0a0.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
+opentrons-8.7.0a0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+opentrons-8.7.0a0.dist-info/RECORD,,