opentrons 8.4.1a2__py2.py3-none-any.whl → 8.5.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/tips.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Optional, List, Union
+from typing import Dict, Iterable, Optional, List, Union
 
 from opentrons.types import NozzleMapInterface
 from opentrons.protocol_engine.state import update_types
@@ -14,36 +14,22 @@ from ..actions import Action, ResetTipsAction, get_state_updates
 from opentrons.hardware_control.nozzle_manager import NozzleMap
 
 
-class TipRackWellState(Enum):
+class _TipRackWellState(Enum):
     """The state of a single tip in a tip rack's well."""
 
     CLEAN = "clean"
     USED = "used"
 
 
-TipRackStateByWellName = Dict[str, TipRackWellState]
-
-
-# todo(mm, 2024-10-10): This info is duplicated between here and PipetteState because
-# TipStore is using it to compute which tips a PickUpTip removes from the tip rack,
-# given the pipette's current nozzle map. We could avoid this duplication by moving the
-# computation to TipView, calling it from PickUpTipImplementation, and passing the
-# precomputed list of wells to TipStore.
-@dataclass
-class _PipetteInfo:
-    channels: int
-    active_channels: int
-    nozzle_map: NozzleMap
+_TipRackStateByWellName = Dict[str, _TipRackWellState]
 
 
 @dataclass
 class TipState:
     """State of all tips."""
 
-    tips_by_labware_id: Dict[str, TipRackStateByWellName]
-    column_by_labware_id: Dict[str, List[List[str]]]
-
-    pipette_info_by_pipette_id: Dict[str, _PipetteInfo]
+    tips_by_labware_id: Dict[str, _TipRackStateByWellName]
+    columns_by_labware_id: Dict[str, List[List[str]]]
 
 
 class TipStore(HasState[TipState], HandlesActions):
@@ -55,8 +41,7 @@ class TipStore(HasState[TipState], HandlesActions):
         """Initialize a liquid store and its state."""
         self._state = TipState(
             tips_by_labware_id={},
-            column_by_labware_id={},
-            pipette_info_by_pipette_id={},
+            columns_by_labware_id={},
         )
 
     def handle_action(self, action: Action) -> None:
@@ -70,44 +55,25 @@ class TipStore(HasState[TipState], HandlesActions):
             for well_name in self._state.tips_by_labware_id[labware_id].keys():
                 self._state.tips_by_labware_id[labware_id][
                     well_name
-                ] = TipRackWellState.CLEAN
+                ] = _TipRackWellState.CLEAN
 
     def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
-        if state_update.pipette_config != update_types.NO_CHANGE:
-            self._state.pipette_info_by_pipette_id[
-                state_update.pipette_config.pipette_id
-            ] = _PipetteInfo(
-                channels=state_update.pipette_config.config.channels,
-                active_channels=state_update.pipette_config.config.channels,
-                nozzle_map=state_update.pipette_config.config.nozzle_map,
-            )
-
         if state_update.tips_used != update_types.NO_CHANGE:
             self._set_used_tips(
-                pipette_id=state_update.tips_used.pipette_id,
                 labware_id=state_update.tips_used.labware_id,
-                well_name=state_update.tips_used.well_name,
-            )
-
-        if state_update.pipette_nozzle_map != update_types.NO_CHANGE:
-            pipette_info = self._state.pipette_info_by_pipette_id[
-                state_update.pipette_nozzle_map.pipette_id
-            ]
-            pipette_info.active_channels = (
-                state_update.pipette_nozzle_map.nozzle_map.tip_count
+                well_names=state_update.tips_used.well_names,
             )
-            pipette_info.nozzle_map = state_update.pipette_nozzle_map.nozzle_map
 
         if state_update.loaded_labware != update_types.NO_CHANGE:
             labware_id = state_update.loaded_labware.labware_id
             definition = state_update.loaded_labware.definition
             if definition.parameters.isTiprack:
                 self._state.tips_by_labware_id[labware_id] = {
-                    well_name: TipRackWellState.CLEAN
+                    well_name: _TipRackWellState.CLEAN
                     for column in definition.ordering
                     for well_name in column
                 }
