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

opentrons/protocol_engine/notes/notes.py

@@ -35,7 +35,7 @@ def make_error_recovery_debug_note(type: "ErrorRecoveryType") -> CommandNote:
     This is intended to be read by developers and support people, not computers.
     """
     message = f"Handling this command failure with {type.name}."
-    return CommandNote.construct(
+    return CommandNote.model_construct(
         noteKind="debugErrorRecovery",
         shortMessage=message,
         longMessage=message,

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

@@ -14,6 +14,11 @@ def is_absorbance_reader_lid(load_name: str) -> bool:
     return load_name == "opentrons_flex_lid_absorbance_plate_reader_module"
 
 
+def is_evotips(load_name: str) -> bool:
+    """Check if a labware is an evotips tiprack."""
+    return load_name == "evotips_opentrons_96_labware"
+
+
 def validate_definition_is_labware(definition: LabwareDefinition) -> bool:
     """Validate that one of the definition's allowed roles is `labware`.
 
@@ -32,6 +37,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:
@@ -39,6 +49,14 @@ def validate_labware_can_be_stacked(
     return below_labware_load_name in top_labware_definition.stackingOffsetWithLabware
 
 
+def validate_labware_can_be_ondeck(definition: LabwareDefinition) -> bool:
+    """Validate that the labware being loaded onto the deck can sit in a slot."""
+    return (
+        definition.parameters.quirks is None
+        or "stackingOnly" not in definition.parameters.quirks
+    )
+
+
 def validate_gripper_compatible(definition: LabwareDefinition) -> bool:
     """Validate that the labware definition does not have a quirk disallowing movement with gripper."""
     return (

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,9 @@ 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
 
 
 class VirtualPipetteDataProvider:
@@ -95,6 +98,7 @@ class VirtualPipetteDataProvider:
                 config.pipette_type,
                 config.channels,
                 config.version,
+                pip_types.PipetteOEMType.OT,
             )
             new_nozzle_manager = NozzleConfigurationManager.build_from_config(
                 config, valid_nozzle_maps
@@ -127,6 +131,7 @@ class VirtualPipetteDataProvider:
             pipette_model.pipette_type,
             pipette_model.pipette_channels,
             pipette_model.pipette_version,
+            pipette_model.oem_type,
         )
 
         liquid_class = pipette_definition.liquid_class_for_volume_between_default_and_defaultlowvolume(
@@ -160,6 +165,7 @@ class VirtualPipetteDataProvider:
             pipette_model.pipette_type,
             pipette_model.pipette_channels,
             pipette_model.pipette_version,
+            pipette_model.oem_type,
         )
 
     def _get_virtual_pipette_static_config_by_model(  # noqa: C901
@@ -176,6 +182,7 @@ class VirtualPipetteDataProvider:
             pipette_model.pipette_type,
             pipette_model.pipette_channels,
             pipette_model.pipette_version,
+            pipette_model.oem_type,
         )
         try:
             tip_type = pip_types.PipetteTipType(
@@ -192,6 +199,7 @@ class VirtualPipetteDataProvider:
             pipette_model.pipette_type,
             pipette_model.pipette_channels,
             pipette_model.pipette_version,
+            pipette_model.oem_type,
         )
         if pipette_id not in self._nozzle_manager_layout_by_id:
             nozzle_manager = NozzleConfigurationManager.build_from_config(
@@ -252,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,
@@ -280,6 +289,15 @@ 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=[]),
         )
 
     def get_virtual_pipette_static_config(
@@ -298,6 +316,11 @@ def get_pipette_static_config(
     """Get the config for a pipette, given the state/config object from the HW API."""
     back_left_offset = pipette_dict["pipette_bounding_box_offsets"].back_left_corner
     front_right_offset = pipette_dict["pipette_bounding_box_offsets"].front_right_corner
+    available_sensors = (
+        pipette_dict["available_sensors"]
+        if "available_sensors" in pipette_dict.keys()
+        else pipette_definition.AvailableSensorDefinition(sensors=[])
+    )
     return LoadedStaticPipetteData(
         model=pipette_dict["model"],
         display_name=pipette_dict["display_name"],
@@ -327,6 +350,9 @@ 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])
+    )