opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/protocols/duration/estimator.py

@@ -1,7 +1,6 @@
 import logging
-from typing import Optional, List
+from typing import Any, Optional, List, cast
 from typing_extensions import Final
-
 import math
 import functools
 
@@ -54,7 +53,7 @@ class DurationEstimator:
     Broker listener that calculates the duration of protocol steps.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Which slot the last command was in.
         self._last_deckslot = STARTING_SLOT
         # todo(mm, 2021-09-08): Support protocols with more than one
@@ -128,39 +127,50 @@ class DurationEstimator:
         # TODO (al, 2021-09-09):
         #  - Make this into a map
         #  - Remove "noqa: C901"
-        #  - type the payload in the on_X methods.
         if message_name == types.PICK_UP_TIP:
+            payload = cast(types.PickUpTipCommandPayload, payload)
             duration = self.on_pick_up_tip(payload=payload)
         elif message_name == types.DROP_TIP:
+            payload = cast(types.DropTipCommandPayload, payload)
             duration = self.on_drop_tip(payload=payload)
         elif message_name == types.ASPIRATE:
+            payload = cast(types.AspirateDispenseCommandPayload, payload)
             duration = self.on_aspirate(payload=payload)
         elif message_name == types.DISPENSE:
+            payload = cast(types.AspirateDispenseCommandPayload, payload)
             duration = self.on_dispense(payload=payload)
         elif message_name == types.BLOW_OUT:
+            payload = cast(types.BlowOutCommandPayload, payload)
             duration = self.on_blow_out(payload=payload)
         elif message_name == types.TOUCH_TIP:
-            duration = self.on_touch_tip(payload=payload)
+            payload = cast(types.TouchTipCommandPayload, payload)
+            duration = self.on_touch_tip()
         elif message_name == types.DELAY:
+            payload = cast(types.DelayCommandPayload, payload)
             duration = self.on_delay(payload=payload)
         elif message_name == types.TEMPDECK_SET_TEMP:
+            payload = cast(types.TempdeckSetTempCommandPayload, payload)
             duration = self.on_tempdeck_set_temp(payload=payload)
         elif message_name == types.TEMPDECK_DEACTIVATE:
-            duration = self.on_tempdeck_deactivate(payload=payload)
+            payload = cast(types.TempdeckDeactivateCommandPayload, payload)
+            duration = self.on_tempdeck_deactivate()
         elif message_name == types.TEMPDECK_AWAIT_TEMP:
-            duration = self.on_tempdeck_await_temp(payload=payload)
+            payload = cast(types.TempdeckAwaitTempCommandPayload, payload)
+            duration = self.on_tempdeck_await_temp()
         elif message_name == types.THERMOCYCLER_SET_BLOCK_TEMP:
+            payload = cast(types.ThermocyclerSetBlockTempCommandPayload, payload)
             duration = self.on_thermocycler_block_temp(payload=payload)
         elif message_name == types.THERMOCYCLER_EXECUTE_PROFILE:
+            payload = cast(types.ThermocyclerExecuteProfileCommandPayload, payload)
             duration = self.on_execute_profile(payload=payload)
         elif message_name == types.THERMOCYCLER_SET_LID_TEMP:
-            duration = self.on_thermocycler_set_lid_temp(payload=payload)
+            duration = self.on_thermocycler_set_lid_temp()
         elif message_name == types.THERMOCYCLER_CLOSE:
-            duration = self.on_thermocycler_lid_close(payload=payload)
+            duration = self.on_thermocycler_lid_close()
         elif message_name == types.THERMOCYCLER_DEACTIVATE_LID:
-            duration = self.on_thermocycler_deactivate_lid(payload=payload)
+            duration = self.on_thermocycler_deactivate_lid()
         elif message_name == types.THERMOCYCLER_OPEN:
-            duration = self.on_thermocycler_lid_open(payload=payload)
+            duration = self.on_thermocycler_lid_open()
         elif message_name == types.TRANSFER:
             # Already accounted for in other steps
             pass
