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

opentrons/protocol_engine/state/module_substates/thermocycler_module_substate.py

@@ -5,6 +5,7 @@ from typing import NewType, Optional
 from opentrons.protocol_engine.errors import (
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
+    InvalidRampRateError,
     NoTargetTemperatureSetError,
     InvalidHoldTimeError,
 )
@@ -23,6 +24,10 @@ from opentrons.hardware_control.modules import ModuleData, ModuleDataValidator
 
 ThermocyclerModuleId = NewType("ThermocyclerModuleId", str)
 
+# These are our published numbers, and from testing they are good bounds
+MAX_HEATING_RATE = 4.25
+MAX_COOLING_RATE = 2.0
+
 
 @dataclass(frozen=True)
 class ThermocyclerModuleSubState:
@@ -143,6 +148,38 @@ class ThermocyclerModuleSubState:
             )
         return target
 
+    def validate_ramp_rate(
+        self, ramp_rate: Optional[float], target_temp: float
+    ) -> Optional[float]:
+        """Validate a given temperature ramp rate.
+
+        Args:
+            ramp_rate: The requested ramp rate in °C/second.
+            target_temp:  The requested block temperature.
+
+        Raises:
+            InvalidRampRateError: The given ramp_rate is invalid
+
+        Returns:
+            The validated ramp rate in °C/second
+        """
+        if ramp_rate is None:
+            return ramp_rate
+
+        heating = target_temp > self.get_target_block_temperature()
+        if (heating and ramp_rate > MAX_HEATING_RATE) or (
+            not heating and ramp_rate > MAX_COOLING_RATE
+        ):
+            raise InvalidRampRateError(
+                f"Thermocycler ramp rate cannot exceed {MAX_HEATING_RATE}°C/s"
+                f" while heating or {MAX_COOLING_RATE}°C/s when cooling."
+            )
+        if ramp_rate <= 0:
+            raise InvalidRampRateError(
+                f"Thermocycler ramp rate cannot be less than or equal to 0, got {ramp_rate}"
+            )
+        return ramp_rate
+
     @classmethod
     def from_live_data(
         cls, module_id: ThermocyclerModuleId, data: ModuleData | None

opentrons/protocol_engine/state/modules.py

@@ -56,7 +56,6 @@ from ..types import (
     HeaterShakerLatchStatus,
     HeaterShakerMovementRestrictors,
     DeckType,
-    LabwareMovementOffsetData,
     AddressableAreaLocation,
     StackerStoredLabwareGroup,
 )
@@ -268,6 +267,7 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 heater_shaker.SetTargetTemperatureResult,
                 heater_shaker.DeactivateHeaterResult,
                 heater_shaker.SetAndWaitForShakeSpeedResult,
+                heater_shaker.SetShakeSpeedResult,
                 heater_shaker.DeactivateShakerResult,
                 heater_shaker.OpenLabwareLatchResult,
                 heater_shaker.CloseLabwareLatchResult,
@@ -431,6 +431,7 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             heater_shaker.SetTargetTemperature,
             heater_shaker.DeactivateHeater,
             heater_shaker.SetAndWaitForShakeSpeed,
+            heater_shaker.SetShakeSpeed,
             heater_shaker.DeactivateShaker,
             heater_shaker.OpenLabwareLatch,
             heater_shaker.CloseLabwareLatch,
@@ -466,6 +467,13 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 is_plate_shaking=True,
                 plate_target_temperature=prev_state.plate_target_temperature,
             )
+        elif isinstance(command.result, heater_shaker.SetShakeSpeedResult):
+            self._state.substate_by_module_id[module_id] = HeaterShakerModuleSubState(
+                module_id=HeaterShakerModuleId(module_id),
+                labware_latch_status=prev_state.labware_latch_status,
+                is_plate_shaking=True,
+                plate_target_temperature=prev_state.plate_target_temperature,
+            )
         elif isinstance(command.result, heater_shaker.DeactivateShakerResult):
             self._state.substate_by_module_id[module_id] = HeaterShakerModuleSubState(
                 module_id=HeaterShakerModuleId(module_id),
@@ -1336,13 +1344,6 @@ class ModuleView:
             return True
         return False
 
-    def get_default_gripper_offsets(
-        self, module_id: str
-    ) -> Optional[LabwareMovementOffsetData]:
-        """Get the deck's default gripper offsets."""
-        offsets = self.get_definition(module_id).gripperOffsets
-        return offsets.get("default") if offsets else None
-
     def get_overflowed_module_in_slot(
         self, slot_name: DeckSlotName
     ) -> Optional[LoadedModule]:
@@ -1519,3 +1520,24 @@ class ModuleView:
                 f"Provided overlap offset {overlap_offset} does not match "
                 f"configured {configured}."
             )
