opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_api/tasks.py

@@ -0,0 +1,48 @@
+"""Data for concurrent protocol tasks."""
+from typing import TYPE_CHECKING
+from datetime import datetime
+from opentrons.protocols.api_support.util import requires_version
+from opentrons.protocols.api_support.types import APIVersion
+
+if TYPE_CHECKING:
+    from .core.common import TaskCore
+
+
+class Task:
+    """A concurrent protocol task created by a protocol API function.
+
+    .. versionadded:: 2.27
+    """
+
+    def __init__(self, core: "TaskCore", api_version: APIVersion) -> None:
+        """Initialize a Task."""
+        self._core = core
+        self._api_version = api_version
+
+    @property
+    @requires_version(2, 27)
+    def created_at(self) -> datetime:
+        """The timestamp of when the task was created."""
+        return self._core.get_created_at_timestamp()
+
+    @property
+    @requires_version(2, 27)
+    def done(self) -> bool:
+        """Returns ``True`` if the task is done."""
+        return self._core.is_done()
+
+    @property
+    @requires_version(2, 27)
+    def started(self) -> bool:
+        """Returns ``True`` if the task has started."""
+        return self._core.is_started()
+        ...
+
+    @property
+    @requires_version(2, 27)
+    def finished_at(self) -> datetime | None:
+        """The timestamp of the when the task finished.
+
+        Returns ``None`` if the task hasn't finished yet.
+        """
+        return self._core.get_finished_at_timestamp()

opentrons/protocol_api/validation.py

@@ -99,11 +99,18 @@ class InvalidFixtureLocationError(ValueError):
     """An error raised when attempting to load a fixture in an invalid cutout."""
 
 
+def is_pipette_96_channel(pipette: Optional[PipetteNameType]) -> bool:
+    """Return if this pipette type is a 96 channel."""
+    if pipette is not None:
+        return pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]
+    return False
+
+
 def ensure_mount_for_pipette(
     mount: Union[str, Mount, None], pipette: PipetteNameType
 ) -> Mount:
     """Ensure that an input value represents a valid mount, and is valid for the given pipette."""
-    if pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]:
+    if is_pipette_96_channel(pipette):
         # Always validate the raw mount input, even if the pipette is a 96-channel and we're not going
         # to use the mount value.
         if mount is not None:
@@ -370,7 +377,7 @@ def ensure_definition_is_not_lid_after_api_version(
         and api_version >= LID_STACK_VERSION_GATE
     ):
         raise APIVersionError(
-            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version greater than {LID_STACK_VERSION_GATE}."
+            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version of {LID_STACK_VERSION_GATE} or higher."
         )
 
 
@@ -489,6 +496,7 @@ 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:
@@ -496,10 +504,14 @@ 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
+                temperature=temperature,
+                hold_time_seconds=validated_seconds,
+                ramp_rate=ramp_rate,
             )
         )
     return validated_steps
@@ -565,6 +577,40 @@ class LocationTypeError(TypeError):
 ValidTarget = Union[WellTarget, PointTarget, DisposalTarget]
 
 
