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

opentrons/protocol_engine/state/pipettes.py

@@ -1,8 +1,15 @@
 """Basic pipette data state and store."""
 from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, List, Mapping, Optional, Tuple, Union
-from typing_extensions import assert_type
+
+import dataclasses
+from typing import (
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Union,
+)
 
 from opentrons_shared_data.pipette import pipette_definition
 from opentrons.config.defaults_ot2 import Z_RETRACT_DISTANCE
@@ -12,15 +19,9 @@ from opentrons.hardware_control.nozzle_manager import (
     NozzleConfigurationType,
     NozzleMap,
 )
-from opentrons.protocol_engine.actions.actions import FailCommandAction
-from opentrons.protocol_engine.commands.command import DefinedErrorData
-from opentrons.protocol_engine.commands.pipetting_common import (
-    LiquidNotFoundError,
-    OverpressureError,
-    OverpressureErrorInternalData,
-)
 from opentrons.types import MountType, Mount as HwMount, Point
 
+from . import update_types
 from .. import commands
 from .. import errors
 from ..types import (
@@ -33,19 +34,17 @@ from ..types import (
     CurrentPipetteLocation,
     TipGeometry,
 )
-from ..commands.configuring_common import (
-    PipetteConfigUpdateResultMixin,
-    PipetteNozzleLayoutResultMixin,
-)
 from ..actions import (
     Action,
+    FailCommandAction,
     SetPipetteMovementSpeedAction,
     SucceedCommandAction,
+    get_state_updates,
 )
-from .abstract_store import HasState, HandlesActions
+from ._abstract_store import HasState, HandlesActions
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class HardwarePipette:
     """Hardware pipette data."""
 
@@ -53,7 +52,7 @@ class HardwarePipette:
     config: PipetteDict
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class CurrentDeckPoint:
     """The latest deck point and mount the robot has accessed."""
 
@@ -61,7 +60,7 @@ class CurrentDeckPoint:
     deck_point: Optional[DeckPoint]
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class BoundingNozzlesOffsets:
     """Offsets of the bounding nozzles of the pipette."""
 
@@ -69,7 +68,7 @@ class BoundingNozzlesOffsets:
     front_right_offset: Point
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class PipetteBoundingBoxOffsets:
     """Offsets of the corners of the pipette's bounding box."""
 
@@ -79,7 +78,7 @@ class PipetteBoundingBoxOffsets:
     front_left_corner: Point
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class StaticPipetteConfig:
     """Static config for a pipette."""
 
@@ -97,14 +96,17 @@ class StaticPipetteConfig:
     nozzle_offset_z: float
     pipette_bounding_box_offsets: PipetteBoundingBoxOffsets
     bounding_nozzle_offsets: BoundingNozzlesOffsets
-    default_nozzle_map: NozzleMap
+    default_nozzle_map: NozzleMap  # todo(mm, 2024-10-14): unused, remove?
     lld_settings: Optional[Dict[str, Dict[str, float]]]
 
 
-@dataclass
+@dataclasses.dataclass
 class PipetteState:
     """Basic pipette data state and getter methods."""
 
+    # todo(mm, 2024-10-14): It's getting difficult to ensure that all of these
+    # attributes are populated at the appropriate times. Refactor to a
+    # single dict-of-many-things instead of many dicts-of-single-things.
     pipettes_by_id: Dict[str, LoadedPipette]
     aspirated_volume_by_id: Dict[str, Optional[float]]
     current_location: Optional[CurrentPipetteLocation]
@@ -113,7 +115,7 @@ class PipetteState:
     movement_speed_by_id: Dict[str, Optional[float]]
     static_config_by_id: Dict[str, StaticPipetteConfig]
     flow_rates_by_id: Dict[str, FlowRates]
-    nozzle_configuration_by_id: Dict[str, Optional[NozzleMap]]
+    nozzle_configuration_by_id: Dict[str, NozzleMap]
     liquid_presence_detection_by_id: Dict[str, bool]
 
 
@@ -139,29 +141,128 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
 
     def handle_action(self, action: Action) -> None:
         """Modify state in reaction to an action."""
+        for state_update in get_state_updates(action):
+            self._set_load_pipette(state_update)
+            self._update_current_location(state_update)
+            self._update_pipette_config(state_update)
+            self._update_pipette_nozzle_map(state_update)
+            self._update_tip_state(state_update)
+
         if isinstance(action, (SucceedCommandAction, FailCommandAction)):
-            self._handle_command(action)
+            self._update_volumes(action)
+
         elif isinstance(action, SetPipetteMovementSpeedAction):
             self._state.movement_speed_by_id[action.pipette_id] = action.speed
 
-    def _handle_command(  # noqa: C901
-        self, action: Union[SucceedCommandAction, FailCommandAction]
-    ) -> None:
-        self._update_current_location(action)
-        self._update_deck_point(action)
-        self._update_volumes(action)
+    def _set_load_pipette(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.loaded_pipette != update_types.NO_CHANGE:
+            pipette_id = state_update.loaded_pipette.pipette_id
 
-        if not isinstance(action, SucceedCommandAction):
-            return
+            self._state.pipettes_by_id[pipette_id] = LoadedPipette(
+                id=pipette_id,
+                pipetteName=state_update.loaded_pipette.pipette_name,
+                mount=state_update.loaded_pipette.mount,
+            )
+            self._state.liquid_presence_detection_by_id[pipette_id] = (
+                state_update.loaded_pipette.liquid_presence_detection or False
+            )
+            self._state.aspirated_volume_by_id[pipette_id] = None
+            self._state.movement_speed_by_id[pipette_id] = None
+            self._state.attached_tip_by_id[pipette_id] = None
 
-        command, private_result = action.command, action.private_result
+    def _update_tip_state(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.pipette_tip_state != update_types.NO_CHANGE:
+            pipette_id = state_update.pipette_tip_state.pipette_id
+            if state_update.pipette_tip_state.tip_geometry:
+                attached_tip = state_update.pipette_tip_state.tip_geometry
+
+                self._state.attached_tip_by_id[pipette_id] = attached_tip
+                self._state.aspirated_volume_by_id[pipette_id] = 0
+
+                static_config = self._state.static_config_by_id.get(pipette_id)
+                if static_config:
+                    try:
+                        tip_configuration = (
+                            static_config.tip_configuration_lookup_table[
+                                attached_tip.volume
+                            ]
+                        )
+                    except KeyError:
+                        # TODO(seth,9/11/2023): this is a bad way of doing defaults but better than max volume.
+                        # we used to look up a default tip config via the pipette max volume, but if that isn't
+                        # tip volume (as it isn't when we're in low-volume mode) then that lookup fails. Using
+                        # the first entry in the table is ok I guess but we really need to generally rethink how
+                        # we identify tip classes - looking things up by volume is not enough.
+                        tip_configuration = list(
+                            static_config.tip_configuration_lookup_table.values()
+                        )[0]
+                    self._state.flow_rates_by_id[pipette_id] = FlowRates(
+                        default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
+                        default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
+                        default_dispense=tip_configuration.default_dispense_flowrate.values_by_api_level,
+                    )
 
-        if isinstance(private_result, PipetteConfigUpdateResultMixin):
-            config = private_result.config
+            else:
+                pipette_id = state_update.pipette_tip_state.pipette_id
+                self._state.aspirated_volume_by_id[pipette_id] = None
+                self._state.attached_tip_by_id[pipette_id] = None
+
+                static_config = self._state.static_config_by_id.get(pipette_id)
+                if static_config:
+                    # TODO(seth,9/11/2023): bad way to do defaulting, see above.
+                    tip_configuration = list(
+                        static_config.tip_configuration_lookup_table.values()
+                    )[0]
+                    self._state.flow_rates_by_id[pipette_id] = FlowRates(
+                        default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
+                        default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
+                        default_dispense=tip_configuration.default_dispense_flowrate.values_by_api_level,
+                    )
+
+    def _update_current_location(self, state_update: update_types.StateUpdate) -> None:
+        location_update = state_update.pipette_location
+
+        if location_update is update_types.NO_CHANGE:
+            pass
+        elif location_update is update_types.CLEAR:
+            self._state.current_location = None
+            self._state.current_deck_point = CurrentDeckPoint(
+                mount=None, deck_point=None
+            )
+        else:
+            new_logical_location = location_update.new_location
+            new_deck_point = location_update.new_deck_point
+            match new_logical_location:
+                case update_types.Well(labware_id=labware_id, well_name=well_name):
+                    self._state.current_location = CurrentWell(
+                        pipette_id=location_update.pipette_id,
+                        labware_id=labware_id,
+                        well_name=well_name,
+                    )
+                case update_types.AddressableArea(
+                    addressable_area_name=addressable_area_name
+                ):
+                    self._state.current_location = CurrentAddressableArea(
+                        pipette_id=location_update.pipette_id,
+                        addressable_area_name=addressable_area_name,
+                    )
+                case None:
+                    self._state.current_location = None
+                case update_types.NO_CHANGE:
+                    pass
+            if new_deck_point is not update_types.NO_CHANGE:
+                loaded_pipette = self._state.pipettes_by_id[location_update.pipette_id]
+                self._state.current_deck_point = CurrentDeckPoint(
+                    mount=loaded_pipette.mount, deck_point=new_deck_point
+                )
+
+    def _update_pipette_config(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.pipette_config != update_types.NO_CHANGE:
+            config = state_update.pipette_config.config
             self._state.static_config_by_id[
-                private_result.pipette_id
+                state_update.pipette_config.pipette_id
             ] = StaticPipetteConfig(
-                serial_number=private_result.serial_number,
+                serial_number=state_update.pipette_config.serial_number,
                 model=config.model,
                 display_name=config.display_name,
                 min_volume=config.min_volume,
@@ -192,276 +293,27 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 default_nozzle_map=config.nozzle_map,
                 lld_settings=config.pipette_lld_settings,
             )
-            self._state.flow_rates_by_id[private_result.pipette_id] = config.flow_rates
+            self._state.flow_rates_by_id[
+                state_update.pipette_config.pipette_id
+            ] = config.flow_rates
             self._state.nozzle_configuration_by_id[
-                private_result.pipette_id
+                state_update.pipette_config.pipette_id
             ] = config.nozzle_map
-        elif isinstance(private_result, PipetteNozzleLayoutResultMixin):
-            self._state.nozzle_configuration_by_id[
-                private_result.pipette_id
-            ] = private_result.nozzle_map
 
-        if isinstance(command.result, commands.LoadPipetteResult):
-            pipette_id = command.result.pipetteId
-
-            self._state.pipettes_by_id[pipette_id] = LoadedPipette(
-                id=pipette_id,
-                pipetteName=command.params.pipetteName,
-                mount=command.params.mount,
-            )
-            self._state.liquid_presence_detection_by_id[pipette_id] = (
-                command.params.liquidPresenceDetection or False
-            )
-            self._state.aspirated_volume_by_id[pipette_id] = None
-            self._state.movement_speed_by_id[pipette_id] = None
-            self._state.attached_tip_by_id[pipette_id] = None
-            static_config = self._state.static_config_by_id.get(pipette_id)
-            if static_config:
-                self._state.nozzle_configuration_by_id[
-                    pipette_id
-                ] = static_config.default_nozzle_map
-
-        elif isinstance(command.result, commands.PickUpTipResult):
-            pipette_id = command.params.pipetteId
-            attached_tip = TipGeometry(
-                length=command.result.tipLength,
-                volume=command.result.tipVolume,
-                diameter=command.result.tipDiameter,
-            )
-
-            self._state.attached_tip_by_id[pipette_id] = attached_tip
-            self._state.aspirated_volume_by_id[pipette_id] = 0
-
-            static_config = self._state.static_config_by_id.get(pipette_id)
-            if static_config:
-                try:
-                    tip_configuration = static_config.tip_configuration_lookup_table[
-                        attached_tip.volume
-                    ]
-                except KeyError:
-                    # TODO(seth,9/11/2023): this is a bad way of doing defaults but better than max volume.
-                    # we used to look up a default tip config via the pipette max volume, but if that isn't
-                    # tip volume (as it isn't when we're in low-volume mode) then that lookup fails. Using
-                    # the first entry in the table is ok I guess but we really need to generally rethink how
-                    # we identify tip classes - looking things up by volume is not enough.
-                    tip_configuration = list(
-                        static_config.tip_configuration_lookup_table.values()
-                    )[0]
-                self._state.flow_rates_by_id[pipette_id] = FlowRates(
-                    default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
-                    default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
-                    default_dispense=tip_configuration.default_dispense_flowrate.values_by_api_level,
-                )
-
-        elif isinstance(
-            command.result,
-            (
-                commands.DropTipResult,
-                commands.DropTipInPlaceResult,
-                commands.unsafe.UnsafeDropTipInPlaceResult,
-            ),
-        ):
-            pipette_id = command.params.pipetteId
-            self._state.aspirated_volume_by_id[pipette_id] = None
-            self._state.attached_tip_by_id[pipette_id] = None
-
-            static_config = self._state.static_config_by_id.get(pipette_id)
-            if static_config:
-                # TODO(seth,9/11/2023): bad way to do defaulting, see above.
-                tip_configuration = list(
-                    static_config.tip_configuration_lookup_table.values()
-                )[0]
-                self._state.flow_rates_by_id[pipette_id] = FlowRates(
-                    default_blow_out=tip_configuration.default_blowout_flowrate.values_by_api_level,
-                    default_aspirate=tip_configuration.default_aspirate_flowrate.values_by_api_level,
-                    default_dispense=tip_configuration.default_dispense_flowrate.values_by_api_level,
-                )
-
-    def _update_current_location(  # noqa: C901
-        self, action: Union[SucceedCommandAction, FailCommandAction]
+    def _update_pipette_nozzle_map(
+        self, state_update: update_types.StateUpdate
     ) -> None:
-        # These commands leave the pipette in a new location.
-        # Update current_location to reflect that.
-        if isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.MoveToWellResult,
-                commands.PickUpTipResult,
-                commands.DropTipResult,
-                commands.AspirateResult,
-                commands.DispenseResult,
-                commands.BlowOutResult,
-                commands.TouchTipResult,
-                commands.LiquidProbeResult,
-                commands.TryLiquidProbeResult,
-            ),
-        ):
-            self._state.current_location = CurrentWell(
-                pipette_id=action.command.params.pipetteId,
-                labware_id=action.command.params.labwareId,
-                well_name=action.command.params.wellName,
-            )
-        elif isinstance(action, FailCommandAction) and (
-            isinstance(action.error, DefinedErrorData)
-            and (
-                (
-                    isinstance(
-                        action.running_command, (commands.Aspirate, commands.Dispense)
-                    )
-                    and isinstance(action.error.public, OverpressureError)
-                )
-                or (
-                    isinstance(action.running_command, commands.LiquidProbe)
-                    and isinstance(action.error.public, LiquidNotFoundError)
-                )
-            )
-        ):
-            self._state.current_location = CurrentWell(
-                pipette_id=action.running_command.params.pipetteId,
-                labware_id=action.running_command.params.labwareId,
-                well_name=action.running_command.params.wellName,
-            )
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.MoveToAddressableAreaResult,
-                commands.MoveToAddressableAreaForDropTipResult,
-            ),
-        ):
-            self._state.current_location = CurrentAddressableArea(
-                pipette_id=action.command.params.pipetteId,
-                addressable_area_name=action.command.params.addressableAreaName,
-            )
-
-        # These commands leave the pipette in a place that we can't logically associate
-        # with a well. Clear current_location to reflect the fact that it's now unknown.
-        #
-        # TODO(mc, 2021-11-12): Wipe out current_location on movement failures, too.
-        # TODO(jbl 2023-02-14): Need to investigate whether move relative should clear current location
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.HomeResult,
-                commands.RetractAxisResult,
-                commands.MoveToCoordinatesResult,
-                commands.thermocycler.OpenLidResult,
-                commands.thermocycler.CloseLidResult,
-            ),
-        ):
-            self._state.current_location = None
-
-        # Heater-Shaker commands may have left the pipette in a place that we can't
-        # associate with a logical location, depending on their result.
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.heater_shaker.SetAndWaitForShakeSpeedResult,
-                commands.heater_shaker.OpenLabwareLatchResult,
-            ),
-        ):
-            if action.command.result.pipetteRetracted:
-                self._state.current_location = None
-
-        # A moveLabware command may have moved the labware that contains the current
-        # well out from under the pipette. Clear the current location to reflect the
-        # fact that the pipette is no longer over any labware.
-        #
-        # This is necessary for safe motion planning in case the next movement
-        # goes to the same labware (now in a new place).
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result, commands.MoveLabwareResult
-        ):
-            moved_labware_id = action.command.params.labwareId
-            if action.command.params.strategy == "usingGripper":
-                # All mounts will have been retracted.
-                self._state.current_location = None
-            elif (
-                isinstance(self._state.current_location, CurrentWell)
-                and self._state.current_location.labware_id == moved_labware_id
-            ):
-                self._state.current_location = None
-
-    def _update_deck_point(
-        self, action: Union[SucceedCommandAction, FailCommandAction]
-    ) -> None:
-        # This function mostly mirrors self._update_current_location().
-        # See there for explanations.
-
-        if isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.MoveToWellResult,
-                commands.MoveToCoordinatesResult,
-                commands.MoveRelativeResult,
-                commands.MoveToAddressableAreaResult,
-                commands.MoveToAddressableAreaForDropTipResult,
-                commands.PickUpTipResult,
-                commands.DropTipResult,
-                commands.AspirateResult,
-                commands.DispenseResult,
-                commands.BlowOutResult,
-                commands.TouchTipResult,
-            ),
-        ):
-            pipette_id = action.command.params.pipetteId
-            deck_point = action.command.result.position
-            loaded_pipette = self._state.pipettes_by_id[pipette_id]
-            self._state.current_deck_point = CurrentDeckPoint(
-                mount=loaded_pipette.mount, deck_point=deck_point
-            )
-        elif (
-            isinstance(action, FailCommandAction)
-            and isinstance(
-                action.running_command,
-                (
-                    commands.Aspirate,
-                    commands.Dispense,
-                    commands.AspirateInPlace,
-                    commands.DispenseInPlace,
-                ),
-            )
-            and isinstance(action.error, DefinedErrorData)
-            and isinstance(action.error.public, OverpressureError)
-        ):
-            assert_type(action.error.private, OverpressureErrorInternalData)
-            pipette_id = action.running_command.params.pipetteId
-            deck_point = action.error.private.position
-            loaded_pipette = self._state.pipettes_by_id[pipette_id]
-            self._state.current_deck_point = CurrentDeckPoint(
-                mount=loaded_pipette.mount, deck_point=deck_point
-            )
-
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.HomeResult,
-                commands.RetractAxisResult,
-                commands.thermocycler.OpenLidResult,
-                commands.thermocycler.CloseLidResult,
-            ),
-        ):
-            self._clear_deck_point()
-
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result,
-            (
-                commands.heater_shaker.SetAndWaitForShakeSpeedResult,
-                commands.heater_shaker.OpenLabwareLatchResult,
-            ),
-        ):
-            if action.command.result.pipetteRetracted:
-                self._clear_deck_point()
-
-        elif isinstance(action, SucceedCommandAction) and isinstance(
-            action.command.result, commands.MoveLabwareResult
-        ):
-            if action.command.params.strategy == "usingGripper":
-                # All mounts will have been retracted.
-                self._clear_deck_point()
+        if state_update.pipette_nozzle_map != update_types.NO_CHANGE:
+            self._state.nozzle_configuration_by_id[
+                state_update.pipette_nozzle_map.pipette_id
+            ] = state_update.pipette_nozzle_map.nozzle_map
 
     def _update_volumes(
         self, action: Union[SucceedCommandAction, FailCommandAction]
     ) -> None:
