opentrons 8.7.0a0__py3-none-any.whl → 8.7.0a2__py3-none-any.whl

opentrons/protocol_engine/protocol_engine.py

@@ -59,7 +59,6 @@ from .actions import (
     AddAddressableAreaAction,
     AddModuleAction,
     HardwareStoppedAction,
-    ResetTipsAction,
     SetPipetteMovementSpeedAction,
 )
 
@@ -322,24 +321,10 @@ class ProtocolEngine:
         )
         return completed_command
 
-    def estop(self) -> None:
-        """Signal to the engine that an E-stop event occurred.
-
-        If an estop happens while the robot is moving, lower layers physically stop
-        motion and raise the event as an exception, which fails the Protocol Engine
-        command. No action from the `ProtocolEngine` caller is needed to handle that.
-
-        However, if an estop happens in between commands, or in the middle of
-        a command like `comment` or `waitForDuration` that doesn't access the hardware,
-        `ProtocolEngine` needs to be told about it so it can interrupt the command
-        and stop executing any more. This method is how to do that.
-
-        This acts roughly like `request_stop()`. After calling this, you should call
-        `finish()` with an EStopActivatedError.
-        """
+    def _stop_from_asynchronous_error(self) -> None:
         try:
             action = self._state_store.commands.validate_action_allowed(
-                StopAction(from_estop=True)
+                StopAction(from_asynchronous_error=True)
             )
         except Exception:  # todo(mm, 2024-04-16): Catch a more specific type.
             # This is likely called from some hardware API callback that doesn't care
@@ -358,9 +343,72 @@ class ProtocolEngine:
         # do this because we want to make sure non-hardware commands, like
         # `waitForDuration`, are also interrupted.
         self._get_queue_worker.cancel()
+
+    def estop(self) -> None:
+        """Signal to the engine that an E-stop event occurred.
+
+        If an estop happens while the robot is moving, lower layers physically stop
+        motion and raise the event as an exception, which fails the Protocol Engine
+        command. No action from the `ProtocolEngine` caller is needed to handle that.
+
+        However, if an estop happens in between commands, or in the middle of
+        a command like `comment` or `waitForDuration` that doesn't access the hardware,
+        `ProtocolEngine` needs to be told about it so it can interrupt the command
+        and stop executing any more. This method is how to do that.
+
+        This acts roughly like `request_stop()`. After calling this, you should call
+        `finish()` with an EStopActivatedError.
+        """
         # Unlike self.request_stop(), we don't need to do
         # self._hardware_api.cancel_execution_and_running_tasks(). Since this was an
         # E-stop event, the hardware API already knows.
+        self._stop_from_asynchronous_error()
+
+    async def async_module_error(
+        self, module_model: ModuleModel, serial: str | None
+    ) -> bool:
+        """Signal to the engine that an asynchronous module error occured.
+
+        The return value of this function signals whether the error is relevant to the protocol
+        or not. If the function returns True, the error is relevant. The engine will stop, and
+        the caller should call `finish()` with the error object that signaled the error. If
+        the function returns False, the error is not relevant. The engine will not stop, and the
+        caller should not call `finish()`.
+
+        Asynchronous module errors are signaled when a module enters a hardware error state
+        - for instance, a thermocycler's thermistors fail because of condensation, or a
+        heater-shaker's wires fray and snap, or a module is accidentally disconnected. These
+        errors are not related to a particular command, even a currently-happening module
+        control command for the module in the error state.
+
+        Similar to an estop error, the error can occur at any time relative to the lifecycle
+        of the engine run or of any particular command.
+
+        Unlike an estop, the motion control hardware will not be raising an error and will not
+        stop on its own; the stop action derived from this call will do that.
+        """
+        if not self._state_store.modules.get_has_module_probably_matching_hardware_details(
+            module_model, serial
+        ):
+            return False
+        self._stop_from_asynchronous_error()
+        # like self.request_stop, and unlike self.estop(), we must explicitly request that the
+        # hardware stops execution, since not all asynchronous errors will cause the hardware
+        # to know that it should stop.
+        await self._do_hardware_stop()
+        return True
+
+    async def _do_hardware_stop(self) -> None:
+        """Make the hardware stop now."""
+        if self._hardware_api.is_movement_execution_taskified():
+            # We 'taskify' hardware controller movement functions when running protocols
+            # that are not backed by the engine. Such runs cannot be stopped by cancelling
+            # the queue worker and hence need to be stopped via the execution manager.
+            # `cancel_execution_and_running_tasks()` sets the execution manager in a CANCELLED state
+            # and cancels the running tasks, which raises an error and gets us out of the
+            # run function execution, just like `_queue_worker.cancel()` does for
+            # engine-backed runs.
+            await self._hardware_api.cancel_execution_and_running_tasks()
 
     async def request_stop(self) -> None:
         """Make command execution stop soon.
@@ -378,15 +426,7 @@ class ProtocolEngine:
         action = self._state_store.commands.validate_action_allowed(StopAction())
         self._action_dispatcher.dispatch(action)
         self._get_queue_worker.cancel()
-        if self._hardware_api.is_movement_execution_taskified():
-            # We 'taskify' hardware controller movement functions when running protocols
-            # that are not backed by the engine. Such runs cannot be stopped by cancelling
-            # the queue worker and hence need to be stopped via the execution manager.
-            # `cancel_execution_and_running_tasks()` sets the execution manager in a CANCELLED state
-            # and cancels the running tasks, which raises an error and gets us out of the
-            # run function execution, just like `_queue_worker.cancel()` does for
-            # engine-backed runs.
-            await self._hardware_api.cancel_execution_and_running_tasks()
+        await self._do_hardware_stop()
 
     async def wait_until_complete(self) -> None:
         """Wait until there are no more commands to execute.