+def validate_dynamic_locations(
+    location: Optional[Union[Location, Well, TrashBin, WasteChute]],
+    end_location: Location,
+) -> None:
+    """Given that we have an end_location we check that they're a vaild dynamic pair."""
+    if location is None:
+        raise ValueError("Location must be supplied if using an End Location.")
+    if not isinstance(location, Location):
+        raise ValueError(
+            "Location must be a point within a well when dynamic pipetting."
+        )
+    # Shouldn't be true ever if using typing but a customer protocol may not check
+    if not isinstance(end_location, Location):
+        raise ValueError(
+            "End location must be a point within a well when dynamic pipetting."
+        )
+    if not location.labware.is_well:
+        raise ValueError("Start location must be within a well when dynamic pipetting")
+    if not end_location.labware.is_well:
+        raise ValueError("End location must be within a well when dynamic pipetting")
+    (
+        _,
+        start_well,
+    ) = location.labware.get_parent_labware_and_well()
+    (
+        _,
+        end_well,
+    ) = end_location.labware.get_parent_labware_and_well()
+    if start_well != end_well:
+        raise ValueError(
+            "Start and end locations must be within the same well when dynamic pipetting"
+        )
+
+
 def validate_location(
     location: Optional[Union[Location, Well, TrashBin, WasteChute]],
     last_location: Optional[Union[Location, TrashBin, WasteChute]],

opentrons/protocol_engine/__init__.py

@@ -41,6 +41,8 @@ from .types import (
     DeckType,
     DeckSlotLocation,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
+    AccessibleByGripperLocation,
     ModuleLocation,
     OnLabwareLocation,
     AddressableAreaLocation,
@@ -120,6 +122,8 @@ __all__ = [
     "ModuleLocation",
     "OnLabwareLocation",
     "AddressableAreaLocation",
+    "WASTE_CHUTE_LOCATION",
+    "AccessibleByGripperLocation",
     "InStackerHopperLocation",
     "OFF_DECK_LOCATION",
     "SYSTEM_LOCATION",

opentrons/protocol_engine/actions/__init__.py

@@ -21,13 +21,15 @@ from .actions import (
     AddLabwareOffsetAction,
     AddLabwareDefinitionAction,
     AddLiquidAction,
+    AddCameraSettingsAction,
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
     AddModuleAction,
     FinishErrorDetails,
     DoorChangeAction,
-    ResetTipsAction,
     SetPipetteMovementSpeedAction,
+    StartTaskAction,
+    FinishTaskAction,
 )
 from .get_state_update import get_state_updates
 
@@ -50,13 +52,15 @@ __all__ = [
     "FailCommandAction",
     "AddLabwareOffsetAction",
     "AddLabwareDefinitionAction",
+    "AddCameraSettingsAction",
     "AddLiquidAction",
     "SetDeckConfigurationAction",
     "AddAddressableAreaAction",
     "AddModuleAction",
     "DoorChangeAction",
-    "ResetTipsAction",
     "SetPipetteMovementSpeedAction",
+    "StartTaskAction",
+    "FinishTaskAction",
     # action payload values
     "PauseSource",
     "FinishErrorDetails",

opentrons/protocol_engine/actions/actions.py

@@ -3,6 +3,7 @@
 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
@@ -20,13 +21,16 @@ 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 ..resources.camera_provider import CameraSettings
 from ..types import (
     LabwareOffsetCreateInternal,
     ModuleDefinition,
     Liquid,
     DeckConfigurationType,
+    Task,
 )
 
 
@@ -60,7 +64,7 @@ class PauseAction:
 class StopAction:
     """Request engine execution to stop soon."""
 
-    from_estop: bool = False
+    from_asynchronous_error: bool = False
 
 
 @dataclasses.dataclass(frozen=True)
@@ -201,6 +205,22 @@ 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."""
@@ -217,6 +237,13 @@ class AddLabwareDefinitionAction:
     definition: LabwareDefinition
 
 
+@dataclasses.dataclass(frozen=True)
+class AddCameraSettingsAction:
+    """Add Camera settings to be used in place of the Camera Provider accessible settings."""
+
+    enablement_settings: CameraSettings
+
+
 @dataclasses.dataclass(frozen=True)
 class AddLiquidAction:
     """Add a liquid, to apply to subsequent `LoadLiquid`s."""
@@ -253,13 +280,6 @@ 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.
@@ -293,10 +313,12 @@ Action = Union[
     AddLabwareOffsetAction,
     AddLabwareDefinitionAction,
     AddModuleAction,
+    AddCameraSettingsAction,
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
     AddLiquidAction,
-    ResetTipsAction,
     SetPipetteMovementSpeedAction,
     SetErrorRecoveryPolicyAction,
+    StartTaskAction,
+    FinishTaskAction,
 ]

opentrons/protocol_engine/clients/sync_client.py

@@ -65,6 +65,48 @@ 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
@@ -149,13 +191,6 @@ 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)

opentrons/protocol_engine/commands/__init__.py

@@ -271,6 +271,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,
@@ -384,6 +400,14 @@ from .get_next_tip import (
     GetNextTipCommandType,
 )
 
+from .set_tip_state import (
+    SetTipState,
+    SetTipStateCreate,
+    SetTipStateParams,
+    SetTipStateResult,
+    SetTipStateCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -427,6 +451,14 @@ from .identify_module import (
     IdentifyModuleCommandType,
 )
 
+from .capture_image import (
+    CaptureImage,
+    CaptureImageParams,
+    CaptureImageCreate,
+    CaptureImageResult,
+    CaptureImageCommandType,
+)
+
 __all__ = [
     # command type unions
     "Command",
@@ -619,6 +651,12 @@ __all__ = [
     "WaitForDurationCreate",
     "WaitForDurationResult",
     "WaitForDurationCommandType",
+    # Timer command models
+    "CreateTimer",
+    "CreateTimerCreate",
+    "CreateTimerParams",
+    "CreateTimerResult",
+    "CreateTimerCommandType",
     # pick up tip command models
     "PickUpTip",
     "PickUpTipCreate",
@@ -725,6 +763,12 @@ __all__ = [
     "GetNextTipParams",
     "GetNextTipResult",
     "GetNextTipCommandType",
+    # set tip state command bundle
+    "SetTipState",
+    "SetTipStateCreate",
+    "SetTipStateParams",
+    "SetTipStateResult",
+    "SetTipStateCommandType",
     # liquid probe command bundle
     "LiquidProbe",
     "LiquidProbeParams",
@@ -754,4 +798,16 @@ __all__ = [
     "PressureDispenseCreate",
     "PressureDispenseResult",
     "PressureDispenseCommandType",
+    # wait for tasks command bundle
+    "WaitForTasks",
+    "WaitForTasksCreate",
+    "WaitForTasksParams",
+    "WaitForTasksResult",
+    "WaitForTasksCommandType",
+    # capture image command bundle
+    "CaptureImage",
+    "CaptureImageCreate",
+    "CaptureImageParams",
+    "CaptureImageResult",
+    "CaptureImageCommandType",
 ]

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -102,25 +102,12 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
                 )
             )
 
-            # The lid's labware definition stores gripper offsets for itself in the
-            # space normally meant for offsets for labware stacked atop it.
-            lid_gripper_offsets = self._state_view.labware.get_child_gripper_offsets(
-                labware_definition=lid_definition,
-                slot_name=None,
-            )
-            if lid_gripper_offsets is None:
-                raise ValueError(
-                    "Gripper Offset values for Absorbance Reader Lid labware must not be None."
-                )
-
             await self._labware_movement.move_labware_with_gripper(
                 labware_definition=lid_definition,
                 current_location=current_location,
                 new_location=new_location,
-                user_pick_up_offset=Point.from_xyz_attrs(
-                    lid_gripper_offsets.pickUpOffset
-                ),
-                user_drop_offset=Point.from_xyz_attrs(lid_gripper_offsets.dropOffset),
+                user_pick_up_offset=Point(),
+                user_drop_offset=Point(),
                 post_drop_slide_offset=None,
                 gripper_z_offset=LID_Z_CLEARANCE,
             )

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -103,25 +103,12 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
                 mod_substate.module_id
             )
 
-            # The lid's labware definition stores gripper offsets for itself in the
-            # space normally meant for offsets for labware stacked atop it.
-            lid_gripper_offsets = self._state_view.labware.get_child_gripper_offsets(
-                labware_definition=lid_definition,
-                slot_name=None,
-            )
-            if lid_gripper_offsets is None:
-                raise ValueError(
-                    "Gripper Offset values for Absorbance Reader Lid labware must not be None."
-                )
-
             await self._labware_movement.move_labware_with_gripper(
                 labware_definition=lid_definition,
                 current_location=current_location,
                 new_location=new_location,
-                user_pick_up_offset=Point.from_xyz_attrs(
-                    lid_gripper_offsets.pickUpOffset
-                ),
-                user_drop_offset=Point.from_xyz_attrs(lid_gripper_offsets.dropOffset),
+                user_pick_up_offset=Point(),
+                user_drop_offset=Point(),
                 post_drop_slide_offset=None,
                 gripper_z_offset=LID_Z_CLEARANCE,
             )

opentrons/protocol_engine/commands/absorbance_reader/read.py

@@ -7,14 +7,15 @@ from typing_extensions import Literal, Type
 from pydantic import BaseModel, Field
 from pydantic.json_schema import SkipJsonSchema
 
+from opentrons_shared_data.data_files import MimeType
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ...errors import CannotPerformModuleAction, StorageLimitReachedError
+from ...errors import CannotPerformModuleAction
 from ...errors.error_occurrence import ErrorOccurrence
 
 from ...resources.file_provider import (
     PlateReaderData,
     ReadData,
-    MAXIMUM_CSV_FILE_LIMIT,
+    ReadCmdFileNameMetadata,
 )
 from ...resources import FileProvider
 from ...state import update_types
@@ -93,21 +94,6 @@ class ReadAbsorbanceImpl(
                 "Absorbance Plate Reader can't read a plate with the lid open. Call `close_lid()` first."
             )
 
-        # TODO: we need to return a file ID and increase the file count even when a moduel is not attached
-        if (
-            params.fileName is not None
-            and abs_reader_substate.configured_wavelengths is not None
-        ):
-            # Validate that the amount of files we are about to generate does not put us higher than the limit
-            if (
-                self._state_view.files.get_filecount()
-                + len(abs_reader_substate.configured_wavelengths)
-                > MAXIMUM_CSV_FILE_LIMIT
-            ):
-                raise StorageLimitReachedError(
-                    message=f"Attempt to write file {params.fileName} exceeds file creation limit of {MAXIMUM_CSV_FILE_LIMIT} files."
-                )
-
         asbsorbance_result: Dict[int, Dict[str, float]] = {}
         transform_results = []
         # Handle the measurement and begin building data for return
@@ -172,15 +158,28 @@ class ReadAbsorbanceImpl(
             )
 
             if isinstance(plate_read_result, PlateReaderData):
+                this_cmd_id = self._state_view.commands.get_running_command_id()
+                prev_cmd = (
+                    self._state_view.commands.get_most_recently_finalized_command()
+                )
+                prev_cmd_id = prev_cmd.command.id if prev_cmd is not None else None
+
                 # Write a CSV file for each of the measurements taken
                 for measurement in plate_read_result.read_results:
-                    file_id = await self._file_provider.write_csv(
-                        write_data=plate_read_result.build_generic_csv(
-                            filename=params.fileName,
-                            measurement=measurement,
-                        )
+                    csv_bytes = plate_read_result.build_csv_bytes(
+                        measurement=measurement,
+                    )
+                    file_info = await self._file_provider.write_file(
+                        data=csv_bytes,
+                        mime_type=MimeType.TEXT_CSV,
+                        command_metadata=ReadCmdFileNameMetadata(
+                            base_filename=params.fileName,
+                            wavelength=measurement.wavelength,
+                            command_id=this_cmd_id or "",
+                            prev_command_id=prev_cmd_id or "",
+                        ),
                     )
-                    file_ids.append(file_id)
+                    file_ids.append(file_info.id)
 
                 state_update.files_added = update_types.FilesAddedUpdate(
                     file_ids=file_ids

opentrons/protocol_engine/commands/aspirate.py

@@ -161,6 +161,7 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
             well_location=well_location,
             current_well=current_well,
             operation_volume=-params.volume,
+            offset_pipette_for_reservoir_subwells=False,
         )
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):