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

opentrons/protocol_engine/commands/wait_for_tasks.py

@@ -0,0 +1,98 @@
+"""WaitForTasks command request, result, and implementation models."""
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import Optional, Type, TYPE_CHECKING
+from typing_extensions import Literal
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
+from ..errors.exceptions import TaskFailedError
+
+if TYPE_CHECKING:
+    from ..execution import TaskHandler, RunControlHandler
+    from ..state.state import StateView
+
+
+WaitForTasksCommandType = Literal["waitForTasks"]
+
+
+class WaitForTasksParams(BaseModel):
+    """Payload required to annotate execution with a WaitForTasks."""
+
+    task_ids: list[str] = Field(
+        ...,
+        description="The list of task ids to wait for.",
+    )
+
+
+class WaitForTasksResult(BaseModel):
+    """Result data from the execution of a WaitForTasks command."""
+
+    task_ids: list[str] = Field(
+        ...,
+        description="The list of completed task ids.",
+    )
+
+
+class WaitForTasksImplementation(
+    AbstractCommandImpl[WaitForTasksParams, SuccessData[WaitForTasksResult]]
+):
+    """WaitForTasks command implementation."""
+
+    def __init__(
+        self,
+        task_handler: TaskHandler,
+        run_control: RunControlHandler,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._task_handler = task_handler
+        self._run_control = run_control
+        self._state_view = state_view
+
+    async def execute(
+        self, params: WaitForTasksParams
+    ) -> SuccessData[WaitForTasksResult]:
+        """Checks for existance of task id and then asynchronously waits for the valid, specified tasks to finish."""
+        # Raises the exception if we don't have a valid task id.
+        for task_id in params.task_ids:
+            _ = self._state_view.tasks.get(task_id)
+
+        await self._run_control.wait_for_tasks(params.task_ids)
+
+        failed_tasks = self._state_view.tasks.get_failed_tasks(params.task_ids)
+        if failed_tasks:
+            raise TaskFailedError(
+                message=f"{len(failed_tasks)} tasks failed.",
+                details={"failed_task_ids": failed_tasks},
+                wrapping=[
+                    ProtocolCommandFailedError(
+                        original_error=self._state_view.tasks.get_finished(
+                            task_id
+                        ).error
+                    )
+                    for task_id in failed_tasks
+                ],
+            )
+        return SuccessData(public=WaitForTasksResult(task_ids=params.task_ids))
+
+
+class WaitForTasks(
+    BaseCommand[WaitForTasksParams, WaitForTasksResult, ErrorOccurrence]
+):
+    """WaitForTasks command model."""
+
+    commandType: WaitForTasksCommandType = "waitForTasks"
+    params: WaitForTasksParams
+    result: Optional[WaitForTasksResult] = None
+
+    _ImplementationCls: Type[WaitForTasksImplementation] = WaitForTasksImplementation
+
+
+class WaitForTasksCreate(BaseCommandCreate[WaitForTasksParams]):
+    """WaitForTasks command request model."""
+
+    commandType: WaitForTasksCommandType = "waitForTasks"
+    params: WaitForTasksParams
+
+    _CommandCls: Type[WaitForTasks] = WaitForTasks

opentrons/protocol_engine/errors/__init__.py

@@ -57,6 +57,7 @@ from .exceptions import (
     InvalidTargetSpeedError,
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
+    InvalidRampRateError,
     InvalidHoldTimeError,
     InvalidWavelengthError,
     CannotPerformModuleAction,
@@ -90,6 +91,7 @@ from .exceptions import (
     FlexStackerLabwarePoolNotYetDefinedError,
     FlexStackerNotLogicallyEmptyError,
     InvalidLabwarePositionError,
+    InvalidModuleOrientation,
 )
 
 from .error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
@@ -151,6 +153,7 @@ __all__ = [
     "NoTargetTemperatureSetError",
     "InvalidTargetTemperatureError",
     "InvalidTargetSpeedError",
+    "InvalidRampRateError",
     "InvalidBlockVolumeError",
     "InvalidHoldTimeError",
     "InvalidLiquidError",
@@ -174,6 +177,7 @@ __all__ = [
     "FlexStackerLabwarePoolNotYetDefinedError",
     "FlexStackerNotLogicallyEmptyError",
     "InvalidLabwarePositionError",
+    "InvalidModuleOrientation",
     # error occurrence models
     "ErrorOccurrence",
     "CommandNotAllowedError",

opentrons/protocol_engine/errors/exceptions.py

@@ -413,6 +413,36 @@ 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."""
 
@@ -825,6 +855,19 @@ 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."""
 
@@ -1306,3 +1349,15 @@ 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,6 +21,7 @@ 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.
@@ -46,5 +47,6 @@ __all__ = [
     "DoorWatcher",
     "RailLightsHandler",
     "StatusBarHandler",
+    "TaskHandler",
     "FileProvider",
 ]

opentrons/protocol_engine/execution/command_executor.py

@@ -35,6 +35,7 @@ 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__)
@@ -85,6 +86,7 @@ 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:
@@ -106,6 +108,7 @@ 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.
@@ -131,6 +134,7 @@ 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()
@@ -214,3 +218,7 @@ 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,6 +17,7 @@ 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(
@@ -76,7 +77,9 @@ 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(
@@ -93,6 +96,7 @@ 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

@@ -31,6 +31,7 @@ from ..types import (
     OnLabwareLocation,
     LabwareLocation,
     OnDeckLabwareLocation,
+    GripperMoveType,
 )
 
 if TYPE_CHECKING:
@@ -141,10 +142,16 @@ 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
+            labware_definition=labware_definition,
+            location=current_location,
+            move_type=GripperMoveType.PICK_UP_LABWARE,
+            user_additional_offset=user_pick_up_offset,
         )
         to_labware_center = self._state_store.geometry.get_labware_grip_point(
-            labware_definition=labware_definition, location=new_location
+            labware_definition=labware_definition,
+            location=new_location,
+            move_type=GripperMoveType.DROP_LABWARE,
+            user_additional_offset=user_drop_offset,
         )
 
         if use_virtual_gripper:
@@ -193,20 +200,10 @@ 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,
             )

opentrons/protocol_engine/execution/movement.py

@@ -83,6 +83,7 @@ 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(
@@ -143,6 +144,7 @@ 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,6 +51,7 @@ 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."""
@@ -65,7 +66,10 @@ 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,3 +31,11 @@ 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/execution/task_handler.py

@@ -0,0 +1,157 @@
+"""Task handling."""
+
+from __future__ import annotations
+import logging
+from typing import Protocol, AsyncIterator
+from ..state.state import StateStore
+from ..resources import ModelUtils, ConcurrencyProvider
+from ..types import Task
+import asyncio
+import contextlib
+from ..actions import ActionDispatcher, FinishTaskAction, StartTaskAction
+from ..errors import ErrorOccurrence
+from opentrons_shared_data.errors.exceptions import EnumeratedError, PythonException
+
+log = logging.getLogger(__name__)
+
+
+class TaskFunction(Protocol):
+    """The function run inside a task protocol."""
+
+    async def __call__(self, task_handler: TaskHandler) -> None:
+        """The function called inside a task."""
+        ...
+
+
+class TaskHandler:
+    """Implementation logic for fast concurrency."""
+
+    _state_store: StateStore
+    _model_utils: ModelUtils
+    _concurrency_provider: ConcurrencyProvider
+
+    def __init__(
+        self,
+        state_store: StateStore,
+        action_dispatcher: ActionDispatcher,
+        model_utils: ModelUtils | None = None,
+        concurrency_provider: ConcurrencyProvider | None = None,
+    ) -> None:
+        """Initialize a TaskHandler instance."""
+        self._state_store = state_store
+        self._model_utils = model_utils or ModelUtils()
+        self._concurrency_provider = concurrency_provider or ConcurrencyProvider()
+        self._action_dispatcher = action_dispatcher
+
+    async def create_task(
+        self, task_function: TaskFunction, id: str | None = None
+    ) -> Task:
+        """Create a task and immediately schedules it."""
+        task_id = self._model_utils.ensure_id(id)
+        asyncio_task = asyncio.create_task(
+            task_function(task_handler=self), name=f"engine-task-{task_id}"
+        )
+
+        def _done_callback(task: asyncio.Task[None]) -> None:
+            try:
+                maybe_exception = task.exception()
+            except asyncio.CancelledError as e:
+                maybe_exception = e
+            if isinstance(maybe_exception, EnumeratedError):
+                occurence: ErrorOccurrence | None = ErrorOccurrence.from_failed(
+                    id=self._model_utils.generate_id(),
+                    createdAt=self._model_utils.get_timestamp(),
+                    error=maybe_exception,
+                )
+            elif isinstance(maybe_exception, BaseException):
+                occurence = ErrorOccurrence.from_failed(
+                    id=self._model_utils.generate_id(),
+                    createdAt=self._model_utils.get_timestamp(),
+                    error=PythonException(maybe_exception),
+                )
+            else:
+                occurence = None
+            try:
+                self._action_dispatcher.dispatch(
+                    FinishTaskAction(
+                        task_id=task_id,
+                        finished_at=self._model_utils.get_timestamp(),
+                        error=occurence,
+                    ),
+                )
+            except BaseException:
+                log.exception("Exception in task finish dispatch.")
+
+        asyncio_task.add_done_callback(_done_callback)
+        task = Task(
+            id=task_id,
+            createdAt=self._model_utils.get_timestamp(),
+            asyncioTask=asyncio_task,
+        )
+        self._action_dispatcher.dispatch(StartTaskAction(task))
+        return task
+
+    @staticmethod
+    def _empty_queue(
+        queue: "asyncio.Queue[asyncio.Task[None]]", this_task: asyncio.Task[None]
+    ) -> None:
+        """Empties the queue."""
+        try:
+            while True:
+                task = queue.get_nowait()
+                if task is this_task:
+                    break
+        except asyncio.QueueEmpty:
+            pass
+
+    @contextlib.asynccontextmanager
+    async def synchronize_cancel_latest(self, group_id: str) -> AsyncIterator[None]:
+        """Cancel current task."""
+        lock = self._concurrency_provider.lock_for_group(group_id)
+        if lock.locked():
+            raise asyncio.CancelledError()
+        async with lock:
+            yield
+
+    @contextlib.asynccontextmanager
+    async def synchronize_cancel_previous(self, group_id: str) -> AsyncIterator[None]:
+        """Cancel previous run."""
+        queue = self._concurrency_provider.queue_for_group(group_id)
+        while not queue.empty():
+            task = queue.get_nowait()
+            task.cancel()
+        this_task = asyncio.current_task()
+        assert this_task is not None
+        queue.put_nowait(this_task)
+        try:
+            yield
+        except asyncio.CancelledError:
+            raise
+        except BaseException:
+            self._empty_queue(queue, this_task)
+            raise
+        else:
+            self._empty_queue(queue, this_task)
+
+    @contextlib.asynccontextmanager
+    async def synchronize_sequential(self, group_id: str) -> AsyncIterator[None]:
+        """Run tasks one after the other."""
+        lock = self._concurrency_provider.lock_for_group(group_id)
+        async with lock:
+            yield
+
+    @contextlib.asynccontextmanager
+    async def synchronize_concurrent(self, group_id: str) -> AsyncIterator[None]:
+        """Run a list of tasks at the same time."""
+        yield
+
+    def cancel_all(self, message: str | None = None) -> None:
+        """Cancel all asyncio tasks immediately.
+
+        Do not call this more than once synchronously because
+        that could lead to tasks cancelling more than once.
+        It can be called if there are no current tasks. In that case
+        nothing will happen.
+        """
+        for task in self._state_store.tasks.get_all_current():
+            task.asyncioTask.cancel(msg=message)

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.