+
+    def get_has_module_probably_matching_hardware_details(
+        self, module_model: ModuleModel, module_serial: str | None
+    ) -> bool:
+        """Get the ID of a model that possibly matches the provided details.
+
+        If the provided serial is not None, return True if there is a module with the same serial or
+        False if there is not.
+        If the provided serial is None, return True if there is a module with the same model or False if
+        there is not.
+
+        This is intended to provide a good probability that a module matching the provided details
+        is or is not present in the state store. It is used to drive whether the engine cancels a protocol
+        in response to an asynchronous module error or not.
+        """
+        for module_id, module in self._state.hardware_by_module_id.items():
+            if module_serial is not None and module_serial == module.serial_number:
+                return True
+            if module_serial is None and module.definition.model == module_model:
+                return True
+        return False

opentrons/protocol_engine/state/motion.py

@@ -1,6 +1,8 @@
 """Motion state store and getters."""
+
 from dataclasses import dataclass
 from typing import List, Optional, Union
+import logging
 
 from opentrons.types import MountType, Point, StagingSlotName
 from opentrons.hardware_control.types import CriticalPoint
@@ -28,6 +30,8 @@ from .geometry import GeometryView
 from .modules import ModuleView
 from .module_substates import HeaterShakerModuleId
 
+log = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class PipetteLocationData:
@@ -75,16 +79,58 @@ class MotionView:
             isinstance(current_location, CurrentWell)
             and current_location.pipette_id == pipette_id
         ):
-            if self._labware.get_should_center_column_on_target_well(
-                current_location.labware_id
-            ):
-                critical_point = CriticalPoint.Y_CENTER
-            elif self._labware.get_should_center_pipette_on_target_well(
+            critical_point = self.get_critical_point_for_wells_in_labware(
                 current_location.labware_id
-            ):
-                critical_point = CriticalPoint.XY_CENTER
+            )
         return PipetteLocationData(mount=mount, critical_point=critical_point)
 
+    def _get_pipette_offset_for_reservoirs(
+        self, labware_id: str, well_name: str, pipette_id: str
+    ) -> Point:
+        #   8 rows, 12 columns
+        subwells_96 = self._labware.get_has_96_subwells(labware_id)
+        #   1 row, 12 columns
+        subwells_12 = self._labware.get_has_12_subwells(labware_id)
+        if subwells_12 and subwells_96:
+            log.warning(
+                f"{self._labware.get_display_name(labware_id)} has both offsetPipetteFor96GridSubwells and"
+                " offsetPipetteFor12GridSubwells quirks."
+            )
+
+        pipette_rows = self._pipettes.get_nozzle_configuration(pipette_id).rows
+        pipette_cols = self._pipettes.get_nozzle_configuration(pipette_id).columns
+
+        even_labware_rows = subwells_96
+        even_labware_columns = subwells_96 or subwells_12
+        odd_pipette_rows = len(pipette_rows) % 2 == 1
+        odd_pipette_cols = len(pipette_cols) % 2 == 1
+
+        well_x_dim, well_y_dim, well_z_dim = self._labware.get_well_size(
+            labware_id=labware_id, well_name=well_name
+        )
+        x_offset = 0.0
+        y_offset = 0.0
+        if even_labware_rows and odd_pipette_rows:
+            # need to move up half a row
+            # there's 8 rows, so move 1/16 of reservoir length
+            y_offset = well_y_dim / 16
+        if even_labware_columns and odd_pipette_cols:
+            # need to move left half a column
+            # there's 12 columns, so move 1/24 of reservoir width
+            x_offset = -1 * well_x_dim / 24
+        return Point(x=x_offset, y=y_offset)
+
+    def get_critical_point_for_wells_in_labware(
+        self, labware_id: str
+    ) -> CriticalPoint | None:
+        """Get the appropriate critical point override for this labware."""
+        if self._labware.get_should_center_column_on_target_well(labware_id):
+            return CriticalPoint.Y_CENTER
+        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
+            return CriticalPoint.XY_CENTER
+        else:
+            return None
+
     def get_movement_waypoints_to_well(
         self,
         pipette_id: str,
@@ -98,15 +144,12 @@ class MotionView:
         force_direct: bool = False,
         minimum_z_height: Optional[float] = None,
         operation_volume: Optional[float] = None,
+        offset_pipette_for_reservoir_subwells: bool = False,
     ) -> List[motion_planning.Waypoint]:
         """Calculate waypoints to a destination that's specified as a well."""
         location = current_well or self._pipettes.get_current_location()
 