-                self._state.column_by_labware_id[labware_id] = [
+                self._state.columns_by_labware_id[labware_id] = [
                     column for column in definition.ordering
                 ]
         if state_update.batch_loaded_labware != update_types.NO_CHANGE:
@@ -117,20 +83,18 @@ class TipStore(HasState[TipState], HandlesActions):
                 ]
                 if definition.parameters.isTiprack:
                     self._state.tips_by_labware_id[labware_id] = {
-                        well_name: TipRackWellState.CLEAN
+                        well_name: _TipRackWellState.CLEAN
                         for column in definition.ordering
                         for well_name in column
                     }
-                    self._state.column_by_labware_id[labware_id] = [
+                    self._state.columns_by_labware_id[labware_id] = [
                         column for column in definition.ordering
                     ]
 
-    def _set_used_tips(self, pipette_id: str, well_name: str, labware_id: str) -> None:
-        columns = self._state.column_by_labware_id.get(labware_id, [])
-        wells = self._state.tips_by_labware_id.get(labware_id, {})
-        nozzle_map = self._state.pipette_info_by_pipette_id[pipette_id].nozzle_map
-        for well in wells_covered_dense(nozzle_map, well_name, columns):
-            wells[well] = TipRackWellState.USED
+    def _set_used_tips(self, labware_id: str, well_names: Iterable[str]) -> None:
+        well_states = self._state.tips_by_labware_id.get(labware_id, {})
+        for well_name in well_names:
+            well_states[well_name] = _TipRackWellState.USED
 
 
 class TipView:
@@ -155,7 +119,7 @@ class TipView:
     ) -> Optional[str]:
         """Get the next available clean tip. Does not support use of a starting tip if the pipette used is in a partial configuration."""
         wells = self._state.tips_by_labware_id.get(labware_id, {})
-        columns = self._state.column_by_labware_id.get(labware_id, [])
+        columns = self._state.columns_by_labware_id.get(labware_id, [])
 
         # TODO(sf): I'm pretty sure this can be replaced with wells_covered_96 but I'm not quite sure how
         def _identify_tip_cluster(
@@ -202,9 +166,9 @@ class TipView:
         def _validate_tip_cluster(
             active_columns: int, active_rows: int, tip_cluster: List[str]
         ) -> Union[str, int, None]:
-            if not any(wells[well] == TipRackWellState.USED for well in tip_cluster):
+            if not any(wells[well] == _TipRackWellState.USED for well in tip_cluster):
                 return tip_cluster[0]
-            elif all(wells[well] == TipRackWellState.USED for well in tip_cluster):
+            elif all(wells[well] == _TipRackWellState.USED for well in tip_cluster):
                 return None
             else:
                 # In the case of an 8ch pipette where a column has mixed state tips we may simply progress to the next column in our search
@@ -224,12 +188,12 @@ class TipView:
                         tip_cluster[(active_rows - 1) + (i * active_rows)]
                     )
                 if all(
-                    wells[well] == TipRackWellState.USED
+                    wells[well] == _TipRackWellState.USED
                     for well in tip_cluster_final_column
                 ):
                     return None
                 elif all(
-                    wells[well] == TipRackWellState.USED
+                    wells[well] == _TipRackWellState.USED
                     for well in tip_cluster_final_row
                 ):
                     return None
@@ -386,7 +350,9 @@ class TipView:
                                 starting_column_index = idx
 
                 for column in columns[starting_column_index:]:
-                    if not any(wells[well] == TipRackWellState.USED for well in column):
+                    if not any(
+                        wells[well] == _TipRackWellState.USED for well in column
+                    ):
                         return column[0]
 
             elif num_tips == len(wells.keys()):  # Get next tips for 96 channel
