opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__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:
@@ -1444,7 +1338,7 @@ class FlexStackerContext(ModuleContext):
     def set_stored_labware_items(
         self,
         labware: list[Labware],
-        stacking_offset_z: float | None,
+        stacking_offset_z: float | None = None,
     ) -> None:
         """Configure the labware the Flex Stacker will store during a protocol by providing an initial list of stored labware objects. The start of the list represents the bottom of the Stacker,
         and the end of the list represents the top of the Stacker.
@@ -1573,16 +1467,61 @@ class FlexStackerContext(ModuleContext):
               - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below.
         """
 
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            if adapter_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if adapter_version is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `lid_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_version is not None:
+                raise APIVersionError(
+                    api_element="The `lid_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            checked_adapter_namespace = namespace
+            checked_adapter_version = version
+            checked_lid_namespace = namespace
+            checked_lid_version = version
+        else:
+            checked_adapter_namespace = adapter_namespace
+            checked_adapter_version = adapter_version
+            checked_lid_namespace = lid_namespace
+            checked_lid_version = lid_version
+
         self._core.set_stored_labware(
             main_load_name=load_name,
             main_namespace=namespace,
             main_version=version,
             lid_load_name=lid,
-            lid_namespace=lid_namespace,
-            lid_version=lid_version,
+            lid_namespace=checked_lid_namespace,
+            lid_version=checked_lid_version,
             adapter_load_name=adapter,
-            adapter_namespace=adapter_namespace,
-            adapter_version=adapter_version,
+            adapter_namespace=checked_adapter_namespace,
+            adapter_version=checked_adapter_version,
             count=count,
             stacking_offset_z=stacking_offset_z,
         )

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",