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

opentrons/protocol_api/core/engine/well.py

@@ -1,13 +1,18 @@
 """ProtocolEngine-based Well core implementations."""
-from typing import Optional
+from typing import Optional, Union
 
 from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 
+from opentrons.types import Point
+
 from opentrons.protocol_engine import WellLocation, WellOrigin, WellOffset
 from opentrons.protocol_engine import commands as cmd
 from opentrons.protocol_engine.clients import SyncClient as EngineClient
 from opentrons.protocols.api_support.util import UnsupportedAPIError
-from opentrons.types import Point
+from opentrons.protocol_engine.types.liquid_level_detection import (
+    SimulatedProbeResult,
+    LiquidTrackingType,
+)
 
 from . import point_calculations
 from . import stringify
@@ -44,17 +49,27 @@ class WellCore(AbstractWellCore):
     @property
     def diameter(self) -> Optional[float]:
         """Get the well's diameter, if circular."""
-        return self._definition.diameter
+        return (
+            self._definition.diameter if self._definition.shape == "circular" else None
+        )
 
     @property
     def length(self) -> Optional[float]:
         """Get the well's length, if rectangular."""
-        return self._definition.xDimension
+        return (
+            self._definition.xDimension
+            if self._definition.shape == "rectangular"
+            else None
+        )
 
     @property
     def width(self) -> Optional[float]:
         """Get the well's width, if rectangular."""
-        return self._definition.yDimension
+        return (
+            self._definition.yDimension
+            if self._definition.shape == "rectangular"
+            else None
+        )
 
     @property
     def depth(self) -> float:
@@ -125,6 +140,14 @@ class WellCore(AbstractWellCore):
             well_location=WellLocation(origin=WellOrigin.CENTER),
         )
 
+    def get_meniscus(self) -> Union[Point, SimulatedProbeResult]:
+        """Get the coordinate of the well's meniscus."""
+        current_liquid_height = self.current_liquid_height()
+        if isinstance(current_liquid_height, float):
+            return self.get_bottom(z_offset=current_liquid_height)
+        else:
+            return current_liquid_height
+
     def load_liquid(
         self,
         liquid: Liquid,
@@ -155,3 +178,35 @@ class WellCore(AbstractWellCore):
             y_ratio=y,
             z_ratio=z,
         )
+
+    def estimate_liquid_height_after_pipetting(
+        self,
+        operation_volume: float,
+    ) -> LiquidTrackingType:
+        """Return an estimate of liquid height after pipetting without raising an error."""
+        labware_id = self.labware_id
+        well_name = self._name
+        starting_liquid_height = self.current_liquid_height()
+        projected_final_height = self._engine_client.state.geometry.get_well_height_after_liquid_handling_no_error(
+            labware_id=labware_id,
+            well_name=well_name,
+            initial_height=starting_liquid_height,
+            volume=operation_volume,
+        )
+        return projected_final_height
+
+    def current_liquid_height(self) -> LiquidTrackingType:
+        """Return the current liquid height within a well."""
+        labware_id = self.labware_id
+        well_name = self._name
+        return self._engine_client.state.geometry.get_meniscus_height(
+            labware_id=labware_id, well_name=well_name
+        )
+
+    def get_liquid_volume(self) -> LiquidTrackingType:
+        """Return the current volume in a well."""
+        labware_id = self.labware_id
+        well_name = self._name
+        return self._engine_client.state.geometry.get_current_well_volume(
+            labware_id=labware_id, well_name=well_name
+        )

opentrons/protocol_api/core/instrument.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
-from typing import Any, Generic, Optional, TypeVar, Union, List
+from typing import Any, Generic, Optional, TypeVar, Union, List, Tuple
 
 from opentrons import types
 from opentrons.hardware_control.dev_types import PipetteDict
@@ -11,11 +11,14 @@ from opentrons.protocols.api_support.util import FlowRates
 from opentrons.protocols.advanced_control.transfers.common import TransferTipPolicyV2
 from opentrons.protocol_api._nozzle_layout import NozzleLayout
 from opentrons.protocol_api._liquid import LiquidClass
