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

opentrons/protocol_engine/commands/load_liquid.py

@@ -4,11 +4,14 @@ from pydantic import BaseModel, Field
 from typing import Optional, Type, Dict, TYPE_CHECKING
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
+
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
+    from ..resources import ModelUtils
 
 LoadLiquidCommandType = Literal["loadLiquid"]
 
@@ -37,16 +40,17 @@ class LoadLiquidResult(BaseModel):
 
 
 class LoadLiquidImplementation(
-    AbstractCommandImpl[LoadLiquidParams, SuccessData[LoadLiquidResult, None]]
+    AbstractCommandImpl[LoadLiquidParams, SuccessData[LoadLiquidResult]]
 ):
     """Load liquid command implementation."""
 
-    def __init__(self, state_view: StateView, **kwargs: object) -> None:
+    def __init__(
+        self, state_view: StateView, model_utils: ModelUtils, **kwargs: object
+    ) -> None:
         self._state_view = state_view
+        self._model_utils = model_utils
 
-    async def execute(
-        self, params: LoadLiquidParams
-    ) -> SuccessData[LoadLiquidResult, None]:
+    async def execute(self, params: LoadLiquidParams) -> SuccessData[LoadLiquidResult]:
         """Load data necessary for a liquid."""
         self._state_view.liquid.validate_liquid_id(params.liquidId)
 
@@ -54,7 +58,14 @@ class LoadLiquidImplementation(
             labware_id=params.labwareId, wells=params.volumeByWell
         )
 
