opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/state.py

@@ -14,7 +14,7 @@ from opentrons.util.change_notifier import ChangeNotifier
 
 from ..resources import DeckFixedLabware
 from ..actions import Action, ActionHandler
-from .abstract_store import HasState, HandlesActions
+from ._abstract_store import HasState, HandlesActions
 from .commands import CommandState, CommandStore, CommandView
 from .addressable_areas import (
     AddressableAreaState,
@@ -26,8 +26,10 @@ from .pipettes import PipetteState, PipetteStore, PipetteView
 from .modules import ModuleState, ModuleStore, ModuleView
 from .liquids import LiquidState, LiquidView, LiquidStore
 from .tips import TipState, TipView, TipStore
+from .wells import WellState, WellView, WellStore
 from .geometry import GeometryView
 from .motion import MotionView
+from .files import FileView, FileState, FileStore
 from .config import Config
 from .state_summary import StateSummary
 from ..types import DeckConfigurationType
@@ -48,6 +50,8 @@ class State:
     modules: ModuleState
     liquids: LiquidState
     tips: TipState
+    wells: WellState
+    files: FileState
 
 
 class StateView(HasState[State]):
@@ -61,8 +65,10 @@ class StateView(HasState[State]):
     _modules: ModuleView
     _liquid: LiquidView
     _tips: TipView
+    _wells: WellView
     _geometry: GeometryView
     _motion: MotionView
+    _files: FileView
     _config: Config
 
     @property
@@ -100,6 +106,11 @@ class StateView(HasState[State]):
         """Get state view selectors for tip state."""
         return self._tips
 
+    @property
+    def wells(self) -> WellView:
+        """Get state view selectors for well state."""
+        return self._wells
+
     @property
     def geometry(self) -> GeometryView:
         """Get state view selectors for derived geometry state."""
@@ -110,6 +121,11 @@ class StateView(HasState[State]):
         """Get state view selectors for derived motion state."""
         return self._motion
 
+    @property
+    def files(self) -> FileView:
+        """Get state view selectors for engine create file state."""
+        return self._files
+
     @property
     def config(self) -> Config:
         """Get ProtocolEngine configuration."""
@@ -129,7 +145,9 @@ class StateView(HasState[State]):
             completedAt=self._state.commands.run_completed_at,
             startedAt=self._state.commands.run_started_at,
             liquids=self._liquid.get_all(),
+            wells=self._wells.get_all(),
             hasEverEnteredErrorRecovery=self._commands.get_has_entered_recovery_mode(),
+            files=self._state.files.file_ids,
         )
 
 
@@ -191,10 +209,13 @@ class StateStore(StateView, ActionHandler):
         )
         self._module_store = ModuleStore(
             config=config,
+            deck_fixed_labware=deck_fixed_labware,
             module_calibration_offsets=module_calibration_offsets,
         )
         self._liquid_store = LiquidStore()
         self._tip_store = TipStore()
+        self._well_store = WellStore()
+        self._file_store = FileStore()
 
         self._substores: List[HandlesActions] = [
             self._command_store,
@@ -204,6 +225,8 @@ class StateStore(StateView, ActionHandler):
             self._module_store,
             self._liquid_store,
             self._tip_store,
+            self._well_store,
+            self._file_store,
         ]
         self._config = config
         self._change_notifier = change_notifier or ChangeNotifier()
@@ -320,6 +343,8 @@ class StateStore(StateView, ActionHandler):
             modules=self._module_store.state,
             liquids=self._liquid_store.state,
             tips=self._tip_store.state,
+            wells=self._well_store.state,
+            files=self._file_store.state,
         )
 
     def _initialize_state(self) -> None:
@@ -335,11 +360,14 @@ class StateStore(StateView, ActionHandler):
         self._modules = ModuleView(state.modules)
         self._liquid = LiquidView(state.liquids)
         self._tips = TipView(state.tips)