+from opentrons.protocol_engine.types.liquid_level_detection import LiquidTrackingType
+
 from ..disposal_locations import TrashBin, WasteChute
 from .well import WellCoreType
+from .labware import LabwareCoreType
 
 
-class AbstractInstrument(ABC, Generic[WellCoreType]):
+class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
     @abstractmethod
     def get_default_speed(self) -> float:
         ...
@@ -25,11 +28,14 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         ...
 
     @abstractmethod
-    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:
         """Aspirate a given volume of air from the current location of the pipette.
         Args:
             volume: The volume of air to aspirate, in microliters.
             flow_rate: The flow rate of air into the pipette, in microliters.
+            correction_volume: The correction volume in uL.
         """
 
     @abstractmethod
@@ -41,7 +47,8 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         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:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -51,6 +58,8 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
             rate: The rate for how quickly to aspirate.
             flow_rate: The flow rate in µL/s to aspirate at.
             in_place: Whether this is in-place.
+            meniscus_tracking: Optional data about where to aspirate from.
+            correction_volume: The correction volume in uL
         """
         ...
 
@@ -64,7 +73,8 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         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:
         """Dispense a given volume of liquid into the specified location.
         Args:
@@ -75,6 +85,8 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
             flow_rate: The flow rate in µL/s to dispense at.
             in_place: Whether this is in-place.
             push_out: The amount to push the plunger below bottom position.
+            correction_volume: The correction volume in uL
+            meniscus_tracking: Optional data about where to dispense from.
         """
         ...
 
@@ -102,6 +114,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         radius: float,
         z_offset: float,
         speed: float,
+        mm_from_edge: Optional[float] = None,
     ) -> None:
         ...
 
@@ -239,10 +252,18 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
     def get_current_volume(self) -> float:
         ...
 
+    @abstractmethod
+    def get_has_clean_tip(self) -> bool:
+        ...
+
     @abstractmethod
     def get_available_volume(self) -> float:
         ...
 
+    @abstractmethod
+    def get_minimum_liquid_sense_height(self) -> float:
+        ...
+
     @abstractmethod
     def get_hardware_state(self) -> PipetteDict:
         """Get the current state of the pipette hardware as a dictionary."""
@@ -338,29 +359,54 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         ...
 
     @abstractmethod
-    def load_liquid_class(
+    def transfer_liquid(
         self,
         liquid_class: LiquidClass,
-        pipette_load_name: str,
-        tiprack_uri: str,
-    ) -> str:
-        """Load the liquid class properties of given pipette and tiprack into the engine.
+        volume: float,
+        source: List[Tuple[types.Location, WellCoreType]],
+        dest: List[Tuple[types.Location, WellCoreType]],
+        new_tip: TransferTipPolicyV2,
+        tip_racks: List[Tuple[types.Location, LabwareCoreType]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
+    ) -> None:
+        """Transfer a liquid from source to dest according to liquid class properties."""
+        ...
 
