opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a2__py2.py3-none-any.whl

opentrons/protocol_engine/protocol_engine.py

@@ -30,7 +30,6 @@ from .types import (
     HexColor,
     PostRunHardwareState,
     DeckConfigurationType,
-    AddressableAreaLocation,
 )
 from .execution import (
     QueueWorker,
@@ -427,7 +426,7 @@ class ProtocolEngine:
             post_run_hardware_state: The state in which to leave the gantry and motors in
                 after the run is over.
         """
-        if self._state_store.commands.state.stopped_by_estop:
+        if self._state_store.commands.get_is_stopped_by_estop():
             # This handles the case where the E-stop was pressed while we were *not* in the middle
             # of some hardware interaction that would raise it as an exception. For example, imagine
             # we were paused between two commands, or imagine we were executing a waitForDuration.
@@ -565,15 +564,17 @@ class ProtocolEngine:
             description=(description or ""),
             displayColor=color,
         )
+        validated_liquid = self._state_store.liquid.validate_liquid_allowed(
+            liquid=liquid
+        )
 
-        self._action_dispatcher.dispatch(AddLiquidAction(liquid=liquid))
-        return liquid
+        self._action_dispatcher.dispatch(AddLiquidAction(liquid=validated_liquid))
+        return validated_liquid
 
     def add_addressable_area(self, addressable_area_name: str) -> None:
         """Add an addressable area to state."""
-        area = AddressableAreaLocation(addressableAreaName=addressable_area_name)
         self._action_dispatcher.dispatch(
-            AddAddressableAreaAction(addressable_area=area)
+            AddAddressableAreaAction(addressable_area_name)
         )
 
     def reset_tips(self, labware_id: str) -> None:

opentrons/protocol_engine/resources/labware_data_provider.py

@@ -44,7 +44,7 @@ class LabwareDataProvider:
     def _get_labware_definition_sync(
         load_name: str, namespace: str, version: int
     ) -> LabwareDefinition:
-        return LabwareDefinition.parse_obj(
+        return LabwareDefinition.model_validate(
             get_labware_definition(load_name, namespace, version)
         )
 

opentrons/protocol_engine/resources/labware_validation.py

@@ -32,6 +32,11 @@ def validate_definition_is_lid(definition: LabwareDefinition) -> bool:
     return LabwareRole.lid in definition.allowedRoles
 
 
+def validate_definition_is_system(definition: LabwareDefinition) -> bool:
+    """Validate that one of the definition's allowed roles is `system`."""
+    return LabwareRole.system in definition.allowedRoles
+
+
 def validate_labware_can_be_stacked(
     top_labware_definition: LabwareDefinition, below_labware_load_name: str
 ) -> bool:

opentrons/protocol_engine/resources/module_data_provider.py

@@ -22,7 +22,7 @@ class ModuleDataProvider:
     def get_definition(model: ModuleModel) -> ModuleDefinition:
         """Get the module definition."""
         data = load_definition(model_or_loadname=model.value, version="3")
-        return ModuleDefinition.parse_obj(data)
+        return ModuleDefinition.model_validate(data)
 
     @staticmethod
     def load_module_calibrations() -> Dict[str, ModuleOffsetData]:

opentrons/protocol_engine/resources/pipette_data_provider.py

@@ -67,6 +67,8 @@ class LoadedStaticPipetteData:
     back_left_corner_offset: Point
     front_right_corner_offset: Point
     pipette_lld_settings: Optional[Dict[str, Dict[str, float]]]
+    plunger_positions: Dict[str, float]
+    shaft_ul_per_mm: float
     available_sensors: pipette_definition.AvailableSensorDefinition
 
 
@@ -258,6 +260,7 @@ class VirtualPipetteDataProvider:
 
         pip_back_left = config.pipette_bounding_box_offsets.back_left_corner
         pip_front_right = config.pipette_bounding_box_offsets.front_right_corner
+        plunger_positions = config.plunger_positions_configurations[liquid_class]
         return LoadedStaticPipetteData(
             model=str(pipette_model),
             display_name=config.display_name,
@@ -286,6 +289,13 @@ class VirtualPipetteDataProvider:
                 pip_front_right[0], pip_front_right[1], pip_front_right[2]
             ),
             pipette_lld_settings=config.lld_settings,
+            plunger_positions={
+                "top": plunger_positions.top,
+                "bottom": plunger_positions.bottom,
+                "blow_out": plunger_positions.blow_out,
+                "drop_tip": plunger_positions.drop_tip,
+            },
+            shaft_ul_per_mm=config.shaft_ul_per_mm,
             available_sensors=config.available_sensors
             or pipette_definition.AvailableSensorDefinition(sensors=[]),
         )