+        self._wells = WellView(state.wells)
+        self._files = FileView(state.files)
 
         # Derived states
         self._geometry = GeometryView(
             config=self._config,
             labware_view=self._labware,
+            well_view=self._wells,
             module_view=self._modules,
             pipette_view=self._pipettes,
             addressable_area_view=self._addressable_areas,
@@ -364,6 +392,7 @@ class StateStore(StateView, ActionHandler):
         self._modules._state = next_state.modules
         self._liquid._state = next_state.liquids
         self._tips._state = next_state.tips
+        self._wells._state = next_state.wells
         self._change_notifier.notify()
         if self._notify_robot_server is not None:
             self._notify_robot_server()

opentrons/protocol_engine/state/state_summary.py

@@ -11,6 +11,7 @@ from ..types import (
     LoadedModule,
     LoadedPipette,
     Liquid,
+    WellInfoSummary,
 )
 
 
@@ -29,3 +30,5 @@ class StateSummary(BaseModel):
     startedAt: Optional[datetime]
     completedAt: Optional[datetime]
     liquids: List[Liquid] = Field(default_factory=list)
+    wells: List[WellInfoSummary] = Field(default_factory=list)
+    files: List[str] = Field(default_factory=list)

opentrons/protocol_engine/state/tips.py

@@ -3,27 +3,10 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Dict, Optional, List, Union
 
-from .abstract_store import HasState, HandlesActions
-from ..actions import (
-    Action,
-    SucceedCommandAction,
-    FailCommandAction,
-    ResetTipsAction,
-)
-from ..commands import (
-    Command,
-    LoadLabwareResult,
-    PickUpTip,
-    PickUpTipResult,
-    DropTipResult,
-    DropTipInPlaceResult,
-    unsafe,
-)
-from ..commands.configuring_common import (
-    PipetteConfigUpdateResultMixin,
-    PipetteNozzleLayoutResultMixin,
-)
-from ..error_recovery_policy import ErrorRecoveryType
+from opentrons.protocol_engine.state import update_types
+
+from ._abstract_store import HasState, HandlesActions
+from ..actions import Action, ResetTipsAction, get_state_updates
 
 from opentrons.hardware_control.nozzle_manager import NozzleMap
 
@@ -38,16 +21,26 @@ class TipRackWellState(Enum):
 TipRackStateByWellName = Dict[str, TipRackWellState]
 
 
+# todo(mm, 2024-10-10): This info is duplicated between here and PipetteState because
+# TipStore is using it to compute which tips a PickUpTip removes from the tip rack,
+# given the pipette's current nozzle map. We could avoid this duplication by moving the
+# computation to TipView, calling it from PickUpTipImplementation, and passing the
+# precomputed list of wells to TipStore.
+@dataclass
+class _PipetteInfo:
+    channels: int
+    active_channels: int
+    nozzle_map: NozzleMap
+
+
 @dataclass
 class TipState:
     """State of all tips."""
 
     tips_by_labware_id: Dict[str, TipRackStateByWellName]
     column_by_labware_id: Dict[str, List[List[str]]]
-    channels_by_pipette_id: Dict[str, int]
-    length_by_pipette_id: Dict[str, float]
-    active_channels_by_pipette_id: Dict[str, int]
-    nozzle_map_by_pipette_id: Dict[str, NozzleMap]
+
+    pipette_info_by_pipette_id: Dict[str, _PipetteInfo]
 
 
 class TipStore(HasState[TipState], HandlesActions):
@@ -60,40 +53,15 @@ class TipStore(HasState[TipState], HandlesActions):
         self._state = TipState(
             tips_by_labware_id={},
             column_by_labware_id={},
-            channels_by_pipette_id={},
-            length_by_pipette_id={},
-            active_channels_by_pipette_id={},
-            nozzle_map_by_pipette_id={},
+            pipette_info_by_pipette_id={},
         )
 
     def handle_action(self, action: Action) -> None:
         """Modify state in reaction to an action."""
-        if isinstance(action, SucceedCommandAction):
-            if isinstance(action.private_result, PipetteConfigUpdateResultMixin):
-                pipette_id = action.private_result.pipette_id
-                config = action.private_result.config
-                self._state.channels_by_pipette_id[pipette_id] = config.channels
-                self._state.active_channels_by_pipette_id[pipette_id] = config.channels
-                self._state.nozzle_map_by_pipette_id[pipette_id] = config.nozzle_map
-            self._handle_succeeded_command(action.command)
-
-            if isinstance(action.private_result, PipetteNozzleLayoutResultMixin):
-                pipette_id = action.private_result.pipette_id
-                nozzle_map = action.private_result.nozzle_map
-                if nozzle_map:
-                    self._state.active_channels_by_pipette_id[
-                        pipette_id
-                    ] = nozzle_map.tip_count
-                    self._state.nozzle_map_by_pipette_id[pipette_id] = nozzle_map
-                else:
-                    self._state.active_channels_by_pipette_id[
-                        pipette_id
-                    ] = self._state.channels_by_pipette_id[pipette_id]
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
 
-        elif isinstance(action, FailCommandAction):
-            self._handle_failed_command(action)
-
-        elif isinstance(action, ResetTipsAction):
+        if isinstance(action, ResetTipsAction):
             labware_id = action.labware_id
 
             for well_name in self._state.tips_by_labware_id[labware_id].keys():
@@ -101,67 +69,51 @@ class TipStore(HasState[TipState], HandlesActions):
                     well_name
                 ] = TipRackWellState.CLEAN
 
