add move_to_well to dispense_while_tracking command

Author: caila-marashaj

api/src/opentrons/protocol_api/core/engine/instrument.py

@@ -339,21 +339,6 @@ def dispense(
                 well_location=well_location,
             )
             if dynamic_liquid_tracking:
-                self._engine_client.execute_command(
-                    cmd.MoveToWellParams(
-                        pipetteId=self._pipette_id,
-                        labwareId=labware_id,
-                        wellName=well_name,
-                        wellLocation=WellLocation(
-                            origin=well_location.origin,
-                            offset=well_location.offset,
-                            volumeOffset=0,
-                        ),
-                        minimumZHeight=None,
-                        forceDirect=False,
-                        speed=None,
-                    )
-                )
                 self._engine_client.execute_command(
                     cmd.DispenseWhileTrackingParams(
                         pipetteId=self._pipette_id,

api/src/opentrons/protocol_api/instrument_context.py

@@ -2543,6 +2543,8 @@ def _handle_aspirate_target(
             if target.location:
                 move_to_location = target.location
                 meniscus_tracking = target.location.meniscus_tracking
+                if meniscus_tracking == types.MeniscusTrackingTarget.START:
+                    raise ValueError("Cannot aspirate at starting height.")
 
             else:
                 move_to_location = target.well.bottom(

api/src/opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -8,7 +8,7 @@
 from pydantic import Field
 from pydantic.json_schema import SkipJsonSchema
 
-from ..state.update_types import CLEAR
+from ..state.update_types import CLEAR, StateUpdate
 from ..types import CurrentWell, DeckPoint
 from .pipetting_common import (
     PipetteIdMixin,
@@ -22,6 +22,7 @@
     LiquidHandlingWellLocationMixin,
     DestinationPositionResult,
     StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -32,7 +33,7 @@
 )
 
 if TYPE_CHECKING:
-    from ..execution import PipettingHandler, GantryMover
+    from ..execution import PipettingHandler, GantryMover, MovementHandler
     from ..resources import ModelUtils
     from ..state.state import StateView
 
@@ -82,12 +83,14 @@ def __init__(
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         gantry_mover: GantryMover,
+        movement: MovementHandler,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._pipetting = pipetting
         self._model_utils = model_utils
         self._gantry_mover = gantry_mover
+        self._movement = movement
 
     async def execute(self, params: DispenseWhileTrackingParams) -> _ExecuteReturn:
         """Move to and dispense to the requested well."""
@@ -98,6 +101,28 @@ async def execute(self, params: DispenseWhileTrackingParams) -> _ExecuteReturn:
 
         current_location = self._state_view.pipettes.get_current_location()
         current_position = await self._gantry_mover.get_position(params.pipetteId)
+        current_well = CurrentWell(
+            pipette_id=params.pipetteId,
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+        )
+        state_update = StateUpdate()
+        move_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
+            pipette_id=params.pipetteId,
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.wellLocation,
+            current_well=current_well,
+            operation_volume=-params.volume,
+        )
+        state_update.append(move_result.state_update)
+        if isinstance(move_result, DefinedErrorData):
+            return DefinedErrorData(
+                public=move_result.public, state_update=state_update
+            )
+
         dispense_result = await dispense_while_tracking(
             pipette_id=params.pipetteId,
             labware_id=labware_id,

api/src/opentrons/protocol_engine/state/geometry.py

@@ -1809,12 +1809,11 @@ def get_liquid_handling_z_change(
             initial_height=initial_handling_height,
             volume=operation_volume,
         )
-        if isinstance(initial_handling_height, SimulatedProbeResult) or isinstance(
-            final_height, SimulatedProbeResult
-        ):
-            raise errors.LiquidHeightUnknownError(
-                "liquid handling z change can only be found using real height and volume inputs."
-            )
+        # this function is only called by
+        # HardwarePipetteHandler::aspirate/dispense while_tracking, and shouldn't
+        # be reached in the case of a simulated liquid_probe
+        assert not isinstance(initial_handling_height, SimulatedProbeResult)
+        assert not isinstance(final_height, SimulatedProbeResult)
         return final_height - initial_handling_height
 
     def get_well_offset_adjustment(

api/tests/opentrons/protocol_engine/commands/test_dispense_while_tracking.py

@@ -8,7 +8,11 @@
 from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 
 from opentrons.types import Point
-from opentrons.protocol_engine.execution import PipettingHandler, GantryMover
+from opentrons.protocol_engine.execution import (
+    PipettingHandler,
+    GantryMover,
+    MovementHandler,
+)
 
 from opentrons.protocol_engine.commands.command import SuccessData, DefinedErrorData
 from opentrons.protocol_engine.commands.dispense_while_tracking import (
@@ -36,6 +40,7 @@ def subject(
     pipetting: PipettingHandler,
     state_view: StateView,
     gantry_mover: GantryMover,
+    movement: MovementHandler,
     model_utils: ModelUtils,
 ) -> DispenseWhileTrackingImplementation:
     """Build a command implementation."""
@@ -44,20 +49,27 @@ def subject(
         state_view=state_view,
         gantry_mover=gantry_mover,
         model_utils=model_utils,
+        movement=movement,
     )
 
 
+@pytest.fixture
+def movement(decoy: Decoy) -> MovementHandler:
+    """Get a mock in the shape of a MovementHandler."""
+    return decoy.mock(cls=MovementHandler)
+
+
 @pytest.mark.parametrize(
     "location,stateupdateLabware,stateupdateWell",
     [
         (
             CurrentWell(
                 pipette_id="pipette-id-abc",
-                labware_id="labware-id-1",
-                well_name="well-name-1",
+                labware_id="funky-labware",
+                well_name="funky-well",
             ),
-            "labware-id-1",
-            "well-name-1",
+            "funky-labware",
+            "funky-well",
         ),
         (
             CurrentAddressableArea("pipette-id-abc", "addressable-area-1"),
@@ -124,6 +136,25 @@ async def test_dispense_while_tracking_implementation(
     decoy.when(await gantry_mover.get_position("pipette-id-abc")).then_return(
         Point(1, 2, 3)
     )
+    _well_location = LiquidHandlingWellLocation(
+        origin=WellOrigin.MENISCUS, offset=WellOffset(x=0.0, y=0.0, z=1.0)
+    )
+    _current_well = CurrentWell(
+        pipette_id="pipette-id-abc", labware_id="funky-labware", well_name="funky-well"
+    )
+    decoy.when(
+        await subject._movement.move_to_well(
+            pipette_id="pipette-id-abc",
+            labware_id="funky-labware",
+            well_name="funky-well",
+            well_location=_well_location,
+            current_well=_current_well,
+            force_direct=False,
+            minimum_z_height=None,
+            speed=None,
+            operation_volume=-123.0,
+        ),
+    ).then_return(Point(x=4, y=5, z=6))
 
     result = await subject.execute(data)
 
@@ -162,11 +193,11 @@ async def test_dispense_while_tracking_implementation(
         (
             CurrentWell(
                 pipette_id="pipette-id",
-                labware_id="labware-id-1",
-                well_name="well-name-1",
+                labware_id="funky-labware",
+                well_name="funky-well",
             ),
-            "labware-id-1",
-            "well-name-1",
+            "funky-labware",
+            "funky-well",
         ),
         (
             CurrentAddressableArea("pipette-id", "addressable-area-1"),
@@ -237,6 +268,26 @@ async def test_overpressure_error(
     decoy.when(await gantry_mover.get_position(pipette_id)).then_return(position)
     decoy.when(state_view.pipettes.get_current_location()).then_return(location)
 
+    _well_location = LiquidHandlingWellLocation(
+        origin=WellOrigin.MENISCUS, offset=WellOffset(x=0.0, y=0.0, z=1.0)
+    )
+    _current_well = CurrentWell(
+        pipette_id="pipette-id", labware_id="funky-labware", well_name="funky-well"
+    )
+    decoy.when(
+        await subject._movement.move_to_well(
+            pipette_id="pipette-id",
+            labware_id="funky-labware",
+            well_name="funky-well",
+            well_location=_well_location,
+            current_well=_current_well,
+            force_direct=False,
+            minimum_z_height=None,
+            speed=None,
+            operation_volume=-50.0,
+        ),
+    ).then_return(Point(x=4, y=5, z=6))
+
     result = await subject.execute(data)
 
     if isinstance(location, CurrentWell):