-        destination_cp: Optional[CriticalPoint] = None
-        if self._labware.get_should_center_column_on_target_well(labware_id):
-            destination_cp = CriticalPoint.Y_CENTER
-        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
-            destination_cp = CriticalPoint.XY_CENTER
+        destination_cp = self.get_critical_point_for_wells_in_labware(labware_id)
 
         destination = self._geometry.get_well_position(
             labware_id=labware_id,
@@ -115,6 +158,10 @@ class MotionView:
             operation_volume=operation_volume,
             pipette_id=pipette_id,
         )
+        if offset_pipette_for_reservoir_subwells:
+            destination += self._get_pipette_offset_for_reservoirs(
+                labware_id=labware_id, well_name=well_name, pipette_id=pipette_id
+            )
 
         move_type = _move_types.get_move_type_to_well(
             pipette_id, labware_id, well_name, location, force_direct
@@ -353,12 +400,7 @@ class MotionView:
             mm_from_edge=mm_from_edge,
             edge_path_type=edge_path_type,
         )
-        critical_point: Optional[CriticalPoint] = None
-
-        if self._labware.get_should_center_column_on_target_well(labware_id):
-            critical_point = CriticalPoint.Y_CENTER
-        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
-            critical_point = CriticalPoint.XY_CENTER
+        critical_point = self.get_critical_point_for_wells_in_labware(labware_id)
 
         return [
             motion_planning.Waypoint(position=p, critical_point=critical_point)

opentrons/protocol_engine/state/preconditions.py

@@ -0,0 +1,59 @@
+"""Command precondition state and store resource."""
+from dataclasses import dataclass
+
+from opentrons.protocol_engine.actions.get_state_update import get_state_updates
+from opentrons.protocol_engine.state import update_types
+from opentrons.protocol_engine.types import CommandPreconditions, PreconditionTypes
+
+from ._abstract_store import HasState, HandlesActions
+from ..actions import Action
+
+
+@dataclass
+class CommandPreconditionState:
+    """State of Engine command precondition references."""
+
+    preconditions: CommandPreconditions
+
+
+class CommandPreconditionStore(HasState[CommandPreconditionState], HandlesActions):
+    """Command Precondition container."""
+
+    _state: CommandPreconditionState
+
+    def __init__(self) -> None:
+        """Initialize a Command Precondition store and its state."""
+        self._state = CommandPreconditionState(
+            preconditions=CommandPreconditions(isCameraUsed=False)
+        )
+
+    def handle_action(self, action: Action) -> None:
+        """Modify state in reaction to an action."""
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
+
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.precondition_update != update_types.NO_CHANGE:
+            for key in state_update.precondition_update.preconditions:
+                if key == PreconditionTypes.IS_CAMERA_USED:
+                    self._state.preconditions.isCameraUsed = (
+                        state_update.precondition_update.preconditions[key]
+                    )
+
+
+class CommandPreconditionView:
+    """Read-only engine created Command Precondition state view."""
+
+    _state: CommandPreconditionState
+
+    def __init__(self, state: CommandPreconditionState) -> None:
+        """Initialize the view of Command Precondition state.
+
+        Arguments:
+            state: Command precondition dataclass used for tracking preconditions used during a protocol.
+        """
+        self._state = state
+
+    def get_precondition(self) -> CommandPreconditions:
+        """Get the Command Preconditions currently set by a protocol."""
+        return self._state.preconditions

opentrons/protocol_engine/state/state.py

@@ -34,6 +34,13 @@ from .files import FileView, FileState, FileStore
 from .config import Config
 from .state_summary import StateSummary
 from ..types import DeckConfigurationType
+from .tasks import TaskState, TaskView, TaskStore
+from .preconditions import (
+    CommandPreconditionState,
+    CommandPreconditionStore,
+    CommandPreconditionView,
+)
+from .camera import CameraState, CameraView, CameraStore
 
 
 _ParamsT = ParamSpec("_ParamsT")
@@ -54,6 +61,9 @@ class State:
     tips: TipState
     wells: WellState
     files: FileState
+    tasks: TaskState
+    preconditions: CommandPreconditionState
+    camera: CameraState
 
 
 class StateView(HasState[State]):
@@ -73,6 +83,9 @@ class StateView(HasState[State]):
     _motion: MotionView
     _files: FileView
     _config: Config
+    _tasks: TaskView
+    _preconditions: CommandPreconditionView
+    _camera: CameraView
 
     @property
     def commands(self) -> CommandView:
@@ -139,6 +152,21 @@ class StateView(HasState[State]):
         """Get ProtocolEngine configuration."""
         return self._config
 
+    @property
+    def preconditions(self) -> CommandPreconditionView:
+        """Get state view selectors for command preconditions."""
+        return self._preconditions
+
+    @property
+    def camera(self) -> CameraView:
+        """Get state view for the Camera."""
+        return self._camera
+
+    @property
+    def tasks(self) -> TaskView:
+        """Get state view selectors for task state."""
+        return self._tasks
+
     def get_summary(self) -> StateSummary:
         """Get protocol run data."""
         error = self._commands.get_error()
@@ -162,6 +190,8 @@ class StateView(HasState[State]):
                 )
                 for liquid_class_id, liquid_class_record in self._liquid_classes.get_all().items()
             ],
