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

opentrons/legacy_commands/commands.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, List, Union, overload
+from typing import TYPE_CHECKING, List, Sequence, Union, overload
 
 
-from .helpers import stringify_location, stringify_disposal_location, listify
+from .helpers import (
+    stringify_location,
+    stringify_disposal_location,
+    stringify_well_list,
+    listify,
+)
 from . import types as command_types
 
 from opentrons.types import Location
 from opentrons.protocol_api.disposal_locations import TrashBin, WasteChute
+from opentrons.protocol_api._liquid import LiquidClass
 
 if TYPE_CHECKING:
     from opentrons.protocol_api import InstrumentContext
@@ -234,9 +240,25 @@ def touch_tip(instrument: InstrumentContext) -> command_types.TouchTipCommand:
     }
 
 
-def air_gap() -> command_types.AirGapCommand:
-    text = "Air gap"
-    return {"name": command_types.AIR_GAP, "payload": {"text": text}}
+def air_gap(
+    instrument: InstrumentContext,
+    volume: float | None,
+    height: float | None,
+) -> command_types.AirGapCommand:
+    text = (
+        "Air gap"
+        + (f" of {volume} uL" if volume is not None else "")
+        + (f" at height {height}" if height is not None else "")
+    )
+    return {
+        "name": command_types.AIR_GAP,
+        "payload": {
+            "instrument": instrument,
+            "volume": volume,
+            "height": height,
+            "text": text,
+        },
+    }
 
 
 def return_tip() -> command_types.ReturnTipCommand:
@@ -301,6 +323,81 @@ def move_to_disposal_location(
     }
 
 
