opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a1__py2.py3-none-any.whl

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

opentrons/protocol_engine/commands/move_to_well.py

@@ -1,23 +1,32 @@
 """Move to well command request, result, and implementation models."""
+
 from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
-from ..types import DeckPoint
 from .pipetting_common import (
     PipetteIdMixin,
+)
+from .movement_common import (
     WellLocationMixin,
     MovementMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence
-from ..state import update_types
 from ..errors import LabwareIsTipRackError
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
     from ..state.state import StateView
+    from ..resources.model_utils import ModelUtils
 
 MoveToWellCommandType = Literal["moveToWell"]
 
@@ -35,25 +44,33 @@ class MoveToWellResult(DestinationPositionResult):
 
 
 class MoveToWellImplementation(
-    AbstractCommandImpl[MoveToWellParams, SuccessData[MoveToWellResult]]
+    AbstractCommandImpl[
+        MoveToWellParams,
+        SuccessData[MoveToWellResult] | DefinedErrorData[StallOrCollisionError],
+    ]
 ):
     """Move to well command implementation."""
 
     def __init__(
-        self, state_view: StateView, movement: MovementHandler, **kwargs: object
+        self,
+        state_view: StateView,
+        movement: MovementHandler,
+        model_utils: ModelUtils,
+        **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
+        self._model_utils = model_utils
 
-    async def execute(self, params: MoveToWellParams) -> SuccessData[MoveToWellResult]:
+    async def execute(
+        self, params: MoveToWellParams
+    ) -> SuccessData[MoveToWellResult] | DefinedErrorData[StallOrCollisionError]:
         """Move the requested pipette to the requested well."""
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
         well_location = params.wellLocation
 
-        state_update = update_types.StateUpdate()
-
         if (
             self._state_view.labware.is_tiprack(labware_id)
             and well_location.volumeOffset
@@ -62,7 +79,9 @@ class MoveToWellImplementation(
                 "Cannot specify a WellLocation with a volumeOffset with movement to a tip rack"
             )
 
-        x, y, z = await self._movement.move_to_well(
+        move_result = await move_to_well(
+            model_utils=self._model_utils,
+            movement=self._movement,
             pipette_id=pipette_id,
             labware_id=labware_id,
             well_name=well_name,
@@ -71,26 +90,23 @@ class MoveToWellImplementation(
             minimum_z_height=params.minimumZHeight,
             speed=params.speed,
         )
-        deck_point = DeckPoint.construct(x=x, y=y, z=z)
-        state_update.set_pipette_location(
-            pipette_id=pipette_id,
-            new_labware_id=labware_id,
-            new_well_name=well_name,
-            new_deck_point=deck_point,
-        )
-
-        return SuccessData(
-            public=MoveToWellResult(position=deck_point),
-            state_update=state_update,
-        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+        else:
+            return SuccessData(
+                public=MoveToWellResult(position=move_result.public.position),
+                state_update=move_result.state_update,
+            )
 
 
-class MoveToWell(BaseCommand[MoveToWellParams, MoveToWellResult, ErrorOccurrence]):
+class MoveToWell(
+    BaseCommand[MoveToWellParams, MoveToWellResult, StallOrCollisionError]
+):
     """Move to well command model."""
 
     commandType: MoveToWellCommandType = "moveToWell"
     params: MoveToWellParams
-    result: Optional[MoveToWellResult]
+    result: Optional[MoveToWellResult] = None
 
     _ImplementationCls: Type[MoveToWellImplementation] = MoveToWellImplementation