opentrons 8.2.0a3__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/addressable_areas.py

@@ -1,7 +1,7 @@
 """Basic addressable area data state and store."""
 from dataclasses import dataclass
 from functools import cached_property
-from typing import Dict, List, Optional, Set, Union
+from typing import Dict, List, Optional, Set
 
 from opentrons_shared_data.robot.types import RobotType, RobotDefinition
 from opentrons_shared_data.deck.types import (
@@ -12,14 +12,6 @@ from opentrons_shared_data.deck.types import (
 
 from opentrons.types import Point, DeckSlotName
 
-from ..commands import (
-    Command,
-    LoadLabwareResult,
-    LoadModuleResult,
-    MoveLabwareResult,
-    MoveToAddressableAreaResult,
-    MoveToAddressableAreaForDropTipResult,
-)
 from ..errors import (
     IncompatibleAddressableAreaError,
     AreaNotInDeckConfigurationError,
@@ -29,19 +21,18 @@ from ..errors import (
 )
 from ..resources import deck_configuration_provider
 from ..types import (
-    DeckSlotLocation,
-    AddressableAreaLocation,
     AddressableArea,
     PotentialCutoutFixture,
     DeckConfigurationType,
     Dimensions,
 )
+from ..actions.get_state_update import get_state_updates
 from ..actions import (
     Action,
-    SucceedCommandAction,
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
 )
+from . import update_types
 from .config import Config
 from ._abstract_store import HasState, HandlesActions
 
@@ -193,10 +184,14 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
 
     def handle_action(self, action: Action) -> None:
         """Modify state in reaction to an action."""
-        if isinstance(action, SucceedCommandAction):
-            self._handle_command(action.command)
-        elif isinstance(action, AddAddressableAreaAction):
-            self._check_location_is_addressable_area(action.addressable_area)
+        for state_update in get_state_updates(action):
+            if state_update.addressable_area_used != update_types.NO_CHANGE:
+                self._add_addressable_area(
+                    state_update.addressable_area_used.addressable_area_name
+                )
+
+        if isinstance(action, AddAddressableAreaAction):
+            self._add_addressable_area(action.addressable_area_name)
         elif isinstance(action, SetDeckConfigurationAction):
             current_state = self._state
             if (
@@ -211,28 +206,6 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
                     )
                 )
 
-    def _handle_command(self, command: Command) -> None:
-        """Modify state in reaction to a command."""
-        if isinstance(command.result, LoadLabwareResult):
-            location = command.params.location
-            if isinstance(location, (DeckSlotLocation, AddressableAreaLocation)):
-                self._check_location_is_addressable_area(location)
-
-        elif isinstance(command.result, MoveLabwareResult):
-            location = command.params.newLocation
-            if isinstance(location, (DeckSlotLocation, AddressableAreaLocation)):
-                self._check_location_is_addressable_area(location)
-
-        elif isinstance(command.result, LoadModuleResult):
-            self._check_location_is_addressable_area(command.params.location)
-
-        elif isinstance(
-            command.result,
-            (MoveToAddressableAreaResult, MoveToAddressableAreaForDropTipResult),
-        ):
-            addressable_area_name = command.params.addressableAreaName
-            self._check_location_is_addressable_area(addressable_area_name)
-
     @staticmethod
     def _get_addressable_areas_from_deck_configuration(
         deck_config: DeckConfigurationType, deck_definition: DeckDefinitionV5
@@ -260,16 +233,7 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
                 )
         return {area.area_name: area for area in addressable_areas}
 
-    def _check_location_is_addressable_area(
-        self, location: Union[DeckSlotLocation, AddressableAreaLocation, str]
-    ) -> None:
-        if isinstance(location, DeckSlotLocation):
-            addressable_area_name = location.slotName.id
-        elif isinstance(location, AddressableAreaLocation):
-            addressable_area_name = location.addressableAreaName
-        else:
-            addressable_area_name = location
-
+    def _add_addressable_area(self, addressable_area_name: str) -> None:
         if addressable_area_name not in self._state.loaded_addressable_areas_by_name:
             cutout_id = self._validate_addressable_area_for_simulation(
                 addressable_area_name
@@ -323,7 +287,7 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
         return cutout_id
 
 
-class AddressableAreaView(HasState[AddressableAreaState]):
+class AddressableAreaView:
     """Read-only addressable area state view."""
 
     _state: AddressableAreaState
@@ -345,8 +309,8 @@ class AddressableAreaView(HasState[AddressableAreaState]):
     @cached_property
     def mount_offsets(self) -> Dict[str, Point]:
         """The left and right mount offsets of the robot."""
-        left_offset = self.state.robot_definition["mountOffsets"]["left"]
-        right_offset = self.state.robot_definition["mountOffsets"]["right"]
+        left_offset = self._state.robot_definition["mountOffsets"]["left"]
+        right_offset = self._state.robot_definition["mountOffsets"]["right"]
         return {
             "left": Point(x=left_offset[0], y=left_offset[1], z=left_offset[2]),
             "right": Point(x=right_offset[0], y=right_offset[1], z=right_offset[2]),
@@ -355,10 +319,10 @@ class AddressableAreaView(HasState[AddressableAreaState]):
     @cached_property
     def padding_offsets(self) -> Dict[str, float]:
         """The padding offsets to be applied to the deck extents of the robot."""
-        rear_offset = self.state.robot_definition["paddingOffsets"]["rear"]
-        front_offset = self.state.robot_definition["paddingOffsets"]["front"]
-        left_side_offset = self.state.robot_definition["paddingOffsets"]["leftSide"]
-        right_side_offset = self.state.robot_definition["paddingOffsets"]["rightSide"]
+        rear_offset = self._state.robot_definition["paddingOffsets"]["rear"]
+        front_offset = self._state.robot_definition["paddingOffsets"]["front"]
+        left_side_offset = self._state.robot_definition["paddingOffsets"]["leftSide"]
+        right_side_offset = self._state.robot_definition["paddingOffsets"]["rightSide"]
         return {
             "rear": rear_offset,
             "front": front_offset,
@@ -420,12 +384,12 @@ class AddressableAreaView(HasState[AddressableAreaState]):
                     _get_conflicting_addressable_areas_error_string(
                         self._state.potential_cutout_fixtures_by_cutout_id[cutout_id],
                         self._state.loaded_addressable_areas_by_name,
-                        self.state.deck_definition,
+                        self._state.deck_definition,
                     )
                 )
                 area_display_name = (
                     deck_configuration_provider.get_addressable_area_display_name(
-                        area_name, self.state.deck_definition
+                        area_name, self._state.deck_definition
                     )
                 )
                 raise IncompatibleAddressableAreaError(
@@ -504,7 +468,7 @@ class AddressableAreaView(HasState[AddressableAreaState]):
         addressable_area_name: str,
     ) -> Point:
         """Get the offset form cutout fixture of an addressable area."""
-        for addressable_area in self.state.deck_definition["locations"][
+        for addressable_area in self._state.deck_definition["locations"][
             "addressableAreas"
         ]:
             if addressable_area["id"] == addressable_area_name:
@@ -568,7 +532,7 @@ class AddressableAreaView(HasState[AddressableAreaState]):
         self, slot_name: DeckSlotName
     ) -> Optional[CutoutFixture]:
         """Get the Cutout Fixture currently loaded where a specific Deck Slot would be."""
-        deck_config = self.state.deck_configuration
+        deck_config = self._state.deck_configuration
         if deck_config:
             slot_cutout_id = DECK_SLOT_TO_CUTOUT_MAP[slot_name]
             slot_cutout_fixture = None
@@ -581,7 +545,7 @@ class AddressableAreaView(HasState[AddressableAreaState]):
                 if cutout_id == slot_cutout_id:
                     slot_cutout_fixture = (
                         deck_configuration_provider.get_cutout_fixture(
-                            cutout_fixture_id, self.state.deck_definition
+                            cutout_fixture_id, self._state.deck_definition
                         )
                     )
                     return slot_cutout_fixture
@@ -605,7 +569,7 @@ class AddressableAreaView(HasState[AddressableAreaState]):
         self, slot_name: DeckSlotName
     ) -> Optional[str]:
         """Get the serial number provided by the deck configuration for a Fixture at a given location."""
-        deck_config = self.state.deck_configuration
+        deck_config = self._state.deck_configuration
         if deck_config:
             slot_cutout_id = DECK_SLOT_TO_CUTOUT_MAP[slot_name]
             # This will only ever be one under current assumptions

opentrons/protocol_engine/state/command_history.py

@@ -24,6 +24,9 @@ class CommandHistory:
     _all_command_ids: List[str]
     """All command IDs, in insertion order."""
 
+    _all_failed_command_ids: List[str]
+    """All failed command IDs, in insertion order."""
+
     _all_command_ids_but_fixit_command_ids: List[str]
     """All command IDs besides fixit command intents, in insertion order."""
 
@@ -47,6 +50,7 @@ class CommandHistory:
 
     def __init__(self) -> None:
         self._all_command_ids = []
+        self._all_failed_command_ids = []
         self._all_command_ids_but_fixit_command_ids = []
         self._queued_command_ids = OrderedSet()
         self._queued_setup_command_ids = OrderedSet()
@@ -101,6 +105,13 @@ class CommandHistory:
             for command_id in self._all_command_ids
         ]
 
+    def get_all_failed_commands(self) -> List[Command]:
+        """Get all failed commands."""
+        return [
+            self._commands_by_id[command_id].command
+            for command_id in self._all_failed_command_ids
+        ]
+
     def get_filtered_command_ids(self, include_fixit_commands: bool) -> List[str]:
         """Get all fixit command IDs."""
         if include_fixit_commands:
@@ -242,6 +253,7 @@ class CommandHistory:
         self._remove_queue_id(command.id)
         self._remove_setup_queue_id(command.id)
         self._set_most_recently_completed_command_id(command.id)
+        self._all_failed_command_ids.append(command.id)
 
     def _add(self, command_id: str, command_entry: CommandEntry) -> None:
         """Create or update a command entry."""

opentrons/protocol_engine/state/commands.py

@@ -1,4 +1,5 @@
 """Protocol engine commands sub-state."""
+
 from __future__ import annotations
 
 import enum
@@ -228,9 +229,6 @@ class CommandState:
     This value can be used to generate future hashes.
     """
 
-    failed_command_errors: List[ErrorOccurrence]
-    """List of command errors that occurred during run execution."""
-
     has_entered_error_recovery: bool
     """Whether the run has entered error recovery."""
 
@@ -269,7 +267,6 @@ class CommandStore(HasState[CommandState], HandlesActions):
             run_started_at=None,
             latest_protocol_command_hash=None,
             stopped_by_estop=False,
-            failed_command_errors=[],
             error_recovery_policy=error_recovery_policy,
             has_entered_error_recovery=False,
         )
@@ -308,7 +305,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         # TODO(mc, 2021-06-22): mypy has trouble with this automatic
         # request > command mapping, figure out how to type precisely
         # (or wait for a future mypy version that can figure it out).
-        queued_command = action.request._CommandCls.construct(
+        queued_command = action.request._CommandCls.model_construct(
             id=action.command_id,
             key=(
                 action.request.key
@@ -330,7 +327,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
     def _handle_run_command_action(self, action: RunCommandAction) -> None:
         prev_entry = self._state.command_history.get(action.command_id)
 
-        running_command = prev_entry.command.copy(
+        running_command = prev_entry.command.model_copy(
             update={
                 "status": CommandStatus.RUNNING,
                 "startedAt": action.started_at,
@@ -366,7 +363,6 @@ class CommandStore(HasState[CommandState], HandlesActions):
             notes=action.notes,
         )
         self._state.failed_command = self._state.command_history.get(action.command_id)
-        self._state.failed_command_errors.append(public_error_occurrence)
 
         if (
             prev_entry.command.intent in (CommandIntent.PROTOCOL, None)
@@ -511,7 +507,10 @@ class CommandStore(HasState[CommandState], HandlesActions):
                         pass
                     case QueueStatus.RUNNING | QueueStatus.PAUSED:
                         self._state.queue_status = QueueStatus.PAUSED
-                    case QueueStatus.AWAITING_RECOVERY | QueueStatus.AWAITING_RECOVERY_PAUSED:
+                    case (
+                        QueueStatus.AWAITING_RECOVERY
+                        | QueueStatus.AWAITING_RECOVERY_PAUSED
+                    ):
                         self._state.queue_status = QueueStatus.AWAITING_RECOVERY_PAUSED
             elif action.door_state == DoorState.CLOSED:
                 self._state.is_door_blocking = False
@@ -530,7 +529,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         notes: Optional[List[CommandNote]],
     ) -> None:
         prev_entry = self._state.command_history.get(command_id)
-        failed_command = prev_entry.command.copy(
+        failed_command = prev_entry.command.model_copy(
             update={
                 "completedAt": failed_at,
                 "status": CommandStatus.FAILED,
@@ -584,7 +583,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
             )
 
 
-class CommandView(HasState[CommandState]):
+class CommandView:
     """Read-only command state view."""
 
     _state: CommandState
@@ -684,7 +683,7 @@ class CommandView(HasState[CommandState]):
         finish_error = self._state.finish_error
 
         if run_error and finish_error:
-            combined_error = ErrorOccurrence.construct(
+            combined_error = ErrorOccurrence(
                 id=finish_error.id,
                 createdAt=finish_error.createdAt,
                 errorType="RunAndFinishFailed",
@@ -706,7 +705,12 @@ class CommandView(HasState[CommandState]):
 
     def get_all_errors(self) -> List[ErrorOccurrence]:
         """Get the run's full error list, if there was none, returns an empty list."""
-        return self._state.failed_command_errors
+        failed_commands = self._state.command_history.get_all_failed_commands()
+        return [
+            command_error.error
+            for command_error in failed_commands
+            if command_error.error is not None
+        ]
 
     def get_has_entered_recovery_mode(self) -> bool:
         """Get whether the run has entered recovery mode."""
@@ -916,7 +920,7 @@ class CommandView(HasState[CommandState]):
         fatal error of the overall run coming from anywhere in the Python script,
         including in between commands.
         """
-        failed_command = self.state.failed_command
+        failed_command = self._state.failed_command
         if (
             failed_command
             and failed_command.command.error
@@ -932,12 +936,16 @@ class CommandView(HasState[CommandState]):
 
         The command ID is assumed to point to a failed command.
         """
-        return self.state.command_error_recovery_types[command_id]
+        return self._state.command_error_recovery_types[command_id]
 
     def get_is_stopped(self) -> bool:
         """Get whether an engine stop has completed."""
         return self._state.run_completed_at is not None
 
+    def get_is_stopped_by_estop(self) -> bool:
+        """Return whether the engine was stopped specifically by an E-stop."""
+        return self._state.stopped_by_estop
+
     def has_been_played(self) -> bool:
         """Get whether engine has started."""
         return self._state.run_started_at is not None

opentrons/protocol_engine/state/files.py

@@ -2,12 +2,11 @@
 from dataclasses import dataclass
 from typing import List
 
+from opentrons.protocol_engine.actions.get_state_update import get_state_updates
+from opentrons.protocol_engine.state import update_types
+
 from ._abstract_store import HasState, HandlesActions
-from ..actions import Action, SucceedCommandAction
-from ..commands import (
-    Command,
-    absorbance_reader,
-)
+from ..actions import Action
 
 
 @dataclass
@@ -28,16 +27,15 @@ class FileStore(HasState[FileState], HandlesActions):
 
     def handle_action(self, action: Action) -> None:
         """Modify state in reaction to an action."""
-        if isinstance(action, SucceedCommandAction):
-            self._handle_command(action.command)
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
 
-    def _handle_command(self, command: Command) -> None:
-        if isinstance(command.result, absorbance_reader.ReadAbsorbanceResult):
-            if command.result.fileIds is not None:
-                self._state.file_ids.extend(command.result.fileIds)
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.files_added != update_types.NO_CHANGE:
+            self._state.file_ids.extend(state_update.files_added.file_ids)
 
 
-class FileView(HasState[FileState]):
+class FileView:
     """Read-only engine created file state view."""
 
     _state: FileState

opentrons/protocol_engine/state/fluid_stack.py

@@ -0,0 +1,138 @@
+"""Implements fluid stack tracking for pipettes.
+
+Inside a pipette's tip, there can be a mix of kinds of fluids - here, "fluid" means "liquid" (i.e. a protocol-relevant
+working liquid that is aspirated or dispensed from wells) or "air" (i.e. because there was an air gap). Since sometimes
+you want air gaps in different places - physically-below liquid to prevent dripping, physically-above liquid to provide
+extra room to push the plunger - we need to support some notion of at least phsyical ordinal position of air and liquid,
+and we do so as a logical stack because that's physically relevant.
+"""
+from logging import getLogger
+from numpy import isclose
+from ..types import AspiratedFluid, FluidKind
+
+_LOG = getLogger(__name__)
+
+
+class FluidStack:
+    """A FluidStack data structure is a list of AspiratedFluids, with stack-style (last-in-first-out) ordering.
+
+    The front of the list is the physical-top of the liquid stack (logical-bottom of the stack data structure)
+    and the back of the list is the physical-bottom of the liquid stack (logical-top of the stack data structure).
+    The state is internal and the interaction surface is the methods. This is a mutating API.
+    """
+
+    _FluidStack = list[AspiratedFluid]
+
+    _fluid_stack: _FluidStack
+
+    def __init__(self, _fluid_stack: _FluidStack | None = None) -> None:
+        """Build a FluidStack.
+
+        The argument is provided for testing and shouldn't be generally used.
+        """
+        self._fluid_stack = _fluid_stack or []
+
+    def add_fluid(self, new: AspiratedFluid) -> None:
+        """Add fluid to a stack.
+
+        If the new fluid is of a different kind than what's on the physical-bottom of the stack, add a new record.
+        If the new fluid is of the same kind as what's on the physical-bottom of the stack, add the new volume to
+        the same record.
+        """
+        if len(self._fluid_stack) == 0 or self._fluid_stack[-1].kind != new.kind:
+            # this is a new kind of fluid, append the record
+            self._fluid_stack.append(new)
+        else:
+            # this is more of the same kind of fluid, add the volumes
+            old_fluid = self._fluid_stack.pop(-1)
+            self._fluid_stack.append(
+                AspiratedFluid(kind=new.kind, volume=old_fluid.volume + new.volume)
+            )
+
+    def _alter_fluid_records(
+        self, remove: int, new_last: AspiratedFluid | None
+    ) -> None:
+        if remove >= len(self._fluid_stack) or len(self._fluid_stack) == 0:
+            self._fluid_stack = []
+            return
+        if remove != 0:
+            removed = self._fluid_stack[:-remove]
+        else:
+            removed = self._fluid_stack
+        if new_last:
+            removed[-1] = new_last
+        self._fluid_stack = removed
+
+    def remove_fluid(self, volume: float) -> None:
+        """Remove a specific amount of fluid from the physical-bottom of the stack.
+
+        This will consume records that are wholly included in the provided volume and alter the remaining
+        final records (if any) to decrement the amount of volume removed from it.
+
+        This function is designed to be used inside pipette store action handlers, which are generally not
+        exception-safe, and therefore swallows and logs errors.
+        """
+        self._fluid_stack_iterator = reversed(self._fluid_stack)
+        removed_elements: list[AspiratedFluid] = []
+        while volume > 0:
+            try:
+                last_stack_element = next(self._fluid_stack_iterator)
+            except StopIteration:
+                _LOG.error(
+                    f"Attempting to remove more fluid than present, {volume}uL left over"
+                )
+                self._alter_fluid_records(len(removed_elements), None)
+                return
+            if last_stack_element.volume < volume:
+                removed_elements.append(last_stack_element)
+                volume -= last_stack_element.volume
+            elif isclose(last_stack_element.volume, volume):
+                self._alter_fluid_records(len(removed_elements) + 1, None)
+                return
+            else:
+                self._alter_fluid_records(
+                    len(removed_elements),
+                    AspiratedFluid(
+                        kind=last_stack_element.kind,
+                        volume=last_stack_element.volume - volume,
+                    ),
+                )
+                return
+
+        _LOG.error(f"Failed to handle removing {volume}uL from {self._fluid_stack}")
+
+    def aspirated_volume(self, kind: FluidKind | None = None) -> float:
+        """Measure the total amount of fluid (optionally filtered by kind) in the stack."""
+        volume = 0.0
+        for el in self._fluid_stack:
+            if kind is not None and el.kind != kind:
+                continue
+            volume += el.volume
+        return volume
+
+    def liquid_part_of_dispense_volume(self, volume: float) -> float:
+        """Get the amount of liquid in the specified volume starting at the physical-bottom of the stack."""
+        liquid_volume = 0.0
+        for el in reversed(self._fluid_stack):
+            if el.kind == FluidKind.LIQUID:
+                liquid_volume += min(volume, el.volume)
+            volume -= min(el.volume, volume)
+            if isclose(volume, 0.0):
+                return liquid_volume
+        return liquid_volume
+
+    def __eq__(self, other: object) -> bool:
+        """Equality."""
+        if isinstance(other, type(self)):
+            return other._fluid_stack == self._fluid_stack
+        return False
+
+    def __repr__(self) -> str:
+        """String representation of a fluid stack."""
+        if self._fluid_stack:
+            stringified_stack = (
+                f'(top) {", ".join([str(item) for item in self._fluid_stack])} (bottom)'
+            )
+        else:
+            stringified_stack = "empty"
+        return f"<{self.__class__.__name__}: {stringified_stack}>"