opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/update_types.py

@@ -1,5 +1,7 @@
 """Structures to represent changes that commands want to make to engine state."""
 
+from __future__ import annotations
+
 import dataclasses
 import enum
 import typing
@@ -16,6 +18,7 @@ from opentrons.protocol_engine.types import (
     AspiratedFluid,
     LiquidClassRecord,
     ABSMeasureMode,
+    LiquidTrackingType,
 )
 from opentrons.types import MountType
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
@@ -58,6 +61,16 @@ 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."""
@@ -104,6 +117,16 @@ class LabwareLocationUpdate:
     """The ID of the labware's new offset, for its new location."""
 
 
+@dataclasses.dataclass
+class BatchLabwareLocationUpdate:
+    """An update to the locations of multiple labware."""
+
+    new_locations_by_id: dict[str, LabwareLocation]
+    """The new locations of each ID."""
+    new_offset_ids_by_id: dict[str, str | None]
+    """The new offsets of each id."""
+
+
 @dataclasses.dataclass
 class LoadedLabwareUpdate:
     """An update that loads a new labware."""
@@ -122,6 +145,23 @@ class LoadedLabwareUpdate:
     definition: LabwareDefinition
 
 
+@dataclasses.dataclass
+class BatchLoadedLabwareUpdate:
+    """An update that loads multiple new labware."""
+
+    new_locations_by_id: typing.Dict[str, LabwareLocation]
+    """Each new labwares's initial location keyed by Labware ID."""
+
+    offset_ids_by_id: typing.Dict[str, str | None]
+    """The ID of each labware's offset keyed by labware ID."""
+
+    display_names_by_id: typing.Dict[str, str | None]
+    """The Display Name for each new labware keyed by labware ID"""
+
+    definitions_by_id: typing.Dict[str, LabwareDefinition]
+    """The Labware Definition for each labware keyed by Labware ID."""
+
+
 @dataclasses.dataclass
 class LoadedLidStackUpdate:
     """An update that loads a new lid stack."""
@@ -135,13 +175,10 @@ class LoadedLidStackUpdate:
     stack_location: LabwareLocation
     "The initial location of the Lid Stack Object."
 
-    labware_ids: typing.List[str]
-    """The unique IDs of the new lids."""
-
     new_locations_by_id: typing.Dict[str, OnLabwareLocation]
     """Each lid's initial location keyed by Labware ID."""
 
-    definition: LabwareDefinition
+    definition: LabwareDefinition | None
     "The Labware Definition of the Lid Labware(s) loaded."
 
 
@@ -149,10 +186,10 @@ class LoadedLidStackUpdate:
 class LabwareLidUpdate:
     """An update that identifies a lid on a given parent labware."""
 
-    parent_labware_id: str
-    """The unique ID of the parent labware."""
+    parent_labware_ids: typing.List[str]
+    """The unique IDs of the parent labwares."""
 
-    lid_id: str
+    lid_ids: typing.List[str | None]
     """The unique IDs of the new lids."""
 
 
@@ -201,6 +238,14 @@ class PipetteTipStateUpdate:
     tip_geometry: TipGeometry | None
 
 
+@dataclasses.dataclass
+class PipetteAspirateReadyUpdate:
+    """Update pipette ready state."""
+
+    pipette_id: str
+    ready_to_aspirate: bool
+
+
 @dataclasses.dataclass
 class TipsUsedUpdate:
     """Represents an update that marks tips in a tip rack as used."""
@@ -234,8 +279,8 @@ class LiquidProbedUpdate:
     labware_id: str
     well_name: str
     last_probed: datetime
-    height: float | ClearType
-    volume: float | ClearType
+    height: LiquidTrackingType | ClearType
+    volume: LiquidTrackingType | ClearType
 
 
 @dataclasses.dataclass
@@ -278,6 +323,7 @@ class PipetteEmptyFluidUpdate:
     """Sets the pipette to be valid and empty."""
 
     pipette_id: str
+    clean_tip: bool
     type: typing.Literal["empty"] = "empty"
 
 
@@ -311,9 +357,40 @@ class AbsorbanceReaderStateUpdate:
     module_id: str
     absorbance_reader_lid: AbsorbanceReaderLidUpdate | NoChangeType = NO_CHANGE
     absorbance_reader_data: AbsorbanceReaderDataUpdate | NoChangeType = NO_CHANGE
