opentrons 8.3.1a1__py2.py3-none-any.whl → 8.4.0a1__py2.py3-none-any.whl

opentrons/protocol_api/core/legacy/load_info.py

@@ -7,7 +7,7 @@ It's only for internal Opentrons use.
 
 from dataclasses import dataclass
 from typing import Optional, Union
-from opentrons_shared_data.labware.types import LabwareDefinition
+from opentrons_shared_data.labware.types import LabwareDefinition2
 
 from opentrons.hardware_control.dev_types import PipetteDict
 from opentrons.hardware_control.modules.types import ModuleModel
@@ -18,13 +18,11 @@ from opentrons.types import Mount, DeckSlotName
 class LabwareLoadInfo:
     """Information about a successful labware load.
 
-    :meta private:
-
     This is a separate class from the main user-facing `Labware` class
     because this is easier to construct in unit tests.
     """
 
-    labware_definition: LabwareDefinition
+    labware_definition: LabwareDefinition2
 
     # todo(mm, 2021-10-11): Namespace, load name, and version can be derived from the
     # definition. Should they be removed from here?
@@ -47,10 +45,7 @@ class LabwareLoadInfo:
 
 @dataclass(frozen=True)
 class InstrumentLoadInfo:
-    """Like `LabwareLoadInfo`, but for instruments (pipettes).
-
-    :meta private:
-    """
+    """Like `LabwareLoadInfo`, but for instruments (pipettes)."""
 
     instrument_load_name: str
     mount: Mount
@@ -59,10 +54,7 @@ class InstrumentLoadInfo:
 
 @dataclass(frozen=True)
 class ModuleLoadInfo:
-    """Like `LabwareLoadInfo`, but for hardware modules.
-
-    :meta private:
-    """
+    """Like `LabwareLoadInfo`, but for hardware modules."""
 
     requested_model: ModuleModel
     loaded_model: ModuleModel

opentrons/protocol_api/core/legacy/module_geometry.py

@@ -273,8 +273,13 @@ class ThermocyclerGeometry(ModuleGeometry):
             LegacyLabwareCore,
         )
 
-        # Block first three columns from being accessed
         definition = labware._core.get_definition()
