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

opentrons/protocol_api/_types.py

@@ -17,3 +17,27 @@ A special location value, indicating that a labware is not currently on the robo
 
 See :ref:`off-deck-location` for details on using ``OFF_DECK`` with :py:obj:`ProtocolContext.move_labware()`.
 """
+
+
+class PlungerPositionTypes(enum.Enum):
+    PLUNGER_TOP = "top"
+    PLUNGER_BOTTOM = "bottom"
+    PLUNGER_BLOWOUT = "blow_out"
+    PLUNGER_DROPTIP = "drop_tip"
+
+
+PLUNGER_TOP: Final = PlungerPositionTypes.PLUNGER_TOP
+PLUNGER_BOTTOM: Final = PlungerPositionTypes.PLUNGER_BOTTOM
+PLUNGER_BLOWOUT: Final = PlungerPositionTypes.PLUNGER_BLOWOUT
+PLUNGER_DROPTIP: Final = PlungerPositionTypes.PLUNGER_DROPTIP
+
+
+class PipetteActionTypes(enum.Enum):
+    ASPIRATE_ACTION = "aspirate"
+    DISPENSE_ACTION = "dispense"
+    BLOWOUT_ACTION = "blowout"
+
+
+ASPIRATE_ACTION: Final = PipetteActionTypes.ASPIRATE_ACTION
+DISPENSE_ACTION: Final = PipetteActionTypes.DISPENSE_ACTION
+BLOWOUT_ACTION: Final = PipetteActionTypes.BLOWOUT_ACTION

opentrons/protocol_api/core/common.py

@@ -14,6 +14,7 @@ from .module import (
 )
 from .protocol import AbstractProtocol
 from .well import AbstractWellCore
+from .robot import AbstractRobot
 
 
 WellCore = AbstractWellCore
@@ -26,4 +27,5 @@ ThermocyclerCore = AbstractThermocyclerCore
 HeaterShakerCore = AbstractHeaterShakerCore
 MagneticBlockCore = AbstractMagneticBlockCore
 AbsorbanceReaderCore = AbstractAbsorbanceReaderCore
+RobotCore = AbstractRobot
 ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore]

opentrons/protocol_api/core/engine/instrument.py

@@ -1,13 +1,14 @@
 """ProtocolEngine-based InstrumentContext core implementation."""
-from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING, cast, Union
-from opentrons.protocols.api_support.types import APIVersion
+from __future__ import annotations
 
-from opentrons.types import Location, Mount
+from typing import Optional, TYPE_CHECKING, cast, Union, List
+from opentrons.types import Location, Mount, NozzleConfigurationType, NozzleMapInterface
 from opentrons.hardware_control import SyncHardwareAPI
 from opentrons.hardware_control.dev_types import PipetteDict
 from opentrons.protocols.api_support.util import FlowRates, find_value_for_api_version
+from opentrons.protocols.api_support.types import APIVersion
+from opentrons.protocols.advanced_control.transfers.common import TransferTipPolicyV2
 from opentrons.protocol_engine import commands as cmd
 from opentrons.protocol_engine import (
     DeckPoint,
@@ -26,24 +27,25 @@ from opentrons.protocol_engine.types import (
     PRIMARY_NOZZLE_LITERAL,
     NozzleLayoutConfigurationType,
     AddressableOffsetVector,
+    LiquidClassRecord,
 )
 from opentrons.protocol_engine.errors.exceptions import TipNotAttachedError
 from opentrons.protocol_engine.clients import SyncClient as EngineClient
 from opentrons.protocols.api_support.definitions import MAX_SUPPORTED_VERSION
 from opentrons_shared_data.pipette.types import PipetteNameType
+from opentrons_shared_data.errors.exceptions import (
+    UnsupportedHardwareCommand,
+)
 from opentrons.protocol_api._nozzle_layout import NozzleLayout
-from opentrons.hardware_control.nozzle_manager import NozzleConfigurationType
-from opentrons.hardware_control.nozzle_manager import NozzleMap
 from . import overlap_versions, pipette_movement_conflict
 
-from ..instrument import AbstractInstrument
 from .well import WellCore
-
+from ..instrument import AbstractInstrument
 from ...disposal_locations import TrashBin, WasteChute
 
 if TYPE_CHECKING:
     from .protocol import ProtocolCore
-
+    from opentrons.protocol_api._liquid import LiquidClass
 
 _DISPENSE_VOLUME_VALIDATION_ADDED_IN = APIVersion(2, 17)
 
@@ -86,6 +88,13 @@ class InstrumentCore(AbstractInstrument[WellCore]):
         self._liquid_presence_detection = bool(
             self._engine_client.state.pipettes.get_liquid_presence_detection(pipette_id)
         )
+        if (
+            self._liquid_presence_detection
+            and not self._pressure_supported_by_pipette()
+        ):
+            raise UnsupportedHardwareCommand(
+                "Pressure sensor not available for this pipette"
+            )
 
     @property
     def pipette_id(self) -> str:
@@ -104,6 +113,19 @@ class InstrumentCore(AbstractInstrument[WellCore]):
             pipette_id=self._pipette_id, speed=speed
         )
 
+    def air_gap_in_place(self, volume: float, flow_rate: float) -> None:
+        """Aspirate a given volume of air from the current location of the pipette.
+
+        Args:
+            volume: The volume of air to aspirate, in microliters.
+            folw_rate: The flow rate of air into the pipette, in microliters/s
+        """
+        self._engine_client.execute_command(
+            cmd.AirGapInPlaceParams(
+                pipetteId=self._pipette_id, volume=volume, flowRate=flow_rate
+            )
+        )
+
     def aspirate(
         self,
         location: Location,
@@ -724,7 +746,7 @@ class InstrumentCore(AbstractInstrument[WellCore]):
             self._pipette_id
         )
 
-    def get_nozzle_map(self) -> NozzleMap:
+    def get_nozzle_map(self) -> NozzleMapInterface:
         return self._engine_client.state.tips.get_pipette_nozzle_map(self._pipette_id)
 
     def has_tip(self) -> bool:
@@ -842,11 +864,55 @@ class InstrumentCore(AbstractInstrument[WellCore]):
             )
         )
 
+    def load_liquid_class(
+        self,
+        liquid_class: LiquidClass,
+        pipette_load_name: str,
+        tiprack_uri: str,
+    ) -> str:
+        """Load a liquid class into the engine and return its ID."""
+        transfer_props = liquid_class.get_for(
+            pipette=pipette_load_name, tiprack=tiprack_uri
+        )
+
+        liquid_class_record = LiquidClassRecord(
+            liquidClassName=liquid_class.name,
+            pipetteModel=self.get_model(),  # TODO: verify this is the correct 'model' to use
+            tiprack=tiprack_uri,
+            aspirate=transfer_props.aspirate.as_shared_data_model(),
+            singleDispense=transfer_props.dispense.as_shared_data_model(),
+            multiDispense=transfer_props.multi_dispense.as_shared_data_model()
+            if transfer_props.multi_dispense
+            else None,
+        )
+        result = self._engine_client.execute_command_without_recovery(
+            cmd.LoadLiquidClassParams(
+                liquidClassRecord=liquid_class_record,
+            )
+        )
+        return result.liquidClassId
+
+    def transfer_liquid(
+        self,
+        liquid_class_id: str,
+        volume: float,
+        source: List[WellCore],
+        dest: List[WellCore],
+        new_tip: TransferTipPolicyV2,
+        trash_location: Union[WellCore, Location, TrashBin, WasteChute],
+    ) -> None:
+        """Execute transfer using liquid class properties."""
+
     def retract(self) -> None:
         """Retract this instrument to the top of the gantry."""
         z_axis = self._engine_client.state.pipettes.get_z_axis(self._pipette_id)
         self._engine_client.execute_command(cmd.HomeParams(axes=[z_axis]))
 
+    def _pressure_supported_by_pipette(self) -> bool:
+        return self._engine_client.state.pipettes.get_pipette_supports_pressure(
+            self.pipette_id
+        )
+
     def detect_liquid_presence(self, well_core: WellCore, loc: Location) -> bool:
         labware_id = well_core.labware_id
         well_name = well_core.get_name()
@@ -922,3 +988,9 @@ class InstrumentCore(AbstractInstrument[WellCore]):
         self._protocol_core.set_last_location(location=loc, mount=self.get_mount())
 
         return result.z_position
+
+    def nozzle_configuration_valid_for_lld(self) -> bool:
+        """Check if the nozzle configuration currently supports LLD."""
+        return self._engine_client.state.pipettes.get_nozzle_configuration_supports_lld(
+            self.pipette_id
+        )

opentrons/protocol_api/core/engine/labware.py

@@ -1,5 +1,6 @@
 """ProtocolEngine-based Labware core implementations."""
-from typing import List, Optional, cast
+
+from typing import List, Optional, cast, Dict
 
 from opentrons_shared_data.labware.types import (
     LabwareParameters as LabwareParametersDict,
@@ -19,11 +20,12 @@ from opentrons.protocol_engine.types import (
     LabwareOffsetCreate,
     LabwareOffsetVector,
 )
-from opentrons.types import DeckSlotName, Point, StagingSlotName
-from opentrons.hardware_control.nozzle_manager import NozzleMap
+from opentrons.types import DeckSlotName, NozzleMapInterface, Point, StagingSlotName
 
 
+from ..._liquid import Liquid
 from ..labware import AbstractLabware, LabwareLoadParams
+
 from .well import WellCore
 
 
@@ -90,12 +92,14 @@ class LabwareCore(AbstractLabware[WellCore]):
 
     def get_definition(self) -> LabwareDefinitionDict:
         """Get the labware's definition as a plain dictionary."""