-    initialize_absorbance_reader_update: AbsorbanceReaderInitializeUpdate | NoChangeType = (
-        NO_CHANGE
-    )
+    initialize_absorbance_reader_update: (
+        AbsorbanceReaderInitializeUpdate | NoChangeType
+    ) = NO_CHANGE
+
+
+@dataclasses.dataclass
+class FlexStackerPoolConstraint:
+    """The labware definitions that are contained in the pool."""
+
+    max_pool_count: int
+    primary_definition: LabwareDefinition
+    lid_definition: LabwareDefinition | None
+    adapter_definition: LabwareDefinition | None
+
+
+@dataclasses.dataclass
+class FlexStackerStateUpdate:
+    """An update to the Flex Stacker module state."""
+
+    module_id: str
+    pool_constraint: FlexStackerPoolConstraint | NoChangeType = NO_CHANGE
+    pool_count: int | NoChangeType = NO_CHANGE
+
+    @classmethod
+    def create_or_override(
+        cls,
+        maybe_inst: FlexStackerStateUpdate | NoChangeType,
+        module_id: str,
+    ) -> FlexStackerStateUpdate:
+        """Build or default a state update."""
+        if maybe_inst == NO_CHANGE:
+            return FlexStackerStateUpdate(module_id=module_id)
+        else:
+            return maybe_inst
 
 
 @dataclasses.dataclass
@@ -362,8 +439,12 @@ class StateUpdate:
 
     labware_location: LabwareLocationUpdate | NoChangeType = NO_CHANGE
 
+    batch_labware_location: BatchLabwareLocationUpdate | NoChangeType = NO_CHANGE
+
     loaded_labware: LoadedLabwareUpdate | NoChangeType = NO_CHANGE
 
+    batch_loaded_labware: BatchLoadedLabwareUpdate | NoChangeType = NO_CHANGE
+
     loaded_lid_stack: LoadedLidStackUpdate | NoChangeType = NO_CHANGE
 
     labware_lid: LabwareLidUpdate | NoChangeType = NO_CHANGE
@@ -380,12 +461,16 @@ class StateUpdate:
         NO_CHANGE
     )
 
+    flex_stacker_state_update: FlexStackerStateUpdate | NoChangeType = NO_CHANGE
+
     liquid_class_loaded: LiquidClassLoadedUpdate | NoChangeType = NO_CHANGE
 
     files_added: FilesAddedUpdate | NoChangeType = NO_CHANGE
 
     addressable_area_used: AddressableAreaUsedUpdate | NoChangeType = NO_CHANGE
 