+def transfer_with_liquid_class(
+    instrument: InstrumentContext,
+    liquid_class: LiquidClass,
+    volume: float,
+    source: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+    destination: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+) -> command_types.TransferWithLiquidClassCommand:
+    text = (
+        "Transferring "
+        + f"{volume} uL of {liquid_class.display_name} liquid class from "
+        + f"{stringify_well_list(source)} to {stringify_well_list(destination)}"
+    )
+    return {
+        "name": command_types.TRANSFER_WITH_LIQUID_CLASS,
+        "payload": {
+            "instrument": instrument,
+            "liquid_class": liquid_class,
+            "volume": volume,
+            "source": source,
+            "destination": destination,
+            "text": text,
+        },
+    }
+
+
+def distribute_with_liquid_class(
+    instrument: InstrumentContext,
+    liquid_class: LiquidClass,
+    volume: float,
+    source: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+    destination: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+) -> command_types.DistributeWithLiquidClassCommand:
+    text = (
+        "Distributing "
+        + f"{volume} uL of {liquid_class.display_name} liquid class from "
+        + f"{stringify_well_list(source)} to {stringify_well_list(destination)}"
+    )
+    return {
+        "name": command_types.DISTRIBUTE_WITH_LIQUID_CLASS,
+        "payload": {
+            "instrument": instrument,
+            "liquid_class": liquid_class,
+            "volume": volume,
+            "source": source,
+            "destination": destination,
+            "text": text,
+        },
+    }
+
+
+def consolidate_with_liquid_class(
+    instrument: InstrumentContext,
+    liquid_class: LiquidClass,
+    volume: float,
+    source: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+    destination: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+) -> command_types.ConsolidateWithLiquidClassCommand:
+    text = (
+        "Consolidating "
+        + f"{volume} uL of {liquid_class.display_name} liquid class from "
+        + f"{stringify_well_list(source)} to {stringify_well_list(destination)}"
+    )
+    return {
+        "name": command_types.CONSOLIDATE_WITH_LIQUID_CLASS,
+        "payload": {
+            "instrument": instrument,
+            "liquid_class": liquid_class,
+            "volume": volume,
+            "source": source,
+            "destination": destination,
+            "text": text,
+        },
+    }
+
+
 def seal(
     instrument: InstrumentContext,
     location: Well,

opentrons/legacy_commands/helpers.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Union, Sequence
 
 from opentrons.protocol_api.labware import Well, Labware
 from opentrons.protocol_api.module_contexts import ModuleContext
@@ -48,6 +48,64 @@ def stringify_disposal_location(location: Union[TrashBin, WasteChute]) -> str:
         return "Waste Chute"
 
 
+def _group_wells_by_labware(wells: List[Well]) -> List[List[Well]]:
+    wells_by_labware: List[List[Well]] = []
+    sub_list = []
+    active_parent_labware = None
+    for well in wells:
+        if well.parent == active_parent_labware:
+            sub_list.append(well)
+        else:
+            active_parent_labware = well.parent
+            if sub_list:
+                wells_by_labware.append(sub_list)
+            sub_list = [well]
+    if sub_list:
+        wells_by_labware.append(sub_list)
+
+    return wells_by_labware
+
+
+def _stringify_multiple_wells_for_labware(wells: List[Well]) -> str:
+    if len(wells) == 0:
+        return ""
+    elif len(wells) == 1:
+        return str(wells[0])
+    # TODO(jbl 2025-04-10) this logic can be improved to more intelligently group wells
+    elif len(wells) < 9:  # At most we'll print out a full column's worth of well
+        return ", ".join([well.well_name for well in wells[:-1]]) + f", {wells[-1]}"
+    else:  # Otherwise print the first and last three
+        return (
+            ", ".join([well.well_name for well in wells[:3]])
+            + ", ... "
+            + ", ".join([well.well_name for well in wells[-3:-1]])
+            + f", {wells[-1]}"
+        )
+
+
+def stringify_well_list(
+    wells: Union[Well, Sequence[Well], Sequence[Sequence[Well]]]
+) -> str:
+    """Takes an arbitrary sequence of wells and returns a string representation of each well, associated by labware."""
+    if isinstance(wells, Well):
+        well_list = [wells]
+    elif len(wells) == 0:
+        well_list = []
+    elif isinstance(wells, list) and isinstance(wells[0], list):
+        well_list = [well for sub_well_list in wells for well in sub_well_list]
+    elif isinstance(wells, list):
+        well_list = wells
+    else:
+        return ""
+
+    return "; ".join(
+        [
+            _stringify_multiple_wells_for_labware(wells_by_labware)
+            for wells_by_labware in _group_wells_by_labware(well_list)
+        ]
+    )
+
+
 def _stringify_labware_movement_location(
     location: Union[
         DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
@@ -78,3 +136,18 @@ def stringify_labware_movement_command(
     destination_text = _stringify_labware_movement_location(destination)
     gripper_text = " with gripper" if use_gripper else ""
     return f"Moving {source_labware_text} to {destination_text}{gripper_text}"
+
+
+def stringify_lid_movement_command(
+    source: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ],
+    destination: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ],
+    use_gripper: bool,
+) -> str:
+    source_labware_text = _stringify_labware_movement_location(source)
+    destination_text = _stringify_labware_movement_location(destination)
+    gripper_text = " with gripper" if use_gripper else ""
+    return f"Moving lid from {source_labware_text} to {destination_text}{gripper_text}"

opentrons/legacy_commands/types.py

@@ -8,6 +8,7 @@ if TYPE_CHECKING:
     from opentrons.protocol_api import InstrumentContext
     from opentrons.protocol_api.labware import Well
     from opentrons.protocol_api.disposal_locations import TrashBin, WasteChute
+    from opentrons.protocol_api._liquid import LiquidClass
 
 from opentrons.types import Location
 
@@ -43,6 +44,9 @@ TOUCH_TIP: Final = "command.TOUCH_TIP"
 RETURN_TIP: Final = "command.RETURN_TIP"
 MOVE_TO: Final = "command.MOVE_TO"
 MOVE_TO_DISPOSAL_LOCATION: Final = "command.MOVE_TO_DISPOSAL_LOCATION"
+TRANSFER_WITH_LIQUID_CLASS: Final = "command.TRANSFER_WITH_LIQUID_CLASS"
+DISTRIBUTE_WITH_LIQUID_CLASS: Final = "command.DISTRIBUTE_WITH_LIQUID_CLASS"
+CONSOLIDATE_WITH_LIQUID_CLASS: Final = "command.CONSOLIDATE_WITH_LIQUID_CLASS"
 SEAL: Final = "command.SEAL"
 UNSEAL: Final = "command.UNSEAL"
 PRESSURIZE: Final = "command.PRESSURIZE"
@@ -472,8 +476,9 @@ class TouchTipCommand(TypedDict):
     payload: TouchTipCommandPayload
 
 
-class AirGapCommandPayload(TextOnlyPayload):
-    pass
+class AirGapCommandPayload(TextOnlyPayload, SingleInstrumentPayload):
+    volume: Union[float, None]
+    height: Union[float, None]
 
 
 class AirGapCommand(TypedDict):
@@ -539,6 +544,28 @@ class MoveLabwareCommandPayload(TextOnlyPayload):
     pass
 
 
+class LiquidClassCommandPayload(TextOnlyPayload, SingleInstrumentPayload):
+    liquid_class: LiquidClass
+    volume: float
+    source: Union[Well, Sequence[Well], Sequence[Sequence[Well]]]
+    destination: Union[Well, Sequence[Well], Sequence[Sequence[Well]]]
+
+
+class TransferWithLiquidClassCommand(TypedDict):
+    name: Literal["command.TRANSFER_WITH_LIQUID_CLASS"]
+    payload: LiquidClassCommandPayload
+
+
+class DistributeWithLiquidClassCommand(TypedDict):
+    name: Literal["command.DISTRIBUTE_WITH_LIQUID_CLASS"]
+    payload: LiquidClassCommandPayload
+
+
+class ConsolidateWithLiquidClassCommand(TypedDict):
+    name: Literal["command.CONSOLIDATE_WITH_LIQUID_CLASS"]
+    payload: LiquidClassCommandPayload
+
+
 class SealCommandPayload(TextOnlyPayload):
     instrument: InstrumentContext
     location: Union[None, Location, Well]
@@ -621,6 +648,9 @@ Command = Union[
     MoveToCommand,
     MoveToDisposalLocationCommand,
     MoveLabwareCommand,
+    TransferWithLiquidClassCommand,
+    DistributeWithLiquidClassCommand,
+    ConsolidateWithLiquidClassCommand,
     SealCommand,
     UnsealCommand,
     PressurizeCommand,
@@ -673,6 +703,7 @@ CommandPayload = Union[
     MoveToCommandPayload,
     MoveToDisposalLocationCommandPayload,
     MoveLabwareCommandPayload,
+    LiquidClassCommandPayload,
     SealCommandPayload,
     UnsealCommandPayload,
     PressurizeCommandPayload,

opentrons/protocol_api/__init__.py

@@ -27,6 +27,7 @@ from .module_contexts import (
     HeaterShakerContext,
     MagneticBlockContext,
     AbsorbanceReaderContext,
+    FlexStackerContext,
 )
 from .disposal_locations import TrashBin, WasteChute
 from ._liquid import Liquid, LiquidClass
@@ -70,6 +71,7 @@ __all__ = [
     "HeaterShakerContext",
     "MagneticBlockContext",
     "AbsorbanceReaderContext",
+    "FlexStackerContext",
     "ParameterContext",
     "Labware",
     "TrashBin",

opentrons/protocol_api/_liquid.py

@@ -1,17 +1,24 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional, Dict
+from typing import Optional, Dict, Union, TYPE_CHECKING
 
 from opentrons_shared_data.liquid_classes.liquid_class_definition import (
     LiquidClassSchemaV1,
 )
 
+from opentrons.protocols.advanced_control.transfers.common import (
+    NoLiquidClassPropertyError,
+)
+
 from ._liquid_properties import (
     TransferProperties,
     build_transfer_properties,
 )
 
+if TYPE_CHECKING:
+    from . import InstrumentContext, Labware
+
 
 @dataclass(frozen=True)
 class Liquid:
@@ -64,18 +71,42 @@ class LiquidClass:
     def display_name(self) -> str:
         return self._display_name
 
-    def get_for(self, pipette: str, tiprack: str) -> TransferProperties:
+    def get_for(
+        self, pipette: Union[str, InstrumentContext], tip_rack: Union[str, Labware]
+    ) -> TransferProperties:
         """Get liquid class transfer properties for the specified pipette and tip."""
+        from . import InstrumentContext, Labware
+
+        if isinstance(pipette, InstrumentContext):
+            pipette_name = pipette.name
+        elif isinstance(pipette, str):
+            pipette_name = pipette
+        else:
+            raise ValueError(
+                f"{pipette} should either be an InstrumentContext object"
+                f" or a pipette name string."
+            )
+
+        if isinstance(tip_rack, Labware):
+            tiprack_uri = tip_rack.uri
+        elif isinstance(tip_rack, str):
+            tiprack_uri = tip_rack
+        else:
+            raise ValueError(
+                f"{tip_rack} should either be a tiprack Labware object"
+                f" or a tiprack URI string."
+            )
+
         try:
-            settings_for_pipette = self._by_pipette_setting[pipette]
+            settings_for_pipette = self._by_pipette_setting[pipette_name]
         except KeyError:
-            raise ValueError(
-                f"No properties found for {pipette} in {self._name} liquid class"
+            raise NoLiquidClassPropertyError(
+                f"No properties found for {pipette_name} in {self._name} liquid class"
             )
         try:
-            transfer_properties = settings_for_pipette[tiprack]
+            transfer_properties = settings_for_pipette[tiprack_uri]
         except KeyError:
-            raise ValueError(
-                f"No properties found for {tiprack} in {self._name} liquid class"
+            raise NoLiquidClassPropertyError(
+                f"No properties found for {tiprack_uri} for {pipette_name} in {self._name} liquid class"
             )
         return transfer_properties

opentrons/protocol_api/_liquid_properties.py

@@ -83,7 +83,10 @@ class LiquidHandlingPropertyByVolume:
         )
 
 
-@dataclass
+# We use slots for this dataclass (and the rest of liquid properties) to prevent dynamic creation of attributes
+# not defined in the class, not for any performance reasons. This is so that mistyping properties when overriding
+# values will cause the protocol to fail analysis, rather than silently passing.
+@dataclass(slots=True)
 class DelayProperties:
 
     _enabled: bool
@@ -118,7 +121,7 @@ class DelayProperties:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class TouchTipProperties:
 
     _enabled: bool
@@ -157,7 +160,7 @@ class TouchTipProperties:
     @mm_to_edge.setter
     def mm_to_edge(self, new_mm: float) -> None:
         validated_mm = validation.ensure_float(new_mm)
-        self._z_offset = validated_mm
+        self._mm_to_edge = validated_mm
 
     @property
     def speed(self) -> Optional[float]:
@@ -165,7 +168,7 @@ class TouchTipProperties:
 
     @speed.setter
     def speed(self, new_speed: float) -> None:
-        validated_speed = validation.ensure_positive_float(new_speed)
+        validated_speed = validation.ensure_greater_than_zero_float(new_speed)
         self._speed = validated_speed
 
     def _get_shared_data_params(self) -> Optional[SharedDataTouchTipParams]:
@@ -190,7 +193,7 @@ class TouchTipProperties:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class MixProperties:
 
     _enabled: bool
@@ -223,7 +226,7 @@ class MixProperties:
 
     @volume.setter
     def volume(self, new_volume: float) -> None:
-        validated_volume = validation.ensure_positive_float(new_volume)
+        validated_volume = validation.ensure_greater_than_zero_float(new_volume)
         self._volume = validated_volume
 
     def _get_shared_data_params(self) -> Optional[SharedDataMixParams]:
@@ -243,7 +246,7 @@ class MixProperties:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class BlowoutProperties:
 
     _enabled: bool
@@ -277,7 +280,7 @@ class BlowoutProperties:
 
     @flow_rate.setter
     def flow_rate(self, new_flow_rate: float) -> None:
-        validated_flow_rate = validation.ensure_positive_float(new_flow_rate)
+        validated_flow_rate = validation.ensure_greater_than_zero_float(new_flow_rate)
         self._flow_rate = validated_flow_rate
 
     def _get_shared_data_params(self) -> Optional[SharedDataBlowoutParams]:
@@ -297,7 +300,7 @@ class BlowoutProperties:
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class SubmergeRetractCommon:
 
     _position_reference: PositionReference
@@ -336,10 +339,8 @@ class SubmergeRetractCommon:
         return self._delay
 
 
-@dataclass
+@dataclass(slots=True)
 class Submerge(SubmergeRetractCommon):
-    ...
-
     def as_shared_data_model(self) -> SharedDataSubmerge:
         return SharedDataSubmerge(
             positionReference=self._position_reference,
@@ -349,7 +350,7 @@ class Submerge(SubmergeRetractCommon):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class RetractAspirate(SubmergeRetractCommon):
 
     _air_gap_by_volume: LiquidHandlingPropertyByVolume
@@ -374,7 +375,7 @@ class RetractAspirate(SubmergeRetractCommon):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class RetractDispense(SubmergeRetractCommon):
 
     _air_gap_by_volume: LiquidHandlingPropertyByVolume
@@ -405,7 +406,7 @@ class RetractDispense(SubmergeRetractCommon):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class BaseLiquidHandlingProperties:
 
     _submerge: Submerge
@@ -449,7 +450,7 @@ class BaseLiquidHandlingProperties:
         return self._delay
 
 
-@dataclass
+@dataclass(slots=True)
 class AspirateProperties(BaseLiquidHandlingProperties):
 
     _retract: RetractAspirate
@@ -487,7 +488,7 @@ class AspirateProperties(BaseLiquidHandlingProperties):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class SingleDispenseProperties(BaseLiquidHandlingProperties):
 
     _retract: RetractDispense
@@ -520,7 +521,7 @@ class SingleDispenseProperties(BaseLiquidHandlingProperties):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class MultiDispenseProperties(BaseLiquidHandlingProperties):
 
     _retract: RetractDispense
@@ -553,7 +554,7 @@ class MultiDispenseProperties(BaseLiquidHandlingProperties):
         )
 
 
-@dataclass
+@dataclass(slots=True)
 class TransferProperties:
     _aspirate: AspirateProperties
     _dispense: SingleDispenseProperties

opentrons/protocol_api/_transfer_liquid_validation.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from typing import List, Union, Sequence, Optional
+
+from opentrons.types import Location, NozzleMapInterface
+from opentrons.protocols.api_support import instrument
+from opentrons.protocols.advanced_control.transfers import (
+    transfer_liquid_utils as tx_liquid_utils,
+)
+from opentrons.protocols.advanced_control.transfers.common import (
+    TransferTipPolicyV2,
+    TransferTipPolicyV2Type,
+)
+
+from .disposal_locations import TrashBin, WasteChute
+from .labware import Labware, Well
+from . import validation
+
+
+@dataclass
+class TransferInfo:
+
+    sources_list: List[Well]
+    destinations_list: List[Well]
+    tip_policy: TransferTipPolicyV2
+    tip_racks: List[Labware]
+    trash_location: Union[Location, TrashBin, WasteChute]
+
+
+def verify_and_normalize_transfer_args(
+    source: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+    dest: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+    tip_policy: TransferTipPolicyV2Type,
+    last_tip_picked_up_from: Optional[Well],
+    tip_racks: List[Labware],
+    nozzle_map: NozzleMapInterface,
+    target_all_wells: bool,
+    current_volume: float,
+    trash_location: Union[Location, Well, Labware, TrashBin, WasteChute],
+) -> TransferInfo:
+    flat_sources_list = validation.ensure_valid_flat_wells_list_for_transfer_v2(source)
+    flat_dests_list = validation.ensure_valid_flat_wells_list_for_transfer_v2(dest)
+    if not target_all_wells and nozzle_map.tip_count > 1:
+        flat_sources_list = tx_liquid_utils.group_wells_for_multi_channel_transfer(
+            flat_sources_list, nozzle_map
+        )
+        flat_dests_list = tx_liquid_utils.group_wells_for_multi_channel_transfer(
+            flat_dests_list, nozzle_map
+        )
+    for well in flat_sources_list + flat_dests_list:
+        instrument.validate_takes_liquid(
+            location=well.top(),
+            reject_module=True,
+            reject_adapter=True,
+        )
+
+    valid_new_tip = validation.ensure_new_tip_policy(tip_policy)
+    if valid_new_tip == TransferTipPolicyV2.NEVER:
+        if last_tip_picked_up_from is None:
+            raise RuntimeError(
+                "Pipette has no tip attached to perform transfer."
+                " Either do a pick_up_tip beforehand or specify a new_tip parameter"
+                " of 'once' or 'always'."
+            )
+        else:
+            valid_tip_racks = [last_tip_picked_up_from.parent]
+    else:
+        valid_tip_racks = tip_racks
+    if current_volume != 0:
+        raise RuntimeError(
+            "A transfer on a liquid class cannot start with liquid already in the tip."
+            " Ensure that all previously aspirated liquid is dispensed before starting"
+            " a new transfer."
+        )
+
+    _trash_location: Union[Location, Well, TrashBin, WasteChute]
+    if isinstance(trash_location, Labware):
+        _trash_location = trash_location.wells()[0]
+    else:
+        _trash_location = trash_location
+
+    valid_trash_location = validation.ensure_valid_trash_location_for_transfer_v2(
+        trash_location=_trash_location
+    )
+
+    return TransferInfo(
+        sources_list=flat_sources_list,
+        destinations_list=flat_dests_list,
+        tip_policy=valid_new_tip,
+        tip_racks=valid_tip_racks,
+        trash_location=valid_trash_location,
+    )

opentrons/protocol_api/core/common.py

@@ -11,6 +11,7 @@ from .module import (
     AbstractHeaterShakerCore,
     AbstractMagneticBlockCore,
     AbstractAbsorbanceReaderCore,
+    AbstractFlexStackerCore,
 )
 from .protocol import AbstractProtocol
 from .well import AbstractWellCore
@@ -19,7 +20,7 @@ from .robot import AbstractRobot
 
 WellCore = AbstractWellCore
 LabwareCore = AbstractLabware[WellCore]
-InstrumentCore = AbstractInstrument[WellCore]
+InstrumentCore = AbstractInstrument[WellCore, LabwareCore]
 ModuleCore = AbstractModuleCore
 TemperatureModuleCore = AbstractTemperatureModuleCore
 MagneticModuleCore = AbstractMagneticModuleCore
@@ -27,5 +28,6 @@ ThermocyclerCore = AbstractThermocyclerCore
 HeaterShakerCore = AbstractHeaterShakerCore
 MagneticBlockCore = AbstractMagneticBlockCore
 AbsorbanceReaderCore = AbstractAbsorbanceReaderCore
+FlexStackerCore = AbstractFlexStackerCore
 RobotCore = AbstractRobot
 ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore]

opentrons/protocol_api/core/engine/deck_conflict.py

@@ -1,4 +1,5 @@
 """A Protocol-Engine-friendly wrapper for opentrons.motion_planning.deck_conflict."""
+
 from __future__ import annotations
 import itertools
 import logging
@@ -24,7 +25,9 @@ from opentrons.protocol_engine import (
     ModuleLocation,
     OnLabwareLocation,
     AddressableAreaLocation,
+    InStackerHopperLocation,
     OFF_DECK_LOCATION,
+    SYSTEM_LOCATION,
 )
 from opentrons.protocol_engine.errors.exceptions import LabwareNotLoadedOnModuleError
 from opentrons.types import DeckSlotName, StagingSlotName, Point
@@ -245,7 +248,11 @@ def _map_labware(
         # TODO(jbl 2023-06-08) check if we need to do any logic here or if this is correct
         return None
 
-    elif location_from_engine == OFF_DECK_LOCATION:
+    elif (
+        location_from_engine == OFF_DECK_LOCATION
+        or location_from_engine == SYSTEM_LOCATION
+        or isinstance(location_from_engine, InStackerHopperLocation)
+    ):
         # This labware is off-deck. Exclude it from conflict checking.
         # todo(mm, 2023-02-23): Move this logic into wrapped_deck_conflict.
         return None
@@ -296,6 +303,9 @@ def _map_module(
                 is_semi_configuration=False,
             ),
         )
+    elif module_type == ModuleType.FLEX_STACKER:
+        # TODO: This is a placeholder. We need to implement this.
+        return None
     else:
         return (
             mapped_location,