-    def _handle_succeeded_command(self, command: Command) -> None:
-        if (
-            isinstance(command.result, LoadLabwareResult)
-            and command.result.definition.parameters.isTiprack
-        ):
-            labware_id = command.result.labwareId
-            definition = command.result.definition
-            self._state.tips_by_labware_id[labware_id] = {
-                well_name: TipRackWellState.CLEAN
-                for column in definition.ordering
-                for well_name in column
-            }
-            self._state.column_by_labware_id[labware_id] = [
-                column for column in definition.ordering
-            ]
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.pipette_config != update_types.NO_CHANGE:
+            self._state.pipette_info_by_pipette_id[
+                state_update.pipette_config.pipette_id
+            ] = _PipetteInfo(
+                channels=state_update.pipette_config.config.channels,
+                active_channels=state_update.pipette_config.config.channels,
+                nozzle_map=state_update.pipette_config.config.nozzle_map,
+            )
 
-        elif isinstance(command.result, PickUpTipResult):
-            labware_id = command.params.labwareId
-            well_name = command.params.wellName
-            pipette_id = command.params.pipetteId
-            length = command.result.tipLength
+        if state_update.tips_used != update_types.NO_CHANGE:
             self._set_used_tips(
-                pipette_id=pipette_id, well_name=well_name, labware_id=labware_id
+                pipette_id=state_update.tips_used.pipette_id,
+                labware_id=state_update.tips_used.labware_id,
+                well_name=state_update.tips_used.well_name,
             )
-            self._state.length_by_pipette_id[pipette_id] = length
-
-        elif isinstance(
-            command.result,
-            (DropTipResult, DropTipInPlaceResult, unsafe.UnsafeDropTipInPlaceResult),
-        ):
-            pipette_id = command.params.pipetteId
-            self._state.length_by_pipette_id.pop(pipette_id, None)
 