+    ready_to_aspirate: PipetteAspirateReadyUpdate | NoChangeType = NO_CHANGE
+
     def append(self, other: Self) -> Self:
         """Apply another `StateUpdate` "on top of" this one.
 
@@ -493,6 +578,19 @@ class StateUpdate:
         )
         return self
 
+    def set_batch_labware_location(
+        self: Self,
+        *,
+        new_locations_by_id: typing.Dict[str, LabwareLocation],
+        new_offset_ids_by_id: typing.Dict[str, str | None],
+    ) -> Self:
+        """Update the location of multiple labware objects."""
+        self.batch_labware_location = BatchLabwareLocationUpdate(
+            new_locations_by_id=new_locations_by_id,
+            new_offset_ids_by_id=new_offset_ids_by_id,
+        )
+        return self
+
     def set_loaded_labware(
         self: Self,
         definition: LabwareDefinition,
@@ -511,14 +609,29 @@ class StateUpdate:
         )
         return self
 
+    def set_batch_loaded_labware(
+        self: Self,
+        definitions_by_id: typing.Dict[str, LabwareDefinition],
+        offset_ids_by_id: typing.Dict[str, str | None],
+        display_names_by_id: typing.Dict[str, str | None],
+        new_locations_by_id: typing.Dict[str, LabwareLocation],
+    ) -> Self:
+        """Add a set of new labwares to state. See `BatchLoadedLabwareUpdate`."""
+        self.batch_loaded_labware = BatchLoadedLabwareUpdate(
+            new_locations_by_id=new_locations_by_id,
+            offset_ids_by_id=offset_ids_by_id,
+            display_names_by_id=display_names_by_id,
+            definitions_by_id=definitions_by_id,
+        )
+        return self
+
     def set_loaded_lid_stack(
         self: Self,
         stack_id: str,
         stack_object_definition: LabwareDefinition,
         stack_location: LabwareLocation,
-        labware_definition: LabwareDefinition,
-        labware_ids: typing.List[str],
         locations: typing.Dict[str, OnLabwareLocation],
+        labware_definition: LabwareDefinition | None,
     ) -> Self:
         """Add a new lid stack to state. See `LoadedLidStackUpdate`."""
         self.loaded_lid_stack = LoadedLidStackUpdate(
@@ -526,20 +639,19 @@ class StateUpdate:
             stack_object_definition=stack_object_definition,
             stack_location=stack_location,
             definition=labware_definition,
-            labware_ids=labware_ids,
             new_locations_by_id=locations,
         )
         return self
 
-    def set_lid(
+    def set_lids(
         self: Self,
-        parent_labware_id: str,
-        lid_id: str,
+        parent_labware_ids: typing.List[str],
+        lid_ids: typing.List[str | None],
     ) -> Self:
         """Update the labware parent of a loaded or moved lid. See `LabwareLidUpdate`."""
         self.labware_lid = LabwareLidUpdate(
-            parent_labware_id=parent_labware_id,
-            lid_id=lid_id,
+            parent_labware_ids=parent_labware_ids,
+            lid_ids=lid_ids,
         )
         return self
 
@@ -617,8 +729,8 @@ class StateUpdate:
         labware_id: str,
         well_name: str,
         last_probed: datetime,
-        height: float | ClearType,
-        volume: float | ClearType,
+        height: LiquidTrackingType | ClearType,
+        volume: LiquidTrackingType | ClearType,
     ) -> Self:
         """Add a liquid height and volume to well state. See `ProbeLiquidUpdate`."""
         self.liquid_probed = LiquidProbedUpdate(
@@ -665,10 +777,10 @@ class StateUpdate:
         )
         return self
 
-    def set_fluid_empty(self: Self, pipette_id: str) -> Self:
-        """Update record fo fluid held inside a pipette. See `PipetteEmptyFluidUpdate`."""
+    def set_fluid_empty(self: Self, pipette_id: str, clean_tip: bool = False) -> Self:
+        """Update record of fluid held inside a pipette. See `PipetteEmptyFluidUpdate`."""
         self.pipette_aspirated_fluid = PipetteEmptyFluidUpdate(
-            type="empty", pipette_id=pipette_id
+            type="empty", pipette_id=pipette_id, clean_tip=clean_tip
         )
         return self
 
@@ -717,3 +829,46 @@ class StateUpdate:
             addressable_area_name=addressable_area_name
         )
         return self
+
+    def update_flex_stacker_labware_pool_definition(
+        self,
+        module_id: str,
+        max_count: int,
+        primary_definition: LabwareDefinition,
+        adapter_definition: LabwareDefinition | None,
+        lid_definition: LabwareDefinition | None,
+    ) -> Self:
+        """Constrain the labware pool to a specific definition."""
+        self.flex_stacker_state_update = dataclasses.replace(
+            FlexStackerStateUpdate.create_or_override(
+                self.flex_stacker_state_update, module_id
+            ),
+            pool_constraint=FlexStackerPoolConstraint(
+                max_pool_count=max_count,
+                primary_definition=primary_definition,
+                lid_definition=lid_definition,
+                adapter_definition=adapter_definition,
+            ),
+        )
+        return self
+
+    def update_flex_stacker_labware_pool_count(
+        self, module_id: str, count: int
+    ) -> Self:
+        """Set the labware pool to a specific count."""
+        self.flex_stacker_state_update = dataclasses.replace(
+            FlexStackerStateUpdate.create_or_override(
+                self.flex_stacker_state_update, module_id
+            ),
+            pool_count=count,
+        )
+        return self
+
+    def set_pipette_ready_to_aspirate(
+        self, pipette_id: str, ready_to_aspirate: bool
+    ) -> Self:
+        """Set the ready to aspirate state for a pipette."""
+        self.ready_to_aspirate = PipetteAspirateReadyUpdate(
+            pipette_id=pipette_id, ready_to_aspirate=ready_to_aspirate
+        )
+        return self

opentrons/protocol_engine/state/wells.py

@@ -1,7 +1,16 @@
 """Basic well data state and store."""
 
 from dataclasses import dataclass
-from typing import Dict, List, Union, Iterator, Optional, Tuple, overload, TypeVar
+from typing import (
+    Dict,
+    List,
+    Union,
+    Iterator,
+    Optional,
+    Tuple,
+    overload,
+)
+from datetime import datetime
 
 from opentrons.protocol_engine.types import (
     ProbedHeightInfo,
@@ -10,6 +19,10 @@ from opentrons.protocol_engine.types import (
     WellInfoSummary,
     WellLiquidInfo,
 )
+from opentrons.protocol_engine.types.liquid_level_detection import (
+    SimulatedProbeResult,
+    LiquidTrackingType,
+)
 
 from . import update_types
 from ._abstract_store import HasState, HandlesActions
@@ -103,7 +116,7 @@ class WellStore(HasState[WellState], HandlesActions):
                 del self._state.loaded_volumes[labware_id][well_name]
             else:
                 prev_loaded_vol_info = self._state.loaded_volumes[labware_id][well_name]
-                assert prev_loaded_vol_info.volume is not None
+                assert prev_loaded_vol_info.volume is not None, "volume info not loaded"
                 self._state.loaded_volumes[labware_id][well_name] = LoadedVolumeInfo(
                     volume=prev_loaded_vol_info.volume + volume_added,
                     last_loaded=prev_loaded_vol_info.last_loaded,
@@ -119,13 +132,28 @@ class WellStore(HasState[WellState], HandlesActions):
             labware_id in self._state.probed_volumes
             and well_name in self._state.probed_volumes[labware_id]
         ):
+            prev_probed_vol_info = self._state.probed_volumes[labware_id][well_name]
             if volume_added is update_types.CLEAR:
                 del self._state.probed_volumes[labware_id][well_name]
+            elif isinstance(
+                prev_probed_vol_info.volume,
+                SimulatedProbeResult,
+            ):
+                prev_probed_vol_info.volume.simulate_probed_aspirate_dispense(
+                    volume_added
+                )
+                self._state.probed_volumes[labware_id][well_name] = ProbedVolumeInfo(
+                    volume=prev_probed_vol_info.volume,
+                    last_probed=prev_probed_vol_info.last_probed,
+                    operations_since_probe=prev_probed_vol_info.operations_since_probe
+                    + 1,
+                )
+                return
             else:
-                prev_probed_vol_info = self._state.probed_volumes[labware_id][well_name]
                 if prev_probed_vol_info.volume is None:
                     new_vol_info: float | None = None
                 else:
+                    assert isinstance(prev_probed_vol_info.volume, float)
                     new_vol_info = prev_probed_vol_info.volume + volume_added
                 self._state.probed_volumes[labware_id][well_name] = ProbedVolumeInfo(
                     volume=new_vol_info,
@@ -177,6 +205,22 @@ class WellView:
             probed_volume=probed_volume_info,
         )
 
+    def get_last_liquid_update(
+        self, labware_id: str, well_name: str
+    ) -> Optional[datetime]:
+        """Return the timestamp of the last load or probe done on the well."""
+        info = self.get_well_liquid_info(labware_id, well_name)
+        update_times: List[datetime] = []
+        if info.loaded_volume is not None and info.loaded_volume.volume is not None:
+            update_times.append(info.loaded_volume.last_loaded)
+        if info.probed_height is not None and info.probed_height.height is not None:
+            update_times.append(info.probed_height.last_probed)
+        if info.probed_volume is not None and info.probed_volume.volume is not None:
+            update_times.append(info.probed_volume.last_probed)
+        if len(update_times) > 0:
+            return max(update_times)
+        return None
+
     def get_all(self) -> List[WellInfoSummary]:
         """Get all well liquid info summaries."""
 
@@ -223,22 +267,24 @@ def _volume_from_info(info: Optional[LoadedVolumeInfo]) -> Optional[float]:
 
 def _volume_from_info(
     info: Union[ProbedVolumeInfo, LoadedVolumeInfo, None],
-) -> Optional[float]:
+) -> Union[LiquidTrackingType, None]:
     if info is None:
         return None
     return info.volume
 
 
-def _height_from_info(info: Optional[ProbedHeightInfo]) -> Optional[float]:
+def _height_from_info(
+    info: Optional[ProbedHeightInfo],
+) -> Union[LiquidTrackingType, None]:
     if info is None:
         return None
     return info.height
 
 
-MaybeClear = TypeVar("MaybeClear")
-
-
-def _none_from_clear(inval: MaybeClear | update_types.ClearType) -> MaybeClear | None:
+def _none_from_clear(
+    inval: LiquidTrackingType | update_types.ClearType,
+) -> LiquidTrackingType | None:
     if inval == update_types.CLEAR:
         return None
+    assert isinstance(inval, (SimulatedProbeResult, float, int))
     return inval