@@ -394,7 +360,7 @@ class TipView:
                     return None
 
                 if not any(
-                    tip_state == TipRackWellState.USED for tip_state in wells.values()
+                    tip_state == _TipRackWellState.USED for tip_state in wells.values()
                 ):
                     return next(iter(wells))
 
@@ -403,29 +369,10 @@ class TipView:
                     wells = _drop_wells_before_starting_tip(wells, starting_tip_name)
 
                 for well_name, tip_state in wells.items():
-                    if tip_state == TipRackWellState.CLEAN:
+                    if tip_state == _TipRackWellState.CLEAN:
                         return well_name
         return None
 
-    def get_pipette_channels(self, pipette_id: str) -> int:
-        """Return the given pipette's number of channels."""
-        return self._state.pipette_info_by_pipette_id[pipette_id].channels
-
-    def get_pipette_active_channels(self, pipette_id: str) -> int:
-        """Get the number of channels being used in the given pipette's configuration."""
-        return self._state.pipette_info_by_pipette_id[pipette_id].active_channels
-
-    def get_pipette_nozzle_map(self, pipette_id: str) -> NozzleMap:
-        """Get the current nozzle map the given pipette's configuration."""
-        return self._state.pipette_info_by_pipette_id[pipette_id].nozzle_map
-
-    def get_pipette_nozzle_maps(self) -> Dict[str, NozzleMap]:
-        """Get current nozzle maps keyed by pipette id."""
-        return {
-            pipette_id: pipette_info.nozzle_map
-            for pipette_id, pipette_info in self._state.pipette_info_by_pipette_id.items()
-        }
-
     def has_clean_tip(self, labware_id: str, well_name: str) -> bool:
         """Get whether a well in a labware has a clean tip.
 
@@ -440,15 +387,31 @@ class TipView:
         tip_rack = self._state.tips_by_labware_id.get(labware_id)
         well_state = tip_rack.get(well_name) if tip_rack else None
 
-        return well_state == TipRackWellState.CLEAN
+        return well_state == _TipRackWellState.CLEAN
+
+    def compute_tips_to_mark_as_used(
+        self, labware_id: str, well_name: str, nozzle_map: NozzleMap
+    ) -> list[str]:
+        """Compute which tips a hypothetical tip pickup should mark as "used".
+
+        Params:
+            labware_id: The labware ID of the tip rack.
+            well_name: The single target well of the tip pickup.
+            nozzle_map: The nozzle configuration that the pipette will use for the pickup.
+
+        Returns:
+            The well names of all the tips that the operation will use.
+        """
+        columns = self._state.columns_by_labware_id.get(labware_id, [])
+        return list(wells_covered_dense(nozzle_map, well_name, columns))
 
 
 def _drop_wells_before_starting_tip(
-    wells: TipRackStateByWellName, starting_tip_name: str
-) -> TipRackStateByWellName:
+    wells: _TipRackStateByWellName, starting_tip_name: str
+) -> _TipRackStateByWellName:
     """Drop any wells that come before the starting tip and return the remaining ones after."""
     seen_starting_well = False
-    remaining_wells = {}
+    remaining_wells: dict[str, _TipRackWellState] = {}
     for well_name, tip_state in wells.items():
         if well_name == starting_tip_name:
             seen_starting_well = True

opentrons/protocol_engine/state/update_types.py

@@ -61,16 +61,6 @@ Unfortunately, mypy doesn't let us write `Literal[CLEAR]`. Use this instead.
 """
 
 
-class _SimulatedEnum(enum.Enum):
-    SIMULATED = enum.auto()
-
-
-SIMULATED: typing.Final = _SimulatedEnum.SIMULATED
-"""A sentinel value to indicate that a liquid probe return value is simulated.
-
-Useful to avoid throwing unnecessary errors in protocol analysis."""
-
-
 @dataclasses.dataclass(frozen=True)
 class Well:
     """Designates a well in a labware."""