-        Returns: ID of the liquid class record
+    @abstractmethod
+    def distribute_liquid(
+        self,
+        liquid_class: LiquidClass,
+        volume: float,
+        source: Tuple[types.Location, WellCoreType],
+        dest: List[Tuple[types.Location, WellCoreType]],
+        new_tip: TransferTipPolicyV2,
+        tip_racks: List[Tuple[types.Location, LabwareCoreType]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
+    ) -> None:
+        """
+        Distribute a liquid from single source to multiple destinations
+        according to liquid class properties.
         """
         ...
 
     @abstractmethod
-    def transfer_liquid(
+    def consolidate_liquid(
         self,
-        liquid_class_id: str,
+        liquid_class: LiquidClass,
         volume: float,
-        source: List[WellCoreType],
-        dest: List[WellCoreType],
+        source: List[Tuple[types.Location, WellCoreType]],
+        dest: Tuple[types.Location, WellCoreType],
         new_tip: TransferTipPolicyV2,
-        trash_location: Union[WellCoreType, types.Location, TrashBin, WasteChute],
+        tip_racks: List[Tuple[types.Location, LabwareCoreType]],
+        trash_location: Union[types.Location, TrashBin, WasteChute],
+        return_tip: bool,
     ) -> None:
-        """Transfer a liquid from source to dest according to liquid class properties."""
+        """
+        Consolidate liquid from multiple sources to a single destination
+        using the specified liquid class properties.
+        """
         ...
 
     @abstractmethod
@@ -388,7 +434,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
     @abstractmethod
     def liquid_probe_without_recovery(
         self, well_core: WellCoreType, loc: types.Location
-    ) -> float:
+    ) -> LiquidTrackingType:
         """Do a liquid probe to find the level of the liquid in the well."""
         ...
 
@@ -397,4 +443,4 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         """Check if the nozzle configuration currently supports LLD."""
 
 
-InstrumentCoreType = TypeVar("InstrumentCoreType", bound=AbstractInstrument[Any])
+InstrumentCoreType = TypeVar("InstrumentCoreType", bound=AbstractInstrument[Any, Any])

opentrons/protocol_api/core/labware.py

@@ -7,7 +7,8 @@ from typing import Any, Generic, List, NamedTuple, Optional, TypeVar, Dict
 
 from opentrons_shared_data.labware.types import (
     LabwareUri,
-    LabwareParameters as LabwareParametersDict,
+    LabwareParameters2,
+    LabwareParameters3,
     LabwareDefinition as LabwareDefinitionDict,
 )
 
@@ -17,6 +18,9 @@ from .._liquid import Liquid
 from .well import WellCoreType
 
 
+_LabwareParametersDict = LabwareParameters2 | LabwareParameters3
+
+
 class LabwareLoadParams(NamedTuple):
     """Unique load parameters of a labware."""
 
@@ -75,7 +79,7 @@ class AbstractLabware(ABC, Generic[WellCoreType]):
         """Get the labware's definition as a plain dictionary."""
 
     @abstractmethod
-    def get_parameters(self) -> LabwareParametersDict:
+    def get_parameters(self) -> _LabwareParametersDict:
         """Get the labware's definition's `parameters` field as a plain dictionary."""
 
     @abstractmethod

opentrons/protocol_api/core/legacy/labware_offset_provider.py

@@ -3,7 +3,11 @@ from dataclasses import dataclass
 from typing import Optional
 
 from opentrons.hardware_control.modules import ModuleModel as HardwareModuleModel
-from opentrons.protocol_engine import ProtocolEngine, LabwareOffsetLocation, ModuleModel
+from opentrons.protocol_engine import (
+    ProtocolEngine,
+    LegacyLabwareOffsetLocation,
+    ModuleModel,
+)
 from opentrons.types import DeckSlotName, Point
 
 from ..labware import LabwareLoadParams
@@ -81,9 +85,9 @@ class LabwareOffsetProvider(AbstractLabwareOffsetProvider):
 
         See the parent class for param details.
         """
-        offset = self._labware_view.find_applicable_labware_offset(
+        offset = self._labware_view.find_applicable_labware_offset_by_legacy_location(
             definition_uri=load_params.as_uri(),
-            location=LabwareOffsetLocation(
+            location=LegacyLabwareOffsetLocation(
                 slotName=deck_slot,
                 moduleModel=(
                     None

opentrons/protocol_api/core/legacy/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 import CriticalPoint
@@ -22,9 +22,12 @@ from opentrons.protocols.geometry import planning
 from opentrons.protocol_api._nozzle_layout import NozzleLayout
 from opentrons.protocol_api._liquid import LiquidClass
 
+from opentrons.protocol_engine.types.liquid_level_detection import LiquidTrackingType
+
 from ...disposal_locations import TrashBin, WasteChute
 from ..instrument import AbstractInstrument
 from .legacy_well_core import LegacyWellCore
+from .legacy_labware_core import LegacyLabwareCore
 from .legacy_module_core import LegacyThermocyclerCore, LegacyHeaterShakerCore
 
 if TYPE_CHECKING:
@@ -37,7 +40,7 @@ _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 LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
+class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]):
     """Implementation of the InstrumentContext interface."""
 
     def __init__(
@@ -73,7 +76,9 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
         """Sets the speed at which the robot's gantry moves."""
         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(
@@ -84,7 +89,8 @@ class LegacyInstrumentCore(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:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -94,6 +100,8 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
             rate: The rate in µL/s to aspirate at.
             flow_rate: Not used in this core.
             in_place: Whether we should move_to location.
+            correction_volume: Not used in this core
+            meniscus_tracking: Optional data about where to aspirate from.
         """
         if self.get_current_volume() == 0:
             # Make sure we're at the top of the labware and clear of any
@@ -127,7 +135,8 @@ class LegacyInstrumentCore(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:
         """Dispense a given volume of liquid into the specified location.
         Args:
@@ -137,7 +146,9 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
             rate: The rate in µL/s to dispense at.
             flow_rate: Not used in this core.
             in_place: Whether we should move_to location.
+            correction_volume: Not used in this core.
             push_out: The amount to push the plunger below bottom position.
+            meniscus_tracking: Optional data about where to dispense from.
         """
         if isinstance(location, (TrashBin, WasteChute)):
             raise APIVersionError(
@@ -179,11 +190,14 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
         radius: float,
         z_offset: float,
         speed: float,
+        mm_from_edge: Optional[float] = None,
     ) -> None:
         """
         Touch the pipette tip to the sides of a well, with the intent of
         removing left-over droplets
         """
+        if mm_from_edge is not None:
+            raise APIVersionError(api_element="mm_from_edge argument")
         # TODO al 20201110 - build_edges relies on where being a Well. This is
         #  an unpleasant compromise until refactoring build_edges to support
         #  LegacyWellCore.
@@ -486,6 +500,10 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
         """Get the current volume."""
         return self.get_hardware_state()["current_volume"]
 
+    def get_has_clean_tip(self) -> bool:
+        """Get if has a clean tip, only used with LLD and engine commands."""
+        return False
+
     def get_available_volume(self) -> float:
         """Get the available volume."""
         return self.get_hardware_state()["available_volume"]
@@ -606,28 +624,47 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore]):
         """This will never be called because it was added in API 2.16."""
         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:
-        """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, "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."""
@@ -657,7 +694,7 @@ class LegacyInstrumentCore(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"
 
@@ -667,3 +704,14 @@ class LegacyInstrumentCore(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:
+        return 0.0

opentrons/protocol_api/core/legacy/legacy_labware_core.py

@@ -6,7 +6,7 @@ from opentrons.protocols.api_support.tip_tracker import TipTracker
 
 from opentrons.types import DeckSlotName, Location, Point, NozzleMapInterface
 
-from opentrons_shared_data.labware.types import LabwareParameters, LabwareDefinition
+from opentrons_shared_data.labware.types import LabwareParameters2, LabwareDefinition2
 
 from ..._liquid import Liquid
 from ..labware import AbstractLabware, LabwareLoadParams
@@ -36,7 +36,11 @@ class LegacyLabwareCore(AbstractLabware[LegacyWellCore]):
 
     def __init__(
         self,
-        definition: LabwareDefinition,
+        # We need labware schema 2, specifically, because schema 3 changes how positions
+        # are calculated, and we don't attempt to handle that here in
+        # `opentrons.protocol_api.core.legacy`. We do handle it in
+        # `opentrons.protocol_api.core.engine` and `opentrons.protocol_engine`.
+        definition: LabwareDefinition2,
         parent: Location,
         label: Optional[str] = None,
     ) -> None:
@@ -106,10 +110,10 @@ class LegacyLabwareCore(AbstractLabware[LegacyWellCore]):
     def set_name(self, new_name: str) -> None:
         self._name = new_name
 
-    def get_definition(self) -> LabwareDefinition:
+    def get_definition(self) -> LabwareDefinition2:
         return self._definition
 
-    def get_parameters(self) -> LabwareParameters:
+    def get_parameters(self) -> LabwareParameters2:
         return self._parameters
 
     def get_quirks(self) -> List[str]:

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -209,6 +209,10 @@ class LegacyProtocolCore(
             bundled_defs=self._bundled_labware,
             extra_defs=self._extra_labware,
         )
+        # For type checking. This should always pass because
+        # opentrons.protocol_api.core.legacy should only load labware with schema 2.
+        assert labware_def["schemaVersion"] == 2
+
         labware_core = LegacyLabwareCore(
             definition=labware_def,
             parent=parent,
@@ -307,6 +311,25 @@ class LegacyProtocolCore(
         """Move labware to new location."""
         raise APIVersionError(api_element="Labware movement")
 
+    def move_lid(
+        self,
+        source_location: Union[DeckSlotName, StagingSlotName, LegacyLabwareCore],
+        new_location: Union[
+            DeckSlotName,
+            StagingSlotName,
+            LegacyLabwareCore,
+            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]],
+    ) -> LegacyLabwareCore | None:
+        """Move lid to new location."""
+        raise APIVersionError(api_element="Lid movement")
+
     def load_module(
         self,
         model: ModuleModel,
@@ -505,6 +528,19 @@ class LegacyProtocolCore(
         """Load a Stack of Lids to a given location, creating a Lid Stack."""
         raise APIVersionError(api_element="Lid stack")
 
+    def load_labware_to_flex_stacker_hopper(
+        self,
+        module_core: legacy_module_core.LegacyModuleCore,
+        load_name: str,
+        quantity: int,
+        label: Optional[str],
+        namespace: Optional[str],
+        version: Optional[int],
+        lid: Optional[str],
+    ) -> None:
+        """Load labware to a Flex stacker hopper."""
+        raise APIVersionError(api_element="Flex stacker")
+
     def get_module_cores(self) -> List[legacy_module_core.LegacyModuleCore]:
         """Get loaded module cores."""
         return self._module_cores

opentrons/protocol_api/core/legacy/legacy_well_core.py

@@ -1,5 +1,5 @@
 """Legacy Well core implementation."""
-from typing import Optional
+from typing import Optional, Union
 
 from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 
@@ -7,6 +7,11 @@ from opentrons.protocols.api_support.util import APIVersionError
 
 from opentrons.types import Point
 
+from opentrons.protocol_engine.types.liquid_level_detection import (
+    SimulatedProbeResult,
+    LiquidTrackingType,
+)
+
 from .well_geometry import WellGeometry
 from ..well import AbstractWellCore
 from ..._liquid import Liquid
@@ -106,6 +111,10 @@ class LegacyWellCore(AbstractWellCore):
         """Get the coordinate of the well's center."""
         return self._geometry.center()
 
+    def get_meniscus(self) -> Union[Point, SimulatedProbeResult]:
+        """Get the coordinate of the well's center."""
+        raise APIVersionError(api_element="Getting a meniscus")
+
     def load_liquid(
         self,
         liquid: Liquid,
@@ -118,6 +127,21 @@ class LegacyWellCore(AbstractWellCore):
         """Gets point in deck coordinates based on percentage of the radius of each axis."""
         return self._geometry.from_center_cartesian(x, y, z)
 
+    def estimate_liquid_height_after_pipetting(
+        self,
+        operation_volume: float,
+    ) -> LiquidTrackingType:
+        """Estimate what the liquid height will be after pipetting, without raising an error."""
+        return 0.0
+
+    def current_liquid_height(self) -> LiquidTrackingType:
+        """Get the current liquid height."""
+        return 0.0
+
+    def get_liquid_volume(self) -> LiquidTrackingType:
+        """Get the current well volume."""
+        return 0.0
+
     # TODO(mc, 2022-10-28): is this used and/or necessary?
     def __repr__(self) -> str:
         """Use the well's display name as its repr."""