-        return cast(LabwareDefinitionDict, self._definition.dict(exclude_none=True))
+        return cast(
+            LabwareDefinitionDict, self._definition.model_dump(exclude_none=True)
+        )
 
     def get_parameters(self) -> LabwareParametersDict:
         return cast(
             LabwareParametersDict,
-            self._definition.parameters.dict(exclude_none=True),
+            self._definition.parameters.model_dump(exclude_none=True),
         )
 
     def get_quirks(self) -> List[str]:
@@ -116,7 +120,7 @@ class LabwareCore(AbstractLabware[WellCore]):
                 details={"kind": "labware-not-in-slot"},
             )
 
-        request = LabwareOffsetCreate.construct(
+        request = LabwareOffsetCreate.model_construct(
             definitionUri=self.get_uri(),
             location=offset_location,
             vector=LabwareOffsetVector(x=delta.x, y=delta.y, z=delta.z),
@@ -162,7 +166,7 @@ class LabwareCore(AbstractLabware[WellCore]):
         self,
         num_tips: int,
         starting_tip: Optional[WellCore],
-        nozzle_map: Optional[NozzleMap],
+        nozzle_map: Optional[NozzleMapInterface],
     ) -> Optional[str]:
         return self._engine_client.state.tips.get_next_tip(
             labware_id=self._labware_id,
@@ -203,3 +207,21 @@ class LabwareCore(AbstractLabware[WellCore]):
             LocationIsStagingSlotError,
         ):
             return None
+
+    def load_liquid(self, volumes: Dict[str, float], liquid: Liquid) -> None:
+        """Load liquid into wells of the labware."""
+        self._engine_client.execute_command(
+            cmd.LoadLiquidParams(
+                labwareId=self._labware_id, liquidId=liquid._id, volumeByWell=volumes
+            )
+        )
+
+    def load_empty(self, wells: List[str]) -> None:
+        """Mark wells of the labware as empty."""
+        self._engine_client.execute_command(
+            cmd.LoadLiquidParams(
+                labwareId=self._labware_id,
+                liquidId="EMPTY",
+                volumeByWell={well: 0.0 for well in wells},
+            )
+        )

opentrons/protocol_api/core/engine/protocol.py

@@ -6,6 +6,7 @@ from opentrons_shared_data.liquid_classes import LiquidClassDefinitionDoesNotExi
 
 from opentrons.protocol_engine import commands as cmd
 from opentrons.protocol_engine.commands import LoadModuleResult
+
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.labware.types import LabwareDefinition as LabwareDefDict
@@ -63,6 +64,7 @@ from ..protocol import AbstractProtocol
 from ..labware import LabwareLoadParams
 from .labware import LabwareCore
 from .instrument import InstrumentCore
+from .robot import RobotCore
 from .module_core import (
     ModuleCore,
     TemperatureModuleCore,
@@ -82,7 +84,9 @@ if TYPE_CHECKING:
 
 class ProtocolCore(
     AbstractProtocol[
-        InstrumentCore, LabwareCore, Union[ModuleCore, NonConnectedModuleCore]
+        InstrumentCore,
+        LabwareCore,
+        Union[ModuleCore, NonConnectedModuleCore],
     ]
 ):
     """Protocol API core using a ProtocolEngine.
@@ -189,7 +193,7 @@ class ProtocolCore(
     ) -> LabwareLoadParams:
         """Add a labware definition to the set of loadable definitions."""
         uri = self._engine_client.add_labware_definition(
-            LabwareDefinition.parse_obj(definition)
+            LabwareDefinition.model_validate(definition)
         )
         return LabwareLoadParams.from_uri(uri)
 
@@ -229,6 +233,9 @@ class ProtocolCore(
         )
         # FIXME(jbl, 2023-08-14) validating after loading the object issue
         validation.ensure_definition_is_labware(load_result.definition)
+        validation.ensure_definition_is_not_lid_after_api_version(
+            self.api_version, load_result.definition
+        )
 
         # FIXME(mm, 2023-02-21):
         #
@@ -318,6 +325,52 @@ class ProtocolCore(
 
         return labware_core
 
+    def load_lid(
+        self,
+        load_name: str,
+        location: LabwareCore,
+        namespace: Optional[str],
+        version: Optional[int],
+    ) -> LabwareCore:
+        """Load an individual lid using its identifying parameters. Must be loaded on an existing Labware."""
+        load_location = self._convert_labware_location(location=location)
+        custom_labware_params = (
+            self._engine_client.state.labware.find_custom_labware_load_params()
+        )
+        namespace, version = load_labware_params.resolve(
+            load_name, namespace, version, custom_labware_params
+        )
+        load_result = self._engine_client.execute_command_without_recovery(
+            cmd.LoadLidParams(
+                loadName=load_name,
+                location=load_location,
+                namespace=namespace,
+                version=version,
+            )
+        )
+        # FIXME(chb, 2024-12-06) validating after loading the object issue
+        validation.ensure_definition_is_lid(load_result.definition)
+
+        deck_conflict.check(
+            engine_state=self._engine_client.state,
+            new_labware_id=load_result.labwareId,
+            existing_disposal_locations=self._disposal_locations,
+            # TODO: We can now fetch these IDs from engine too.
+            #  See comment in self.load_labware().
+            #
+            # Wrapping .keys() in list() is just to make Decoy verification easier.
+            existing_labware_ids=list(self._labware_cores_by_id.keys()),
+            existing_module_ids=list(self._module_cores_by_id.keys()),
+        )
+
+        labware_core = LabwareCore(
+            labware_id=load_result.labwareId,
+            engine_client=self._engine_client,
+        )
+
+        self._labware_cores_by_id[labware_core.labware_id] = labware_core
+        return labware_core
+
     def move_labware(
         self,
         labware_core: LabwareCore,
@@ -422,6 +475,8 @@ class ProtocolCore(
                 raise InvalidModuleLocationError(deck_slot, model.name)
 
         robot_type = self._engine_client.state.config.robot_type
+        # todo(mm, 2024-12-03): This might be possible to remove:
+        # Protocol Engine will normalize the deck slot itself.
         normalized_deck_slot = deck_slot.to_equivalent_for_robot_type(robot_type)
 
         result = self._engine_client.execute_command_without_recovery(
@@ -502,6 +557,12 @@ class ProtocolCore(
                 load_module_result=load_module_result, model=model
             )
 
+    def load_robot(self) -> RobotCore:
+        """Load a robot core into the RobotContext."""
+        return RobotCore(
+            engine_client=self._engine_client, sync_hardware_api=self._sync_hardware
+        )
+
     def load_instrument(
         self,
         instrument_name: PipetteNameType,
@@ -632,6 +693,72 @@ class ProtocolCore(
         self._last_location = location
         self._last_mount = mount
 
+    def load_lid_stack(
+        self,
+        load_name: str,
+        location: Union[DeckSlotName, StagingSlotName, LabwareCore],
+        quantity: int,
+        namespace: Optional[str],
+        version: Optional[int],
+    ) -> LabwareCore:
+        """Load a Stack of Lids to a given location, creating a Lid Stack."""
+        if quantity < 1:
+            raise ValueError(
+                "When loading a lid stack quantity cannot be less than one."
+            )
+        if isinstance(location, DeckSlotName) or isinstance(location, StagingSlotName):
+            load_location = self._convert_labware_location(location=location)
+        else:
+            if isinstance(location, LabwareCore):
+                load_location = self._convert_labware_location(location=location)
+            else:
+                raise ValueError(
+                    "Expected type of Labware Location for lid stack must be Labware, not Legacy Labware or Well."
+                )
+
+        custom_labware_params = (
+            self._engine_client.state.labware.find_custom_labware_load_params()
+        )
+        namespace, version = load_labware_params.resolve(
+            load_name, namespace, version, custom_labware_params
+        )
+
+        load_result = self._engine_client.execute_command_without_recovery(
+            cmd.LoadLidStackParams(
+                loadName=load_name,
+                location=load_location,
+                namespace=namespace,
+                version=version,
+                quantity=quantity,
+            )
+        )
+
+        # FIXME(CHB, 2024-12-04) just like load labware and load adapter we have a validating after loading the object issue
+        validation.ensure_definition_is_lid(load_result.definition)
+
+        deck_conflict.check(
+            engine_state=self._engine_client.state,
+            new_labware_id=load_result.stackLabwareId,
+            existing_disposal_locations=self._disposal_locations,
+            # TODO (spp, 2023-11-27): We've been using IDs from _labware_cores_by_id
+            #  and _module_cores_by_id instead of getting the lists directly from engine
+            #  because of the chance of engine carrying labware IDs from LPC too.
+            #  But with https://github.com/Opentrons/opentrons/pull/13943,
+            #  & LPC in maintenance runs, we can now rely on engine state for these IDs too.
+            # Wrapping .keys() in list() is just to make Decoy verification easier.
+            existing_labware_ids=list(self._labware_cores_by_id.keys()),
+            existing_module_ids=list(self._module_cores_by_id.keys()),
+        )
+
+        labware_core = LabwareCore(
+            labware_id=load_result.stackLabwareId,
+            engine_client=self._engine_client,
+        )
+
+        self._labware_cores_by_id[labware_core.labware_id] = labware_core
+
+        return labware_core
+
     def get_deck_definition(self) -> DeckDefinitionV5:
         """Get the geometry definition of the robot's deck."""
         return self._engine_client.state.labware.get_deck_definition()
@@ -725,9 +852,7 @@ class ProtocolCore(
             _id=liquid.id,
             name=liquid.displayName,
             description=liquid.description,
-            display_color=(
-                liquid.displayColor.__root__ if liquid.displayColor else None
-            ),
+            display_color=(liquid.displayColor.root if liquid.displayColor else None),
         )
 
     def define_liquid_class(self, name: str) -> LiquidClass:

opentrons/protocol_api/core/engine/robot.py

@@ -0,0 +1,139 @@
+from typing import Optional, Dict, Union
+from opentrons.hardware_control import SyncHardwareAPI
+
+from opentrons.types import Mount, MountType, Point, AxisType, AxisMapType
+from opentrons_shared_data.pipette import types as pip_types
+from opentrons.protocol_api._types import PipetteActionTypes, PlungerPositionTypes
+from opentrons.protocol_engine import commands as cmd
+from opentrons.protocol_engine.clients import SyncClient as EngineClient
+from opentrons.protocol_engine.types import DeckPoint, MotorAxis
+
+from opentrons.protocol_api.core.robot import AbstractRobot
+
+
+_AXIS_TYPE_TO_MOTOR_AXIS = {
+    AxisType.X: MotorAxis.X,
+    AxisType.Y: MotorAxis.Y,
+    AxisType.P_L: MotorAxis.LEFT_PLUNGER,
+    AxisType.P_R: MotorAxis.RIGHT_PLUNGER,
+    AxisType.Z_L: MotorAxis.LEFT_Z,
+    AxisType.Z_R: MotorAxis.RIGHT_Z,
+    AxisType.Z_G: MotorAxis.EXTENSION_Z,
+    AxisType.G: MotorAxis.EXTENSION_JAW,
+    AxisType.Q: MotorAxis.AXIS_96_CHANNEL_CAM,
+}
+
+
+class RobotCore(AbstractRobot):
+    """Robot API core using a ProtocolEngine.
+
+    Args:
+        engine_client: A client to the ProtocolEngine that is executing the protocol.
+        api_version: The Python Protocol API versionat which  this core is operating.
+        sync_hardware: A SynchronousAdapter-wrapped Hardware Control API.
+    """
+
+    def __init__(
+        self, engine_client: EngineClient, sync_hardware_api: SyncHardwareAPI
+    ) -> None:
+        self._engine_client = engine_client
+        self._sync_hardware_api = sync_hardware_api
+
+    def _convert_to_engine_mount(self, axis_map: AxisMapType) -> Dict[MotorAxis, float]:
+        return {_AXIS_TYPE_TO_MOTOR_AXIS[ax]: dist for ax, dist in axis_map.items()}
+
+    def get_pipette_type_from_engine(
+        self, mount: Union[Mount, str]
+    ) -> Optional[pip_types.PipetteNameType]:
+        """Get the pipette attached to the given mount."""
+        if isinstance(mount, Mount):
+            engine_mount = MountType[mount.name]
+        else:
+            if mount.lower() == "right":
+                engine_mount = MountType.RIGHT
+            else:
+                engine_mount = MountType.LEFT
+        maybe_pipette = self._engine_client.state.pipettes.get_by_mount(engine_mount)
+        return maybe_pipette.pipetteName if maybe_pipette else None
+
+    def get_plunger_position_from_name(
+        self, mount: Mount, position_name: PlungerPositionTypes
+    ) -> float:
+        engine_mount = MountType[mount.name]
+        maybe_pipette = self._engine_client.state.pipettes.get_by_mount(engine_mount)
+        if not maybe_pipette:
+            return 0.0
+        return self._engine_client.state.pipettes.lookup_plunger_position_name(
+            maybe_pipette.id, position_name.value
+        )
+
+    def get_plunger_position_from_volume(
+        self, mount: Mount, volume: float, action: PipetteActionTypes, robot_type: str
+    ) -> float:
+        engine_mount = MountType[mount.name]
+        maybe_pipette = self._engine_client.state.pipettes.get_by_mount(engine_mount)
+        if not maybe_pipette:
+            raise RuntimeError(
+                f"Cannot load plunger position as no pipette is attached to {mount}"
+            )
+        convert_volume = (
+            self._engine_client.state.pipettes.lookup_volume_to_mm_conversion(
+                maybe_pipette.id, volume, action.value
+            )
+        )
+        plunger_bottom = (
+            self._engine_client.state.pipettes.lookup_plunger_position_name(
+                maybe_pipette.id, "bottom"
+            )
+        )
+        mm = volume / convert_volume
+        if robot_type == "OT-2 Standard":
+            position = plunger_bottom + mm
+        else:
+            position = plunger_bottom - mm
+        return round(position, 6)
+
+    def move_to(self, mount: Mount, destination: Point, speed: Optional[float]) -> None:
+        engine_mount = MountType[mount.name]
+        engine_destination = DeckPoint(
+            x=destination.x, y=destination.y, z=destination.z
+        )
+        self._engine_client.execute_command(
+            cmd.robot.MoveToParams(
+                mount=engine_mount, destination=engine_destination, speed=speed
+            )
+        )
+
+    def move_axes_to(
+        self,
+        axis_map: AxisMapType,
+        critical_point: Optional[AxisMapType],
+        speed: Optional[float],
+    ) -> None:
+        axis_engine_map = self._convert_to_engine_mount(axis_map)
+        if critical_point:
+            critical_point_engine = self._convert_to_engine_mount(critical_point)
+        else:
+            critical_point_engine = None
+
+        self._engine_client.execute_command(
+            cmd.robot.MoveAxesToParams(
+                axis_map=axis_engine_map,
+                critical_point=critical_point_engine,
+                speed=speed,
+            )
+        )
+
+    def move_axes_relative(self, axis_map: AxisMapType, speed: Optional[float]) -> None:
+        axis_engine_map = self._convert_to_engine_mount(axis_map)
+        self._engine_client.execute_command(
+            cmd.robot.MoveAxesRelativeParams(axis_map=axis_engine_map, speed=speed)
+        )
+
+    def release_grip(self) -> None:
+        self._engine_client.execute_command(cmd.robot.openGripperJawParams())
+
+    def close_gripper(self, force: Optional[float] = None) -> None:
+        self._engine_client.execute_command(
+            cmd.robot.closeGripperJawParams(force=force)
+        )

opentrons/protocol_api/core/engine/well.py

@@ -130,7 +130,10 @@ class WellCore(AbstractWellCore):
         liquid: Liquid,
         volume: float,
     ) -> None:
-        """Load liquid into a well."""
+        """Load liquid into a well.
+
+        If the well is known to be empty, use ``load_empty()`` instead of calling this with a 0.0 volume.
+        """
         self._engine_client.execute_command(
             cmd.LoadLiquidParams(
                 labwareId=self._labware_id,