-    def _handle_failed_command(
-        self,
-        action: FailCommandAction,
-    ) -> None:
-        # If a pickUpTip command fails recoverably, mark the tips as used. This way,
-        # when the protocol is resumed and the Python Protocol API calls
-        # `get_next_tip()`, we'll move on to other tips as expected.
-        #
-        # We don't attempt this for nonrecoverable errors because maybe the failure
-        # was due to a bad labware ID or well name.
-        if (
-            isinstance(action.running_command, PickUpTip)
-            and action.type != ErrorRecoveryType.FAIL_RUN
-        ):
-            self._set_used_tips(
-                pipette_id=action.running_command.params.pipetteId,
-                labware_id=action.running_command.params.labwareId,
-                well_name=action.running_command.params.wellName,
+        if state_update.pipette_nozzle_map != update_types.NO_CHANGE:
+            pipette_info = self._state.pipette_info_by_pipette_id[
+                state_update.pipette_nozzle_map.pipette_id
+            ]
+            pipette_info.active_channels = (
+                state_update.pipette_nozzle_map.nozzle_map.tip_count
             )
-            # Note: We're logically removing the tip from the tip rack,
-            # but we're not logically updating the pipette to have that tip on it.
+            pipette_info.nozzle_map = state_update.pipette_nozzle_map.nozzle_map
+
+        if state_update.loaded_labware != update_types.NO_CHANGE:
+            labware_id = state_update.loaded_labware.labware_id
+            definition = state_update.loaded_labware.definition
+            if definition.parameters.isTiprack:
+                self._state.tips_by_labware_id[labware_id] = {
+                    well_name: TipRackWellState.CLEAN
+                    for column in definition.ordering
+                    for well_name in column
+                }
+                self._state.column_by_labware_id[labware_id] = [
+                    column for column in definition.ordering
+                ]
 
     def _set_used_tips(  # noqa: C901
         self, pipette_id: str, well_name: str, labware_id: str
     ) -> None:
         columns = self._state.column_by_labware_id.get(labware_id, [])
         wells = self._state.tips_by_labware_id.get(labware_id, {})
-        nozzle_map = self._state.nozzle_map_by_pipette_id[pipette_id]
+        nozzle_map = self._state.pipette_info_by_pipette_id[pipette_id].nozzle_map
 
         # TODO (cb, 02-28-2024): Transition from using partial nozzle map to full instrument map for the set used logic
         num_nozzle_cols = len(nozzle_map.columns)
@@ -229,7 +181,7 @@ class TipView(HasState[TipState]):
             critical_row: int,
             entry_well: str,
         ) -> Optional[List[str]]:
-            tip_cluster = []
+            tip_cluster: list[str] = []
             for i in range(active_columns):
                 if entry_well == "A1" or entry_well == "H1":
                     if critical_column - i >= 0:
@@ -280,12 +232,12 @@ class TipView(HasState[TipState]):
 
                 # In the case of a 96ch we can attempt to index in by singular rows and columns assuming that indexed direction is safe
                 # The tip cluster list is ordered: Each row from a column in order by columns
-                tip_cluster_final_column = []
+                tip_cluster_final_column: list[str] = []
                 for i in range(active_rows):
                     tip_cluster_final_column.append(
                         tip_cluster[((active_columns * active_rows) - 1) - i]
                     )
-                tip_cluster_final_row = []
+                tip_cluster_final_row: list[str] = []
                 for i in range(active_columns):
                     tip_cluster_final_row.append(
                         tip_cluster[(active_rows - 1) + (i * active_rows)]
@@ -476,15 +428,22 @@ class TipView(HasState[TipState]):
 
     def get_pipette_channels(self, pipette_id: str) -> int:
         """Return the given pipette's number of channels."""
-        return self._state.channels_by_pipette_id[pipette_id]
+        return self._state.pipette_info_by_pipette_id[pipette_id].channels
 
     def get_pipette_active_channels(self, pipette_id: str) -> int:
         """Get the number of channels being used in the given pipette's configuration."""
-        return self._state.active_channels_by_pipette_id[pipette_id]
+        return self._state.pipette_info_by_pipette_id[pipette_id].active_channels
 
     def get_pipette_nozzle_map(self, pipette_id: str) -> NozzleMap:
         """Get the current nozzle map the given pipette's configuration."""
-        return self._state.nozzle_map_by_pipette_id[pipette_id]
+        return self._state.pipette_info_by_pipette_id[pipette_id].nozzle_map
+
+    def get_pipette_nozzle_maps(self) -> Dict[str, NozzleMap]:
+        """Get current nozzle maps keyed by pipette id."""
+        return {
+            pipette_id: pipette_info.nozzle_map
+            for pipette_id, pipette_info in self._state.pipette_info_by_pipette_id.items()
+        }
 
     def has_clean_tip(self, labware_id: str, well_name: str) -> bool:
         """Get whether a well in a labware has a clean tip.
@@ -502,10 +461,6 @@ class TipView(HasState[TipState]):
 
         return well_state == TipRackWellState.CLEAN
 
-    def get_tip_length(self, pipette_id: str) -> float:
-        """Return the given pipette's tip length."""
-        return self._state.length_by_pipette_id.get(pipette_id, 0)
-
 
 def _drop_wells_before_starting_tip(
     wells: TipRackStateByWellName, starting_tip_name: str