@@ -340,6 +350,8 @@ def get_pipette_static_config(
             front_right_offset[0], front_right_offset[1], front_right_offset[2]
         ),
         pipette_lld_settings=pipette_dict["lld_settings"],
+        plunger_positions=pipette_dict["plunger_positions"],
+        shaft_ul_per_mm=pipette_dict["shaft_ul_per_mm"],
         available_sensors=available_sensors,
     )
 

opentrons/protocol_engine/slot_standardization.py

@@ -35,9 +35,9 @@ def standardize_labware_offset(
     original: LabwareOffsetCreate, robot_type: RobotType
 ) -> LabwareOffsetCreate:
     """Convert the deck slot in the given `LabwareOffsetCreate` to match the given robot type."""
-    return original.copy(
+    return original.model_copy(
         update={
-            "location": original.location.copy(
+            "location": original.location.model_copy(
                 update={
                     "slotName": original.location.slotName.to_equivalent_for_robot_type(
                         robot_type
@@ -70,40 +70,40 @@ def standardize_command(
 def _standardize_load_labware(
     original: commands.LoadLabwareCreate, robot_type: RobotType
 ) -> commands.LoadLabwareCreate:
-    params = original.params.copy(
+    params = original.params.model_copy(
         update={
             "location": _standardize_labware_location(
                 original.params.location, robot_type
             )
         }
     )
-    return original.copy(update={"params": params})
+    return original.model_copy(update={"params": params})
 
 
 def _standardize_load_module(
     original: commands.LoadModuleCreate, robot_type: RobotType
 ) -> commands.LoadModuleCreate:
-    params = original.params.copy(
+    params = original.params.model_copy(
         update={
             "location": _standardize_deck_slot_location(
                 original.params.location, robot_type
             )
         }
     )
-    return original.copy(update={"params": params})
+    return original.model_copy(update={"params": params})
 
 
 def _standardize_move_labware(
     original: commands.MoveLabwareCreate, robot_type: RobotType
 ) -> commands.MoveLabwareCreate:
-    params = original.params.copy(
+    params = original.params.model_copy(
         update={
             "newLocation": _standardize_labware_location(
                 original.params.newLocation, robot_type
             )
         }
     )
-    return original.copy(update={"params": params})
+    return original.model_copy(update={"params": params})
 
 
 _standardize_command_functions: Dict[
@@ -135,6 +135,6 @@ def _standardize_labware_location(
 def _standardize_deck_slot_location(
     original: DeckSlotLocation, robot_type: RobotType
 ) -> DeckSlotLocation:
-    return original.copy(
+    return original.model_copy(
         update={"slotName": original.slotName.to_equivalent_for_robot_type(robot_type)}
     )

opentrons/protocol_engine/state/_move_types.py

@@ -53,15 +53,19 @@ def get_move_type_to_well(
 
 
 def get_edge_point_list(
-    center: Point, x_radius: float, y_radius: float, edge_path_type: EdgePathType
+    center: Point,
+    x_radius: float,
+    y_radius: float,
+    mm_from_edge: float,
+    edge_path_type: EdgePathType,
 ) -> List[Point]:
     """Get list of edge points dependent on edge path type."""
     edges = EdgeList(
-        right=center + Point(x=x_radius, y=0, z=0),
-        left=center + Point(x=-x_radius, y=0, z=0),
+        right=center + Point(x=x_radius - mm_from_edge, y=0, z=0),
+        left=center + Point(x=-x_radius + mm_from_edge, y=0, z=0),
         center=center,
-        forward=center + Point(x=0, y=y_radius, z=0),
-        back=center + Point(x=0, y=-y_radius, z=0),
+        forward=center + Point(x=0, y=y_radius - mm_from_edge, z=0),
+        back=center + Point(x=0, y=-y_radius + mm_from_edge, z=0),
     )
 
     if edge_path_type == EdgePathType.LEFT:

opentrons/protocol_engine/state/_well_math.py

@@ -0,0 +1,193 @@
+"""Utilities for doing coverage math on wells."""
+
+from typing import Iterator
+from opentrons_shared_data.errors.exceptions import (
+    InvalidStoredData,
+    InvalidProtocolData,
+)
+
+from opentrons.hardware_control.nozzle_manager import NozzleMap
+
+
+def wells_covered_by_pipette_configuration(
+    nozzle_map: NozzleMap,
+    target_well: str,
+    labware_wells_by_column: list[list[str]],
+) -> Iterator[str]:
+    """Compute the wells covered by a pipette nozzle configuration."""
+    if len(labware_wells_by_column) >= 12 and len(labware_wells_by_column[0]) >= 8:
+        yield from wells_covered_dense(
+            nozzle_map,
+            target_well,
+            labware_wells_by_column,
+        )
+    elif len(labware_wells_by_column) < 12 and len(labware_wells_by_column[0]) < 8:
+        yield from wells_covered_sparse(
+            nozzle_map, target_well, labware_wells_by_column
+        )
+    else:
+        raise InvalidStoredData(
+            "Labware of non-SBS and non-reservoir format cannot be handled"
+        )
+
+
+def row_col_ordinals_from_column_major_map(
+    target_well: str, column_major_wells: list[list[str]]
+) -> tuple[int, int]:
+    """Turn a well name into the index of its row and column (in that order) within the labware."""
+    for column_index, column in enumerate(column_major_wells):
+        if target_well in column:
+            return column.index(target_well), column_index
+    raise InvalidStoredData(f"Well name {target_well} is not present in labware")
+
+
+def wells_covered_dense(  # noqa: C901
+    nozzle_map: NozzleMap, target_well: str, target_wells_by_column: list[list[str]]
+) -> Iterator[str]:
+    """Get the list of wells covered by a nozzle map on an SBS format labware with a specified multiplier of 96 into the number of wells.
+
+    This will handle the offsetting of the nozzle map into higher-density well plates. For instance, a full column config target at A1 of a
+    96 plate would cover wells A1, B1, C1, D1, E1, F1, G1, H1, and use downsample_factor 1.0 (96*1 = 96). A full column config target on a
+    384 plate would cover wells A1, C1, E1, G1, I1, K1, M1, O1 and use downsample_factor 4.0 (96*4 = 384), while a full column config
+    targeting B1 would cover wells B1, D1, F1, H1, J1, L1, N1, P1 - still using downsample_factor 4.0, with the offset gathered from the
+    target well.
+
+    The function may also handle sub-96 regular labware with fractional downsample factors, but that's physically improbable and it's not
+    tested. If you have a regular labware with fewer than 96 wells that is still regularly-spaced and has little enough space between well
+    walls that it's reasonable to use with multiple channels, you probably want wells_covered_trough.
+    """
+    target_row_index, target_column_index = row_col_ordinals_from_column_major_map(
+        target_well, target_wells_by_column
+    )
+    column_downsample = len(target_wells_by_column) // 12
+    row_downsample = len(target_wells_by_column[0]) // 8
+    if column_downsample < 1 or row_downsample < 1:
+        raise InvalidStoredData(
+            "This labware cannot be used wells_covered_dense because it is less dense than an SBS 96 standard"
+        )
+
+    for nozzle_column in range(len(nozzle_map.columns)):
+        target_column_offset = nozzle_column * column_downsample
+        for nozzle_row in range(len(nozzle_map.rows)):
+            target_row_offset = nozzle_row * row_downsample
+            if nozzle_map.starting_nozzle == "A1":
+                if (
+                    target_column_index + target_column_offset
+                    < len(target_wells_by_column)
+                ) and (
+                    target_row_index + target_row_offset
+                    < len(target_wells_by_column[target_column_index])
+                ):
+                    yield target_wells_by_column[
+                        target_column_index + target_column_offset
+                    ][target_row_index + target_row_offset]
+            elif nozzle_map.starting_nozzle == "A12":
+                if (target_column_index - target_column_offset >= 0) and (
+                    target_row_index + target_row_offset
+                    < len(target_wells_by_column[target_column_index])
+                ):
+                    yield target_wells_by_column[
+                        target_column_index - target_column_offset
+                    ][target_row_index + target_row_offset]
+            elif nozzle_map.starting_nozzle == "H1":
+                if (
+                    target_column_index + target_column_offset
+                    < len(target_wells_by_column)
+                ) and (target_row_index - target_row_offset >= 0):
+                    yield target_wells_by_column[
+                        target_column_index + target_column_offset
+                    ][target_row_index - target_row_offset]
+            elif nozzle_map.starting_nozzle == "H12":
+                if (target_column_index - target_column_offset >= 0) and (
+                    target_row_index - target_row_offset >= 0
+                ):
+                    yield target_wells_by_column[
+                        target_column_index - target_column_offset
+                    ][target_row_index - target_row_offset]
+            else:
+                raise InvalidProtocolData(
+                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
+                )
+
+
+def wells_covered_sparse(  # noqa: C901
+    nozzle_map: NozzleMap, target_well: str, target_wells_by_column: list[list[str]]
+) -> Iterator[str]:
+    """Get the list of wells covered by a nozzle map on a column-oriented reservoir.
+
+    This function handles reservoirs whose wells span multiple rows and columns - the most common case is something like a
+    12-well reservoir, whose wells are the height of an SBS column and the width of an SBS row, or a 1-well reservoir whose well
+    is the size of an SBS active area.
+    """
+    target_row_index, target_column_index = row_col_ordinals_from_column_major_map(
+        target_well, target_wells_by_column
+    )
+    column_upsample = 12 // len(target_wells_by_column)
+    row_upsample = 8 // len(target_wells_by_column[0])
+    if column_upsample < 1 or row_upsample < 1:
+        raise InvalidStoredData(
+            "This labware cannot be used with wells_covered_sparse because it is more dense than an SBS 96 standard."
+        )
+    for nozzle_column in range(max(1, len(nozzle_map.columns) // column_upsample)):
+        for nozzle_row in range(max(1, len(nozzle_map.rows) // row_upsample)):
+            if nozzle_map.starting_nozzle == "A1":
+                if (
+                    target_column_index + nozzle_column < len(target_wells_by_column)
+                ) and (
+                    target_row_index + nozzle_row
+                    < len(target_wells_by_column[target_column_index])
+                ):
+                    yield target_wells_by_column[target_column_index + nozzle_column][
+                        target_row_index + nozzle_row
+                    ]
+            elif nozzle_map.starting_nozzle == "A12":
+                if (target_column_index - nozzle_column >= 0) and (
+                    target_row_index + nozzle_row
+                    < len(target_wells_by_column[target_column_index])
+                ):
+                    yield target_wells_by_column[target_column_index - nozzle_column][
+                        target_row_index + nozzle_row
+                    ]
+            elif nozzle_map.starting_nozzle == "H1":
+                if (
+                    target_column_index + nozzle_column
+                    < len(target_wells_by_column[target_column_index])
+                ) and (target_row_index - nozzle_row >= 0):
+                    yield target_wells_by_column[target_column_index + nozzle_column][
+                        target_row_index - nozzle_row
+                    ]
+            elif nozzle_map.starting_nozzle == "H12":
+                if (target_column_index - nozzle_column >= 0) and (
+                    target_row_index - nozzle_row >= 0
+                ):
+                    yield target_wells_by_column[target_column_index - nozzle_column][
+                        target_row_index - nozzle_row
+                    ]
+            else:
+                raise InvalidProtocolData(
+                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
+                )
+
+
+def nozzles_per_well(
+    nozzle_map: NozzleMap, target_well: str, target_wells_by_column: list[list[str]]
+) -> int:
+    """Get the number of nozzles that will interact with each well in the labware.
+
+    For instance, if this is an SBS 96 or more dense, there is always 1 nozzle per well
+    that is interacted with (and some wells may not be interacted with at all). If this is
+    a 12-column reservoir, then all active nozzles in each column of the configuration will
+    interact with each well; so an 8-channel full config would have 8 nozzles per well,
+    and a 96 channel with a rectangle config from A1 to D12 would have 4 nozzles per well.
+    """
+    _, target_column_index = row_col_ordinals_from_column_major_map(
+        target_well, target_wells_by_column
+    )
+    # labware as or more dense than a 96 plate will only ever have 1 nozzle per well (and some wells won't be touched)
+    if len(target_wells_by_column) >= len(nozzle_map.columns) and len(
+        target_wells_by_column[target_column_index]
+    ) >= len(nozzle_map.rows):
+        return 1
+    return max(1, len(nozzle_map.columns) // len(target_wells_by_column)) * max(
+        1, len(nozzle_map.rows) // len(target_wells_by_column[target_column_index])
+    )

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."""