opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_api/robot_context.py

@@ -1,11 +1,25 @@
-from typing import NamedTuple, Union, Dict, Optional
+from typing import NamedTuple, Union, Optional
 
-from opentrons.types import Mount, DeckLocation, Point
+from opentrons.types import (
+    Mount,
+    DeckLocation,
+    Location,
+    Point,
+    AxisMapType,
+    AxisType,
+    StringAxisMap,
+)
 from opentrons.legacy_commands import publisher
-from opentrons.hardware_control import SyncHardwareAPI, types as hw_types
+from opentrons.hardware_control import SyncHardwareAPI
+from opentrons.protocols.api_support.util import requires_version
+from opentrons.protocols.api_support.types import APIVersion
+from opentrons_shared_data.pipette.types import PipetteNameType
 
-from ._types import OffDeckType
-from .core.common import ProtocolCore
+from . import validation
+from .core.common import ProtocolCore, RobotCore
+from .module_contexts import ModuleContext
+from .labware import Labware
+from ._types import PipetteActionTypes, PlungerPositionTypes
 
 
 class HardwareManager(NamedTuple):
@@ -34,56 +48,214 @@ class RobotContext(publisher.CommandPublisher):
 
     """
 
-    def __init__(self, core: ProtocolCore) -> None:
-        self._hardware = HardwareManager(hardware=core.get_hardware())
+    def __init__(
+        self, core: RobotCore, protocol_core: ProtocolCore, api_version: APIVersion
+    ) -> None:
+        self._hardware = HardwareManager(hardware=protocol_core.get_hardware())
+        self._core = core
+        self._protocol_core = protocol_core
+        self._api_version = api_version
+
+    @property
+    @requires_version(2, 22)
+    def api_version(self) -> APIVersion:
+        return self._api_version
 
     @property
     def hardware(self) -> HardwareManager:
+        # TODO this hardware attribute should be deprecated
+        # in version 3.0+ as we will only support exposed robot
+        # context commands.
         return self._hardware
 
+    @requires_version(2, 22)
     def move_to(
         self,
         mount: Union[Mount, str],
-        destination: Point,
-        velocity: float,
+        destination: Location,
+        speed: Optional[float] = None,
     ) -> None:
-        raise NotImplementedError()
+        """
+        Move a specified mount to a destination location on the deck.
+
+        :param mount: The mount of the instrument you wish to move.
+                      This can either be an instance of :py:class:`.types.Mount` or one
+                      of the strings ``"left"``, ``"right"``, ``"extension"``, ``"gripper"``. Note
+                      that the gripper mount can be referred to either as ``"extension"`` or ``"gripper"``.
+        :type mount: types.Mount or str
+        :param Location destination:
+        :param speed:
+        """
+        mount = validation.ensure_instrument_mount(mount)
+        self._core.move_to(mount, destination.point, speed)
 
+    @requires_version(2, 22)
     def move_axes_to(
         self,
-        abs_axis_map: Dict[hw_types.Axis, hw_types.AxisMapValue],
-        velocity: float,
-        critical_point: Optional[hw_types.CriticalPoint],
+        axis_map: Union[AxisMapType, StringAxisMap],
+        critical_point: Optional[Union[AxisMapType, StringAxisMap]] = None,
+        speed: Optional[float] = None,
     ) -> None:
-        raise NotImplementedError()
+        """
+        Move a set of axes to an absolute position on the deck.
 
