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

opentrons/protocol_engine/commands/load_pipette.py

@@ -1,20 +1,23 @@
 """Load pipette command request, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+from typing_extensions import Literal
 
-from opentrons.protocol_engine.state.update_types import StateUpdate
 from opentrons_shared_data.pipette.pipette_load_name_conversions import (
     convert_to_pipette_name_type,
 )
 from opentrons_shared_data.pipette.types import PipetteGenerationType
 from opentrons_shared_data.robot import user_facing_robot_type
 from opentrons_shared_data.robot.types import RobotTypeEnum
-from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
-from typing_extensions import Literal
+
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 from opentrons.types import MountType
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
 from ..errors import InvalidSpecificationForRobotTypeError, InvalidLoadPipetteSpecsError
@@ -27,6 +30,10 @@ if TYPE_CHECKING:
 LoadPipetteCommandType = Literal["loadPipette"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class LoadPipetteParams(BaseModel):
     """Payload needed to load a pipette on to a mount."""
 
@@ -38,21 +45,24 @@ class LoadPipetteParams(BaseModel):
         ...,
         description="The mount the pipette should be present on.",
     )
-    pipetteId: Optional[str] = Field(
+    pipetteId: str | SkipJsonSchema[None] = Field(
         None,
         description="An optional ID to assign to this pipette. If None, an ID "
         "will be generated.",
+        json_schema_extra=_remove_default,
     )
-    tipOverlapNotAfterVersion: Optional[str] = Field(
+    tipOverlapNotAfterVersion: str | SkipJsonSchema[None] = Field(
         None,
         description="A version of tip overlap data to not exceed. The highest-versioned "
         "tip overlap data that does not exceed this version will be used. Versions are "
         "expressed as vN where N is an integer, counting up from v0. If None, the current "
         "highest version will be used.",
+        json_schema_extra=_remove_default,
     )
-    liquidPresenceDetection: Optional[bool] = Field(
+    liquidPresenceDetection: bool | SkipJsonSchema[None] = Field(
         None,
         description="Enable liquid presence detection for this pipette. Defaults to False.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -127,6 +137,7 @@ class LoadPipetteImplementation(
             serial_number=loaded_pipette.serial_number,
             config=loaded_pipette.static_config,
         )
+        state_update.set_fluid_unknown(pipette_id=loaded_pipette.pipette_id)
 
         return SuccessData(
             public=LoadPipetteResult(pipetteId=loaded_pipette.pipette_id),
@@ -139,7 +150,7 @@ class LoadPipette(BaseCommand[LoadPipetteParams, LoadPipetteResult, ErrorOccurre
 
     commandType: LoadPipetteCommandType = "loadPipette"
     params: LoadPipetteParams
-    result: Optional[LoadPipetteResult]
+    result: Optional[LoadPipetteResult] = None
 
     _ImplementationCls: Type[LoadPipetteImplementation] = LoadPipetteImplementation
 

opentrons/protocol_engine/commands/magnetic_module/disengage.py

@@ -83,7 +83,7 @@ class Disengage(BaseCommand[DisengageParams, DisengageResult, ErrorOccurrence]):
 
     commandType: DisengageCommandType = "magneticModule/disengage"
     params: DisengageParams
-    result: Optional[DisengageResult]
+    result: Optional[DisengageResult] = None
 
     _ImplementationCls: Type[DisengageImplementation] = DisengageImplementation
 

opentrons/protocol_engine/commands/magnetic_module/engage.py

@@ -105,7 +105,7 @@ class Engage(BaseCommand[EngageParams, EngageResult, ErrorOccurrence]):
 
     commandType: EngageCommandType = "magneticModule/engage"
     params: EngageParams
-    result: Optional[EngageResult]
+    result: Optional[EngageResult] = None
 
     _ImplementationCls: Type[EngageImplementation] = EngageImplementation
 

opentrons/protocol_engine/commands/move_labware.py

@@ -1,14 +1,17 @@
 """Models and implementation for the ``moveLabware`` command."""
 
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic.json_schema import SkipJsonSchema
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
 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
@@ -49,6 +52,10 @@ if TYPE_CHECKING:
 MoveLabwareCommandType = Literal["moveLabware"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 # Extra buffer on top of minimum distance to move to the right
 _TRASH_CHUTE_DROP_BUFFER_MM = 8
 
@@ -63,15 +70,17 @@ class MoveLabwareParams(BaseModel):
         description="Whether to use the gripper to perform the labware movement"
         " or to perform a manual movement with an option to pause.",
     )
-    pickUpOffset: Optional[LabwareOffsetVector] = Field(
+    pickUpOffset: LabwareOffsetVector | SkipJsonSchema[None] = Field(
         None,
         description="Offset to use when picking up labware. "
         "Experimental param, subject to change",
+        json_schema_extra=_remove_default,
     )
-    dropOffset: Optional[LabwareOffsetVector] = Field(
+    dropOffset: LabwareOffsetVector | SkipJsonSchema[None] = Field(
         None,
         description="Offset to use when dropping off labware. "
         "Experimental param, subject to change",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -156,6 +165,7 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 area_name
             )
+            state_update.set_addressable_area_used(addressable_area_name=area_name)
 
             if fixture_validation.is_gripper_waste_chute(area_name):
                 # When dropping off labware in the waste chute, some bigger pieces
@@ -201,6 +211,9 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.newLocation.slotName.id
             )
+            state_update.set_addressable_area_used(
+                addressable_area_name=params.newLocation.slotName.id
+            )
 
         available_new_location = self._state_view.geometry.ensure_location_not_occupied(
             location=params.newLocation
@@ -355,7 +368,7 @@ class MoveLabware(
 
     commandType: MoveLabwareCommandType = "moveLabware"
     params: MoveLabwareParams
-    result: Optional[MoveLabwareResult]
+    result: Optional[MoveLabwareResult] = None
 
     _ImplementationCls: Type[MoveLabwareImplementation] = MoveLabwareImplementation
 

opentrons/protocol_engine/commands/move_relative.py

@@ -5,14 +5,23 @@ 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
-from .pipetting_common import DestinationPositionResult
+from ..types import MovementAxis
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from .movement_common import (
+    DestinationPositionResult,
+    move_relative,
+    StallOrCollisionError,
+)
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
+    from ..resources.model_utils import ModelUtils
 
 
 MoveRelativeCommandType = Literal["moveRelative"]
@@ -39,46 +48,47 @@ class MoveRelativeResult(DestinationPositionResult):
 
 
 class MoveRelativeImplementation(
-    AbstractCommandImpl[MoveRelativeParams, SuccessData[MoveRelativeResult]]
+    AbstractCommandImpl[
+        MoveRelativeParams,
+        SuccessData[MoveRelativeResult] | DefinedErrorData[StallOrCollisionError],
+    ]
 ):
     """Move relative command implementation."""
 
-    def __init__(self, movement: MovementHandler, **kwargs: object) -> None:
+    def __init__(
+        self, movement: MovementHandler, model_utils: ModelUtils, **kwargs: object
+    ) -> None:
         self._movement = movement
+        self._model_utils = model_utils
 
     async def execute(
         self, params: MoveRelativeParams
-    ) -> SuccessData[MoveRelativeResult]:
+    ) -> SuccessData[MoveRelativeResult] | DefinedErrorData[StallOrCollisionError]:
         """Move (jog) a given pipette a relative distance."""
-        state_update = update_types.StateUpdate()
-
-        x, y, z = await self._movement.move_relative(
+        result = await move_relative(
+            movement=self._movement,
+            model_utils=self._model_utils,
             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=deck_point),
-            state_update=state_update,
-        )
+        if isinstance(result, DefinedErrorData):
+            return result
+        else:
+            return SuccessData(
+                public=MoveRelativeResult(position=result.public.position),
+                state_update=result.state_update,
+            )
 
 
 class MoveRelative(
-    BaseCommand[MoveRelativeParams, MoveRelativeResult, ErrorOccurrence]
+    BaseCommand[MoveRelativeParams, MoveRelativeResult, StallOrCollisionError]
 ):
     """Command to move (jog) a given pipette a relative distance."""
 
     commandType: MoveRelativeCommandType = "moveRelative"
     params: MoveRelativeParams
-    result: Optional[MoveRelativeResult]
+    result: Optional[MoveRelativeResult] = None
 
     _ImplementationCls: Type[MoveRelativeImplementation] = MoveRelativeImplementation
 

opentrons/protocol_engine/commands/move_to_addressable_area.py

@@ -7,20 +7,29 @@ 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 ..types import AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
     PipetteIdMixin,
+)
+from .movement_common import (
     MovementMixin,
     DestinationPositionResult,
+    move_to_addressable_area,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
     from ..state.state import StateView
+    from ..resources.model_utils import ModelUtils
 
 MoveToAddressableAreaCommandType = Literal["moveToAddressableArea"]
 
@@ -74,25 +83,29 @@ class MoveToAddressableAreaResult(DestinationPositionResult):
     pass
 
 
+_ExecuteReturn = (
+    SuccessData[MoveToAddressableAreaResult] | DefinedErrorData[StallOrCollisionError]
+)
+
+
 class MoveToAddressableAreaImplementation(
-    AbstractCommandImpl[
-        MoveToAddressableAreaParams, SuccessData[MoveToAddressableAreaResult]
-    ]
+    AbstractCommandImpl[MoveToAddressableAreaParams, _ExecuteReturn]
 ):
     """Move to addressable area command implementation."""
 
     def __init__(
-        self, movement: MovementHandler, state_view: StateView, **kwargs: object
+        self,
+        movement: MovementHandler,
+        state_view: StateView,
+        model_utils: ModelUtils,
+        **kwargs: object,
     ) -> None:
         self._movement = movement
         self._state_view = state_view
+        self._model_utils = model_utils
 
-    async def execute(
-        self, params: MoveToAddressableAreaParams
-    ) -> SuccessData[MoveToAddressableAreaResult]:
+    async def execute(self, params: MoveToAddressableAreaParams) -> _ExecuteReturn:
         """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
         )
