opentrons 8.6.0a11__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.0a11'
-__version_tuple__ = version_tuple = (8, 6, 0, 'a11')
+__version__ = version = '8.7.0a0'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a0')
 
 __commit_id__ = commit_id = None

opentrons/cli/analyze.py

@@ -1,4 +1,5 @@
 """Opentrons analyze CLI."""
+
 import click
 
 from anyio import run
@@ -24,7 +25,9 @@ from typing import (
 import logging
 import sys
 import json
+import gc
 
+from opentrons.protocol_engine import ProtocolEngine
 from opentrons.protocol_engine.types import (
     RunTimeParameter,
     CSVRuntimeParamPaths,
@@ -94,6 +97,18 @@ class _Output:
     help="Return analysis results as JSON, formatted for human eyes. Specify --human-json-output=- to use stdout, but be aware that Python protocols may contain print() which will make the output JSON invalid.",
     type=click.File(mode="wb"),
 )
+@click.option(
+    "--leaks",
+    help="Fail (via exit code) if the analysis engine has not been garbage collected after analysis is complete.",
+    is_flag=True,
+    default=False,
+)
+@click.option(
+    "--leaks-debug",
+    help="Drop into a PDB shell if a leak is detected",
+    is_flag=True,
+    default=False,
+)
 @click.option(
     "--check",
     help="Fail (via exit code) if the protocol had an error. If not specified, always succeed.",
@@ -133,6 +148,8 @@ def analyze(
     log_output: str,
     log_level: str,
     check: bool,
+    leaks: bool,
+    leaks_debug: bool,
 ) -> int:
     """Analyze a protocol.
 
@@ -147,7 +164,18 @@ def analyze(
 
     try:
         with _capture_logs(log_output, log_level):
-            sys.exit(run(_analyze, files, rtp_values, rtp_files, outputs, check))
+            sys.exit(
+                run(
+                    _analyze,
+                    files,
+                    rtp_values,
+                    rtp_files,
+                    outputs,
+                    check,
+                    leaks or leaks_debug,
+                    leaks_debug,
+                )
+            )
     except click.ClickException:
         raise
     except Exception as e:
@@ -344,12 +372,14 @@ async def _do_analyze(
     return await orchestrator.run(deck_configuration=[])
 
 
-async def _analyze(
+async def _analyze(  # noqa: C901
     files_and_dirs: Sequence[Path],
     rtp_values: str,
     rtp_files: str,
     outputs: Sequence[_Output],
     check: bool,
+    fail_on_leak: bool,
+    debug_on_leak: bool,
 ) -> int:
     input_files = _get_input_files(files_and_dirs)
     parsed_rtp_values = _get_runtime_parameter_values(rtp_values)
@@ -366,6 +396,32 @@ async def _analyze(
     analysis = await _do_analyze(protocol_source, parsed_rtp_values, rtp_paths)
     return_code = _get_return_code(analysis)
 
+    # This ugly code checks to see if an engine remains past garbage collection
+    # after analysis is complete.
+    # It should be here and open coded to make it a little easier to present
+    # the debug option.
+    if fail_on_leak or debug_on_leak:
+        gc.collect()
+        leaked_engine = next(
+            (obj for obj in gc.get_objects() if isinstance(obj, ProtocolEngine)), None
+        )
+        if leaked_engine:
+            if fail_on_leak:
+                print(
+                    "A ProtocolEngine instance exists even after garbage collection; "
+                    "some thing (likely in the protocol) has caused it to be leaked, "
+                    "likely by reference to the engine or something that refers to the "
+                    "engine after the run function ends.",
+                    file=sys.stderr,
+                )
+                return_code = -2
+            if debug_on_leak:
+                print(
+                    "You are now in an interactive PDB (https://docs.python.org/3.10/library/pdb.html) "
+                    "session; the leaked engine is bound to the variable leaked_engine."
+                )
+                breakpoint()
+
     if not outputs:
         return return_code
 

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/engine/transfer_components_executor.py

@@ -5,7 +5,7 @@ import logging
 from copy import deepcopy
 from enum import Enum
 from typing import TYPE_CHECKING, Optional, Union, Literal
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 
 from opentrons_shared_data.liquid_classes.liquid_class_definition import (
     PositionReference,
@@ -21,7 +21,6 @@ from opentrons.protocol_api._liquid_properties import (
     MultiDispenseProperties,
     TouchTipProperties,
 )
-from opentrons.protocol_engine.errors import TouchTipDisabledError
 from opentrons.types import Location, Point, Mount
 from opentrons.protocols.advanced_control.transfers.transfer_liquid_utils import (
     LocationCheckDescriptors,
@@ -466,7 +465,7 @@ class TransferComponentsExecutor:
         2. If blowout is enabled and “destination”
             - Do blow-out (at the retract position)
             - Leave plunger down
-        3. Touch-tip
+        3. Touch-tip in the destination well.
         4. If not ready-to-aspirate
             - Prepare-to-aspirate (at the retract position)
         5. Air-gap (at the retract position)
@@ -479,7 +478,7 @@ class TransferComponentsExecutor:
         6. If blowout is “source” or “trash”
             - Move to location (top of Well)
             - Do blow-out (top of well)
-            - Do touch-tip (?????) (only if it’s in a non-trash location)
+            - Do touch-tip AGAIN at the source well (if blowout in a non-trash location)
             - Prepare-to-aspirate (top of well)
             - Do air-gap (top of well)
         7. If drop tip, move to drop tip location, drop tip
@@ -563,9 +562,9 @@ class TransferComponentsExecutor:
             blowout_props.enabled
             and blowout_props.location != BlowoutLocation.DESTINATION
         ):
-            # TODO: no-op touch tip if touch tip is enabled and blowout is in trash/ reservoir/ any labware with touch-tip disabled
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
+            blowout_touch_tip_props = retract_props.touch_tip
             touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
@@ -584,6 +583,13 @@ class TransferComponentsExecutor:
                     source_well.get_top(0), labware=source_location.labware
                 )
                 touch_tip_and_air_gap_well = source_well
+                # Skip touch tip if blowing out at the SOURCE and it's untouchable:
+                if (
+                    "touchTipDisabled"
+                    in source_location.labware.quirks_from_any_parent()
+                ):
+                    blowout_touch_tip_props = replace(blowout_touch_tip_props)
+                    blowout_touch_tip_props.enabled = False
             else:
                 self._instrument.blow_out(
                     location=trash_location,
@@ -612,7 +618,7 @@ class TransferComponentsExecutor:
             )
             # Do touch tip and air gap again after blowing out into source well or trash
             self._do_touch_tip_and_air_gap_after_dispense(
-                touch_tip_properties=retract_props.touch_tip,
+                touch_tip_properties=blowout_touch_tip_props,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
                 air_gap_volume=air_gap_volume,
@@ -758,6 +764,7 @@ class TransferComponentsExecutor:
         ):
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
+            blowout_touch_tip_props = retract_props.touch_tip
             touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
@@ -776,6 +783,13 @@ class TransferComponentsExecutor:
                     source_well.get_top(0), labware=source_location.labware
                 )
                 touch_tip_and_air_gap_well = source_well
+                # Skip touch tip if blowing out at the SOURCE and it's untouchable:
+                if (
+                    "touchTipDisabled"
+                    in source_location.labware.quirks_from_any_parent()
+                ):
+                    blowout_touch_tip_props = replace(blowout_touch_tip_props)
+                    blowout_touch_tip_props.enabled = False
             else:
                 self._instrument.blow_out(
                     location=trash_location,
@@ -807,13 +821,13 @@ class TransferComponentsExecutor:
                 air_gap_volume = 0
             # Do touch tip and air gap again after blowing out into source well or trash
             self._do_touch_tip_and_air_gap_after_dispense(
-                touch_tip_properties=retract_props.touch_tip,
+                touch_tip_properties=blowout_touch_tip_props,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
                 air_gap_volume=air_gap_volume,
             )
 
-    def _do_touch_tip_and_air_gap_after_dispense(  # noqa: C901
+    def _do_touch_tip_and_air_gap_after_dispense(
         self,
         touch_tip_properties: TouchTipProperties,
         location: Union[Location, TrashBin, WasteChute],
@@ -822,6 +836,12 @@ class TransferComponentsExecutor:
     ) -> None:
         """Perform touch tip and air gap as part of post-dispense retract.
 
+        This function can be invoked up to 2 times for each dispense:
+        1) Once for touching tip at the dispense location.
+        2) Then again in the blowout location if it is not the dispense location.
+        For case (2), the caller should disable touch-tip in touch_tip_properties
+        if the blowout location is not touchable (such as reservoirs).
+
         If the retract location is at or above the safe location of
         AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP, then add the air gap at the retract location
         (where the pipette is already assumed to be at).
@@ -842,18 +862,14 @@ class TransferComponentsExecutor:
             #  whether the touch tip params from transfer props should be used for
             #  both dest-well touch tip and non-dest-well touch tip.
             if isinstance(location, Location) and well is not None:
-                try:
-                    self._instrument.touch_tip(
-                        location=location,
-                        well_core=well,
-                        radius=1,
-                        z_offset=touch_tip_properties.z_offset,
-                        speed=touch_tip_properties.speed,
-                        mm_from_edge=touch_tip_properties.mm_from_edge,
-                    )
-                except TouchTipDisabledError:
-                    # TODO: log a warning
-                    pass
+                self._instrument.touch_tip(
+                    location=location,
+                    well_core=well,
+                    radius=1,
+                    z_offset=touch_tip_properties.z_offset,
+                    speed=touch_tip_properties.speed,
+                    mm_from_edge=touch_tip_properties.mm_from_edge,
+                )
 
                 # Move back to the 'retract' position
                 self._instrument.move_to(

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