+            tasks=self._tasks.get_summary(),
+            cameraSettings=self._camera.get_enablement_settings(),
         )
 
 
@@ -231,6 +261,9 @@ class StateStore(StateView, ActionHandler):
         self._tip_store = TipStore()
         self._well_store = WellStore()
         self._file_store = FileStore()
+        self._task_store = TaskStore()
+        self._precondition_store = CommandPreconditionStore()
+        self._camera_store = CameraStore()
 
         self._substores: List[HandlesActions] = [
             self._command_store,
@@ -243,6 +276,9 @@ class StateStore(StateView, ActionHandler):
             self._tip_store,
             self._well_store,
             self._file_store,
+            self._task_store,
+            self._precondition_store,
+            self._camera_store,
         ]
         self._config = config
         self._change_notifier = change_notifier or ChangeNotifier()
@@ -366,6 +402,9 @@ class StateStore(StateView, ActionHandler):
             tips=self._tip_store.state,
             wells=self._well_store.state,
             files=self._file_store.state,
+            tasks=self._task_store.state,
+            preconditions=self._precondition_store.state,
+            camera=self._camera_store.state,
         )
 
     def _initialize_state(self) -> None:
@@ -384,6 +423,9 @@ class StateStore(StateView, ActionHandler):
         self._tips = TipView(state.tips)
         self._wells = WellView(state.wells)
         self._files = FileView(state.files)
