opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__py3-none-any.whl

opentrons/protocol_engine/errors/exceptions.py

@@ -413,36 +413,6 @@ class WellDoesNotExistError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
-class NoTaskFoundError(ProtocolEngineError):
-    """Raised when referencing a task that does not exist.
-
-    This error could be raised if a protocol references a task before it
-    has been created.
-    """
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a NoTaskFoundError."""
-        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
-
-
-class TaskFailedError(ProtocolEngineError):
-    """Raised when waiting on a task that failed."""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a TaskFailedError."""
-        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
-
-
 class PipetteNotLoadedError(ProtocolEngineError):
     """Raised when referencing a pipette that has not been loaded."""
 
@@ -855,19 +825,6 @@ class InvalidTargetTemperatureError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
-class InvalidRampRateError(ProtocolEngineError):
-    """Raised when attempting to set an invalid ramp rate."""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a InvalidRampRateError."""
-        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
-
-
 class InvalidBlockVolumeError(ProtocolEngineError):
     """Raised when attempting to set an invalid block max volume."""
 
@@ -1349,15 +1306,3 @@ class InvalidLabwarePositionError(ProtocolEngineError):
         wrapping: Optional[Sequence[EnumeratedError]] = None,
     ) -> None:
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
-
-
-class InvalidModuleOrientation(ProtocolEngineError):
-    """Raised when a module orientation is invalid for a slot id."""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)

opentrons/protocol_engine/execution/__init__.py

@@ -21,7 +21,6 @@ from .run_control import RunControlHandler
 from .hardware_stopper import HardwareStopper
 from .door_watcher import DoorWatcher
 from .status_bar import StatusBarHandler
-from .task_handler import TaskHandler
 from ..resources.file_provider import FileProvider
 
 # .thermocycler_movement_flagger omitted from package's public interface.
@@ -47,6 +46,5 @@ __all__ = [
     "DoorWatcher",
     "RailLightsHandler",
     "StatusBarHandler",
-    "TaskHandler",
     "FileProvider",
 ]

opentrons/protocol_engine/execution/command_executor.py

@@ -35,7 +35,6 @@ from .tip_handler import TipHandler
 from .run_control import RunControlHandler
 from .rail_lights import RailLightsHandler
 from .status_bar import StatusBarHandler
-from .task_handler import TaskHandler
 
 
 log = getLogger(__name__)
@@ -86,7 +85,6 @@ class CommandExecutor:
         run_control: RunControlHandler,
         rail_lights: RailLightsHandler,
         status_bar: StatusBarHandler,
-        task_handler: TaskHandler,
         model_utils: Optional[ModelUtils] = None,
         command_note_tracker_provider: Optional[CommandNoteTrackerProvider] = None,
     ) -> None:
@@ -108,7 +106,6 @@ class CommandExecutor:
         self._command_note_tracker_provider = (
             command_note_tracker_provider or _NoteTracker
         )
-        self._task_handler = task_handler
 
     async def execute(self, command_id: str) -> None:
         """Run a given command's execution procedure.
@@ -134,7 +131,6 @@ class CommandExecutor:
             model_utils=self._model_utils,
             status_bar=self._status_bar,
             command_note_adder=note_tracker,
-            task_handler=self._task_handler,
         )
 
         started_at = self._model_utils.get_timestamp()
@@ -218,7 +214,3 @@ class CommandExecutor:
                         type=error_recovery_type,
                     )
                 )
-
-    def cancel_tasks(self, message: str | None = None) -> None:
-        """Cancel all concurrent tasks."""
-        self._task_handler.cancel_all(message=message)

opentrons/protocol_engine/execution/create_queue_worker.py

@@ -17,7 +17,6 @@ from .run_control import RunControlHandler
 from .command_executor import CommandExecutor
 from .queue_worker import QueueWorker
 from .status_bar import StatusBarHandler