+        :param axis_map: A dictionary mapping axes to an absolute position on the deck in mm.
+        :param critical_point: The critical point to move the axes with. It should only
+        specify the gantry axes (i.e. `x`, `y`, `z`).
+        :param float speed: The maximum speed with which you want to move all the axes
+        in the axis map.
+        """
+        instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
+        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+        axis_map = validation.ensure_axis_map_type(
+            axis_map, self._protocol_core.robot_type, is_96_channel
+        )
+        if critical_point:
+            critical_point = validation.ensure_axis_map_type(
+                critical_point, self._protocol_core.robot_type, is_96_channel
+            )
+            validation.ensure_only_gantry_axis_map_type(
+                critical_point, self._protocol_core.robot_type
+            )
+        else:
+            critical_point = None
+        self._core.move_axes_to(axis_map, critical_point, speed)
+
+    @requires_version(2, 22)
     def move_axes_relative(
-        self, rel_axis_map: Dict[hw_types.Axis, hw_types.AxisMapValue], velocity: float
+        self,
+        axis_map: Union[AxisMapType, StringAxisMap],
+        speed: Optional[float] = None,
     ) -> None:
-        raise NotImplementedError()
+        """
+        Move a set of axes to a relative position on the deck.
+
+        :param axis_map: A dictionary mapping axes to relative movements in mm.
+        :type mount: types.Mount or str
 
-    def close_gripper_jaw(self, force: float) -> None:
-        raise NotImplementedError()
+        :param float speed: The maximum speed with which you want to move all the axes
+        in the axis map.
+        """
+        instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
+        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+
+        axis_map = validation.ensure_axis_map_type(
+            axis_map, self._protocol_core.robot_type, is_96_channel
+        )
+        self._core.move_axes_relative(axis_map, speed)
+
+    def close_gripper_jaw(self, force: Optional[float] = None) -> None:
+        """Command the gripper closed with some force."""
+        self._core.close_gripper(force)
 
     def open_gripper_jaw(self) -> None:
-        raise NotImplementedError()
+        """Command the gripper open."""
+        self._core.release_grip()
 
     def axis_coordinates_for(
-        self, mount: Union[Mount, str], location: Union[DeckLocation, OffDeckType]
-    ) -> None:
-        raise NotImplementedError()
+        self,
+        mount: Union[Mount, str],
+        location: Union[Location, ModuleContext, DeckLocation],
+    ) -> AxisMapType:
+        """
+        Build a :py:class:`.types.AxisMapType` from a location to be compatible with
+        either :py:meth:`.RobotContext.move_axes_to` or :py:meth:`.RobotContext.move_axes_relative`.
+        You must provide only one of `location`, `slot`, or `module` to build
+        the axis map.
+
+        :param mount: The mount of the instrument you wish create an axis map for.
+                      This can either be an instance of :py:class:`.types.Mount` or one
+                      of the strings ``"left"``, ``"right"``, ``"extension"``, ``"gripper"``. Note
+                      that the gripper mount can be referred to either as ``"extension"`` or ``"gripper"``.
+        :type mount: types.Mount or str
+        :param location: The location to format an axis map for.
+        :type location: `Well`, `ModuleContext`, `DeckLocation` or `OffDeckType`
+        """
+        mount = validation.ensure_instrument_mount(mount)
+
+        mount_axis = AxisType.axis_for_mount(mount)
+        if location:
+            loc: Union[Point, Labware, None]
+            if isinstance(location, ModuleContext):
+                loc = location.labware
+                if not loc:
+                    raise ValueError(f"There must be a labware on {location}")
+                top_of_labware = loc.wells()[0].top()
+                loc = top_of_labware.point
+                return {mount_axis: loc.z, AxisType.X: loc.x, AxisType.Y: loc.y}
+            elif location is DeckLocation and not isinstance(location, Location):
+                slot_name = validation.ensure_and_convert_deck_slot(
+                    location,
+                    api_version=self._api_version,
+                    robot_type=self._protocol_core.robot_type,
+                )
+                loc = self._protocol_core.get_slot_center(slot_name)
+                return {mount_axis: loc.z, AxisType.X: loc.x, AxisType.Y: loc.y}
+            elif isinstance(location, Location):
+                assert isinstance(location, Location)
+                loc = location.point
+                return {mount_axis: loc.z, AxisType.X: loc.x, AxisType.Y: loc.y}
+            else:
+                raise ValueError(
+                    "Location parameter must be a Module, Deck Location, or Location type."
+                )
+        else:
+            raise TypeError("You must specify a location to move to.")
 
     def plunger_coordinates_for_volume(
-        self, mount: Union[Mount, str], volume: float
-    ) -> None:
-        raise NotImplementedError()
+        self, mount: Union[Mount, str], volume: float, action: PipetteActionTypes
+    ) -> AxisMapType:
+        """
+        Build a :py:class:`.types.AxisMapType` for a pipette plunger motor from volume.
+
+        """
+        pipette_name = self._core.get_pipette_type_from_engine(mount)
+        if not pipette_name:
+            raise ValueError(
+                f"Expected a pipette to be attached to provided mount {mount}"
+            )
+        mount = validation.ensure_mount_for_pipette(mount, pipette_name)
+        pipette_axis = AxisType.plunger_axis_for_mount(mount)
+
+        pipette_position = self._core.get_plunger_position_from_volume(
+            mount, volume, action, self._protocol_core.robot_type
+        )
+        return {pipette_axis: pipette_position}
 
     def plunger_coordinates_for_named_position(
-        self, mount: Union[Mount, str], position_name: str
-    ) -> None:
-        raise NotImplementedError()
+        self, mount: Union[Mount, str], position_name: PlungerPositionTypes
+    ) -> AxisMapType:
+        """
+        Build a :py:class:`.types.AxisMapType` for a pipette plunger motor from position_name.
 