@@ -177,10 +187,10 @@ class DurationEstimator:
             )
         return duration
 
-    def on_pick_up_tip(self, payload) -> float:
+    def on_pick_up_tip(self, payload: types.PickUpTipCommandPayload) -> float:
         """Handle a pick up tip event"""
-        instrument = payload["instrument"]
 
+        instrument = payload["instrument"]
         location = payload["location"]
         prev_slot = self._last_deckslot
         curr_slot = self.get_slot(location)
@@ -200,7 +210,8 @@ class DurationEstimator:
         )
         return duration
 
-    def on_drop_tip(self, payload) -> float:
+    def on_drop_tip(self, payload: types.DropTipCommandPayload) -> float:
+
         instrument = payload["instrument"]
         # We are going to once again use our "deck movement" set up. This should
         # be in pickup, drop tip, aspirate, dispense
@@ -221,7 +232,7 @@ class DurationEstimator:
         logger.info(f"{instrument.name}, drop tip duration is {duration}")
         return duration
 
-    def on_aspirate(self, payload) -> float:
+    def on_aspirate(self, payload: types.AspirateDispenseCommandPayload) -> float:
         # General aspiration code
         instrument = payload["instrument"]
         volume = payload["volume"]
@@ -250,13 +261,14 @@ class DurationEstimator:
         deck_travel_time = self.calc_deck_movement_time(
             self._deck, curr_slot, prev_slot, gantry_speed
         )
+        assert isinstance(aspiration_time, float)
         duration = deck_travel_time + z_total_time + aspiration_time
         logger.info(
             f"{instrument.name} aspirate from {slot}, " f"the duration is {duration}"
         )
         return duration
 
-    def on_dispense(self, payload) -> float:
+    def on_dispense(self, payload: types.AspirateDispenseCommandPayload) -> float:
         # General code for aspiration/dispense
         instrument = payload["instrument"]
         volume = payload["volume"]
@@ -282,6 +294,7 @@ class DurationEstimator:
             self._deck, curr_slot, prev_slot, gantry_speed
         )
 
+        assert isinstance(dispense_time, float)
         duration = deck_travel_time + z_total_time + dispense_time
 
         logger.info(
@@ -289,7 +302,7 @@ class DurationEstimator:
         )
         return duration
 
-    def on_blow_out(self, payload) -> float:
+    def on_blow_out(self, payload: types.BlowOutCommandPayload) -> float:
         location = payload["location"]
         curr_slot = self.get_slot(location)
         # In theory, we could use instrument.flow_rate.blow_out, but we don't
@@ -299,7 +312,7 @@ class DurationEstimator:
         logger.info(f"blowing_out_for {duration} seconds, in slot {curr_slot}")
         return duration
 
-    def on_touch_tip(self, payload) -> float:
+    def on_touch_tip(self) -> float:
         # base assumption. Touch_tip takes 0.5 seconds This is consistent with a
         # ~7.5mm diameter (default 60mm/s, 4 sides)
         # plate = protocol.load_labware('corning_96_wellplate_360ul_flat', '1')
@@ -311,17 +324,20 @@ class DurationEstimator:
         logger.info(f"touch_tip for {duration} seconds")
         return duration
 
-    def on_delay(self, payload) -> float:
+    def on_delay(self, payload: types.DelayCommandPayload) -> float:
         # Explanation: we are gathering seconds and minutes here
         seconds_delay = payload["seconds"]
         minutes_delay = payload["minutes"]
         duration = seconds_delay + minutes_delay * 60
+        duration = float(duration)
         # Note will need to multiply minutes by 60
         logger.info(f"delay for {seconds_delay} seconds and {minutes_delay} minutes")
 
         return duration
 
-    def on_thermocycler_block_temp(self, payload) -> float:
+    def on_thermocycler_block_temp(
+        self, payload: types.ThermocyclerSetBlockTempCommandPayload
+    ) -> float:
         temperature = payload["temperature"]
         hold_time = payload["hold_time"]
         temp0 = self._last_thermocycler_module_temperature
