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

opentrons/protocol_api/core/protocol.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
-from typing import Generic, List, Optional, Union, Tuple, Dict, TYPE_CHECKING, Sequence
+from typing import Generic, List, Optional, Union, Tuple, Dict, TYPE_CHECKING
 
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.pipette.types import PipetteNameType
@@ -24,7 +24,6 @@ from opentrons.protocols.api_support.util import AxisMaxSpeeds
 from .instrument import InstrumentCoreType
 from .labware import LabwareCoreType, LabwareLoadParams
 from .module import ModuleCoreType
-from .tasks import TaskCoreType
 from .._liquid import Liquid, LiquidClass
 from .robot import AbstractRobot
 from .._types import OffDeckType
@@ -35,7 +34,7 @@ if TYPE_CHECKING:
 
 
 class AbstractProtocol(
-    ABC, Generic[InstrumentCoreType, LabwareCoreType, ModuleCoreType, TaskCoreType]
+    ABC, Generic[InstrumentCoreType, LabwareCoreType, ModuleCoreType]
 ):
     @property
     @abstractmethod
@@ -193,14 +192,6 @@ class AbstractProtocol(
     def delay(self, seconds: float, msg: Optional[str]) -> None:
         ...
 
-    @abstractmethod
-    def wait_for_tasks(self, task_cores: Sequence[TaskCoreType]) -> None:
-        ...
-
-    @abstractmethod
-    def create_timer(self, seconds: float) -> TaskCoreType:
-        ...
-
     @abstractmethod
     def home(self) -> None:
         ...

opentrons/protocol_api/core/well.py

@@ -112,9 +112,5 @@ class AbstractWellCore(ABC):
     def volume_from_height(self, height: LiquidTrackingType) -> LiquidTrackingType:
         """Return the volume contained in a well at any height."""
 
-    @abstractmethod
-    def has_tracked_liquid(self) -> bool:
-        """Return true if liquid has been loaded or probed."""
-
 
 WellCoreType = TypeVar("WellCoreType", bound=AbstractWellCore)

opentrons/protocol_api/labware.py

@@ -347,11 +347,6 @@ class Well:
         """Get the current liquid volume in a well."""
         return self._core.get_liquid_volume()
 
-    @requires_version(2, 27)
-    def has_tracked_liquid(self) -> bool:
-        """Get the current liquid volume in a well."""
-        return self._core.has_tracked_liquid()
-
     @requires_version(2, 24)
     def volume_from_height(self, height: LiquidTrackingType) -> LiquidTrackingType:
         """Return the volume contained in a well at any height."""

opentrons/protocol_api/module_contexts.py

@@ -43,7 +43,6 @@ from .module_validation_and_errors import (
 )
 from .labware import Labware
 from . import validation
-from . import Task
 
 
 _MAGNETIC_MODULE_HEIGHT_PARAM_REMOVED_IN = APIVersion(2, 14)
@@ -448,28 +447,18 @@ class TemperatureModuleContext(ModuleContext):
         No other protocol commands will execute while waiting for the temperature.
 
         :param celsius: A value between 4 and 95, representing the target temperature in °C.
-
         """
         self._core.set_target_temperature(celsius)
         self._core.wait_for_target_temperature()
 
     @publish(command=cmds.tempdeck_set_temp)
     @requires_version(2, 3)
-    def start_set_temperature(self, celsius: float) -> Task:
+    def start_set_temperature(self, celsius: float) -> None:
         """Set the target temperature without waiting for the target to be hit.
 
-        .. versionchanged:: 2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
-
-        On version 2.26 or below, this function returns ``None``.
         :param celsius: A value between 4 and 95, representing the target temperature in °C.
         """
-        task = self._core.set_target_temperature(celsius)
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        self._core.set_target_temperature(celsius)
 
     @publish(command=cmds.tempdeck_await_temp)
     @requires_version(2, 3)
@@ -667,16 +656,9 @@ class ThermocyclerContext(ModuleContext):
         hold_time_minutes: Optional[float] = None,
         ramp_rate: Optional[float] = None,
         block_max_volume: Optional[float] = None,
-    ) -> Task:
+    ) -> None:
         """Set the target temperature for the well block, in °C.
 
-        .. versionchanged::2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-            the preheat to complete.
-
-        On version 2.26 or below, this function returns ``None``.
-
         :param temperature: A value between 4 and 99, representing the target
                             temperature in °C.
         :param hold_time_minutes: The number of minutes to hold, after reaching
@@ -690,10 +672,6 @@ class ThermocyclerContext(ModuleContext):
         :param block_max_volume: The greatest volume of liquid contained in any
                                  individual well of the loaded labware, in µL.
                                  If not specified, the default is 25 µL.
-                                 After API version 2.27 it will attempt to use
-                                 the liquid tracking of the labware first and
-                                 then fall back to the 25 if there is no probed
-                                 or loaded liquid.
 
         .. note::
 
@@ -704,31 +682,18 @@ class ThermocyclerContext(ModuleContext):
         seconds = validation.ensure_hold_time_seconds(
             seconds=hold_time_seconds, minutes=hold_time_minutes
         )
-        if self._api_version >= APIVersion(2, 27) and block_max_volume is None:
-            block_max_volume = self._get_current_labware_max_vol()
-        task = self._core.set_target_block_temperature(
+        self._core.set_target_block_temperature(
             celsius=temperature,
             hold_time_seconds=seconds,
             block_max_volume=block_max_volume,
-            ramp_rate=ramp_rate,
         )
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        self._core.wait_for_block_temperature()
 
     @publish(command=cmds.thermocycler_set_lid_temperature)
     @requires_version(2, 0)
-    def set_lid_temperature(self, temperature: float) -> Task:
+    def set_lid_temperature(self, temperature: float) -> None:
         """Set the target temperature for the heated lid, in °C.
 
-        .. versionchanged::2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-            the preheat to complete.
-
-        On version 2.26 or below, this function returns ``None``.
-
         :param temperature: A value between 37 and 110, representing the target
                             temperature in °C.
 
@@ -738,11 +703,8 @@ class ThermocyclerContext(ModuleContext):
             ``temperature`` is reached.
 
         """
-        task = self._core.set_target_lid_temperature(celsius=temperature)
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        self._core.set_target_lid_temperature(celsius=temperature)
+        self._core.wait_for_lid_temperature()
 
     @publish(command=cmds.thermocycler_execute_profile)
     @requires_version(2, 0)
@@ -777,39 +739,6 @@ class ThermocyclerContext(ModuleContext):
             block_max_volume=block_max_volume,
         )
 
-    @publish(command=cmds.thermocycler_start_execute_profile)
-    @requires_version(2, 27)
-    def start_execute_profile(
-        self,
-        steps: List[ThermocyclerStep],
-        repetitions: int,
-        block_max_volume: Optional[float] = None,
-    ) -> Task:
-        """Start a Thermocycler profile and return a :py:class:`Task` representing its execution.
-        Profile is defined as a cycle of ``steps``, for a given number of ``repetitions``.
-
-        Returns a task object that represents concurrent execution of the profile.
-        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
-
-        :param steps: List of steps that make up a single cycle.
-                      Each list item should be a dictionary that maps to the parameters
-                      of the :py:meth:`set_block_temperature` method. The dictionary's
-                      keys must be ``temperature`` and one or both of
-                      ``hold_time_seconds`` and ``hold_time_minutes``.
-        :param repetitions: The number of times to repeat the cycled steps.
-        :param block_max_volume: The greatest volume of liquid contained in any
-                                 individual well of the loaded labware, in µL.
-                                 If not specified, the default is 25 µL.
-        """
-        repetitions = validation.ensure_thermocycler_repetition_count(repetitions)
-        validated_steps = validation.ensure_thermocycler_profile_steps(steps)
-        task = self._core.start_execute_profile(
-            steps=validated_steps,
-            repetitions=repetitions,
-            block_max_volume=block_max_volume,
-        )
-        return Task(api_version=self._api_version, core=task)
-
     @publish(command=cmds.thermocycler_deactivate_lid)
     @requires_version(2, 0)
     def deactivate_lid(self) -> None:
@@ -931,19 +860,6 @@ class ThermocyclerContext(ModuleContext):
         """Index of the current step within the current cycle"""
         return self._core.get_current_step_index()
 
-    def _get_current_labware_max_vol(self) -> Optional[float]:
-        max_vol: Optional[float] = None
-        if self.labware is not None:
-            for well in self.labware.wells():
-                if well.has_tracked_liquid():
-                    # make sure that max vol is a float first if we have liquid
-                    max_vol = 0.0 if max_vol is None else max_vol
-                    well_vol = well.current_liquid_volume()
-                    # ignore simulated probe results
-                    if isinstance(well_vol, float):
-                        max_vol = max(max_vol, well_vol)
-        return max_vol
-
 
 class HeaterShakerContext(ModuleContext):
     """An object representing a connected Heater-Shaker Module.
@@ -1057,21 +973,18 @@ class HeaterShakerContext(ModuleContext):
 
     @requires_version(2, 13)
     @publish(command=cmds.heater_shaker_set_target_temperature)
-    def set_target_temperature(self, celsius: float) -> Task:
+    def set_target_temperature(self, celsius: float) -> None:
         """Set target temperature and return immediately.
 
         Sets the Heater-Shaker's target temperature and returns immediately without
         waiting for the target to be reached. Does not delay the protocol until
         target temperature has reached.
         Use :py:meth:`~.HeaterShakerContext.wait_for_temperature` to delay
-        protocol execution for api levels below 2.27.
+        protocol execution.
 
         .. versionchanged:: 2.25
             Removed the minimum temperature limit of 37 °C. Note that temperatures under ambient are
             not achievable.
-        .. versionchanged:: 2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
 
         :param celsius: A value under 95, representing the target temperature in °C.
                         Values are automatically truncated to two decimal places,
@@ -1080,11 +993,7 @@ class HeaterShakerContext(ModuleContext):
         validated_temp = validate_heater_shaker_temperature(
             celsius=celsius, api_version=self.api_version
         )
-        task = self._core.set_target_temperature(celsius=validated_temp)
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        self._core.set_target_temperature(celsius=validated_temp)
 
     @requires_version(2, 13)
     @publish(command=cmds.heater_shaker_wait_for_temperature)
@@ -1112,21 +1021,6 @@ class HeaterShakerContext(ModuleContext):
         validated_speed = validate_heater_shaker_speed(rpm=rpm)
         self._core.set_and_wait_for_shake_speed(rpm=validated_speed)
 
-    @requires_version(2, 27)
-    @publish(command=cmds.heater_shaker_set_shake_speed)
-    def set_shake_speed(self, rpm: int) -> Task:
-        """Set a shake speed in rpm to run in the background.
-
-        .. note::
-
-            Before shaking, this command will retract the pipettes upward if they are parked adjacent to the Heater-Shaker.
-
-        :param rpm: A value between 200 and 3000, representing the target shake speed in revolutions per minute.
-        """
-        validated_speed = validate_heater_shaker_speed(rpm=rpm)
-        task = self._core.set_shake_speed(rpm=validated_speed)
-        return Task(api_version=self._api_version, core=task)
-
     @requires_version(2, 13)
     @publish(command=cmds.heater_shaker_open_labware_latch)
     def open_labware_latch(self) -> None:

opentrons/protocol_api/protocol_context.py

@@ -89,7 +89,6 @@ from .module_contexts import (
     FlexStackerContext,
     ModuleContext,
 )
-from .tasks import Task
 from ._parameters import Parameters
 
 
@@ -235,7 +234,10 @@ class ProtocolContext(CommandPublisher):
     @property
     @requires_version(2, 22)
     def robot(self) -> RobotContext:
-        """The :py:class:`.RobotContext` for the protocol."""
+        """The :py:class:`.RobotContext` for the protocol.
+
+        :meta private:
+        """
         if self._core.robot_type != "OT-3 Standard" or not self._robot:
             raise RobotTypeError("The RobotContext is only available on Flex robots.")
         return self._robot
@@ -1287,30 +1289,6 @@ class ProtocolContext(CommandPublisher):
         delay_time = seconds + minutes * 60
         self._core.delay(seconds=delay_time, msg=msg)
 
-    @publish(command=cmds.wait_for_tasks)
-    @requires_version(2, 27)
-    def wait_for_tasks(self, tasks: list[Task]) -> None:
-        """Wait for a list of tasks to complete before executing subsequent commands.
-
-        :param list Task: tasks: A list of Task objects to wait for.
-
-        Task objects can be commands that are allowed to run concurrently.
-        """
-        task_cores = [task._core for task in tasks]
-        self._core.wait_for_tasks(task_cores)
-
-    @publish(command=cmds.create_timer)
-    @requires_version(2, 27)
-    def create_timer(self, seconds: float) -> Task:
-        """Create a timer task that runs in the background.
-
-        :param float seconds: The time to delay in seconds.
-
-        This timer will continue to run until it is complete and will not block subsequent commands.
-        """
-        task_core = self._core.create_timer(seconds=seconds)
-        return Task(core=task_core, api_version=self._api_version)
-
     @requires_version(2, 0)
     def home(self) -> None:
         """Home the movement system of the robot."""

opentrons/protocol_api/robot_context.py

@@ -46,7 +46,7 @@ class RobotContext(publisher.CommandPublisher):
     Objects in this class should not be instantiated directly. Instead, instances are
     returned by :py:meth:`ProtocolContext.robot`.
 
-    .. versionadded:: 2.22
+    .. versionadded:: 2.20
 
     """
 
@@ -83,19 +83,15 @@ class RobotContext(publisher.CommandPublisher):
         speed: Optional[float] = None,
     ) -> None:
         """
-        Move a specified mount to a location on the deck.
+        Move a specified mount to a destination location on the deck.
 
         :param mount: The mount of the instrument you wish to move.
                       This can either be an instance of :py:class:`.types.Mount` or one
                       of the strings ``"left"``, ``"right"``, ``"extension"``, ``"gripper"``. Note
                       that the gripper mount can be referred to either as ``"extension"`` or ``"gripper"``.
         :type mount: types.Mount or str
-        :param destination: Any location on the deck, specified as:
-
-              -  a slot, like ``"A1"``
-              -  a defined location, like labware in a deck slot
-              -  an absolute location, like a point {x=10 , y=10, z=10} or a deck location and point ("A1" + point {x=10 , y=10, z=10})
-        :param speed: The absolute speed in mm/s.
+        :param Location destination:
+        :param speed:
         """
         mount = validation.ensure_instrument_mount(mount)
         with publisher.publish_context(
@@ -120,9 +116,10 @@ class RobotContext(publisher.CommandPublisher):
         Move a set of axes to an absolute position on the deck.
 
         :param axis_map: A dictionary mapping axes to an absolute position on the deck in mm.
-        :param critical_point: The critical point, or specific point on the object being moved, to move the axes with. It should only specify the gantry axes (i.e. `x`, `y`, `z`). When you specify a critical point, you're specifying the object on the gantry to be moved. If not specified, the critical point defaults to the center of the carriage attached to the gantry.
-        :param float speed: The maximum speed with which to move all axes in mm/s.
-
+        :param critical_point: The critical point to move the axes with. It should only
+        specify the gantry axes (i.e. `x`, `y`, `z`).
+        :param float speed: The maximum speed with which you want to move all the axes
+        in the axis map.
         """
         instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
         is_96_channel = instrument_on_left == PipetteNameType.P1000_96
@@ -157,9 +154,11 @@ class RobotContext(publisher.CommandPublisher):
         """
         Move a set of axes to a relative position on the deck.
 
-        :param axis_map: A dictionary mapping axes to relative movements from the current position in mm.
+        :param axis_map: A dictionary mapping axes to relative movements in mm.
+        :type mount: types.Mount or str
 
-        :param float speed: The maximum speed with which to move all axes in mm/s.
+        :param float speed: The maximum speed with which you want to move all the axes
+        in the axis map.
         """
         instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
         is_96_channel = instrument_on_left == PipetteNameType.P1000_96
@@ -178,10 +177,7 @@ class RobotContext(publisher.CommandPublisher):
             self._core.move_axes_relative(axis_map, speed)
 
     def close_gripper_jaw(self, force: Optional[float] = None) -> None:
-        """Closes the Flex Gripper jaws with a specified force.
-
-        :param force: Force with which to close the gripper jaws in newtons.
-        """
+        """Command the gripper closed with some force."""
         with publisher.publish_context(
             broker=self.broker,
             command=cmds.close_gripper(
@@ -191,10 +187,7 @@ class RobotContext(publisher.CommandPublisher):
             self._core.close_gripper(force)
 
     def open_gripper_jaw(self) -> None:
-        """Opens the Flex Gripper jaws with a specified force.
-
-        :param force: Force with which to open the gripper jaws in newtons.
-        """
+        """Command the gripper open."""
         with publisher.publish_context(
             broker=self.broker,
             command=cmds.open_gripper(),
@@ -207,9 +200,9 @@ class RobotContext(publisher.CommandPublisher):
         location: Union[Location, ModuleContext, DeckLocation],
     ) -> AxisMapType:
         """
-        Build an axis map from a location to provide to
+        Build a :py:class:`.types.AxisMapType` from a location to be compatible with
         either :py:meth:`.RobotContext.move_axes_to` or :py:meth:`.RobotContext.move_axes_relative`.
-        You must provide only one of either a `location`, `slot`, or `module` to build
+        You must provide only one of `location`, `slot`, or `module` to build
         the axis map.
 
         :param mount: The mount of the instrument you wish create an axis map for.
@@ -217,10 +210,7 @@ class RobotContext(publisher.CommandPublisher):
                       of the strings ``"left"``, ``"right"``, ``"extension"``, ``"gripper"``. Note
                       that the gripper mount can be referred to either as ``"extension"`` or ``"gripper"``.
         :type mount: types.Mount or str
-        :param location: Any location on the deck, specified as:
-
-              -  a deck location, like slot ``"A1"``.
-              -  a defined location, like a module on the deck.
+        :param location: The location to format an axis map for.
         :type location: `Well`, `ModuleContext`, `DeckLocation` or `OffDeckType`
         """
         mount = validation.ensure_instrument_mount(mount)
@@ -258,11 +248,7 @@ class RobotContext(publisher.CommandPublisher):
         self, mount: Union[Mount, str], volume: float, action: PipetteActionTypes
     ) -> AxisMapType:
         """
-        Build an axis map to move a pipette plunger motor to complete liquid handling actions.
-
-        :mount: The left or right instrument mount the pipette is attached to.
-        :param volume: A volume to convert to an axis map for linear plunger displacement.
-        :param action: Choose to ``aspirate`` or ``dispense``.
+        Build a :py:class:`.types.AxisMapType` for a pipette plunger motor from volume.
 
         """
         pipette_name = self._core.get_pipette_type_from_engine(mount)
@@ -282,9 +268,7 @@ class RobotContext(publisher.CommandPublisher):
         self, mount: Union[Mount, str], position_name: PlungerPositionTypes
     ) -> AxisMapType:
         """
-        Build an axis map to move a pipette plunger motor to a named position.
-
-        :param position_name: A named position to move the pipette plunger to. Choose from ``top``, ``bottom``, ``blowout``, or ``drop`` plunger positions.
+        Build a :py:class:`.types.AxisMapType` for a pipette plunger motor from position_name.
 
         """
         pipette_name = self._core.get_pipette_type_from_engine(mount)
@@ -300,9 +284,8 @@ class RobotContext(publisher.CommandPublisher):
         return {pipette_axis: pipette_position}
 
     def build_axis_map(self, axis_map: StringAxisMap) -> AxisMapType:
-        """Take in a :py:class:`.types.StringAxisMap` and output an axis map.
-
-        The :py:class:`.types.StringAxisMap` is allowed to contain any of the following strings:
+        """Take in a :py:class:`.types.StringAxisMap` and output a :py:class:`.types.AxisMapType`.
+        A :py:class:`.types.StringAxisMap` is allowed to contain any of the following strings:
         ``"x"``, ``"y"``, "``z_l"``, "``z_r"``, "``z_g"``, ``"q"``.
 
         An example of a valid axis map could be:

opentrons/protocol_api/validation.py

@@ -489,7 +489,6 @@ def ensure_thermocycler_profile_steps(
         temperature = step.get("temperature")
         hold_mins = step.get("hold_time_minutes")
         hold_secs = step.get("hold_time_seconds")
-        ramp_rate = step.get("ramp_rate")
         if temperature is None:
             raise ValueError("temperature must be defined for each step in cycle")
         if hold_mins is None and hold_secs is None:
@@ -497,14 +496,10 @@ def ensure_thermocycler_profile_steps(
                 "either hold_time_minutes or hold_time_seconds must be"
                 "defined for each step in cycle"
             )
-        if ramp_rate is not None and ramp_rate <= 0:
-            raise ValueError("Ramp rate must be greater than 0.")
         validated_seconds = ensure_hold_time_seconds(hold_secs, hold_mins)
         validated_steps.append(
             ThermocyclerStep(
-                temperature=temperature,
-                hold_time_seconds=validated_seconds,
-                ramp_rate=ramp_rate,
+                temperature=temperature, hold_time_seconds=validated_seconds
             )
         )
     return validated_steps

opentrons/protocol_engine/actions/__init__.py

@@ -26,9 +26,8 @@ from .actions import (
     AddModuleAction,
     FinishErrorDetails,
     DoorChangeAction,
+    ResetTipsAction,
     SetPipetteMovementSpeedAction,
-    StartTaskAction,
-    FinishTaskAction,
 )
 from .get_state_update import get_state_updates
 
@@ -56,9 +55,8 @@ __all__ = [
     "AddAddressableAreaAction",
     "AddModuleAction",
     "DoorChangeAction",
+    "ResetTipsAction",
     "SetPipetteMovementSpeedAction",
-    "StartTaskAction",
-    "FinishTaskAction",
     # action payload values
     "PauseSource",
     "FinishErrorDetails",

opentrons/protocol_engine/actions/actions.py

@@ -3,7 +3,6 @@
 Actions can be passed to the ActionDispatcher, where they will trigger
 reactions in objects that subscribe to the pipeline, like the StateStore.
 """
-
 import dataclasses
 from datetime import datetime
 from enum import Enum
@@ -21,7 +20,6 @@ from ..commands import (
     CommandDefinedErrorData,
 )
 from ..error_recovery_policy import ErrorRecoveryPolicy, ErrorRecoveryType
-from ..errors import ErrorOccurrence
 from ..notes.notes import CommandNote
 from ..state.update_types import StateUpdate
 from ..types import (
@@ -29,7 +27,6 @@ from ..types import (
     ModuleDefinition,
     Liquid,
     DeckConfigurationType,
-    Task,
 )
 
 
@@ -63,7 +60,7 @@ class PauseAction:
 class StopAction:
     """Request engine execution to stop soon."""
 
-    from_asynchronous_error: bool = False
+    from_estop: bool = False
 
 
 @dataclasses.dataclass(frozen=True)
@@ -204,22 +201,6 @@ class FailCommandAction:
     """The command to fail, in its prior `running` state."""
 
 
-@dataclasses.dataclass(frozen=True)
-class StartTaskAction:
-    """Store new task in state."""
-
-    task: Task
-
-
-@dataclasses.dataclass(frozen=True)
-class FinishTaskAction:
-    """Mark task as finished in state."""
-
-    task_id: str
-    finished_at: datetime
-    error: ErrorOccurrence | None
-
-
 @dataclasses.dataclass(frozen=True)
 class AddLabwareOffsetAction:
     """Add a labware offset, to apply to subsequent `LoadLabwareCommand`s."""
@@ -272,6 +253,13 @@ class AddModuleAction:
     module_live_data: LiveData
 
 
+@dataclasses.dataclass(frozen=True)
+class ResetTipsAction:
+    """Reset the tip tracking state of a given tip rack."""
+
+    labware_id: str
+
+
 @dataclasses.dataclass(frozen=True)
 class SetPipetteMovementSpeedAction:
     """Set the speed of a pipette's X/Y/Z movements. Does not affect plunger speed.
@@ -308,8 +296,7 @@ Action = Union[
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
     AddLiquidAction,
+    ResetTipsAction,
     SetPipetteMovementSpeedAction,
     SetErrorRecoveryPolicyAction,
-    StartTaskAction,
-    FinishTaskAction,
 ]

opentrons/protocol_engine/clients/sync_client.py

@@ -65,48 +65,6 @@ class SyncClient:
     ) -> commands.LoadLabwareResult:
         pass
 
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.CreateTimerParams
-    ) -> commands.CreateTimerResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.temperature_module.SetTargetTemperatureParams
-    ) -> commands.temperature_module.SetTargetTemperatureResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.thermocycler.StartRunExtendedProfileParams
-    ) -> commands.thermocycler.StartRunExtendedProfileResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.heater_shaker.SetTargetTemperatureParams
-    ) -> commands.heater_shaker.SetTargetTemperatureResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.heater_shaker.SetShakeSpeedParams
-    ) -> commands.heater_shaker.SetShakeSpeedResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.thermocycler.SetTargetBlockTemperatureParams
-    ) -> commands.thermocycler.SetTargetBlockTemperatureResult:
-        pass
-
-    @overload
-    def execute_command_without_recovery(
-        self, params: commands.thermocycler.SetTargetLidTemperatureParams
-    ) -> commands.thermocycler.SetTargetLidTemperatureResult:
-        pass
-
     @overload
     def execute_command_without_recovery(
         self, params: commands.LoadModuleParams
@@ -191,6 +149,13 @@ class SyncClient:
         """Add a liquid to the engine."""
         return self._transport.call_method("add_liquid", name=name, color=color, description=description)  # type: ignore[no-any-return]
 
+    def reset_tips(self, labware_id: str) -> None:
+        """Reset a labware's tip tracking state.."""
+        self._transport.call_method(
+            "reset_tips",
+            labware_id=labware_id,
+        )
+
     def add_labware_offset(self, request: LabwareOffsetCreate) -> None:
         """Add a labware offset."""
         self._transport.call_method("add_labware_offset", request=request)