@@ -429,7 +469,7 @@ class ProtocolEngine:
             post_run_hardware_state: The state in which to leave the gantry and motors in
                 after the run is over.
         """
-        if self._state_store.commands.get_is_stopped_by_estop():
+        if self._state_store.commands.get_is_stopped_by_async_error():
             # This handles the case where the E-stop was pressed while we were *not* in the middle
             # of some hardware interaction that would raise it as an exception. For example, imagine
             # we were paused between two commands, or imagine we were executing a waitForDuration.
@@ -586,12 +626,6 @@ class ProtocolEngine:
             AddAddressableAreaAction(addressable_area_name)
         )
 
-    def reset_tips(self, labware_id: str) -> None:
-        """Reset the tip state of a given labware."""
-        # TODO(mm, 2023-03-10): Safely raise an error if the given labware isn't a
-        # tip rack?
-        self._action_dispatcher.dispatch(ResetTipsAction(labware_id=labware_id))
-
     # TODO(mm, 2022-11-10): This is a method on ProtocolEngine instead of a command
     # as a quick hack to support Python protocols. We should consider making this a
     # command, or adding speed parameters to existing commands.

opentrons/protocol_engine/resources/__init__.py

@@ -11,6 +11,7 @@ from .labware_data_provider import LabwareDataProvider
 from .module_data_provider import ModuleDataProvider
 from .file_provider import FileProvider
 from .ot3_validation import ensure_ot3_hardware
+from .concurrency_provider import ConcurrencyProvider
 
 
 __all__ = [
@@ -18,6 +19,7 @@ __all__ = [
     "LabwareDataProvider",
     "DeckDataProvider",
     "DeckFixedLabware",
+    "ConcurrencyProvider",
     "ModuleDataProvider",
     "FileProvider",
     "ensure_ot3_hardware",

opentrons/protocol_engine/resources/concurrency_provider.py

@@ -0,0 +1,27 @@
+"""Concurrency primitives providers."""
+import asyncio
+
+
+class ConcurrencyProvider:
+    """Concurrency primitives for engine tasks."""
+
+    def __init__(self) -> None:
+        """Build a concurrency provider."""
+        self._locks: dict[str, asyncio.Lock] = {}
+        self._queues: dict[str, "asyncio.Queue[asyncio.Task[None]]"] = {}
+
+    def lock_for_group(self, group_id: str) -> asyncio.Lock:
+        """Returns the lock for specified group id."""
+        try:
+            return self._locks[group_id]
+        except KeyError:
+            self._locks[group_id] = asyncio.Lock()
+            return self._locks[group_id]
+
+    def queue_for_group(self, group_id: str) -> "asyncio.Queue[asyncio.Task[None]]":
+        """Returns the queue for specified group id."""
+        try:
+            return self._queues[group_id]
+        except KeyError:
+            self._queues[group_id] = asyncio.Queue()
+            return self._queues[group_id]

opentrons/protocol_engine/resources/deck_configuration_provider.py

@@ -2,6 +2,7 @@
 
 from typing import List, Set, Tuple
 
+from opentrons_shared_data.module.types import ModuleOrientation
 from opentrons_shared_data.deck.types import (
     DeckDefinitionV5,
     CutoutFixture,
@@ -124,6 +125,11 @@ def get_addressable_area_from_name(
                 z=addressable_area["boundingBox"]["zDimension"],
             )
             features = addressable_area["features"]
+            orientation = (
+                addressable_area["orientation"]
+                if addressable_area["orientation"]
+                else ModuleOrientation.NOT_APPLICABLE
+            )
             mating_surface_unit_vector = addressable_area.get("matingSurfaceUnitVector")
 
             return AddressableArea(
@@ -138,6 +144,7 @@ def get_addressable_area_from_name(
                     "compatibleModuleTypes", []
                 ),
                 features=features,
+                orientation=orientation,
             )
     raise AddressableAreaDoesNotExistError(
         f"Could not find addressable area with name {addressable_area_name}"

opentrons/protocol_engine/resources/labware_validation.py

@@ -2,6 +2,7 @@
 
 from opentrons_shared_data.labware.labware_definition import (
     LabwareDefinition,
+    LabwareDefinition2,
     LabwareRole,
 )
 
@@ -44,15 +45,18 @@ def validate_definition_is_system(definition: LabwareDefinition) -> bool:
     return LabwareRole.system in definition.allowedRoles
 
 
-def validate_labware_can_be_stacked(
-    top_labware_definition: LabwareDefinition, below_labware_load_name: str
+def validate_legacy_labware_can_be_stacked(
+    child_labware_definition: LabwareDefinition2, parent_labware_load_name: str
 ) -> bool:
-    """Validate that the labware being loaded onto is in the above labware's stackingOffsetWithLabware definition."""
+    """Validate that the parent labware is in the child labware's stackingOffsetWithLabware definition.
+
+    Schema 3 Labware stacking validation is handled in locating features.
+    """
     return (
-        below_labware_load_name in top_labware_definition.stackingOffsetWithLabware
+        parent_labware_load_name in child_labware_definition.stackingOffsetWithLabware
         or (
-            "default" in top_labware_definition.stackingOffsetWithLabware
-            and top_labware_definition.compatibleParentLabware is None
+            "default" in child_labware_definition.stackingOffsetWithLabware
+            and child_labware_definition.compatibleParentLabware is None
         )
     )
 