@@ -127,6 +117,7 @@ class BatchLabwareLocationUpdate:
     """The new offsets of each id."""
 
 
+# todo(mm, 2025-04-28): Combine with BatchLoadedLabwareUpdate.
 @dataclasses.dataclass
 class LoadedLabwareUpdate:
     """An update that loads a new labware."""
@@ -250,16 +241,14 @@ class PipetteAspirateReadyUpdate:
 class TipsUsedUpdate:
     """Represents an update that marks tips in a tip rack as used."""
 
-    pipette_id: str
-    """The pipette that did the tip pickup."""
-
     labware_id: str
+    """The labware ID of the tip rack."""
 
-    well_name: str
-    """The well that the pipette's primary nozzle targeted.
+    well_names: list[str]
+    """The exact wells in the tip rack that should be marked as used.
 
-    Wells in addition to this one will also be marked as used, depending on the
-    pipette's nozzle layout.
+    This is the *full* list, which is probably more than what appeared in the pickUpTip
+    command's params, for multi-channel reasons.
     """
 
 
@@ -701,13 +690,9 @@ class StateUpdate:
         )
         return self
 
-    def mark_tips_as_used(
-        self: Self, pipette_id: str, labware_id: str, well_name: str
-    ) -> Self:
+    def mark_tips_as_used(self: Self, labware_id: str, well_names: list[str]) -> Self:
         """Mark tips in a tip rack as used. See `TipsUsedUpdate`."""
-        self.tips_used = TipsUsedUpdate(
-            pipette_id=pipette_id, labware_id=labware_id, well_name=well_name
-        )
+        self.tips_used = TipsUsedUpdate(labware_id=labware_id, well_names=well_names)
         return self
 
     def set_liquid_loaded(

opentrons/protocol_engine/types/liquid_level_detection.py

@@ -27,42 +27,102 @@ class SimulatedProbeResult(BaseModel):
         return data
 
     def __add__(
-        self, other: float | SimulatedProbeResult
+        self, other: float | int | SimulatedProbeResult
     ) -> float | SimulatedProbeResult:
         """Bypass addition and just return self."""
         return self
 
     def __sub__(
-        self, other: float | SimulatedProbeResult
+        self, other: float | int | SimulatedProbeResult
     ) -> float | SimulatedProbeResult:
         """Bypass subtraction and just return self."""
         return self
 
     def __radd__(
-        self, other: float | SimulatedProbeResult
+        self, other: float | int | SimulatedProbeResult
     ) -> float | SimulatedProbeResult:
         """Bypass addition and just return self."""
         return self
 
     def __rsub__(
-        self, other: float | SimulatedProbeResult
+        self, other: float | int | SimulatedProbeResult
     ) -> float | SimulatedProbeResult:
         """Bypass subtraction and just return self."""
         return self
 
-    def __gt__(self, other: float | SimulatedProbeResult) -> bool:
+    def __mul__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass multiplication and just return self."""
+        return self
+
+    def __rmul__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass multiplication and just return self."""
+        return self
+
+    def __truediv__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass division and just return self."""
+        return self
+
+    def __rtruediv__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass division and just return self."""
+        return self
+
+    def __pow__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass exponent math and just return self."""
+        return self
+
+    def __rpow__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass exponent math and just return self."""
+        return self
+
+    def __mod__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass modulus and just return self."""
+        return self
+
+    def __rmod__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass modulus and just return self."""
+        return self
+
+    def __floordiv__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass floor division and just return self."""
+        return self
+
+    def __rfloordiv__(
+        self, other: float | int | SimulatedProbeResult
+    ) -> float | SimulatedProbeResult:
+        """Bypass floor division and just return self."""
+        return self
+
+    def __gt__(self, other: float | int | SimulatedProbeResult) -> bool:
         """Bypass 'greater than' and just return self."""
         return True
 
-    def __lt__(self, other: float | SimulatedProbeResult) -> bool:
+    def __lt__(self, other: float | int | SimulatedProbeResult) -> bool:
         """Bypass 'less than' and just return self."""
         return False
 
-    def __ge__(self, other: float | SimulatedProbeResult) -> bool:
+    def __ge__(self, other: float | int | SimulatedProbeResult) -> bool:
         """Bypass 'greater than or eaqual to' and just return self."""
         return True
 
-    def __le__(self, other: float | SimulatedProbeResult) -> bool:
+    def __le__(self, other: float | int | SimulatedProbeResult) -> bool:
         """Bypass 'less than or equal to' and just return self."""
         return False
 

opentrons/protocol_runner/legacy_command_mapper.py

@@ -634,17 +634,24 @@ class LegacyCommandMapper:
         count = self._command_count["LOAD_LABWARE"]
         slot = labware_load_info.deck_slot
         location: pe_types.LabwareLocation
+        location_sequence: pe_types.LabwareLocationSequence = []
         if labware_load_info.on_module:
-            location = pe_types.ModuleLocation.model_construct(
-                moduleId=self._module_id_by_slot[slot]
+            module_id = self._module_id_by_slot[slot]
+            location = pe_types.ModuleLocation.model_construct(moduleId=module_id)
+            location_sequence.append(
+                pe_types.OnModuleLocationSequenceComponent(moduleId=module_id)
             )
         else:
             location = pe_types.DeckSlotLocation.model_construct(slotName=slot)
 
+        location_sequence.append(
+            pe_types.OnAddressableAreaLocationSequenceComponent(
+                addressableAreaName=slot.value
+            )
+        )
         command_id = f"commands.LOAD_LABWARE-{count}"
         labware_id = f"labware-{count}"
-
-        succeeded_command = pe_commands.LoadLabware.model_construct(
+        succeeded_command = pe_commands.LoadLabware(
             id=command_id,
             key=command_id,
             status=pe_commands.CommandStatus.SUCCEEDED,
@@ -665,8 +672,7 @@ class LegacyCommandMapper:
                     labware_load_info.labware_definition
                 ),
                 offsetId=labware_load_info.offset_id,
-                # These legacy json protocols don't get location sequences because
-                # to do so we'd have to go back and look up where the module gets loaded
+                locationSequence=location_sequence,
             ),
         )
         queue_action = pe_actions.QueueCommandAction(

opentrons/protocol_runner/run_orchestrator.py

@@ -429,7 +429,7 @@ class RunOrchestrator:
 
     def get_nozzle_maps(self) -> Mapping[str, NozzleMapInterface]:
         """Get current nozzle maps keyed by pipette id."""
-        return self._protocol_engine.state_view.tips.get_pipette_nozzle_maps()
+        return self._protocol_engine.state_view.pipettes.get_nozzle_configurations()
 
     def get_tip_attached(self) -> Dict[str, bool]:
         """Get current tip state keyed by pipette id."""

opentrons/protocols/advanced_control/transfers/common.py

@@ -1,7 +1,9 @@
 """Common functions between v1 transfer and liquid-class-based transfer."""
 import enum
 import math
-from typing import Iterable, Generator, Tuple, TypeVar, Literal, List
+from typing import Iterable, Generator, Tuple, TypeVar, Literal, List, Union
+
+from opentrons.protocol_api._liquid_properties import LiquidHandlingPropertyByVolume
 
 
 class NoLiquidClassPropertyError(ValueError):
@@ -13,9 +15,12 @@ class TransferTipPolicyV2(enum.Enum):
     NEVER = "never"
     ALWAYS = "always"
     PER_SOURCE = "per source"
+    PER_DESTINATION = "per destination"
 
 
-TransferTipPolicyV2Type = Literal["once", "always", "per source", "never"]
+TransferTipPolicyV2Type = Literal[
+    "once", "always", "per source", "never", "per destination"
+]
 
 Target = TypeVar("Target")
 
@@ -39,18 +44,24 @@ def check_valid_volume_parameters(
 
 
 def check_valid_liquid_class_volume_parameters(
-    aspirate_volume: float, air_gap: float, disposal_volume: float, max_volume: float
+    aspirate_volume: float,
+    air_gap: float,
+    max_volume: float,
+    current_volume: float,
 ) -> None:
-    if air_gap + aspirate_volume > max_volume:
+    if (
+        current_volume != 0.0
+        and air_gap + aspirate_volume + current_volume > max_volume
+    ):
         raise ValueError(
-            f"Cannot have an air gap of {air_gap} µL for an aspiration of {aspirate_volume} µL"
-            f" with a max volume of {max_volume} µL. Please adjust the retract air gap to fit within"
-            f" the bounds of the tip."
+            f"Cannot have an air gap of {air_gap} µL for an aspiration of {aspirate_volume} µL with"
+            f" a max volume of {max_volume} µL when {current_volume} µL has already been aspirated."
+            f" Please adjust the retract air gap to fit within the bounds of the tip."
         )
-    elif disposal_volume + aspirate_volume > max_volume:
+    elif air_gap + aspirate_volume > max_volume:
         raise ValueError(
-            f"Cannot have a dispense volume of {disposal_volume} µL for an aspiration of {aspirate_volume} µL"
-            f" with a max volume of {max_volume} µL. Please adjust the dispense volume to fit within"
+            f"Cannot have an air gap of {air_gap} µL for an aspiration of {aspirate_volume} µL"
+            f" with a max volume of {max_volume} µL. Please adjust the retract air gap to fit within"
             f" the bounds of the tip."
         )
 
@@ -95,9 +106,41 @@ def expand_for_volume_constraints_for_liquid_classes(
     volumes: Iterable[float],
     targets: Iterable[Target],
     max_volume: float,
+    air_gap: Union[LiquidHandlingPropertyByVolume, float],
+    disposal_vol: Union[LiquidHandlingPropertyByVolume, float] = 0.0,
+    conditioning_vol: Union[LiquidHandlingPropertyByVolume, float] = 0.0,
 ) -> Generator[Tuple[float, "Target"], None, None]:
     """Split a sequence of proposed transfers to keep each under the max volume, splitting larger ones equally."""
     assert max_volume > 0
     for volume, target in zip(volumes, targets):
-        for split_volume in _split_volume_equally(volume, max_volume):
+        disposal_volume = (
+            disposal_vol
+            if isinstance(disposal_vol, float)
+            else disposal_vol.get_for_volume(volume)
+        )
+        air_gap_volume = (
+            air_gap
+            if isinstance(air_gap, float)
+            else air_gap.get_for_volume(volume + disposal_volume)
+        )
+        conditioning_volume = (
+            conditioning_vol
+            if isinstance(conditioning_vol, float)
+            else conditioning_vol.get_for_volume(volume)
+        )
+        # If there is conditioning volume in a multi-aspirate, it will negate the air gap
+        if conditioning_volume > 0:
+            air_gap_volume = 0
+        adjusted_max_volume = (
+            max_volume - air_gap_volume - disposal_volume - conditioning_volume
+        )
+        if adjusted_max_volume <= 0:
+            error_text = f"Pipette cannot aspirate {volume} µL when pipette will need {air_gap_volume} µL for air gap"
+            if disposal_volume:
+                error_text += f", {disposal_volume} for disposal volume"
+            if conditioning_volume:
+                error_text += f", {conditioning_volume} for conditioning volume"
+            error_text += f" with a max volume of {max_volume} µL."
+            raise ValueError(error_text)
+        for split_volume in _split_volume_equally(volume, adjusted_max_volume):
             yield split_volume, target