opentrons 8.7.0a2__py3-none-any.whl → 8.7.0a3__py3-none-any.whl

opentrons/protocol_engine/state/_well_math.py

@@ -17,47 +17,13 @@ def wells_covered_by_pipette_configuration(
     """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.columns,
-            nozzle_map.rows,
-            nozzle_map.starting_nozzle,
+            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.columns,
-            nozzle_map.rows,
-            nozzle_map.starting_nozzle,
-            target_well,
-            labware_wells_by_column,
-        )
-    else:
-        raise InvalidStoredData(
-            "Labware of non-SBS and non-reservoir format cannot be handled"
-        )
-
-
-def wells_covered_by_physical_pipette(
-    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.full_instrument_columns,
-            nozzle_map.full_instrument_rows,
-            nozzle_map.starting_nozzle,
-            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.full_instrument_columns,
-            nozzle_map.full_instrument_rows,
-            nozzle_map.starting_nozzle,
-            target_well,
-            labware_wells_by_column,
+            nozzle_map, target_well, labware_wells_by_column
         )
     else:
         raise InvalidStoredData(
@@ -76,11 +42,7 @@ def row_col_ordinals_from_column_major_map(
 
 
 def wells_covered_dense(  # noqa: C901
-    columns: dict[str, list[str]],
-    rows: dict[str, list[str]],
-    starting_nozzle: str,
-    target_well: str,
-    target_wells_by_column: list[list[str]],
+    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.
 
@@ -104,11 +66,11 @@ def wells_covered_dense(  # noqa: C901
             "This labware cannot be used with wells_covered_dense() because it is less dense than an SBS 96 standard"
         )
 
-    for nozzle_column in range(len(columns)):
+    for nozzle_column in range(len(nozzle_map.columns)):
         target_column_offset = nozzle_column * column_downsample
-        for nozzle_row in range(len(rows)):
+        for nozzle_row in range(len(nozzle_map.rows)):
             target_row_offset = nozzle_row * row_downsample
-            if starting_nozzle == "A1":
+            if nozzle_map.starting_nozzle == "A1":
                 if (
                     target_column_index + target_column_offset
                     < len(target_wells_by_column)
@@ -119,7 +81,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index + target_column_offset
                     ][target_row_index + target_row_offset]
-            elif starting_nozzle == "A12":
+            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])
@@ -127,7 +89,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index - target_column_offset
                     ][target_row_index + target_row_offset]
-            elif starting_nozzle == "H1":
+            elif nozzle_map.starting_nozzle == "H1":
                 if (
                     target_column_index + target_column_offset
                     < len(target_wells_by_column)
@@ -135,7 +97,7 @@ def wells_covered_dense(  # noqa: C901
                     yield target_wells_by_column[
                         target_column_index + target_column_offset
                     ][target_row_index - target_row_offset]
-            elif starting_nozzle == "H12":
+            elif nozzle_map.starting_nozzle == "H12":
                 if (target_column_index - target_column_offset >= 0) and (
                     target_row_index - target_row_offset >= 0
                 ):
@@ -144,16 +106,12 @@ def wells_covered_dense(  # noqa: C901
                     ][target_row_index - target_row_offset]
             else:
                 raise InvalidProtocolData(
-                    f"A pipette nozzle configuration may not having a starting nozzle of {starting_nozzle}"
+                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
                 )
 
 
 def wells_covered_sparse(  # noqa: C901
-    columns: dict[str, list[str]],
-    rows: dict[str, list[str]],
-    starting_nozzle: str,
-    target_well: str,
-    target_wells_by_column: list[list[str]],
+    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.
 
@@ -170,9 +128,9 @@ def wells_covered_sparse(  # noqa: C901
         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(columns) // column_upsample)):
-        for nozzle_row in range(max(1, len(rows) // row_upsample)):
-            if starting_nozzle == "A1":
+    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 (
@@ -182,7 +140,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index + nozzle_column][
                         target_row_index + nozzle_row
                     ]
-            elif starting_nozzle == "A12":
+            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])
@@ -190,7 +148,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index - nozzle_column][
                         target_row_index + nozzle_row
                     ]
-            elif starting_nozzle == "H1":
+            elif nozzle_map.starting_nozzle == "H1":
                 if (
                     target_column_index + nozzle_column
                     < len(target_wells_by_column[target_column_index])
@@ -198,7 +156,7 @@ def wells_covered_sparse(  # noqa: C901
                     yield target_wells_by_column[target_column_index + nozzle_column][
                         target_row_index - nozzle_row
                     ]
-            elif starting_nozzle == "H12":
+            elif nozzle_map.starting_nozzle == "H12":
                 if (target_column_index - nozzle_column >= 0) and (
                     target_row_index - nozzle_row >= 0
                 ):
@@ -207,7 +165,7 @@ def wells_covered_sparse(  # noqa: C901
                     ]
             else:
                 raise InvalidProtocolData(
-                    f"A pipette nozzle configuration may not having a starting nozzle of {starting_nozzle}"
+                    f"A pipette nozzle configuration may not having a starting nozzle of {nozzle_map.starting_nozzle}"
                 )
 
 

opentrons/protocol_engine/state/addressable_areas.py

@@ -5,7 +5,6 @@ from functools import cached_property
 from typing import Dict, List, Optional, Set
 
 from opentrons_shared_data.robot.types import RobotType, RobotDefinition
-from opentrons_shared_data.module.types import ModuleOrientation
 from opentrons_shared_data.deck.types import (
     DeckDefinitionV5,
     SlotDefV3,
@@ -615,7 +614,6 @@ class AddressableAreaView:
             "displayName": addressable_area.display_name,
             "compatibleModuleTypes": addressable_area.compatible_module_types,
             "features": addressable_area.features,
-            "orientation": ModuleOrientation.NOT_APPLICABLE,
         }
 
     def get_deck_slot_definitions(self) -> Dict[str, SlotDefV3]:

opentrons/protocol_engine/state/commands.py

@@ -238,7 +238,7 @@ class CommandState:
     has_entered_error_recovery: bool
     """Whether the run has entered error recovery."""
 
-    stopped_by_async_error: bool
+    stopped_by_estop: bool
     """If this is set to True, the engine was stopped by an estop event."""
 
     error_recovery_policy: ErrorRecoveryPolicy
@@ -272,7 +272,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
             run_completed_at=None,
             run_started_at=None,
             latest_protocol_command_hash=None,
-            stopped_by_async_error=False,
+            stopped_by_estop=False,
             error_recovery_policy=error_recovery_policy,
             has_entered_error_recovery=False,
         )
@@ -472,8 +472,8 @@ class CommandStore(HasState[CommandState], HandlesActions):
             self._state.recovery_target = None
             self._state.queue_status = QueueStatus.PAUSED
 
-            if action.from_asynchronous_error:
-                self._state.stopped_by_async_error = True
+            if action.from_estop:
+                self._state.stopped_by_estop = True
                 self._state.run_result = RunResult.FAILED
             else:
                 self._state.run_result = RunResult.STOPPED
@@ -501,7 +501,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         else:
             # HACK(sf): There needs to be a better way to set
             # an estop error than this else clause
-            if self._state.stopped_by_async_error and action.error_details:
+            if self._state.stopped_by_estop and action.error_details:
                 self._state.run_error = self._map_run_exception_to_error_occurrence(
                     action.error_details.error_id,
                     action.error_details.created_at,
@@ -952,9 +952,9 @@ class CommandView:
         """Get whether an engine stop has completed."""
         return self._state.run_completed_at is not None
 
-    def get_is_stopped_by_async_error(self) -> bool:
+    def get_is_stopped_by_estop(self) -> bool:
         """Return whether the engine was stopped specifically by an E-stop."""
-        return self._state.stopped_by_async_error
+        return self._state.stopped_by_estop
 
     def has_been_played(self) -> bool:
         """Get whether engine has started."""