-from .task_handler import TaskHandler
 
 
 def create_queue_worker(
@@ -77,9 +76,7 @@ def create_queue_worker(
     rail_lights_handler = RailLightsHandler(
         hardware_api=hardware_api,
     )
-    task_handler = TaskHandler(
-        state_store=state_store, action_dispatcher=action_dispatcher
-    )
+
     status_bar_handler = StatusBarHandler(hardware_api=hardware_api)
 
     command_executor = CommandExecutor(
@@ -96,7 +93,6 @@ def create_queue_worker(
         run_control=run_control_handler,
         rail_lights=rail_lights_handler,
         status_bar=status_bar_handler,
-        task_handler=task_handler,
     )
 
     return QueueWorker(

opentrons/protocol_engine/execution/labware_movement.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Optional, TYPE_CHECKING, overload
 
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition, Quirks
 
 from opentrons.types import Point
 
@@ -31,7 +31,6 @@ from ..types import (
     OnLabwareLocation,
     LabwareLocation,
     OnDeckLabwareLocation,
-    GripperMoveType,
 )
 
 if TYPE_CHECKING:
@@ -142,16 +141,10 @@ class LabwareMovementHandler:
             labware_definition = self._state_store.labware.get_definition(labware_id)
 
         from_labware_center = self._state_store.geometry.get_labware_grip_point(
-            labware_definition=labware_definition,
-            location=current_location,
-            move_type=GripperMoveType.PICK_UP_LABWARE,
-            user_additional_offset=user_pick_up_offset,
+            labware_definition=labware_definition, location=current_location
         )
         to_labware_center = self._state_store.geometry.get_labware_grip_point(
-            labware_definition=labware_definition,
-            location=new_location,
-            move_type=GripperMoveType.DROP_LABWARE,
-            user_additional_offset=user_drop_offset,
+            labware_definition=labware_definition, location=new_location
         )
 
         if use_virtual_gripper:
@@ -200,10 +193,20 @@ class LabwareMovementHandler:
         async with self._thermocycler_plate_lifter.lift_plate_for_labware_movement(
             labware_location=current_location
         ):
+            final_offsets = (
+                self._state_store.geometry.get_final_labware_movement_offset_vectors(
+                    from_location=current_location,
+                    to_location=new_location,
+                    additional_pick_up_offset=user_pick_up_offset,
+                    additional_drop_offset=user_drop_offset,
+                    current_labware=labware_definition,
+                )
+            )
             movement_waypoints = get_gripper_labware_movement_waypoints(
                 from_labware_center=from_labware_center,
                 to_labware_center=to_labware_center,
                 gripper_home_z=gripper_homed_position.z,
+                offset_data=final_offsets,
                 post_drop_slide_offset=post_drop_slide_offset,
                 gripper_home_z_offset=gripper_z_offset,
             )
@@ -235,6 +238,13 @@ class LabwareMovementHandler:
                             labware_definition=labware_definition
                         )
 
+                        disable_geometry_grip_check = False
+                        if labware_definition.parameters.quirks is not None:
+                            disable_geometry_grip_check = (
+                                Quirks.disableGeometryBasedGripCheck.value
+                                in labware_definition.parameters.quirks
+                            )
+
                         # todo(mm, 2024-09-26): This currently raises a lower-level 2015 FailedGripperPickupError.
                         # Convert this to a higher-level 3001 LabwareDroppedError or 3002 LabwareNotPickedUpError,
                         # depending on what waypoint we're at, to propagate a more specific error code to users.
@@ -242,6 +252,7 @@ class LabwareMovementHandler:
                             expected_grip_width=grip_specs.targetY,
                             grip_width_uncertainty_wider=grip_specs.uncertaintyWider,
                             grip_width_uncertainty_narrower=grip_specs.uncertaintyNarrower,
+                            disable_geometry_grip_check=disable_geometry_grip_check,
                         )
                 await ot3api.move_to(
                     mount=gripper_mount, abs_position=waypoint_data.position

opentrons/protocol_engine/execution/movement.py

@@ -83,7 +83,6 @@ class MovementHandler:
         minimum_z_height: Optional[float] = None,
         speed: Optional[float] = None,
         operation_volume: Optional[float] = None,
-        offset_pipette_for_reservoir_subwells: bool = False,
     ) -> Point:
         """Move to a specific well."""
         self._state_store.geometry.raise_if_labware_inaccessible_by_pipette(
@@ -144,7 +143,6 @@ class MovementHandler:
             force_direct=force_direct,
             minimum_z_height=minimum_z_height,
             operation_volume=operation_volume,
-            offset_pipette_for_reservoir_subwells=offset_pipette_for_reservoir_subwells,
         )
 
         speed = self._state_store.pipettes.get_movement_speed(

opentrons/protocol_engine/execution/queue_worker.py

@@ -51,7 +51,6 @@ class QueueWorker:
         """
         if self._worker_task:
             self._worker_task.cancel()
-            self._command_executor.cancel_tasks("Engine cancelled")
 
     async def join(self) -> None:
         """Wait for the worker to finish, propagating any errors."""
@@ -66,10 +65,7 @@ class QueueWorker:
                 pass
             except Exception as e:
                 log.error("Unhandled exception in QueueWorker job", exc_info=e)
-                self._command_executor.cancel_tasks("Engine failed")
                 raise e
-            else:
-                self._command_executor.cancel_tasks("Engine commands complete")
 
     async def _run_commands(self) -> None:
         async for command_id in self._command_generator():

opentrons/protocol_engine/execution/run_control.py

@@ -31,11 +31,3 @@ class RunControlHandler:
         """Delay protocol execution for a duration."""
         if not self._state_store.config.ignore_pause:
             await asyncio.sleep(seconds)
-
-    async def wait_for_tasks(self, tasks: list[str]) -> None:
-        """Wait for concurrent tasks to complete."""
-        await self._state_store.wait_for(
-            condition=lambda: self._state_store.tasks.all_tasks_finished_or_any_task_failed(
-                task_ids=tasks
-            )
-        )

opentrons/protocol_engine/protocol_engine.py

@@ -59,6 +59,7 @@ from .actions import (
     AddAddressableAreaAction,
     AddModuleAction,
     HardwareStoppedAction,
+    ResetTipsAction,
     SetPipetteMovementSpeedAction,
 )
 
@@ -321,10 +322,24 @@ class ProtocolEngine:
         )
         return completed_command
 
-    def _stop_from_asynchronous_error(self) -> None:
+    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.
+        """
         try:
             action = self._state_store.commands.validate_action_allowed(
-                StopAction(from_asynchronous_error=True)
+                StopAction(from_estop=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
@@ -343,79 +358,9 @@ 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
-
-        if self._state_store.commands.get_is_terminal():
-            # Do not stop multiple times; it will be common for this action to fire
-            # many times when a module enters an error state, and we don't want to do
-            # the stop behavior over and over
-            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.
@@ -433,7 +378,15 @@ class ProtocolEngine:
         action = self._state_store.commands.validate_action_allowed(StopAction())
         self._action_dispatcher.dispatch(action)
         self._get_queue_worker.cancel()
-        await self._do_hardware_stop()
+        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 wait_until_complete(self) -> None:
         """Wait until there are no more commands to execute.
@@ -476,13 +429,13 @@ 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_async_error():
+        if self._state_store.commands.get_is_stopped_by_estop():
             # 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.
             drop_tips_after_run = False
             post_run_hardware_state = PostRunHardwareState.DISENGAGE_IN_PLACE
-            if error is None and self._state_store.commands.get_error() is None:
+            if error is None:
                 error = EStopActivatedError()
 
         if error:
@@ -633,6 +586,12 @@ 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,7 +11,6 @@ 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__ = [
@@ -19,7 +18,6 @@ __all__ = [
     "LabwareDataProvider",
     "DeckDataProvider",
     "DeckFixedLabware",
-    "ConcurrencyProvider",
     "ModuleDataProvider",
     "FileProvider",
     "ensure_ot3_hardware",

opentrons/protocol_engine/resources/deck_configuration_provider.py

@@ -2,7 +2,6 @@
 
 from typing import List, Set, Tuple
 
-from opentrons_shared_data.module.types import ModuleOrientation
 from opentrons_shared_data.deck.types import (
     DeckDefinitionV5,
     CutoutFixture,
@@ -125,11 +124,6 @@ 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(
@@ -144,7 +138,6 @@ 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,7 +2,6 @@
 
 from opentrons_shared_data.labware.labware_definition import (
     LabwareDefinition,
-    LabwareDefinition2,
     LabwareRole,
 )
 
@@ -45,18 +44,15 @@ def validate_definition_is_system(definition: LabwareDefinition) -> bool:
     return LabwareRole.system in definition.allowedRoles
 
 
-def validate_legacy_labware_can_be_stacked(
-    child_labware_definition: LabwareDefinition2, parent_labware_load_name: str
+def validate_labware_can_be_stacked(
+    top_labware_definition: LabwareDefinition, below_labware_load_name: str
 ) -> bool:
-    """Validate that the parent labware is in the child labware's stackingOffsetWithLabware definition.
-
-    Schema 3 Labware stacking validation is handled in locating features.
-    """
+    """Validate that the labware being loaded onto is in the above labware's stackingOffsetWithLabware definition."""
     return (
-        parent_labware_load_name in child_labware_definition.stackingOffsetWithLabware
+        below_labware_load_name in top_labware_definition.stackingOffsetWithLabware
         or (
-            "default" in child_labware_definition.stackingOffsetWithLabware
-            and child_labware_definition.compatibleParentLabware is None
+            "default" in top_labware_definition.stackingOffsetWithLabware
+            and top_labware_definition.compatibleParentLabware is None
         )
     )