-        return SuccessData(public=LoadLiquidResult(), private=None)
+        state_update = StateUpdate()
+        state_update.set_liquid_loaded(
+            labware_id=params.labwareId,
+            volumes=params.volumeByWell,
+            last_loaded=self._model_utils.get_timestamp(),
+        )
+
+        return SuccessData(public=LoadLiquidResult(), state_update=state_update)
 
 
 class LoadLiquid(BaseCommand[LoadLiquidParams, LoadLiquidResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/load_module.py

@@ -5,6 +5,7 @@ from typing_extensions import Literal
 from pydantic import BaseModel, Field
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors import ModuleNotLoadedError
 from ..errors.error_occurrence import ErrorOccurrence
 from ..types import (
     DeckSlotLocation,
@@ -16,8 +17,10 @@ from opentrons.types import DeckSlotName
 
 from opentrons.protocol_engine.resources import deck_configuration_provider
 
+from opentrons.drivers.types import AbsorbanceReaderLidStatus
+
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
     from ..execution import EquipmentHandler
 
 
@@ -103,7 +106,7 @@ class LoadModuleResult(BaseModel):
 
 
 class LoadModuleImplementation(
-    AbstractCommandImpl[LoadModuleParams, SuccessData[LoadModuleResult, None]]
+    AbstractCommandImpl[LoadModuleParams, SuccessData[LoadModuleResult]]
 ):
     """The implementation of the load module command."""
 
@@ -113,9 +116,7 @@ class LoadModuleImplementation(
         self._equipment = equipment
         self._state_view = state_view
 
-    async def execute(
-        self, params: LoadModuleParams
-    ) -> SuccessData[LoadModuleResult, None]:
+    async def execute(self, params: LoadModuleParams) -> SuccessData[LoadModuleResult]:
         """Check that the requested module is attached and assign its identifier."""
         module_type = params.model.as_type()
         self._ensure_module_location(params.location.slotName, module_type)
@@ -151,6 +152,43 @@ class LoadModuleImplementation(
                 module_id=params.moduleId,
             )
 
+        # Handle lid position update for loaded Plate Reader module on deck
+        if (
+            not self._state_view.config.use_virtual_modules
+            and params.model == ModuleModel.ABSORBANCE_READER_V1
+            and params.moduleId is not None
+        ):
+            try:
+                abs_reader = self._equipment.get_module_hardware_api(
+                    self._state_view.modules.get_absorbance_reader_substate(
+                        params.moduleId
+                    ).module_id
+                )
+            except ModuleNotLoadedError:
+                abs_reader = None
+
+            if abs_reader is not None:
+                result = await abs_reader.get_current_lid_status()
+                if (
+                    isinstance(result, AbsorbanceReaderLidStatus)
+                    and result is not AbsorbanceReaderLidStatus.ON
+                ):
+                    reader_area = self._state_view.modules.ensure_and_convert_module_fixture_location(
+                        params.location.slotName,
+                        self._state_view.config.deck_type,
+                        params.model,
+                    )
+                    lid_labware = self._state_view.labware.get_by_addressable_area(
+                        reader_area
+                    )
+
+                    if lid_labware is not None:
+                        self._state_view.labware._state.labware_by_id[
+                            lid_labware.id
+                        ].location = self._state_view.modules.absorbance_reader_dock_location(
+                            params.moduleId
+                        )
+
         return SuccessData(
             public=LoadModuleResult(
                 moduleId=loaded_module.module_id,
@@ -158,7 +196,6 @@ class LoadModuleImplementation(
                 model=loaded_module.definition.model,
                 definition=loaded_module.definition,
             ),
-            private=None,
         )
 
     def _ensure_module_location(

opentrons/protocol_engine/commands/load_pipette.py

@@ -1,6 +1,7 @@
 """Load pipette command request, result, and implementation models."""
 from __future__ import annotations
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from opentrons_shared_data.pipette.pipette_load_name_conversions import (
     convert_to_pipette_name_type,
 )
@@ -16,23 +17,16 @@ from opentrons.types import MountType
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
-from .configuring_common import PipetteConfigUpdateResultMixin
 from ..errors import InvalidSpecificationForRobotTypeError, InvalidLoadPipetteSpecsError
 
 if TYPE_CHECKING:
     from ..execution import EquipmentHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 LoadPipetteCommandType = Literal["loadPipette"]
 
 
-class LoadPipettePrivateResult(PipetteConfigUpdateResultMixin):
-    """The not-to-be-exposed results of a load pipette call."""
-
-    ...
-
-
 class LoadPipetteParams(BaseModel):
     """Payload needed to load a pipette on to a mount."""
 
@@ -72,9 +66,7 @@ class LoadPipetteResult(BaseModel):
 
 
 class LoadPipetteImplementation(
-    AbstractCommandImpl[
-        LoadPipetteParams, SuccessData[LoadPipetteResult, LoadPipettePrivateResult]
-    ]
+    AbstractCommandImpl[LoadPipetteParams, SuccessData[LoadPipetteResult]]
 ):
     """Load pipette command implementation."""
 
@@ -86,7 +78,7 @@ class LoadPipetteImplementation(
 
     async def execute(
         self, params: LoadPipetteParams
-    ) -> SuccessData[LoadPipetteResult, LoadPipettePrivateResult]:
+    ) -> SuccessData[LoadPipetteResult]:
         """Check that requested pipette is attached and assign its identifier."""
         pipette_generation = convert_to_pipette_name_type(
             params.pipetteName.value
@@ -123,13 +115,22 @@ class LoadPipetteImplementation(
             tip_overlap_version=params.tipOverlapNotAfterVersion,
         )
 
+        state_update = StateUpdate()
+        state_update.set_load_pipette(
+            pipette_id=loaded_pipette.pipette_id,
+            pipette_name=params.pipetteName,
+            mount=params.mount,
+            liquid_presence_detection=params.liquidPresenceDetection,
+        )
+        state_update.update_pipette_config(
+            pipette_id=loaded_pipette.pipette_id,
+            serial_number=loaded_pipette.serial_number,
+            config=loaded_pipette.static_config,
+        )
+
         return SuccessData(
             public=LoadPipetteResult(pipetteId=loaded_pipette.pipette_id),
-            private=LoadPipettePrivateResult(
-                pipette_id=loaded_pipette.pipette_id,
-                serial_number=loaded_pipette.serial_number,
-                config=loaded_pipette.static_config,
-            ),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/magnetic_module/disengage.py

@@ -13,7 +13,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.execution import EquipmentHandler
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
 
 
 DisengageCommandType = Literal["magneticModule/disengage"]
@@ -38,7 +38,7 @@ class DisengageResult(BaseModel):
 
 
 class DisengageImplementation(
-    AbstractCommandImpl[DisengageParams, SuccessData[DisengageResult, None]]
+    AbstractCommandImpl[DisengageParams, SuccessData[DisengageResult]]
 ):
     """The implementation of a Magnetic Module disengage command."""
 
@@ -51,9 +51,7 @@ class DisengageImplementation(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(
-        self, params: DisengageParams
-    ) -> SuccessData[DisengageResult, None]:
+    async def execute(self, params: DisengageParams) -> SuccessData[DisengageResult]:
         """Execute a Magnetic Module disengage command.
 
         Raises:
@@ -75,7 +73,9 @@ class DisengageImplementation(
         if hardware_module is not None:  # Not virtualizing modules.
             await hardware_module.deactivate()
 
-        return SuccessData(public=DisengageResult(), private=None)
+        return SuccessData(
+            public=DisengageResult(),
+        )
 
 
 class Disengage(BaseCommand[DisengageParams, DisengageResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/magnetic_module/engage.py

@@ -10,7 +10,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.execution import EquipmentHandler
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
 
 
 EngageCommandType = Literal["magneticModule/engage"]
@@ -54,7 +54,7 @@ class EngageResult(BaseModel):
 
 
 class EngageImplementation(
-    AbstractCommandImpl[EngageParams, SuccessData[EngageResult, None]]
+    AbstractCommandImpl[EngageParams, SuccessData[EngageResult]]
 ):
     """The implementation of a Magnetic Module engage command."""
 
@@ -67,7 +67,7 @@ class EngageImplementation(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(self, params: EngageParams) -> SuccessData[EngageResult, None]:
+    async def execute(self, params: EngageParams) -> SuccessData[EngageResult]:
         """Execute a Magnetic Module engage command.
 
         Raises:
@@ -95,7 +95,9 @@ class EngageImplementation(
         if hardware_module is not None:  # Not virtualizing modules.
             await hardware_module.engage(height=hardware_height)
 
-        return SuccessData(public=EngageResult(), private=None)
+        return SuccessData(
+            public=EngageResult(),
+        )
 
 
 class Engage(BaseCommand[EngageParams, EngageResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/move_labware.py

@@ -1,12 +1,19 @@
 """Models and implementation for the ``moveLabware`` command."""
 
 from __future__ import annotations
+from opentrons_shared_data.errors.exceptions import (
+    FailedGripperPickupError,
+    LabwareDroppedError,
+    StallOrCollisionDetectedError,
+)
 from pydantic import BaseModel, Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
 from opentrons.types import Point
 from ..types import (
+    CurrentWell,
     LabwareLocation,
     DeckSlotLocation,
     OnLabwareLocation,
@@ -17,13 +24,20 @@ from ..types import (
 )
 from ..errors import LabwareMovementNotAllowedError, NotSupportedOnRobotType
 from ..resources import labware_validation, fixture_validation
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
 from opentrons_shared_data.gripper.constants import GRIPPER_PADDLE_WIDTH
 
 if TYPE_CHECKING:
     from ..execution import EquipmentHandler, RunControlHandler, LabwareMovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 MoveLabwareCommandType = Literal["moveLabware"]
@@ -33,7 +47,6 @@ MoveLabwareCommandType = Literal["moveLabware"]
 _TRASH_CHUTE_DROP_BUFFER_MM = 8
 
 
-# TODO (spp, 2022-12-14): https://opentrons.atlassian.net/browse/RLAB-237
 class MoveLabwareParams(BaseModel):
     """Input parameters for a ``moveLabware`` command."""
 
@@ -74,28 +87,42 @@ class MoveLabwareResult(BaseModel):
     )
 
 
-class MoveLabwareImplementation(
-    AbstractCommandImpl[MoveLabwareParams, SuccessData[MoveLabwareResult, None]]
-):
+class GripperMovementError(ErrorOccurrence):
+    """Returned when something physically goes wrong when the gripper moves labware.
+
+    When this error happens, the engine will leave the labware in its original place.
+    """
+
+    isDefined: bool = True
+
+    errorType: Literal["gripperMovement"] = "gripperMovement"
+
+
+_ExecuteReturn = SuccessData[MoveLabwareResult] | DefinedErrorData[GripperMovementError]
+
+
+class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteReturn]):
     """The execution implementation for ``moveLabware`` commands."""
 
     def __init__(
         self,
+        model_utils: ModelUtils,
         state_view: StateView,
         equipment: EquipmentHandler,
         labware_movement: LabwareMovementHandler,
         run_control: RunControlHandler,
         **kwargs: object,
     ) -> None:
+        self._model_utils = model_utils
         self._state_view = state_view
         self._equipment = equipment
         self._labware_movement = labware_movement
         self._run_control = run_control
 
-    async def execute(  # noqa: C901
-        self, params: MoveLabwareParams
-    ) -> SuccessData[MoveLabwareResult, None]:
+    async def execute(self, params: MoveLabwareParams) -> _ExecuteReturn:  # noqa: C901
         """Move a loaded labware to a new location."""
+        state_update = StateUpdate()
+
         # Allow propagation of LabwareNotLoadedError.
         current_labware = self._state_view.labware.get(labware_id=params.labwareId)
         current_labware_definition = self._state_view.labware.get_definition(
@@ -157,6 +184,10 @@ class MoveLabwareImplementation(
                 top_labware_definition=current_labware_definition,
                 bottom_labware_id=available_new_location.labwareId,
             )
+            if params.labwareId == available_new_location.labwareId:
+                raise LabwareMovementNotAllowedError(
+                    "Cannot move a labware onto itself."
+                )
 
         # Allow propagation of ModuleNotLoadedError.
         new_offset_id = self._equipment.find_applicable_labware_offset_id(
@@ -201,24 +232,80 @@ class MoveLabwareImplementation(
                 dropOffset=params.dropOffset or LabwareOffsetVector(x=0, y=0, z=0),
             )
 
-            # Skips gripper moves when using virtual gripper
-            await self._labware_movement.move_labware_with_gripper(
-                labware_id=params.labwareId,
-                current_location=validated_current_loc,
-                new_location=validated_new_loc,
-                user_offset_data=user_offset_data,
-                post_drop_slide_offset=post_drop_slide_offset,
-            )
+            try:
+                # Skips gripper moves when using virtual gripper
+                await self._labware_movement.move_labware_with_gripper(
+                    labware_id=params.labwareId,
+                    current_location=validated_current_loc,
+                    new_location=validated_new_loc,
+                    user_offset_data=user_offset_data,
+                    post_drop_slide_offset=post_drop_slide_offset,
+                )
+            except (
+                FailedGripperPickupError,
+                LabwareDroppedError,
+                StallOrCollisionDetectedError,
+                # todo(mm, 2024-09-26): Catch LabwareNotPickedUpError when that exists and
+                # move_labware_with_gripper() raises it.
+            ) as exception:
+                gripper_movement_error: GripperMovementError | None = (
+                    GripperMovementError(
+                        id=self._model_utils.generate_id(),
+                        createdAt=self._model_utils.get_timestamp(),
+                        errorCode=exception.code.value.code,
+                        detail=exception.code.value.detail,
+                        wrappedErrors=[
+                            ErrorOccurrence.from_failed(
+                                id=self._model_utils.generate_id(),
+                                createdAt=self._model_utils.get_timestamp(),
+                                error=exception,
+                            )
+                        ],
+                    )
+                )
+            else:
+                gripper_movement_error = None
+
+            # All mounts will have been retracted as part of the gripper move.
+            state_update.clear_all_pipette_locations()
+
+            if gripper_movement_error:
+                return DefinedErrorData(
+                    public=gripper_movement_error,
+                    state_update=state_update,
+                )
+
         elif params.strategy == LabwareMovementStrategy.MANUAL_MOVE_WITH_PAUSE:
             # Pause to allow for manual labware movement
             await self._run_control.wait_for_resume()
 
+        # We may have just moved the labware that contains the current well out from
+        # under the pipette. Clear the current location to reflect the fact that the
+        # pipette is no longer over any labware. This is necessary for safe path
+        # planning in case the next movement goes to the same labware (now in a new
+        # place).
+        pipette_location = self._state_view.pipettes.get_current_location()
+        if (
+            isinstance(pipette_location, CurrentWell)
+            and pipette_location.labware_id == params.labwareId
+        ):
+            state_update.clear_all_pipette_locations()
+
+        state_update.set_labware_location(
+            labware_id=params.labwareId,
+            new_location=available_new_location,
+            new_offset_id=new_offset_id,
+        )
+
         return SuccessData(
-            public=MoveLabwareResult(offsetId=new_offset_id), private=None
+            public=MoveLabwareResult(offsetId=new_offset_id),
+            state_update=state_update,
         )
 
 
-class MoveLabware(BaseCommand[MoveLabwareParams, MoveLabwareResult, ErrorOccurrence]):
+class MoveLabware(
+    BaseCommand[MoveLabwareParams, MoveLabwareResult, GripperMovementError]
+):
     """A ``moveLabware`` command."""
 
     commandType: MoveLabwareCommandType = "moveLabware"

opentrons/protocol_engine/commands/move_relative.py

@@ -4,6 +4,8 @@ from pydantic import BaseModel, Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+
+from ..state import update_types
 from ..types import MovementAxis, DeckPoint
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
@@ -37,7 +39,7 @@ class MoveRelativeResult(DestinationPositionResult):
 
 
 class MoveRelativeImplementation(
-    AbstractCommandImpl[MoveRelativeParams, SuccessData[MoveRelativeResult, None]]
+    AbstractCommandImpl[MoveRelativeParams, SuccessData[MoveRelativeResult]]
 ):
     """Move relative command implementation."""
 
@@ -46,16 +48,26 @@ class MoveRelativeImplementation(
 
     async def execute(
         self, params: MoveRelativeParams
-    ) -> SuccessData[MoveRelativeResult, None]:
+    ) -> SuccessData[MoveRelativeResult]:
         """Move (jog) a given pipette a relative distance."""
+        state_update = update_types.StateUpdate()
+
         x, y, z = await self._movement.move_relative(
             pipette_id=params.pipetteId,
             axis=params.axis,
             distance=params.distance,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.pipette_location = update_types.PipetteLocationUpdate(
+            pipette_id=params.pipetteId,
+            # TODO(jbl 2023-02-14): Need to investigate whether move relative should clear current location
+            new_location=update_types.NO_CHANGE,
+            new_deck_point=deck_point,
+        )
 
         return SuccessData(
-            public=MoveRelativeResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+            public=MoveRelativeResult(position=deck_point),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_addressable_area.py

@@ -4,7 +4,10 @@ from pydantic import Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons_shared_data.pipette.types import PipetteNameType
+
 from ..errors import LocationNotAccessibleByPipetteError
+from ..state import update_types
 from ..types import DeckPoint, AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
@@ -17,7 +20,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 MoveToAddressableAreaCommandType = Literal["moveToAddressableArea"]
 
@@ -73,7 +76,7 @@ class MoveToAddressableAreaResult(DestinationPositionResult):
 
 class MoveToAddressableAreaImplementation(
     AbstractCommandImpl[
-        MoveToAddressableAreaParams, SuccessData[MoveToAddressableAreaResult, None]
+        MoveToAddressableAreaParams, SuccessData[MoveToAddressableAreaResult]
     ]
 ):
     """Move to addressable area command implementation."""
@@ -86,11 +89,26 @@ class MoveToAddressableAreaImplementation(
 
     async def execute(
         self, params: MoveToAddressableAreaParams
-    ) -> SuccessData[MoveToAddressableAreaResult, None]:
+    ) -> SuccessData[MoveToAddressableAreaResult]:
         """Move the requested pipette to the requested addressable area."""
+        state_update = update_types.StateUpdate()
+
         self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
             params.addressableAreaName
         )
+        loaded_pipette = self._state_view.pipettes.get(params.pipetteId)
+        if loaded_pipette.pipetteName in (
+            PipetteNameType.P10_SINGLE,
+            PipetteNameType.P10_MULTI,
+            PipetteNameType.P50_MULTI,
+            PipetteNameType.P50_SINGLE,
+            PipetteNameType.P300_SINGLE,
+            PipetteNameType.P300_MULTI,
+            PipetteNameType.P1000_SINGLE,
+        ):
+            extra_z_offset: Optional[float] = 5.0
+        else:
+            extra_z_offset = None
 
         if fixture_validation.is_staging_slot(params.addressableAreaName):
             raise LocationNotAccessibleByPipetteError(
@@ -105,11 +123,18 @@ class MoveToAddressableAreaImplementation(
             minimum_z_height=params.minimumZHeight,
             speed=params.speed,
             stay_at_highest_possible_z=params.stayAtHighestPossibleZ,
+            highest_possible_z_extra_offset=extra_z_offset,
+        )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_addressable_area_name=params.addressableAreaName,
+            new_deck_point=deck_point,
         )
 
         return SuccessData(
             public=MoveToAddressableAreaResult(position=DeckPoint(x=x, y=y, z=z)),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_addressable_area_for_drop_tip.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
 from ..errors import LocationNotAccessibleByPipetteError
+from ..state import update_types
 from ..types import DeckPoint, AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
@@ -17,7 +18,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 MoveToAddressableAreaForDropTipCommandType = Literal["moveToAddressableAreaForDropTip"]
 
@@ -85,7 +86,7 @@ class MoveToAddressableAreaForDropTipResult(DestinationPositionResult):
 class MoveToAddressableAreaForDropTipImplementation(
     AbstractCommandImpl[
         MoveToAddressableAreaForDropTipParams,
-        SuccessData[MoveToAddressableAreaForDropTipResult, None],
+        SuccessData[MoveToAddressableAreaForDropTipResult],
     ]
 ):
     """Move to addressable area for drop tip command implementation."""
@@ -98,8 +99,10 @@ class MoveToAddressableAreaForDropTipImplementation(
 
     async def execute(
         self, params: MoveToAddressableAreaForDropTipParams
-    ) -> SuccessData[MoveToAddressableAreaForDropTipResult, None]:
+    ) -> SuccessData[MoveToAddressableAreaForDropTipResult]:
         """Move the requested pipette to the requested addressable area in preperation of a drop tip."""
+        state_update = update_types.StateUpdate()
+
         self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
             params.addressableAreaName
         )
@@ -126,12 +129,18 @@ class MoveToAddressableAreaForDropTipImplementation(
             speed=params.speed,
             ignore_tip_configuration=params.ignoreTipConfiguration,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_addressable_area_name=params.addressableAreaName,
+            new_deck_point=deck_point,
+        )
 
         return SuccessData(
             public=MoveToAddressableAreaForDropTipResult(
                 position=DeckPoint(x=x, y=y, z=z)
             ),
-            private=None,
+            state_update=state_update,
         )