+
+        # For type checking. This should always pass because
+        # opentrons.protocol_api.core.legacy should only load labware with schema 2.
+        assert definition["schemaVersion"] == 2
+
+        # Block first three columns from being accessed
         definition["ordering"] = definition["ordering"][2::]
         return Labware(
             core=LegacyLabwareCore(definition, super().location),

opentrons/protocol_api/core/legacy/well_geometry.py

@@ -4,9 +4,9 @@ from typing import Optional, cast, TYPE_CHECKING
 
 from opentrons.types import Point
 from opentrons_shared_data.labware.types import (
-    WellDefinition,
-    CircularWellDefinition,
-    RectangularWellDefinition,
+    WellDefinition2 as WellDefinition,
+    CircularWellDefinition2 as CircularWellDefinition,
+    RectangularWellDefinition2 as RectangularWellDefinition,
 )
 
 if TYPE_CHECKING:

opentrons/protocol_api/core/legacy_simulator/legacy_instrument_core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Optional, Union, List
+from typing import TYPE_CHECKING, Optional, Union, List, Tuple
 
 from opentrons import types
 from opentrons.hardware_control.dev_types import PipetteDict
@@ -23,6 +23,9 @@ from opentrons_shared_data.errors.exceptions import (
     UnexpectedTipAttachError,
 )
 
+from opentrons.protocol_engine.types.liquid_level_detection import LiquidTrackingType
+
+from ..legacy.legacy_labware_core import LegacyLabwareCore
 from ...disposal_locations import TrashBin, WasteChute
 from opentrons.protocol_api._nozzle_layout import NozzleLayout
 from opentrons.protocol_api._liquid import LiquidClass
@@ -42,7 +45,9 @@ _PRE_2_2_TIP_DROP_HEIGHT_MM = 10
 """In PAPIv2.1 and below, tips are always dropped 10 mm from the bottom of the well."""
 
 
-class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
+class LegacyInstrumentCoreSimulator(
+    AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
+):
     """A simulation of an instrument context."""
 
     def __init__(
@@ -84,7 +89,9 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
     def set_default_speed(self, speed: float) -> None:
         self._default_speed = speed
 
-    def air_gap_in_place(self, volume: float, flow_rate: float) -> None:
+    def air_gap_in_place(
+        self, volume: float, flow_rate: float, correction_volume: Optional[float] = None
+    ) -> None:
         assert False, "Air gap tracking only available in API version 2.22 and later"
 
     def aspirate(
@@ -95,7 +102,8 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
         rate: float,
         flow_rate: float,
         in_place: bool,
-        is_meniscus: Optional[bool] = None,
+        meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        correction_volume: Optional[float] = None,
     ) -> None:
         if self.get_current_volume() == 0:
             # Make sure we're at the top of the labware and clear of any
@@ -137,7 +145,8 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
         flow_rate: float,
         in_place: bool,
         push_out: Optional[float],
-        is_meniscus: Optional[bool] = None,
+        meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        correction_volume: Optional[float] = None,
     ) -> None:
         if isinstance(location, (TrashBin, WasteChute)):
             raise APIVersionError(
@@ -177,7 +186,10 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
         radius: float,
         z_offset: float,
         speed: float,
+        mm_from_edge: Optional[float] = None,
     ) -> None:
+        if mm_from_edge is not None:
+            raise APIVersionError(api_element="mm_from_edge argument")
         self.move_to(location)
 
     def pick_up_tip(
@@ -365,6 +377,9 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
     def get_current_volume(self) -> float:
         return self._pipette_dict["current_volume"]
 
+    def get_has_clean_tip(self) -> bool:
+        return False
+
     def get_available_volume(self) -> float:
         return self._pipette_dict["available_volume"]
 
@@ -498,28 +513,47 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
         """This will never be called because it was added in API 2.15."""
         pass
 
-    def load_liquid_class(
+    def transfer_liquid(
         self,
         liquid_class: LiquidClass,
-        pipette_load_name: str,
-        tiprack_uri: str,
-    ) -> str:
-        """This will never be called because it was added in .."""
-        # TODO(spp, 2024-11-20): update the docstring and error to include API version
-        assert False, "load_liquid_class is not supported in legacy context"
+        volume: float,
+        source: List[Tuple[types.Location, LegacyWellCore]],
+        dest: List[Tuple[types.Location, LegacyWellCore]],
+        new_tip: TransferTipPolicyV2,
+        tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
+    ) -> None:
+        """This will never be called because it was added in API 2.23."""
+        assert False, "transfer_liquid is not supported in legacy context"
 
-    def transfer_liquid(
+    def distribute_liquid(
         self,
-        liquid_class_id: str,
+        liquid_class: LiquidClass,
         volume: float,
-        source: List[LegacyWellCore],
-        dest: List[LegacyWellCore],
+        source: Tuple[types.Location, LegacyWellCore],
+        dest: List[Tuple[types.Location, LegacyWellCore]],
         new_tip: TransferTipPolicyV2,
-        trash_location: Union[LegacyWellCore, types.Location, TrashBin, WasteChute],
+        tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
     ) -> None:
-        """Transfer a liquid from source to dest according to liquid class properties."""
-        # TODO(spp, 2024-11-20): update the docstring and error to include API version
-        assert False, "transfer_liquid is not supported in legacy context"
+        """This will never be called because it was added in API 2.23."""
+        assert False, "distribute_liquid is not supported in legacy context"
+
+    def consolidate_liquid(
+        self,
+        liquid_class: LiquidClass,
+        volume: float,
+        source: List[Tuple[types.Location, LegacyWellCore]],
+        dest: Tuple[types.Location, LegacyWellCore],
+        new_tip: TransferTipPolicyV2,
+        tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
+    ) -> None:
+        """This will never be called because it was added in API 2.23."""
+        assert False, "consolidate_liquid is not supported in legacy context"
 
     def get_active_channels(self) -> int:
         """This will never be called because it was added in API 2.16."""
@@ -549,7 +583,7 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
 
     def liquid_probe_without_recovery(
         self, well_core: WellCore, loc: types.Location
-    ) -> float:
+    ) -> LiquidTrackingType:
         """This will never be called because it was added in API 2.20."""
         assert False, "liquid_probe_without_recovery only supported in API 2.20 & later"
 
@@ -559,3 +593,15 @@ class LegacyInstrumentCoreSimulator(AbstractInstrument[LegacyWellCore]):
     def nozzle_configuration_valid_for_lld(self) -> bool:
         """Check if the nozzle configuration currently supports LLD."""
         return False
+
+    def get_minimum_liquid_sense_height(self) -> float:
+        return 0.0
+
+    def estimate_liquid_height(
+        self,
+        well_core: LegacyWellCore,
+        starting_liquid_height: float,
+        operation_volume: float,
+    ) -> float:
+        """This will never be called because it was added in API 2.21."""
+        assert False, "estimate_liquid_height only supported in API 2.21 & later"

opentrons/protocol_api/core/module.py

@@ -1,4 +1,5 @@
 """Core module control interfaces."""
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
@@ -379,3 +380,45 @@ class AbstractAbsorbanceReaderCore(AbstractModuleCore):
     @abstractmethod
     def is_lid_on(self) -> bool:
         """Return True if the Absorbance Reader's lid is currently closed."""
+
+
+class AbstractFlexStackerCore(AbstractModuleCore):
+    """Core control interface for an attached Flex Stacker."""
+
+    MODULE_TYPE: ClassVar = ModuleType.FLEX_STACKER
+
+    @abstractmethod
+    def get_serial_number(self) -> str:
+        """Get the module's unique hardware serial number."""
+
+    @abstractmethod
+    def retrieve(self) -> None:
+        """Release a labware from the hopper to the staging slot."""
+
+    @abstractmethod
+    def store(self) -> None:
+        """Store a labware in the stacker hopper."""
+
+    @abstractmethod
+    def fill(self, message: str, count: int | None) -> None:
+        """Pause the protocol to allow for filling the stacker."""
+
+    @abstractmethod
+    def empty(self, message: str) -> None:
+        """Pause the protocol to allow for emptying the stacker."""
+
+    @abstractmethod
+    def set_stored_labware(
+        self,
+        main_load_name: str,
+        main_namespace: str | None,
+        main_version: int | None,
+        lid_load_name: str | None,
+        lid_namespace: str | None,
+        lid_version: int | None,
+        adapter_load_name: str | None,
+        adapter_namespace: str | None,
+        adapter_version: int | None,
+        count: int | None,
+    ) -> None:
+        """Configure the kind of labware that the stacker stores."""

opentrons/protocol_api/core/protocol.py

@@ -111,6 +111,20 @@ class AbstractProtocol(
         """Load an individual lid labware using its identifying parameters. Must be loaded on a labware."""
         ...
 
+    @abstractmethod
+    def load_labware_to_flex_stacker_hopper(
+        self,
+        module_core: ModuleCoreType,
+        load_name: str,
+        quantity: int,
+        label: Optional[str],
+        namespace: Optional[str],
+        version: Optional[int],
+        lid: Optional[str],
+    ) -> None:
+        """Load one or more labware with or without a lid to the flex stacker hopper."""
+        ...
+
     @abstractmethod
     def move_labware(
         self,
@@ -131,6 +145,25 @@ class AbstractProtocol(
     ) -> None:
         ...
 
+    @abstractmethod
+    def move_lid(
+        self,
+        source_location: Union[DeckSlotName, StagingSlotName, LabwareCoreType],
+        new_location: Union[
+            DeckSlotName,
+            StagingSlotName,
+            LabwareCoreType,
+            OffDeckType,
+            WasteChute,
+            TrashBin,
+        ],
+        use_gripper: bool,
+        pause_for_manual_move: bool,
+        pick_up_offset: Optional[Tuple[float, float, float]],
+        drop_offset: Optional[Tuple[float, float, float]],
+    ) -> LabwareCoreType | None:
+        ...
+
     @abstractmethod
     def load_module(
         self,

opentrons/protocol_api/core/well.py

@@ -1,9 +1,10 @@
 """Abstract interface for Well core implementations."""
 
 from abc import ABC, abstractmethod
-from typing import TypeVar, Optional
+from typing import TypeVar, Optional, Union
 
 from opentrons.types import Point
+from opentrons.protocol_engine.types.liquid_level_detection import LiquidTrackingType
 
 from .._liquid import Liquid
 
@@ -71,6 +72,10 @@ class AbstractWellCore(ABC):
     def get_center(self) -> Point:
         """Get the coordinate of the well's center."""
 
+    @abstractmethod
+    def get_meniscus(self) -> Union[Point, LiquidTrackingType]:
+        """Get the coordinate of the well's meniscus."""
+
     @abstractmethod
     def load_liquid(
         self,
@@ -83,5 +88,20 @@ class AbstractWellCore(ABC):
     def from_center_cartesian(self, x: float, y: float, z: float) -> Point:
         """Gets point in deck coordinates based on percentage of the radius of each axis."""
 
+    @abstractmethod
+    def estimate_liquid_height_after_pipetting(
+        self,
+        operation_volume: float,
+    ) -> LiquidTrackingType:
+        """Estimate what the liquid height will be after pipetting, without raising an error."""
+
+    @abstractmethod
+    def current_liquid_height(self) -> LiquidTrackingType:
+        """Get the current liquid height."""
+
+    @abstractmethod
+    def get_liquid_volume(self) -> LiquidTrackingType:
+        """Get the current volume within a well."""
+
 
 WellCoreType = TypeVar("WellCoreType", bound=AbstractWellCore)