-    def build_axis_map(
-        self, axis_map: Dict[hw_types.Axis, hw_types.AxisMapValue]
-    ) -> None:
-        raise NotImplementedError()
+        """
+        pipette_name = self._core.get_pipette_type_from_engine(mount)
+        if not pipette_name:
+            raise ValueError(
+                f"Expected a pipette to be attached to provided mount {mount}"
+            )
+        mount = validation.ensure_mount_for_pipette(mount, pipette_name)
+        pipette_axis = AxisType.plunger_axis_for_mount(mount)
+        pipette_position = self._core.get_plunger_position_from_name(
+            mount, position_name
+        )
+        return {pipette_axis: pipette_position}
+
+    def build_axis_map(self, axis_map: StringAxisMap) -> AxisMapType:
+        """Take in a :py:class:`.types.StringAxisMap` and output a :py:class:`.types.AxisMapType`.
+        A :py:class:`.types.StringAxisMap` is allowed to contain any of the following strings:
+        ``"x"``, ``"y"``, "``z_l"``, "``z_r"``, "``z_g"``, ``"q"``.
+
+        An example of a valid axis map could be:
+
+        {"x": 1, "y": 2} or {"Z_L": 100}
+
+        Note that capitalization does not matter.
+
+        """
+        instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
+        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+
+        return validation.ensure_axis_map_type(
+            axis_map, self._protocol_core.robot_type, is_96_channel
+        )

opentrons/protocol_api/validation.py

@@ -11,7 +11,7 @@ from typing import (
     NamedTuple,
     TYPE_CHECKING,
 )
-
+from math import isinf, isnan
 from typing_extensions import TypeGuard
 
 from opentrons_shared_data.labware.labware_definition import LabwareRole
@@ -21,7 +21,16 @@ from opentrons_shared_data.robot.types import RobotType
 from opentrons.protocols.api_support.types import APIVersion, ThermocyclerStep
 from opentrons.protocols.api_support.util import APIVersionError
 from opentrons.protocols.models import LabwareDefinition
-from opentrons.types import Mount, DeckSlotName, StagingSlotName, Location
+from opentrons.protocols.advanced_control.transfers.common import TransferTipPolicyV2
+from opentrons.types import (
+    Mount,
+    DeckSlotName,
+    StagingSlotName,
+    Location,
+    AxisType,
+    AxisMapType,
+    StringAxisMap,
+)
 from opentrons.hardware_control.modules.types import (
     ModuleModel,
     MagneticModuleModel,
@@ -44,6 +53,9 @@ _COORDINATE_DECK_LABEL_VERSION_GATE = APIVersion(2, 15)
 # The first APIVersion where Python protocols can specify staging deck slots (e.g. "D4")
 _STAGING_DECK_SLOT_VERSION_GATE = APIVersion(2, 16)
 
+# The first APIVersion where Python protocols can load lids as stacks and treat them as attributes of a parent labware.
+LID_STACK_VERSION_GATE = APIVersion(2, 23)
+
 # Mapping of public Python Protocol API pipette load names
 # to names used by the internal Opentrons system
 _PIPETTE_NAMES_MAP = {
@@ -63,7 +75,9 @@ _PIPETTE_NAMES_MAP = {
     "flex_8channel_50": PipetteNameType.P50_MULTI_FLEX,
     "flex_1channel_1000": PipetteNameType.P1000_SINGLE_FLEX,
     "flex_8channel_1000": PipetteNameType.P1000_MULTI_FLEX,
+    "flex_8channel_1000_em": PipetteNameType.P1000_MULTI_EM,
     "flex_96channel_1000": PipetteNameType.P1000_96,
+    "flex_96channel_200": PipetteNameType.P200_96,
 }
 
 
@@ -75,6 +89,14 @@ class PipetteMountTypeError(TypeError):
     """An error raised when an invalid mount type is used for loading pipettes."""
 
 
+class InstrumentMountTypeError(TypeError):
+    """An error raised when an invalid mount type is used for any available instruments."""
+
+
+class IncorrectAxisError(TypeError):
+    """An error raised when an invalid axis key is provided in an axis map."""
+
+
 class LabwareDefinitionIsNotAdapterError(ValueError):
     """An error raised when an adapter is attempted to be loaded as a labware."""
 
@@ -95,7 +117,7 @@ def ensure_mount_for_pipette(
     mount: Union[str, Mount, None], pipette: PipetteNameType
 ) -> Mount:
     """Ensure that an input value represents a valid mount, and is valid for the given pipette."""
-    if pipette == PipetteNameType.P1000_96:
+    if pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]:
         # Always validate the raw mount input, even if the pipette is a 96-channel and we're not going
         # to use the mount value.
         if mount is not None:
@@ -146,6 +168,25 @@ def _ensure_mount(mount: Union[str, Mount]) -> Mount:
     )
 
 
+def ensure_instrument_mount(mount: Union[str, Mount]) -> Mount:
+    """Ensure that an input value represents a valid Mount for all instruments."""
+    if isinstance(mount, Mount):
+        return mount
+
+    if isinstance(mount, str):
+        if mount == "gripper":
+            # TODO (lc 08-02-2024) We should decide on the user facing name for
+            # the gripper mount axis.
+            mount = "extension"
+        try:
+            return Mount[mount.upper()]
+        except KeyError as e:
+            raise InstrumentMountTypeError(
+                "If mount is specified as a string, it must be 'left', 'right', 'gripper', or 'extension';"
+                f" instead, {mount} was given."
+            ) from e
+
+
 def ensure_pipette_name(pipette_name: str) -> PipetteNameType:
     """Ensure that an input value represents a valid pipette name."""
     pipette_name = ensure_lowercase_name(pipette_name)
@@ -158,6 +199,79 @@ def ensure_pipette_name(pipette_name: str) -> PipetteNameType:
         ) from None
 
 
+def _check_ot2_axis_type(
+    robot_type: RobotType, axis_map_keys: Union[List[str], List[AxisType]]
+) -> None:
+    if robot_type == "OT-2 Standard" and isinstance(axis_map_keys[0], AxisType):
+        if any(k not in AxisType.ot2_axes() for k in axis_map_keys):
+            raise IncorrectAxisError(
+                f"An OT-2 Robot only accepts the following axes {AxisType.ot2_axes()}"
+            )
+    if robot_type == "OT-2 Standard" and isinstance(axis_map_keys[0], str):
+        if any(k.upper() not in [axis.value for axis in AxisType.ot2_axes()] for k in axis_map_keys):  # type: ignore [union-attr]
+            raise IncorrectAxisError(
+                f"An OT-2 Robot only accepts the following axes {AxisType.ot2_axes()}"
+            )
+
+
+def _check_96_channel_axis_type(
+    is_96_channel: bool, axis_map_keys: Union[List[str], List[AxisType]]
+) -> None:
+    if is_96_channel and any(
+        key_variation in axis_map_keys for key_variation in ["Z_R", "z_r", AxisType.Z_R]
+    ):
+        raise IncorrectAxisError(
+            "A 96 channel is attached. You cannot move the `Z_R` mount."
+        )
+    if not is_96_channel and any(
+        key_variation in axis_map_keys for key_variation in ["Q", "q", AxisType.Q]
+    ):
+        raise IncorrectAxisError(
+            "A 96 channel is not attached. The clamp `Q` motor does not exist."
+        )
+
+
+def ensure_axis_map_type(
+    axis_map: Union[AxisMapType, StringAxisMap],
+    robot_type: RobotType,
+    is_96_channel: bool = False,
+) -> AxisMapType:
+    """Ensure that the axis map provided is in the correct shape and contains the correct keys."""
+    axis_map_keys: Union[List[str], List[AxisType]] = list(axis_map.keys())  # type: ignore
+    key_type = set(type(k) for k in axis_map_keys)
+
+    if len(key_type) > 1:
+        raise IncorrectAxisError(
+            "Please provide an `axis_map` with only string or only AxisType keys."
+        )
+    _check_ot2_axis_type(robot_type, axis_map_keys)
+    _check_96_channel_axis_type(is_96_channel, axis_map_keys)
+
+    if all(isinstance(k, AxisType) for k in axis_map_keys):
+        return_map: AxisMapType = axis_map  # type: ignore
+        return return_map
+    try:
+        return {AxisType[k.upper()]: v for k, v in axis_map.items()}  # type: ignore [union-attr]
+    except KeyError as e:
+        raise IncorrectAxisError(f"{e} is not a supported `AxisMapType`")
+
+
+def ensure_only_gantry_axis_map_type(
+    axis_map: AxisMapType, robot_type: RobotType
+) -> None:
+    """Ensure that the axis map provided is in the correct shape and matches the gantry axes for the robot."""
+    if robot_type == "OT-2 Standard":
+        if any(k not in AxisType.ot2_gantry_axes() for k in axis_map.keys()):
+            raise IncorrectAxisError(
+                f"A critical point only accepts OT-2 gantry axes which are {AxisType.ot2_gantry_axes()}"
+            )
+    else:
+        if any(k not in AxisType.flex_gantry_axes() for k in axis_map.keys()):
+            raise IncorrectAxisError(
+                f"A critical point only accepts Flex gantry axes which are {AxisType.flex_gantry_axes()}"
+            )
+
+
 # TODO(jbl 11-17-2023) this function's original purpose was ensure a valid deck slot for a given robot type
 #   With deck configuration, the shape of this should change to better represent it checking if a deck slot
 #   (and maybe any addressable area) being valid for that deck configuration
@@ -253,6 +367,27 @@ def ensure_definition_is_labware(definition: LabwareDefinition) -> None:
         )
 
 
+def ensure_definition_is_lid(definition: LabwareDefinition) -> None:
+    """Ensure that one of the definition's allowed roles is `lid` or that that field is empty."""
+    if LabwareRole.lid not in definition.allowedRoles:
+        raise LabwareDefinitionIsNotLabwareError(
+            f"Labware {definition.parameters.loadName} is not a lid."
+        )
+
+
+def ensure_definition_is_not_lid_after_api_version(
+    api_version: APIVersion, definition: LabwareDefinition
+) -> None:
+    """Ensure that one of the definition's allowed roles is not `lid` or that the API Version is below the release where lid loading was seperated."""
+    if (
+        LabwareRole.lid in definition.allowedRoles
+        and api_version >= LID_STACK_VERSION_GATE
+    ):
+        raise APIVersionError(
+            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version greater than {LID_STACK_VERSION_GATE}."
+        )
+
+
 _MODULE_ALIASES: Dict[str, ModuleModel] = {
     "magdeck": MagneticModuleModel.MAGNETIC_V1,
     "magnetic module": MagneticModuleModel.MAGNETIC_V1,
@@ -483,3 +618,127 @@ def validate_location(
         if well is not None
         else PointTarget(location=target_location, in_place=in_place)
     )
+
+
+def ensure_boolean(value: bool) -> bool:
+    """Ensure value is a boolean."""
+    if not isinstance(value, bool):
+        raise ValueError("Value must be a boolean.")
+    return value
+
+
+def ensure_float(value: Union[int, float]) -> float:
+    """Ensure value is a float (or an integer) and return it as a float."""
+    if not isinstance(value, (int, float)):
+        raise ValueError("Value must be a floating point number.")
+    return float(value)
+
+
+def ensure_positive_float(value: Union[int, float]) -> float:
+    """Ensure value is a positive and real float value."""
+    float_value = ensure_float(value)
+    if isnan(float_value) or isinf(float_value):
+        raise ValueError("Value must be a defined, non-infinite number.")
+    if float_value < 0:
+        raise ValueError("Value must be a positive float.")
+    return float_value
+
+
+def ensure_positive_int(value: int) -> int:
+    """Ensure value is a positive integer."""
+    if not isinstance(value, int):
+        raise ValueError("Value must be an integer.")
+    if value < 0:
+        raise ValueError("Value must be a positive integer.")
+    return value
+
+
+def validate_coordinates(value: Sequence[float]) -> Tuple[float, float, float]:
+    """Ensure value is a valid sequence of 3 floats and return a tuple of 3 floats."""
+    if len(value) != 3:
+        raise ValueError("Coordinates must be a sequence of exactly three numbers")
+    if not all(isinstance(v, (float, int)) for v in value):
+        raise ValueError("All values in coordinates must be floats.")
+    return float(value[0]), float(value[1]), float(value[2])
+
+
+def ensure_new_tip_policy(value: str) -> TransferTipPolicyV2:
+    """Ensure that new_tip value is a valid TransferTipPolicy value."""
+    try:
+        return TransferTipPolicyV2(value.lower())
+    except ValueError:
+        raise ValueError(
+            f"'{value}' is invalid value for 'new_tip'."
+            f" Acceptable value is either 'never', 'once', 'always' or 'per source'."
+        )
+
+
+def _verify_each_list_element_is_valid_location(locations: Sequence[Well]) -> None:
+    from .labware import Well
+
+    for loc in locations:
+        if not isinstance(loc, Well):
+            raise ValueError(
+                f"'{loc}' is not a valid location for transfer."
+                f" Location should be a well instance."
+            )
+
+
+def ensure_valid_flat_wells_list_for_transfer_v2(
+    target: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+) -> List[Well]:
+    """Ensure that the given target(s) for a liquid transfer are valid and in a flat list."""
+    from .labware import Well
+
+    if isinstance(target, Well):
+        return [target]
+
+    if isinstance(target, (list, tuple)):
+        if len(target) == 0:
+            raise ValueError("No target well(s) specified for transfer.")
+        if isinstance(target[0], (list, tuple)):
+            for sub_sequence in target:
+                _verify_each_list_element_is_valid_location(sub_sequence)
+            return [loc for sub_sequence in target for loc in sub_sequence]
+        else:
+            _verify_each_list_element_is_valid_location(target)
+            return list(target)
+    else:
+        raise ValueError(
+            f"'{target}' is not a valid location for transfer."
+            f" Location should be a well instance, or a 1-dimensional or"
+            f" 2-dimensional sequence of well instances."
+        )
+
+
+def ensure_valid_tip_drop_location_for_transfer_v2(
+    tip_drop_location: Union[Location, Well, TrashBin, WasteChute]
+) -> Union[Location, Well, TrashBin, WasteChute]:
+    """Ensure that the tip drop location is valid for v2 transfer."""
+    from .labware import Well
+
+    if (
+        isinstance(tip_drop_location, Well)
+        or isinstance(tip_drop_location, TrashBin)
+        or isinstance(tip_drop_location, WasteChute)
+    ):
+        return tip_drop_location
+    elif isinstance(tip_drop_location, Location):
+        _, maybe_well = tip_drop_location.labware.get_parent_labware_and_well()
+
+        if maybe_well is None:
+            raise TypeError(
+                "If a location is specified as a `types.Location`"
+                " (for instance, as the result of a call to `Well.top()`),"
+                " it must be a location relative to a well,"
+                " since that is where a tip is dropped."
+                " However, the given location doesn't refer to any well."
+            )
+        return tip_drop_location
+    else:
+        raise TypeError(
+            f"If specified, location should be an instance of"
+            f" `types.Location` (e.g. the return value from `Well.top()`)"
+            f" or `Well` (e.g. `reservoir.wells()[0]`) or an instance of `TrashBin` or `WasteChute`."
+            f" However, it is '{tip_drop_location}'."
+        )

opentrons/protocol_engine/__init__.py

@@ -57,6 +57,8 @@ from .types import (
     ModuleModel,
     ModuleDefinition,
     Liquid,
+    LiquidClassRecord,
+    LiquidClassRecordWithId,
     AllNozzleLayoutConfiguration,
     SingleNozzleLayoutConfiguration,
     RowNozzleLayoutConfiguration,
@@ -122,6 +124,8 @@ __all__ = [
     "ModuleModel",
     "ModuleDefinition",
     "Liquid",
+    "LiquidClassRecord",
+    "LiquidClassRecordWithId",
     "AllNozzleLayoutConfiguration",
     "SingleNozzleLayoutConfiguration",
     "RowNozzleLayoutConfiguration",

opentrons/protocol_engine/actions/actions.py

@@ -27,7 +27,6 @@ from ..types import (
     ModuleDefinition,
     Liquid,
     DeckConfigurationType,
-    AddressableAreaLocation,
 )
 
 
@@ -235,12 +234,12 @@ class SetDeckConfigurationAction:
 class AddAddressableAreaAction:
     """Add a single addressable area to state.
 
-    This differs from the deck configuration in ProvideDeckConfigurationAction which
+    This differs from the deck configuration in SetDeckConfigurationAction which
     sends over a mapping of cutout fixtures. This action will only load one addressable
     area and that should be pre-validated before being sent via the action.
     """
 
-    addressable_area: AddressableAreaLocation
+    addressable_area_name: str
 
 
 @dataclasses.dataclass(frozen=True)

opentrons/protocol_engine/clients/sync_client.py

@@ -77,6 +77,18 @@ class SyncClient:
     ) -> commands.LoadPipetteResult:
         pass
 
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLidStackParams
+    ) -> commands.LoadLidStackResult:
+        pass
+
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLidParams
+    ) -> commands.LoadLidResult:
+        pass
+
     @overload
     def execute_command_without_recovery(
         self, params: commands.LiquidProbeParams
@@ -89,6 +101,12 @@ class SyncClient:
     ) -> commands.TryLiquidProbeResult:
         pass
 
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLiquidClassParams
+    ) -> commands.LoadLiquidClassResult:
+        pass
+
     def execute_command_without_recovery(
         self, params: commands.CommandParams
     ) -> commands.CommandResult: