opentrons 8.7.0a6__py3-none-any.whl → 8.7.0a7__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,
 )
@@ -1336,13 +1335,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 +1511,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,7 @@
 """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 +29,8 @@ from .geometry import GeometryView
 from .modules import ModuleView
 from .module_substates import HeaterShakerModuleId
 
+log = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class PipetteLocationData:
@@ -85,6 +88,42 @@ class MotionView:
                 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_movement_waypoints_to_well(
         self,
         pipette_id: str,
@@ -98,6 +137,7 @@ 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()
@@ -115,6 +155,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

opentrons/protocol_engine/state/state.py

@@ -34,6 +34,7 @@ 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
 
 
 _ParamsT = ParamSpec("_ParamsT")
@@ -54,6 +55,7 @@ class State:
     tips: TipState
     wells: WellState
     files: FileState
+    tasks: TaskState
 
 
 class StateView(HasState[State]):
@@ -73,6 +75,7 @@ class StateView(HasState[State]):
     _motion: MotionView
     _files: FileView
     _config: Config
+    _tasks: TaskView
 
     @property
     def commands(self) -> CommandView:
@@ -139,6 +142,11 @@ class StateView(HasState[State]):
         """Get ProtocolEngine configuration."""
         return self._config
 
+    @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 +170,7 @@ class StateView(HasState[State]):
                 )
                 for liquid_class_id, liquid_class_record in self._liquid_classes.get_all().items()
             ],
+            tasks=self._tasks.get_summary(),
         )
 
 
@@ -231,6 +240,7 @@ class StateStore(StateView, ActionHandler):
         self._tip_store = TipStore()
         self._well_store = WellStore()
         self._file_store = FileStore()
+        self._task_store = TaskStore()
 
         self._substores: List[HandlesActions] = [
             self._command_store,
@@ -243,6 +253,7 @@ class StateStore(StateView, ActionHandler):
             self._tip_store,
             self._well_store,
             self._file_store,
+            self._task_store,
         ]
         self._config = config
         self._change_notifier = change_notifier or ChangeNotifier()
@@ -366,6 +377,7 @@ class StateStore(StateView, ActionHandler):
             tips=self._tip_store.state,
             wells=self._well_store.state,
             files=self._file_store.state,
+            tasks=self._task_store.state,
         )
 
     def _initialize_state(self) -> None:
@@ -384,6 +396,7 @@ class StateStore(StateView, ActionHandler):
         self._tips = TipView(state.tips)
         self._wells = WellView(state.wells)
         self._files = FileView(state.files)
+        self._tasks = TaskView(state.tasks)
 
         # Derived states
         self._geometry = GeometryView(
@@ -416,6 +429,7 @@ 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._change_notifier.notify()
         if self._notify_robot_server is not None:
             self._notify_robot_server()

opentrons/protocol_engine/state/state_summary.py

@@ -13,6 +13,7 @@ from ..types import (
     Liquid,
     LiquidClassRecordWithId,
     WellInfoSummary,
+    TaskSummary,
 )
 
 
@@ -34,3 +35,4 @@ 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)

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