@@ -115,7 +128,9 @@ class MoveToAddressableAreaImplementation(
                 f"Cannot move pipette to staging slot {params.addressableAreaName}"
             )
 
-        x, y, z = await self._movement.move_to_addressable_area(
+        result = await move_to_addressable_area(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             addressable_area_name=params.addressableAreaName,
             offset=params.offset,
@@ -125,29 +140,27 @@ class MoveToAddressableAreaImplementation(
             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)),
-            state_update=state_update,
-        )
+        if isinstance(result, DefinedErrorData):
+            return result
+        else:
+            return SuccessData(
+                public=MoveToAddressableAreaResult(position=result.public.position),
+                state_update=result.state_update,
+            )
 
 
 class MoveToAddressableArea(
     BaseCommand[
-        MoveToAddressableAreaParams, MoveToAddressableAreaResult, ErrorOccurrence
+        MoveToAddressableAreaParams,
+        MoveToAddressableAreaResult,
+        StallOrCollisionError,
     ]
 ):
     """Move to addressable area command model."""
 
     commandType: MoveToAddressableAreaCommandType = "moveToAddressableArea"
     params: MoveToAddressableAreaParams
-    result: Optional[MoveToAddressableAreaResult]
+    result: Optional[MoveToAddressableAreaResult] = None
 
     _ImplementationCls: Type[
         MoveToAddressableAreaImplementation

opentrons/protocol_engine/commands/move_to_addressable_area_for_drop_tip.py

@@ -1,28 +1,43 @@
 """Move to addressable area for drop tip command request, result, and implementation models."""
 from __future__ import annotations
-from pydantic import Field
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional, Type, Any
 from typing_extensions import Literal
 
+from pydantic import Field
+from pydantic.json_schema import SkipJsonSchema
+
 from ..errors import LocationNotAccessibleByPipetteError
-from ..state import update_types
-from ..types import DeckPoint, AddressableOffsetVector
+from ..types import AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
     PipetteIdMixin,
+)
+from .movement_common import (
     MovementMixin,
     DestinationPositionResult,
+    move_to_addressable_area,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
     from ..state.state import StateView
+    from ..resources.model_utils import ModelUtils
 
 MoveToAddressableAreaForDropTipCommandType = Literal["moveToAddressableAreaForDropTip"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
     """Payload required to move a pipette to a specific addressable area.
 
@@ -56,7 +71,7 @@ class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
         AddressableOffsetVector(x=0, y=0, z=0),
         description="Relative offset of addressable area to move pipette's critical point.",
     )
-    alternateDropLocation: Optional[bool] = Field(
+    alternateDropLocation: bool | SkipJsonSchema[None] = Field(
         False,
         description=(
             "Whether to alternate location where tip is dropped within the addressable area."
@@ -65,8 +80,9 @@ class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
             " labware well."
             " If False, the tip will be dropped at the top center of the area."
         ),
+        json_schema_extra=_remove_default,
     )
-    ignoreTipConfiguration: Optional[bool] = Field(
+    ignoreTipConfiguration: bool | SkipJsonSchema[None] = Field(
         True,
         description=(
             "Whether to utilize the critical point of the tip configuraiton when moving to an addressable area."
@@ -74,6 +90,7 @@ class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
             " as the critical point for movement."
             " If False, this command will use the critical point provided by the current tip configuration."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -83,26 +100,32 @@ class MoveToAddressableAreaForDropTipResult(DestinationPositionResult):
     pass
 
 
+_ExecuteReturn = (
+    SuccessData[MoveToAddressableAreaForDropTipResult]
+    | DefinedErrorData[StallOrCollisionError]
+)
+
+
 class MoveToAddressableAreaForDropTipImplementation(
-    AbstractCommandImpl[
-        MoveToAddressableAreaForDropTipParams,
-        SuccessData[MoveToAddressableAreaForDropTipResult],
-    ]
+    AbstractCommandImpl[MoveToAddressableAreaForDropTipParams, _ExecuteReturn]
 ):
     """Move to addressable area for drop tip command implementation."""
 
     def __init__(
-        self, movement: MovementHandler, state_view: StateView, **kwargs: object
+        self,
+        movement: MovementHandler,
+        state_view: StateView,
+        model_utils: ModelUtils,
+        **kwargs: object,
     ) -> None:
         self._movement = movement
         self._state_view = state_view
+        self._model_utils = model_utils
 
     async def execute(
         self, params: MoveToAddressableAreaForDropTipParams
-    ) -> SuccessData[MoveToAddressableAreaForDropTipResult]:
+    ) -> _ExecuteReturn:
         """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
         )
@@ -120,7 +143,9 @@ class MoveToAddressableAreaForDropTipImplementation(
         else:
             offset = params.offset
 
-        x, y, z = await self._movement.move_to_addressable_area(
+        result = await move_to_addressable_area(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             addressable_area_name=params.addressableAreaName,
             offset=offset,
@@ -129,26 +154,22 @@ 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)
-            ),
-            state_update=state_update,
-        )
+        if isinstance(result, DefinedErrorData):
+            return result
+        else:
+            return SuccessData(
+                public=MoveToAddressableAreaForDropTipResult(
+                    position=result.public.position,
+                ),
+                state_update=result.state_update,
+            )
 
 
 class MoveToAddressableAreaForDropTip(
     BaseCommand[
         MoveToAddressableAreaForDropTipParams,
         MoveToAddressableAreaForDropTipResult,
-        ErrorOccurrence,
+        StallOrCollisionError,
     ]
 ):
     """Move to addressable area for drop tip command model."""
@@ -157,7 +178,7 @@ class MoveToAddressableAreaForDropTip(
         "moveToAddressableAreaForDropTip"
     )
     params: MoveToAddressableAreaForDropTipParams
-    result: Optional[MoveToAddressableAreaForDropTipResult]
+    result: Optional[MoveToAddressableAreaForDropTipResult] = None
 
     _ImplementationCls: Type[
         MoveToAddressableAreaForDropTipImplementation

opentrons/protocol_engine/commands/move_to_coordinates.py

@@ -6,14 +6,25 @@ from typing import Optional, Type, TYPE_CHECKING
 from typing_extensions import Literal
 
 
-from ..state import update_types
 from ..types import DeckPoint
-from .pipetting_common import PipetteIdMixin, MovementMixin, DestinationPositionResult
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence
+from .pipetting_common import PipetteIdMixin
+from .movement_common import (
+    MovementMixin,
+    DestinationPositionResult,
+    move_to_coordinates,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
+    from ..resources.model_utils import ModelUtils
 
 
 MoveToCoordinatesCommandType = Literal["moveToCoordinates"]
@@ -34,50 +45,53 @@ class MoveToCoordinatesResult(DestinationPositionResult):
     pass
 
 
+_ExecuteReturn = (
+    SuccessData[MoveToCoordinatesResult] | DefinedErrorData[StallOrCollisionError]
+)
+
+
 class MoveToCoordinatesImplementation(
-    AbstractCommandImpl[MoveToCoordinatesParams, SuccessData[MoveToCoordinatesResult]]
+    AbstractCommandImpl[MoveToCoordinatesParams, _ExecuteReturn]
 ):
     """Move to coordinates command implementation."""
 
     def __init__(
         self,
         movement: MovementHandler,
+        model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._movement = movement
+        self._model_utils = model_utils
 
-    async def execute(
-        self, params: MoveToCoordinatesParams
-    ) -> SuccessData[MoveToCoordinatesResult]:
+    async def execute(self, params: MoveToCoordinatesParams) -> _ExecuteReturn:
         """Move the requested pipette to the requested coordinates."""
-        state_update = update_types.StateUpdate()
-
-        x, y, z = await self._movement.move_to_coordinates(
+        result = await move_to_coordinates(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             deck_coordinates=params.coordinates,
             direct=params.forceDirect,
             additional_min_travel_z=params.minimumZHeight,
             speed=params.speed,
         )
-        deck_point = DeckPoint.construct(x=x, y=y, z=z)
-        state_update.pipette_location = update_types.PipetteLocationUpdate(
-            pipette_id=params.pipetteId, new_location=None, new_deck_point=deck_point
-        )
-
-        return SuccessData(
-            public=MoveToCoordinatesResult(position=DeckPoint(x=x, y=y, z=z)),
-            state_update=state_update,
-        )
+        if isinstance(result, DefinedErrorData):
+            return result
+        else:
+            return SuccessData(
+                public=MoveToCoordinatesResult(position=result.public.position),
+                state_update=result.state_update,
+            )
 
 
 class MoveToCoordinates(
-    BaseCommand[MoveToCoordinatesParams, MoveToCoordinatesResult, ErrorOccurrence]
+    BaseCommand[MoveToCoordinatesParams, MoveToCoordinatesResult, StallOrCollisionError]
 ):
     """Move to well command model."""
 
     commandType: MoveToCoordinatesCommandType = "moveToCoordinates"
     params: MoveToCoordinatesParams
-    result: Optional[MoveToCoordinatesResult]
+    result: Optional[MoveToCoordinatesResult] = None
 
     _ImplementationCls: Type[
         MoveToCoordinatesImplementation