+        self._tasks = TaskView(state.tasks)
+        self._preconditions = CommandPreconditionView(state.preconditions)
+        self._camera = CameraView(state.camera)
 
         # Derived states
         self._geometry = GeometryView(
@@ -416,6 +458,8 @@ class StateStore(StateView, ActionHandler):
         self._liquid_classes._state = next_state.liquid_classes
         self._tips._state = next_state.tips
         self._wells._state = next_state.wells
+        self._tasks._state = next_state.tasks
+        self._camera._state = next_state.camera
         self._change_notifier.notify()
         if self._notify_robot_server is not None:
             self._notify_robot_server()

opentrons/protocol_engine/state/state_summary.py

@@ -13,7 +13,9 @@ from ..types import (
     Liquid,
     LiquidClassRecordWithId,
     WellInfoSummary,
+    TaskSummary,
 )
+from ..resources.camera_provider import CameraSettings
 
 
 class StateSummary(BaseModel):
@@ -34,3 +36,5 @@ class StateSummary(BaseModel):
     wells: List[WellInfoSummary] = Field(default_factory=list)
     files: List[str] = Field(default_factory=list)
     liquidClasses: List[LiquidClassRecordWithId] = Field(default_factory=list)
+    tasks: List[TaskSummary] = Field(default_factory=list)
+    cameraSettings: Optional[CameraSettings] = None

opentrons/protocol_engine/state/tasks.py

@@ -0,0 +1,139 @@
+"""Task state tracking."""
+from dataclasses import dataclass
+from itertools import chain
+from typing import Iterable
+from ..types import Task, TaskSummary, FinishedTask
+from ._abstract_store import HasState, HandlesActions
+from opentrons.protocol_engine.state import update_types
+from opentrons.protocol_engine.errors.exceptions import NoTaskFoundError
+from ..actions import (
+    get_state_updates,
+    Action,
+    StartTaskAction,
+    FinishTaskAction,
+)
+
+
+@dataclass
+class TaskState:
+    """Task state tracking."""
+
+    current_tasks_by_id: dict[str, Task]
+    finished_tasks_by_id: dict[str, FinishedTask]
+
+
+class TaskStore(HasState[TaskState], HandlesActions):
+    """Stores tasks."""
+
+    _state: TaskState
+
+    def __init__(self) -> None:
+        """Initialize a TaskStore."""
+        self._state = TaskState(current_tasks_by_id={}, finished_tasks_by_id={})
+
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        """Handle a state update."""
+        return
+
+    def _handle_start_task_action(self, action: StartTaskAction) -> None:
+        self._state.current_tasks_by_id[action.task.id] = action.task
+
+    def _handle_finish_task_action(self, action: FinishTaskAction) -> None:
+        task = self._state.current_tasks_by_id[action.task_id]
+        self._state.finished_tasks_by_id[action.task_id] = FinishedTask(
+            id=task.id,
+            createdAt=task.createdAt,
+            finishedAt=action.finished_at,
+            error=action.error,
+        )
+        del self._state.current_tasks_by_id[action.task_id]
+
+    def handle_action(self, action: Action) -> None:
+        """Modify the state in reaction to an action."""
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
+        match action:
+            case StartTaskAction():
+                self._handle_start_task_action(action)
+            case FinishTaskAction():
+                self._handle_finish_task_action(action)
+            case _:
+                pass
+
+
+class TaskView:
+    """Read-only task state view."""
+
+    _state: TaskState
+
+    def __init__(self, state: TaskState) -> None:
+        """Initialize a TaskView."""
+        self._state = state
+
+    def get_current(self, id: str) -> Task:
+        """Get a task by ID."""
+        try:
+            return self._state.current_tasks_by_id[id]
+        except KeyError as e:
+            raise NoTaskFoundError(f"No current task with ID {id}") from e
+
+    def get_all_current(self) -> list[Task]:
+        """Get all currently running tasks."""
+        return [task for task in self._state.current_tasks_by_id.values()]
+
+    def get_finished(self, id: str) -> FinishedTask:
+        """Get a finished task by ID."""
+        try:
+            return self._state.finished_tasks_by_id[id]
+        except KeyError as e:
+            raise NoTaskFoundError(f"No finished task with ID {id}") from e
+
+    def get(self, id: str) -> Task | FinishedTask:
+        """Get a single task by id."""
+        if id in self._state.current_tasks_by_id:
+            return self._state.current_tasks_by_id[id]
+        elif id in self._state.finished_tasks_by_id:
+            return self._state.finished_tasks_by_id[id]
+        else:
+            raise NoTaskFoundError(message=f"Task {id} not found.")
+
+    def get_summary(self) -> list[TaskSummary]:
+        """Get a summary of all tasks."""
+        return [
+            TaskSummary(
+                id=task_id,
+                createdAt=task.createdAt,
+                finishedAt=getattr(task, "finishedAt", None),
+                error=getattr(task, "error", None),
+            )
+            for task_id, task in chain(
+                self._state.current_tasks_by_id.items(),
+                self._state.finished_tasks_by_id.items(),
+            )
+        ]
+
+    def all_tasks_finished_or_any_task_failed(self, task_ids: Iterable[str]) -> bool:
+        """Implements wait semantics of asyncio.gather(return_exceptions = False).
+
+        This returns true when any of the following are true:
+        - All tasks in task_ids are complete with or without an error
+        - Any task in task_ids is complete with an error.
+
+        NOTE: Does not raise the error that the errored task has.
+        """
+        finished = set(self._state.finished_tasks_by_id.keys())
+        task_ids = set(task_ids)
+        if task_ids.issubset(finished):
+            return True
+        if self.get_failed_tasks(task_ids):
+            return True
+        return False
+
+    def get_failed_tasks(self, task_ids: Iterable[str]) -> list[str]:
+        """Return a list of failed task ids of the ones that were passed."""
+        failed_tasks: list[str] = []
+        for task_id in task_ids:
+            task = self._state.finished_tasks_by_id.get(task_id, None)
+            if task and task.error:
+                failed_tasks.append(task_id)
+        return failed_tasks