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

opentrons/protocol_engine/commands/command_unions.py

@@ -267,6 +267,22 @@ from .wait_for_duration import (
     WaitForDurationCommandType,
 )
 
+from .create_timer import (
+    CreateTimer,
+    CreateTimerCreate,
+    CreateTimerParams,
+    CreateTimerResult,
+    CreateTimerCommandType,
+)
+
+from .wait_for_tasks import (
+    WaitForTasks,
+    WaitForTasksCreate,
+    WaitForTasksParams,
+    WaitForTasksResult,
+    WaitForTasksCommandType,
+)
+
 from .pick_up_tip import (
     PickUpTip,
     PickUpTipParams,
@@ -372,6 +388,14 @@ from .get_next_tip import (
     GetNextTipCommandType,
 )
 
+from .set_tip_state import (
+    SetTipState,
+    SetTipStateCreate,
+    SetTipStateParams,
+    SetTipStateResult,
+    SetTipStateCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -454,6 +478,8 @@ Command = Annotated[
         PrepareToAspirate,
         WaitForResume,
         WaitForDuration,
+        WaitForTasks,
+        CreateTimer,
         PickUpTip,
         SavePosition,
         SetRailLights,
@@ -462,6 +488,7 @@ Command = Annotated[
         VerifyTipPresence,
         GetTipPresence,
         GetNextTip,
+        SetTipState,
         LiquidProbe,
         TryLiquidProbe,
         SealPipetteToTip,
@@ -557,6 +584,8 @@ CommandParams = Union[
     PrepareToAspirateParams,
     WaitForResumeParams,
     WaitForDurationParams,
+    WaitForTasksParams,
+    CreateTimerParams,
     PickUpTipParams,
     SavePositionParams,
     SetRailLightsParams,
@@ -565,6 +594,7 @@ CommandParams = Union[
     VerifyTipPresenceParams,
     GetTipPresenceParams,
     GetNextTipParams,
+    SetTipStateParams,
     LiquidProbeParams,
     TryLiquidProbeParams,
     SealPipetteToTipParams,
@@ -658,6 +688,8 @@ CommandType = Union[
     PrepareToAspirateCommandType,
     WaitForResumeCommandType,
     WaitForDurationCommandType,
+    WaitForTasksCommandType,
+    CreateTimerCommandType,
     PickUpTipCommandType,
     SavePositionCommandType,
     SetRailLightsCommandType,
@@ -666,6 +698,7 @@ CommandType = Union[
     VerifyTipPresenceCommandType,
     GetTipPresenceCommandType,
     GetNextTipCommandType,
+    SetTipStateCommandType,
     LiquidProbeCommandType,
     TryLiquidProbeCommandType,
     SealPipetteToTipCommandType,
@@ -760,6 +793,8 @@ CommandCreate = Annotated[
         PrepareToAspirateCreate,
         WaitForResumeCreate,
         WaitForDurationCreate,
+        WaitForTasksCreate,
+        CreateTimerCreate,
         PickUpTipCreate,
         SavePositionCreate,
         SetRailLightsCreate,
@@ -768,6 +803,7 @@ CommandCreate = Annotated[
         VerifyTipPresenceCreate,
         GetTipPresenceCreate,
         GetNextTipCreate,
+        SetTipStateCreate,
         LiquidProbeCreate,
         TryLiquidProbeCreate,
         SealPipetteToTipCreate,
@@ -870,6 +906,8 @@ CommandResult = Union[
     PrepareToAspirateResult,
     WaitForResumeResult,
     WaitForDurationResult,
+    WaitForTasksResult,
+    CreateTimerResult,
     PickUpTipResult,
     SavePositionResult,
     SetRailLightsResult,
@@ -878,6 +916,7 @@ CommandResult = Union[
     VerifyTipPresenceResult,
     GetTipPresenceResult,
     GetNextTipResult,
+    SetTipStateResult,
     LiquidProbeResult,
     TryLiquidProbeResult,
     SealPipetteToTipResult,

opentrons/protocol_engine/commands/create_timer.py

@@ -0,0 +1,83 @@
+"""CreateTimer 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
+
+if TYPE_CHECKING:
+    from ..execution import TaskHandler, RunControlHandler
+
+
+CreateTimerCommandType = Literal["createTimer"]
+
+
+class CreateTimerParams(BaseModel):
+    """Payload required to annotate execution with a CreateTimer."""
+
+    time: float = Field(
+        ...,
+        description="The time before the timer should elapse in seconds. This is the minimum time before the timer elapses; it may in practice take longer than this.",
+    )
+    task_id: str | None = Field(
+        None,
+        description="The id of the timer task",
+    )
+
+
+class CreateTimerResult(BaseModel):
+    """Result data from the execution of a CreateTimer command."""
+
+    task_id: str = Field(..., description="The id of the timer task")
+    time: float = Field(..., description="The same time as the parameter.")
+
+
+class CreateTimerImplementation(
+    AbstractCommandImpl[CreateTimerParams, SuccessData[CreateTimerResult]]
+):
+    """CreateTimer command implementation."""
+
+    def __init__(
+        self,
+        task_handler: TaskHandler,
+        run_control: RunControlHandler,
+        **kwargs: object,
+    ) -> None:
+        self._task_handler = task_handler
+        self._run_control = run_control
+
+    async def execute(
+        self, params: CreateTimerParams
+    ) -> SuccessData[CreateTimerResult]:
+        """No operation taken other than capturing message in command."""
+
+        async def timer(task_handler: TaskHandler) -> None:
+            async with task_handler.synchronize_concurrent("createTimer"):
+                await self._run_control.wait_for_duration(params.time)
+
+        task = await self._task_handler.create_task(timer, params.task_id)
+        return SuccessData(
+            public=CreateTimerResult(task_id=task.id, time=params.time),
+        )
+
+
+class CreateTimer(BaseCommand[CreateTimerParams, CreateTimerResult, ErrorOccurrence]):
+    """CreateTimer command model."""
+
+    commandType: CreateTimerCommandType = "createTimer"
+    params: CreateTimerParams
+    result: Optional[CreateTimerResult] = None
+
+    _ImplementationCls: Type[CreateTimerImplementation] = CreateTimerImplementation
+
+
+class CreateTimerCreate(BaseCommandCreate[CreateTimerParams]):
+    """CreateTimer command request model."""
+
+    commandType: CreateTimerCommandType = "createTimer"
+    params: CreateTimerParams
+
+    _CommandCls: Type[CreateTimer] = CreateTimer

opentrons/protocol_engine/commands/dispense.py

@@ -101,6 +101,7 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
             well_name=well_name,
             well_location=well_location,
             operation_volume=volume,
+            offset_pipette_for_reservoir_subwells=False,
         )
         if isinstance(move_result, DefinedErrorData):
             return move_result

opentrons/protocol_engine/commands/drop_tip.py

@@ -12,7 +12,7 @@ from opentrons.protocol_engine.errors.exceptions import TipAttachedError
 from opentrons.protocol_engine.resources.model_utils import ModelUtils
 
 from ..state.update_types import StateUpdate
-from ..types import DropTipWellLocation
+from ..types import DropTipWellLocation, TipRackWellState
 from .pipetting_common import (
     PipetteIdMixin,
     TipPhysicallyAttachedError,
@@ -140,6 +140,25 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             partially_configured=is_partially_configured,
         )
 
+        is_tip_rack = self._state_view.labware.get_definition(
+            labware_id
+        ).parameters.isTiprack
+
+        # It's possible that we are dropping tips into a labware trash for pre API v2.14 OT-2 protocols
+        # (or something else unexpected), so if it is not a tip rack mark no wells as used
+        if is_tip_rack:
+            tips_to_mark_as_used = (
+                self._state_view.tips.compute_tips_to_mark_as_used_or_empty(
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    nozzle_map=self._state_view.pipettes.get_nozzle_configuration(
+                        pipette_id
+                    ),
+                )
+            )
+        else:
+            tips_to_mark_as_used = []
+
         move_result = await move_to_well(
             movement=self._movement_handler,
             model_utils=self._model_utils,
@@ -152,12 +171,7 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             return move_result
 
         scrape_type = TipScrapeType.NONE
-        if (
-            params.scrape_tips
-            and self._state_view.geometry._labware.get_definition(
-                labware_id
-            ).parameters.isTiprack
-        ):
+        if params.scrape_tips and is_tip_rack:
             if int("".join(filter(str.isdigit, well_name))) <= 6:
                 scrape_type = TipScrapeType.RIGHT_ONE_COL
             else:
@@ -194,6 +208,10 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                     pipette_id=params.pipetteId,
                     tip_geometry=None,
                     tip_source=None,
+                ).update_tip_rack_well_state(
+                    tip_state=TipRackWellState.USED,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_used,
                 ),
             )
         else:
@@ -201,10 +219,16 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                 public=DropTipResult(position=move_result.public.position),
                 state_update=move_result.state_update.set_fluid_unknown(
                     pipette_id=pipette_id
-                ).update_pipette_tip_state(
+                )
+                .update_pipette_tip_state(
                     pipette_id=params.pipetteId,
                     tip_geometry=None,
                     tip_source=None,
+                )
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.USED,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_used,
                 ),
             )
 

opentrons/protocol_engine/commands/movement_common.py

@@ -152,6 +152,7 @@ async def move_to_well(
     minimum_z_height: Optional[float] = None,
     speed: Optional[float] = None,
     operation_volume: Optional[float] = None,
+    offset_pipette_for_reservoir_subwells: bool = False,
 ) -> MoveToWellOperationReturn:
     """Execute a move to well microoperation."""
     try:
@@ -165,6 +166,7 @@ async def move_to_well(
             minimum_z_height=minimum_z_height,
             speed=speed,
             operation_volume=operation_volume,
+            offset_pipette_for_reservoir_subwells=offset_pipette_for_reservoir_subwells,
         )
     except StallOrCollisionDetectedError as e:
         return DefinedErrorData(

opentrons/protocol_engine/commands/pick_up_tip.py

@@ -10,7 +10,7 @@ from typing_extensions import Literal
 from ..errors import ErrorOccurrence, PickUpTipTipNotAttachedError
 from ..resources import ModelUtils
 from ..state import update_types
-from ..types import PickUpTipWellLocation, LabwareWellId
+from ..types import PickUpTipWellLocation, LabwareWellId, TipRackWellState
 from .pipetting_common import (
     PipetteIdMixin,
 )
@@ -121,10 +121,14 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
         labware_id = params.labwareId
         well_name = params.wellName
 
-        tips_to_mark_as_used = self._state_view.tips.compute_tips_to_mark_as_used(
-            labware_id=labware_id,
-            well_name=well_name,
-            nozzle_map=self._state_view.pipettes.get_nozzle_configuration(pipette_id),
+        tips_to_mark_as_empty = (
+            self._state_view.tips.compute_tips_to_mark_as_used_or_empty(
+                labware_id=labware_id,
+                well_name=well_name,
+                nozzle_map=self._state_view.pipettes.get_nozzle_configuration(
+                    pipette_id
+                ),
+            )
         )
 
         well_location = self._state_view.geometry.convert_pick_up_tip_well_location(
@@ -160,16 +164,20 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                     ),
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
             )
             state_update = (
                 update_types.StateUpdate.reduce(
                     update_types.StateUpdate(), move_result.state_update
                 )
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
                 .set_fluid_unknown(pipette_id=pipette_id)
             )
@@ -197,8 +205,10 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                         labware_id=labware_id, well_name=well_name
                     ),
                 )
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
                 .set_pipette_ready_to_aspirate(

opentrons/protocol_engine/commands/set_tip_state.py

@@ -0,0 +1,97 @@
+"""Set tip state command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, Type, List
+from typing_extensions import Literal
+
+from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
+from ..types import TipRackWellState
+
+
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+
+
+SetTipStateCommandType = Literal["setTipState"]
+
+
+class SetTipStateParams(BaseModel):
+    """Payload needed to set tip wells of a tip rack to the requested state."""
+
+    labwareId: str = Field(
+        ..., description="Identifier of tip rack labware to set tip wells in."
+    )
+    wellNames: List[str] = Field(
+        ..., description="Names of the well to set tip well state for."
+    )
+    tipWellState: TipRackWellState = Field(
+        ..., description="State to set tip wells to."
+    )
+
+
+class SetTipStateResult(BaseModel):
+    """Result data from the execution of a setTipState command."""
+
+    pass
+
+
+class SetTipStateImplementation(
+    AbstractCommandImpl[SetTipStateParams, SuccessData[SetTipStateResult]]
+):
+    """Set tip state command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+
+    async def execute(
+        self, params: SetTipStateParams
+    ) -> SuccessData[SetTipStateResult]:
+        """Set the tip rack wells to the requested state."""
+        labware_id = params.labwareId
+        well_names = params.wellNames
+
+        self._state_view.labware.raise_if_not_tip_rack(labware_id=labware_id)
+        self._state_view.labware.raise_if_wells_are_invalid(
+            labware_id=labware_id, well_names=well_names
+        )
+
+        return SuccessData(
+            public=SetTipStateResult(),
+            state_update=StateUpdate().update_tip_rack_well_state(
+                tip_state=params.tipWellState,
+                labware_id=labware_id,
+                well_names=well_names,
+            ),
+        )
+
+
+class SetTipState(BaseCommand[SetTipStateParams, SetTipStateResult, ErrorOccurrence]):
+    """Set tip state command model."""
+
+    commandType: SetTipStateCommandType = "setTipState"
+    params: SetTipStateParams
+    result: Optional[SetTipStateResult] = None
+
+    _ImplementationCls: Type[SetTipStateImplementation] = SetTipStateImplementation
+
+
+class SetTipStateCreate(BaseCommandCreate[SetTipStateParams]):
+    """Set tip state command creation request model."""
+
+    commandType: SetTipStateCommandType = "setTipState"
+    params: SetTipStateParams
+
+    _CommandCls: Type[SetTipState] = SetTipState

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -33,6 +33,11 @@ class ProfileStep(BaseModel):
     holdSeconds: float = Field(
         ..., description="Time to hold target temperature in seconds."
     )
+    rampRate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="How quickly to change temperature in °C/second.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class ProfileCycle(BaseModel):
@@ -68,6 +73,7 @@ def _transform_profile_step(
     return ThermocyclerStep(
         temperature=thermocycler_state.validate_target_block_temperature(step.celsius),
         hold_time_seconds=step.holdSeconds,
+        ramp_rate=thermocycler_state.validate_ramp_rate(step.rampRate, step.celsius),
     )
 
 

opentrons/protocol_engine/commands/thermocycler/run_profile.py

@@ -30,6 +30,11 @@ class RunProfileStepParams(BaseModel):
     holdSeconds: float = Field(
         ..., description="Time to hold target temperature at in seconds."
     )
+    rampRate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="How quickly to change temperature in °C/second.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class RunProfileParams(BaseModel):
@@ -81,6 +86,9 @@ class RunProfileImpl(
                     profile_step.celsius
                 ),
                 hold_time_seconds=profile_step.holdSeconds,
+                ramp_rate=thermocycler_state.validate_ramp_rate(
+                    profile_step.rampRate, profile_step.celsius
+                ),
             )
             for profile_step in params.profile
         ]

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -39,6 +39,12 @@ class SetTargetBlockTemperatureParams(BaseModel):
         " the given hold time has elapsed.",
         json_schema_extra=_remove_default,
     )
+    ramp_rate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="The rate in C°/second to change temperature from the current target."
+        " If unspecified, the Thermocycler will change temperature at the fastest possible rate.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetBlockTemperatureResult(BaseModel):
@@ -90,6 +96,13 @@ class SetTargetBlockTemperatureImpl(
             hold_time = thermocycler_state.validate_hold_time(params.holdTimeSeconds)
         else:
             hold_time = None
+        target_ramp_rate: Optional[float]
+        if params.ramp_rate is not None:
+            target_ramp_rate = thermocycler_state.validate_ramp_rate(
+                params.ramp_rate, target_temperature
+            )
+        else:
+            target_ramp_rate = None
 
         thermocycler_hardware = self._equipment.get_module_hardware_api(
             thermocycler_state.module_id
@@ -97,7 +110,10 @@ class SetTargetBlockTemperatureImpl(
 
         if thermocycler_hardware is not None:
             await thermocycler_hardware.set_target_block_temperature(
-                target_temperature, volume=target_volume, hold_time_seconds=hold_time
+                target_temperature,
+                volume=target_volume,
+                hold_time_seconds=hold_time,
+                ramp_rate=target_ramp_rate,
             )
 
         return SuccessData(

opentrons/protocol_engine/commands/touch_tip.py

@@ -114,7 +114,7 @@ class TouchTipImplementation(
 
         if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
             raise TouchTipDisabledError(
-                f"Touch tip not allowed on labware {labware_id}"
+                f"Touch tip not allowed on labware {self._state_view.labware.get_display_name(labware_id)}"
             )
 
         if self._state_view.labware.is_tiprack(labware_id):

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -14,12 +14,11 @@ from opentrons.protocol_engine.errors.exceptions import (
     CannotPerformGripperAction,
     GripperNotAttachedError,
 )
-from opentrons.types import Point
-
 from ...types import (
     DeckSlotLocation,
     ModuleModel,
     OnDeckLabwareLocation,
+    GripperMoveType,
 )
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
@@ -100,22 +99,6 @@ class UnsafePlaceLabwareImplementation(
             LabwareUri(params.labwareURI)
         )
 
-        # todo(mm, 2024-11-06): This is only correct in the special case of an
-        # absorbance reader lid. Its definition currently puts the offsets for *itself*
-        # in the property that's normally meant for offsets for its *children.*
-        final_offsets = self._state_view.labware.get_child_gripper_offsets(
-            labware_definition=definition, slot_name=None
-        )
-        drop_offset = (
-            Point(
-                final_offsets.dropOffset.x,
-                final_offsets.dropOffset.y,
-                final_offsets.dropOffset.z,
-            )
-            if final_offsets
-            else None
-        )
-
         if isinstance(params.location, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.location.slotName.id
@@ -139,7 +122,7 @@ class UnsafePlaceLabwareImplementation(
         await ot3api.update_axis_position_estimations([Axis.X, Axis.Y])
 
         # Place the labware down
-        await self._start_movement(ot3api, definition, location, drop_offset)
+        await self._start_movement(ot3api, definition, location)
 
         return SuccessData(public=UnsafePlaceLabwareResult())
 
@@ -148,7 +131,6 @@ class UnsafePlaceLabwareImplementation(
         ot3api: OT3HardwareControlAPI,
         labware_definition: LabwareDefinition,
         location: OnDeckLabwareLocation,
-        drop_offset: Optional[Point],
     ) -> None:
         gripper_homed_position = await ot3api.gantry_position(
             mount=OT3Mount.GRIPPER,
@@ -156,13 +138,15 @@ class UnsafePlaceLabwareImplementation(
         )
 
         to_labware_center = self._state_view.geometry.get_labware_grip_point(
-            labware_definition=labware_definition, location=location
+            labware_definition=labware_definition,
+            location=location,
+            move_type=GripperMoveType.DROP_LABWARE,
+            user_additional_offset=None,
         )
 
         movement_waypoints = get_gripper_labware_placement_waypoints(
             to_labware_center=to_labware_center,
             gripper_home_z=gripper_homed_position.z,
-            drop_offset=drop_offset,
         )
 
         # start movement