@@ -340,10 +356,13 @@ class DurationEstimator:
             f"hold for {hold_time} seconds and set temp for {temperature}"
             f" C total duration {duration}"
         )
+        duration = float(duration)
 
         return duration
 
-    def on_execute_profile(self, payload) -> float:
+    def on_execute_profile(
+        self, payload: types.ThermocyclerExecuteProfileCommandPayload
+    ) -> float:
         # Overview We need to run each time a temperature change happens
         # through thermocycler_handler and multiply
         # By the cycle count. Then we also (in parallel) do the same with delays
@@ -386,35 +405,37 @@ class DurationEstimator:
         )
         return duration
 
-    def on_thermocycler_set_lid_temp(self, payload) -> float:
+    def on_thermocycler_set_lid_temp(self) -> float:
         # Hardware said ~1 minute
         duration = 60
         thermoaction = "set lid temperature"
         logger.info(f"thermocation =  {thermoaction}")
         return duration
 
-    def on_thermocycler_lid_close(self, payload) -> float:
+    def on_thermocycler_lid_close(self) -> float:
         # Hardware said ~24 seconds
         duration = 24
         thermoaction = "closing"
         logger.info(f"thermocation =  {thermoaction}")
         return duration
 
-    def on_thermocycler_lid_open(self, payload) -> float:
+    def on_thermocycler_lid_open(self) -> float:
         # Hardware said ~24 seconds
         duration = 24
         thermoaction = "opening"
         logger.info(f"thermocation =  {thermoaction}")
         return duration
 
-    def on_thermocycler_deactivate_lid(self, payload) -> float:
+    def on_thermocycler_deactivate_lid(self) -> float:
         # Hardware said ~23 seconds
         duration = 23
         thermoaction = "Deactivating"
         logger.info(f"thermocation =  {thermoaction}")
         return duration
 
-    def on_tempdeck_set_temp(self, payload) -> float:
+    def on_tempdeck_set_temp(
+        self, payload: types.TempdeckSetTempCommandPayload
+    ) -> float:
         temperature_tempdeck = payload["celsius"]
         temp0 = self._last_temperature_module_temperature
         temp1 = float(temperature_tempdeck)
@@ -460,20 +481,20 @@ class DurationEstimator:
                 duration = self.rate_low(temp0, temp1)
         return duration
 
-    def on_tempdeck_deactivate(self, payload) -> float:
+    def on_tempdeck_deactivate(self) -> float:
         # TODO (al, 2021-09-08: Find an answer for this value.
         duration = 0.0
         logger.info("tempdeck deactivating")
         return duration
 
-    def on_tempdeck_await_temp(self, payload) -> float:
+    def on_tempdeck_await_temp(self) -> float:
         # The duration is accounted for in set temperature
         duration = 0.0
         logger.info("tempdeck awaiting temperature")
         return duration
 
     @staticmethod
-    def get_slot(location) -> Optional[str]:
+    def get_slot(location: Any) -> Optional[str]:
         """A utility function to extract the slot number from the location."""
         if isinstance(location, Location):
             return location.labware.first_parent()

opentrons/protocols/execution/dev_types.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, TYPE_CHECKING
+from typing import Callable, Dict, TYPE_CHECKING, Any
 
 from typing_extensions import Protocol, TypedDict
 