opentrons/protocol_engine/state/_well_math.py

@@ -17,13 +17,47 @@ def wells_covered_by_pipette_configuration(
     """Compute the wells covered by a pipette nozzle configuration."""
     if len(labware_wells_by_column) >= 12 and len(labware_wells_by_column[0]) >= 8:
         yield from wells_covered_dense(
-            nozzle_map,
+            nozzle_map.columns,
+            nozzle_map.rows,
+            nozzle_map.starting_nozzle,
             target_well,
             labware_wells_by_column,
         )
     elif len(labware_wells_by_column) < 12 and len(labware_wells_by_column[0]) < 8:
         yield from wells_covered_sparse(
-            nozzle_map, target_well, labware_wells_by_column
+            nozzle_map.columns,
+            nozzle_map.rows,
+            nozzle_map.starting_nozzle,
+            target_well,
+            labware_wells_by_column,
+        )
+    else:
+        raise InvalidStoredData(
+            "Labware of non-SBS and non-reservoir format cannot be handled"
+        )
+
+
+def wells_covered_by_physical_pipette(
+    nozzle_map: NozzleMap,
+    target_well: str,
+    labware_wells_by_column: list[list[str]],
+) -> Iterator[str]:
+    """Compute the wells covered by a pipette nozzle configuration."""
+    if len(labware_wells_by_column) >= 12 and len(labware_wells_by_column[0]) >= 8:
+        yield from wells_covered_dense(
+            nozzle_map.full_instrument_columns,
+            nozzle_map.full_instrument_rows,
+            nozzle_map.starting_nozzle,
+            target_well,
+            labware_wells_by_column,
+        )
+    elif len(labware_wells_by_column) < 12 and len(labware_wells_by_column[0]) < 8:
+        yield from wells_covered_sparse(
+            nozzle_map.full_instrument_columns,
+            nozzle_map.full_instrument_rows,
+            nozzle_map.starting_nozzle,
+            target_well,
+            labware_wells_by_column,
         )
     else:
         raise InvalidStoredData(
@@ -42,7 +76,11 @@ def row_col_ordinals_from_column_major_map(
 
 
 def wells_covered_dense(  # noqa: C901
-    nozzle_map: NozzleMap, target_well: str, target_wells_by_column: list[list[str]]
+    columns: dict[str, list[str]],
+    rows: dict[str, list[str]],
+    starting_nozzle: str,
+    target_well: str,
+    target_wells_by_column: list[list[str]],
 ) -> Iterator[str]:
     """Get the list of wells covered by a nozzle map on an SBS format labware with a specified multiplier of 96 into the number of wells.
 
@@ -66,11 +104,11 @@ def wells_covered_dense(  # noqa: C901
             "This labware cannot be used with wells_covered_dense() because it is less dense than an SBS 96 standard"
         )
 
-    for nozzle_column in range(len(nozzle_map.columns)):
+    for nozzle_column in range(len(columns)):
         target_column_offset = nozzle_column * column_downsample
-        for nozzle_row in range(len(nozzle_map.rows)):
+        for nozzle_row in range(len(rows)):
             target_row_offset = nozzle_row * row_downsample
-            if nozzle_map.starting_nozzle == "A1":
+            if starting_nozzle == "A1":
                 if (
                     target_column_index + target_column_offset
                     < len(target_wells_by_column)
@@ -81,7 +119,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index + target_column_offset
                     ][target_row_index + target_row_offset]
-            elif nozzle_map.starting_nozzle == "A12":
+            elif starting_nozzle == "A12":
                 if (target_column_index - target_column_offset >= 0) and (
                     target_row_index + target_row_offset
                     < len(target_wells_by_column[target_column_index])
@@ -89,7 +127,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index - target_column_offset
                     ][target_row_index + target_row_offset]
-            elif nozzle_map.starting_nozzle == "H1":
+            elif starting_nozzle == "H1":
                 if (
                     target_column_index + target_column_offset
                     < len(target_wells_by_column)
@@ -97,7 +135,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index + target_column_offset
                     ][target_row_index - target_row_offset]
-            elif nozzle_map.starting_nozzle == "H12":
+            elif starting_nozzle == "H12":
                 if (target_column_index - target_column_offset >= 0) and (
                     target_row_index - target_row_offset >= 0
                 ):
@@ -106,12 +144,16 @@ def wells_covered_dense(  # noqa: C901
                     ][target_row_index - target_row_offset]
             else:
                 raise InvalidProtocolData(
-                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
+                    f"A pipette nozzle configuration may not having a starting nozzle of {starting_nozzle}"
                 )
 
 
 def wells_covered_sparse(  # noqa: C901
-    nozzle_map: NozzleMap, target_well: str, target_wells_by_column: list[list[str]]
+    columns: dict[str, list[str]],
+    rows: dict[str, list[str]],
+    starting_nozzle: str,
+    target_well: str,
+    target_wells_by_column: list[list[str]],
 ) -> Iterator[str]:
     """Get the list of wells covered by a nozzle map on a column-oriented reservoir.
 
@@ -128,9 +170,9 @@ def wells_covered_sparse(  # noqa: C901
         raise InvalidStoredData(
             "This labware cannot be used with wells_covered_sparse() because it is more dense than an SBS 96 standard."
         )
-    for nozzle_column in range(max(1, len(nozzle_map.columns) // column_upsample)):
-        for nozzle_row in range(max(1, len(nozzle_map.rows) // row_upsample)):
-            if nozzle_map.starting_nozzle == "A1":
+    for nozzle_column in range(max(1, len(columns) // column_upsample)):
+        for nozzle_row in range(max(1, len(rows) // row_upsample)):
+            if starting_nozzle == "A1":
                 if (
                     target_column_index + nozzle_column < len(target_wells_by_column)
                 ) and (
@@ -140,7 +182,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index + nozzle_column][
                         target_row_index + nozzle_row
                     ]
-            elif nozzle_map.starting_nozzle == "A12":
+            elif starting_nozzle == "A12":
                 if (target_column_index - nozzle_column >= 0) and (
                     target_row_index + nozzle_row
                     < len(target_wells_by_column[target_column_index])
@@ -148,7 +190,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index - nozzle_column][
                         target_row_index + nozzle_row
                     ]
-            elif nozzle_map.starting_nozzle == "H1":
+            elif starting_nozzle == "H1":
                 if (
                     target_column_index + nozzle_column
                     < len(target_wells_by_column[target_column_index])
@@ -156,7 +198,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index + nozzle_column][
                         target_row_index - nozzle_row
                     ]
-            elif nozzle_map.starting_nozzle == "H12":
+            elif starting_nozzle == "H12":
                 if (target_column_index - nozzle_column >= 0) and (
                     target_row_index - nozzle_row >= 0
                 ):
@@ -165,7 +207,7 @@ def wells_covered_sparse(  # noqa: C901
                     ]
             else:
                 raise InvalidProtocolData(
-                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
+                    f"A pipette nozzle configuration may not having a starting nozzle of {starting_nozzle}"
                 )
 
 

opentrons/protocol_engine/state/addressable_areas.py

@@ -5,6 +5,7 @@ from functools import cached_property
 from typing import Dict, List, Optional, Set
 
 from opentrons_shared_data.robot.types import RobotType, RobotDefinition
+from opentrons_shared_data.module.types import ModuleOrientation
 from opentrons_shared_data.deck.types import (
     DeckDefinitionV5,
     SlotDefV3,
@@ -614,6 +615,7 @@ class AddressableAreaView:
             "displayName": addressable_area.display_name,
             "compatibleModuleTypes": addressable_area.compatible_module_types,
             "features": addressable_area.features,
+            "orientation": ModuleOrientation.NOT_APPLICABLE,
         }
 
     def get_deck_slot_definitions(self) -> Dict[str, SlotDefV3]:

opentrons/protocol_engine/state/commands.py

@@ -238,7 +238,7 @@ class CommandState:
     has_entered_error_recovery: bool
     """Whether the run has entered error recovery."""
 
-    stopped_by_estop: bool
+    stopped_by_async_error: bool
     """If this is set to True, the engine was stopped by an estop event."""
 
     error_recovery_policy: ErrorRecoveryPolicy
@@ -272,7 +272,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
             run_completed_at=None,
             run_started_at=None,
             latest_protocol_command_hash=None,
-            stopped_by_estop=False,
+            stopped_by_async_error=False,
             error_recovery_policy=error_recovery_policy,
             has_entered_error_recovery=False,
         )
@@ -472,8 +472,8 @@ class CommandStore(HasState[CommandState], HandlesActions):
             self._state.recovery_target = None
             self._state.queue_status = QueueStatus.PAUSED
 
-            if action.from_estop:
-                self._state.stopped_by_estop = True
+            if action.from_asynchronous_error:
+                self._state.stopped_by_async_error = True
                 self._state.run_result = RunResult.FAILED
             else:
                 self._state.run_result = RunResult.STOPPED
@@ -501,7 +501,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         else:
             # HACK(sf): There needs to be a better way to set
             # an estop error than this else clause
-            if self._state.stopped_by_estop and action.error_details:
+            if self._state.stopped_by_async_error and action.error_details:
                 self._state.run_error = self._map_run_exception_to_error_occurrence(
                     action.error_details.error_id,
                     action.error_details.created_at,
@@ -952,9 +952,9 @@ class CommandView:
         """Get whether an engine stop has completed."""
         return self._state.run_completed_at is not None
 
-    def get_is_stopped_by_estop(self) -> bool:
+    def get_is_stopped_by_async_error(self) -> bool:
         """Return whether the engine was stopped specifically by an E-stop."""
-        return self._state.stopped_by_estop
+        return self._state.stopped_by_async_error
 
     def has_been_played(self) -> bool:
         """Get whether engine has started."""