+        # todo(mm, 2024-10-10): Port these isinstance checks to StateUpdate.
+        # https://opentrons.atlassian.net/browse/EXEC-754
+
         if isinstance(action, SucceedCommandAction) and isinstance(
             action.command.result,
             (commands.AspirateResult, commands.AspirateInPlaceResult),
@@ -502,10 +354,6 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             pipette_id = action.command.params.pipetteId
             self._state.aspirated_volume_by_id[pipette_id] = 0
 
-    def _clear_deck_point(self) -> None:
-        """Reset last deck point to default None value for mount and point."""
-        self._state.current_deck_point = CurrentDeckPoint(mount=None, deck_point=None)
-
 
 class PipetteView(HasState[PipetteState]):
     """Read-only view of computed pipettes state."""
@@ -781,31 +629,23 @@ class PipetteView(HasState[PipetteState]):
 
     def get_nozzle_layout_type(self, pipette_id: str) -> NozzleConfigurationType:
         """Get the current set nozzle layout configuration."""
-        nozzle_map_for_pipette = self._state.nozzle_configuration_by_id.get(pipette_id)
-        if nozzle_map_for_pipette:
-            return nozzle_map_for_pipette.configuration
-        else:
-            return NozzleConfigurationType.FULL
+        nozzle_map_for_pipette = self._state.nozzle_configuration_by_id[pipette_id]
+        return nozzle_map_for_pipette.configuration
 
     def get_is_partially_configured(self, pipette_id: str) -> bool:
         """Determine if the provided pipette is partially configured."""
         return self.get_nozzle_layout_type(pipette_id) != NozzleConfigurationType.FULL
 
-    def get_primary_nozzle(self, pipette_id: str) -> Optional[str]:
+    def get_primary_nozzle(self, pipette_id: str) -> str:
         """Get the primary nozzle, if any, related to the given pipette's nozzle configuration."""
-        nozzle_map = self._state.nozzle_configuration_by_id.get(pipette_id)
-        return nozzle_map.starting_nozzle if nozzle_map else None
+        nozzle_map = self._state.nozzle_configuration_by_id[pipette_id]
+        return nozzle_map.starting_nozzle
 
     def _get_critical_point_offset_without_tip(
         self, pipette_id: str, critical_point: Optional[CriticalPoint]
     ) -> Point:
         """Get the offset of the specified critical point from pipette's mount position."""
-        nozzle_map = self._state.nozzle_configuration_by_id.get(pipette_id)
-        # Nozzle map is unavailable only when there's no pipette loaded
-        # so this is merely for satisfying the type checker
-        assert (
-            nozzle_map is not None
-        ), "Error getting critical point offset. Nozzle map not found."
+        nozzle_map = self._state.nozzle_configuration_by_id[pipette_id]
         match critical_point:
             case CriticalPoint.INSTRUMENT_XY_CENTER:
                 return nozzle_map.instrument_xy_center_offset