@@ -45,7 +45,7 @@ if Protocol is not None:
         not a type (https://github.com/python/mypy/issues/3915)
         """
 
-        async def _asdict(self):
+        async def _asdict(self) -> Dict[Any, Any]:
             ...
 
 

opentrons/protocols/execution/execute_json_v4.py

@@ -8,6 +8,11 @@ from opentrons.protocol_api import (
     ModuleContext,
     ThermocyclerContext,
 )
+from opentrons_shared_data.protocol.types import (
+    MagneticModuleCommand,
+    TemperatureModuleCommand,
+    ThermocyclerCommand,
+)
 from .execute_json_v3 import _delay, _move_to_slot
 from opentrons.protocols.execution.types import LoadedLabware, Instruments
 from opentrons_shared_data.protocol.constants import (
@@ -277,21 +282,21 @@ def dispatch_json(
                 params,  # type: ignore
                 modules,
                 command_type,  # type: ignore
-                magnetic_module_command_map,
+                magnetic_module_command_map,  # type: ignore[arg-type]
             )
         elif command_type in temperature_module_command_map:
             handleTemperatureCommand(
-                params,  # type: ignore
+                params,  # type: ignore[arg-type]
                 modules,
                 command_type,  # type: ignore
-                temperature_module_command_map,
+                temperature_module_command_map,  # type: ignore[arg-type]
             )
         elif command_type in thermocycler_module_command_map:
             handleThermocyclerCommand(
                 params,  # type: ignore
                 modules,  # type: ignore
                 command_type,  # type: ignore
-                thermocycler_module_command_map,
+                thermocycler_module_command_map,  # type: ignore[arg-type]
             )
         elif command_item["command"] == JsonRobotCommand.delay.value:
             _delay(context, params)  # type: ignore
@@ -305,12 +310,12 @@ def handleTemperatureCommand(
     params: Union["TemperatureParams", "ModuleIDParams"],
     modules: Dict[str, ModuleContext],
     command_type: "TemperatureModuleCommandId",
-    temperature_module_command_map,
+    temperature_module_command_map: TemperatureModuleCommand,
 ) -> None:
     module_id = params["module"]
     module = modules[module_id]
     if isinstance(module, TemperatureModuleContext):
-        temperature_module_command_map[command_type](module, params)
+        temperature_module_command_map[command_type](module, params)  # type: ignore[typeddict-item]
     else:
         raise RuntimeError(
             "Temperature Module does not match " + "TemperatureModuleContext interface"
@@ -326,12 +331,12 @@ def handleThermocyclerCommand(
     ],
     modules: Dict[str, ThermocyclerContext],
     command_type: "ThermocyclerCommandId",
-    thermocycler_module_command_map,
+    thermocycler_module_command_map: ThermocyclerCommand,
 ) -> None:
     module_id = params["module"]
     module = modules[module_id]
     if isinstance(module, ThermocyclerContext):
-        thermocycler_module_command_map[command_type](module, params)
+        thermocycler_module_command_map[command_type](module, params)  # type: ignore[typeddict-item]
     else:
         raise RuntimeError(
             "Thermocycler Module does not match ThermocyclerContext interface"
@@ -342,12 +347,12 @@ def handleMagnetCommand(
     params: Union["ModuleIDParams", "MagneticModuleEngageParams"],
     modules: Dict[str, ModuleContext],
     command_type: "MagneticModuleCommandId",
-    magnetic_module_command_map,
+    magnetic_module_command_map: MagneticModuleCommand,
 ) -> None:
     module_id = params["module"]
     module = modules[module_id]
     if isinstance(module, MagneticModuleContext):
-        magnetic_module_command_map[command_type](module, params)
+        magnetic_module_command_map[command_type](module, params)  # type: ignore[typeddict-item]
     else:
         raise RuntimeError(
             "Magnetic Module does not match MagneticModuleContext interface"

opentrons/protocols/execution/execute_python.py

@@ -3,6 +3,7 @@ import inspect
 import logging
 import traceback
 import sys
+from types import TracebackType
 from typing import Any, Dict, Optional
 
 from opentrons.drivers.smoothie_drivers.errors import SmoothieAlarm
@@ -21,7 +22,7 @@ from opentrons_shared_data.errors.exceptions import ExecutionCancelledError
 MODULE_LOG = logging.getLogger(__name__)
 
 
-def _runfunc_ok(run_func: Any):
+def _runfunc_ok(run_func: Any) -> None:
     if not callable(run_func):
         raise SyntaxError("No function 'run(ctx)' defined")
     sig = inspect.Signature.from_callable(run_func)
@@ -44,10 +45,14 @@ def _add_parameters_func_ok(add_parameters_func: Any) -> None:
         raise SyntaxError("Function 'add_parameters' must take exactly one argument.")
 
 
-def _find_protocol_error(tb, proto_name):
+def _find_protocol_error(
+    tb: TracebackType | None, proto_name: str
+) -> traceback.FrameSummary:
     """Return the FrameInfo for the lowest frame in the traceback from the
     protocol.
     """
+    if tb is None:
+        raise KeyError
     tb_info = traceback.extract_tb(tb)
     for frame in reversed(tb_info):
         if frame.filename == proto_name:
@@ -57,7 +62,7 @@ def _find_protocol_error(tb, proto_name):
 
 
 def _raise_pretty_protocol_error(exception: Exception, filename: str) -> None:
-    exc_type, exc_value, tb = sys.exc_info()
+    _, _, tb = sys.exc_info()
     try:
         frame = _find_protocol_error(tb, filename)
     except KeyError:

opentrons/protocols/geometry/planning.py

@@ -1,7 +1,7 @@
 import functools
 import logging
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
+from typing import Any, List, Optional, Tuple, Type
 
 from opentrons import types
 from opentrons.hardware_control.types import CriticalPoint
@@ -27,7 +27,7 @@ class LabwareHeightError(Exception):
     pass
 
 
-def max_many(*args):
+def max_many(*args: float) -> float:
     return functools.reduce(max, args[1:], args[0])
 
 
@@ -76,7 +76,7 @@ class MoveConstraints:
     minimum_z_height: float = 0.0
 
     @classmethod
-    def build(cls, **kwargs):
+    def build(cls: Type["MoveConstraints"], **kwargs: Any) -> "MoveConstraints":
         return cls(**{k: v for k, v in kwargs.items() if v is not None})
 
 
@@ -103,10 +103,10 @@ def safe_height(
     to_loc: types.Location,
     deck: Deck,
     instr_max_height: float,
-    well_z_margin: float = None,
-    lw_z_margin: float = None,
-    minimum_lw_z_margin: float = None,
-    minimum_z_height: float = None,
+    well_z_margin: Optional[float] = None,
+    lw_z_margin: Optional[float] = None,
+    minimum_lw_z_margin: Optional[float] = None,
+    minimum_z_height: Optional[float] = None,
 ) -> float:
     """
     Derive the height required to clear the current deck setup along
@@ -147,7 +147,7 @@ def _build_safe_height(
     from_point = from_loc.point
     from_lw, from_well = from_loc.labware.get_parent_labware_and_well()
 
-    if to_lw and to_lw == from_lw:
+    if to_lw and from_lw and to_lw == from_lw:
         # If we know the labwares we’re moving from and to, we can calculate
         # a safe z based on their heights
         if to_well:
@@ -206,11 +206,11 @@ def plan_moves(
     to_loc: types.Location,
     deck: Deck,
     instr_max_height: float,
-    well_z_margin: float = None,
-    lw_z_margin: float = None,
+    well_z_margin: Optional[float] = None,
+    lw_z_margin: Optional[float] = None,
     force_direct: bool = False,
-    minimum_lw_z_margin: float = None,
-    minimum_z_height: float = None,
+    minimum_lw_z_margin: Optional[float] = None,
+    minimum_z_height: Optional[float] = None,
     use_experimental_waypoint_planning: bool = False,
 ) -> List[Tuple[types.Point, Optional[CriticalPoint]]]:
     """Plan moves between one :py:class:`.Location` and another.

opentrons/protocols/labware.py

@@ -2,14 +2,12 @@ from __future__ import annotations
 
 import logging
 import json
-import os
 
 from pathlib import Path
-from typing import Any, AnyStr, List, Dict, Optional, Union
+from typing import Any, AnyStr, Dict, Optional, Union
 
 import jsonschema  # type: ignore
 
-from opentrons.protocols.api_support.util import ModifiedList
 from opentrons_shared_data import load_shared_data, get_shared_data_root
 from opentrons.protocols.api_support.constants import (
     OPENTRONS_NAMESPACE,
@@ -63,29 +61,6 @@ def get_labware_definition(
     return _get_standard_labware_definition(load_name, namespace, version)
 
 
-def get_all_labware_definitions() -> List[str]:
-    """
-    Return a list of standard and custom labware definitions with load_name +
-        name_space + version existing on the robot
-    """
-    labware_list = ModifiedList()
-
-    def _check_for_subdirectories(path):
-        with os.scandir(path) as top_path:
-            for sub_dir in top_path:
-                if sub_dir.is_dir():
-                    labware_list.append(sub_dir.name)
-
-    # check for standard labware
-    _check_for_subdirectories(get_shared_data_root() / STANDARD_DEFS_PATH)
-
-    # check for custom labware
-    for namespace in os.scandir(USER_DEFS_PATH):
-        _check_for_subdirectories(namespace)
-
-    return labware_list
-
-
 def save_definition(
     labware_def: LabwareDefinition, force: bool = False, location: Optional[Path] = None
 ) -> None:
@@ -114,7 +89,6 @@ def save_definition(
             f'Saving definitions to the "{OPENTRONS_NAMESPACE}" namespace '
             + "is not permitted"
         )
-
     def_path = _get_path_to_labware(load_name, namespace, version, location)
 
     if not force and def_path.is_file():
@@ -150,7 +124,7 @@ def verify_definition(
     jsonschema.validate(to_return, labware_schema_v2)
     # we can type ignore this because if it passes the jsonschema it has
     # the correct structure
-    return to_return  # type: ignore
+    return to_return  # type: ignore[return-value]
 
 
 def _get_labware_definition_from_bundle(
@@ -219,7 +193,6 @@ def _get_standard_labware_definition(
         Definitions Folder from the Opentrons App before
         uploading your protocol.
         """
-
     if namespace is None:
         for fallback_namespace in [OPENTRONS_NAMESPACE, CUSTOM_NAMESPACE]:
             try:
@@ -244,8 +217,7 @@ def _get_standard_labware_definition(
             f'Labware "{load_name}" not found with version {checked_version} '
             f'in namespace "{namespace}".'
         )
-
-    return labware_def
+    return labware_def  # type: ignore[no-any-return]
 
 
 def _get_path_to_labware(
@@ -253,9 +225,21 @@ def _get_path_to_labware(
 ) -> Path:
     if namespace == OPENTRONS_NAMESPACE:
         # all labware in OPENTRONS_NAMESPACE is stored in shared data
-        return (
-            get_shared_data_root() / STANDARD_DEFS_PATH / load_name / f"{version}.json"
+        schema_3_path = (
+            get_shared_data_root()
+            / STANDARD_DEFS_PATH
+            / "3"
+            / load_name
+            / f"{version}.json"
+        )
+        schema_2_path = (
+            get_shared_data_root()
+            / STANDARD_DEFS_PATH
+            / "2"
+            / load_name
+            / f"{version}.json"
         )
+        return schema_3_path if schema_3_path.exists() else schema_2_path
     if not base_path:
         base_path = USER_DEFS_PATH
     def_path = base_path / namespace / load_name / f"{version}.json"

opentrons/simulate.py

@@ -815,6 +815,7 @@ def _create_live_context_pe(
                 robot_type, use_pe_virtual_hardware=use_pe_virtual_hardware
             ),
             deck_configuration=None,
+            file_provider=None,
             error_recovery_policy=error_recovery_policy.never_recover,
             drop_tips_after_run=False,
             post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
@@ -883,8 +884,6 @@ def _run_file_non_pe(
     context.home()
     with scraper.scrape():
         try:
-            # TODO (spp, 2024-03-18): use true run-time param overrides once enabled
-            #  for cli protocol simulation/ execution
             execute.run_protocol(
                 protocol, context, run_time_parameters_with_overrides=None
             )
@@ -914,6 +913,7 @@ def _run_file_pe(
     log_level: str,
 ) -> _SimulateResult:
     """Run a protocol file with Protocol Engine."""
+    # TODO (spp, 2024-03-18): use run-time param overrides once enabled for cli protocol simulation.
 
     async def run(protocol_source: ProtocolSource) -> _SimulateResult:
         hardware_api_wrapped = hardware_api.wrapped()
@@ -1014,7 +1014,7 @@ def main() -> int:
     args = parser.parse_args()
 
     # TODO(mm, 2022-12-01): Configure the DurationEstimator with the correct deck type.
-    duration_estimator = DurationEstimator() if args.estimate_duration else None  # type: ignore[no-untyped-call]
+    duration_estimator = DurationEstimator() if args.estimate_duration else None
 
     try:
         runlog, maybe_bundle = simulate(

opentrons/types.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import enum
 from math import sqrt, isclose
-from typing import TYPE_CHECKING, Any, NamedTuple, Iterator, Union, List
+from typing import TYPE_CHECKING, Any, NamedTuple, Iterator, Union, List, Optional
 
 from opentrons_shared_data.robot.types import RobotType
 
@@ -79,7 +79,9 @@ LocationLabware = Union[
 
 
 class Location:
-    """A location to target as a motion.
+    """Location(point: Point, labware: Union["Labware", "Well", str, "ModuleGeometry", LabwareLike, None, "ModuleContext"])
+
+    A location to target as a motion.
 
     The location contains a :py:class:`.Point` (in
     :ref:`protocol-api-deck-coords`) and possibly an associated
@@ -116,10 +118,13 @@ class Location:
             None,
             "ModuleContext",
         ],
+        *,
+        _ot_internal_is_meniscus: Optional[bool] = None,
     ):
         self._point = point
         self._given_labware = labware
         self._labware = LabwareLike(labware)
+        self._is_meniscus = _ot_internal_is_meniscus
 
     # todo(mm, 2021-10-01): Figure out how to get .point and .labware to show up
     # in the rendered docs, and then update the class docstring to use cross-references.
@@ -132,6 +137,10 @@ class Location:
     def labware(self) -> LabwareLike:
         return self._labware
 
+    @property
+    def is_meniscus(self) -> Optional[bool]:
+        return self._is_meniscus
+
     def __iter__(self) -> Iterator[Union[Point, LabwareLike]]:
         """Iterable interface to support unpacking. Like a tuple.
 
@@ -148,6 +157,7 @@ class Location:
             isinstance(other, Location)
             and other._point == self._point
             and other._labware == self._labware
+            and other._is_meniscus == self._is_meniscus
         )
 
     def move(self, point: Point) -> "Location":
@@ -173,7 +183,7 @@ class Location:
         return Location(point=self.point + point, labware=self._given_labware)
 
     def __repr__(self) -> str:
-        return f"Location(point={repr(self._point)}, labware={self._labware})"
+        return f"Location(point={repr(self._point)}, labware={self._labware}, is_meniscus={self._is_meniscus if self._is_meniscus is not None else False})"
 
 
 # TODO(mc, 2020-10-22): use MountType implementation for Mount
@@ -282,6 +292,23 @@ class DeckSlotName(enum.Enum):
         str_val = str(value).upper()
         return cls(str_val)
 
+    @classmethod
+    def ot3_slots(cls) -> List["DeckSlotName"]:
+        return [
+            DeckSlotName.SLOT_A1,
+            DeckSlotName.SLOT_A2,
+            DeckSlotName.SLOT_A3,
+            DeckSlotName.SLOT_B1,
+            DeckSlotName.SLOT_B2,
+            DeckSlotName.SLOT_B3,
+            DeckSlotName.SLOT_C1,
+            DeckSlotName.SLOT_C2,
+            DeckSlotName.SLOT_C3,
+            DeckSlotName.SLOT_D1,
+            DeckSlotName.SLOT_D2,
+            DeckSlotName.SLOT_D3,
+        ]
+
     # TODO(mm, 2023-05-08):
     # Migrate callers off of this method. https://opentrons.atlassian.net/browse/RLAB-345
     def as_int(self) -> int: