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

opentrons/protocol_engine/commands/touch_tip.py

@@ -1,29 +1,50 @@
 """Touch 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 opentrons.protocol_engine.state import update_types
+from opentrons.types import Point
 
-from ..errors import TouchTipDisabledError, LabwareIsTipRackError
+from ..errors import (
+    TouchTipDisabledError,
+    TouchTipIncompatibleArgumentsError,
+    LabwareIsTipRackError,
+)
 from ..types import DeckPoint
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors.error_occurrence import ErrorOccurrence
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
 from .pipetting_common import (
     PipetteIdMixin,
+)
+from .movement_common import (
     WellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, GantryMover
     from ..state.state import StateView
+    from ..resources.model_utils import ModelUtils
 
 
 TouchTipCommandType = Literal["touchTip"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class TouchTipParams(PipetteIdMixin, WellLocationMixin):
     """Payload needed to touch a pipette tip the sides of a specific well."""
 
@@ -34,12 +55,20 @@ class TouchTipParams(PipetteIdMixin, WellLocationMixin):
         ),
     )
 
-    speed: Optional[float] = Field(
+    mmFromEdge: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Offset away from the the well edge, in millimeters."
+        "Incompatible when a radius is included as a non 1.0 value.",
+        json_schema_extra=_remove_default,
+    )
+
+    speed: float | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Override the travel speed in mm/s."
             " This controls the straight linear speed of motion."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -50,7 +79,10 @@ class TouchTipResult(DestinationPositionResult):
 
 
 class TouchTipImplementation(
-    AbstractCommandImpl[TouchTipParams, SuccessData[TouchTipResult]]
+    AbstractCommandImpl[
+        TouchTipParams,
+        SuccessData[TouchTipResult] | DefinedErrorData[StallOrCollisionError],
+    ]
 ):
     """Touch tip command implementation."""
 
@@ -59,19 +91,26 @@ class TouchTipImplementation(
         state_view: StateView,
         movement: MovementHandler,
         gantry_mover: GantryMover,
+        model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
         self._gantry_mover = gantry_mover
+        self._model_utils = model_utils
 
-    async def execute(self, params: TouchTipParams) -> SuccessData[TouchTipResult]:
+    async def execute(
+        self, params: TouchTipParams
+    ) -> SuccessData[TouchTipResult] | DefinedErrorData[StallOrCollisionError]:
         """Touch tip to sides of a well using the requested pipette."""
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
 
-        state_update = update_types.StateUpdate()
+        if params.radius != 1.0 and params.mmFromEdge is not None:
+            raise TouchTipIncompatibleArgumentsError(
+                "Cannot use mmFromEdge with a radius that is not 1.0"
+            )
 
         if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
             raise TouchTipDisabledError(
@@ -81,23 +120,33 @@ class TouchTipImplementation(
         if self._state_view.labware.is_tiprack(labware_id):
             raise LabwareIsTipRackError("Cannot touch tip on tip rack")
 
-        center_point = await self._movement.move_to_well(
+        center_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=pipette_id,
             labware_id=labware_id,
             well_name=well_name,
             well_location=params.wellLocation,
         )
+        if isinstance(center_result, DefinedErrorData):
+            return center_result
 
         touch_speed = self._state_view.pipettes.get_movement_speed(
             pipette_id, params.speed
         )
 
+        mm_from_edge = params.mmFromEdge if params.mmFromEdge is not None else 0
         touch_waypoints = self._state_view.motion.get_touch_tip_waypoints(
             pipette_id=pipette_id,
             labware_id=labware_id,
             well_name=well_name,
             radius=params.radius,
-            center_point=center_point,
+            mm_from_edge=mm_from_edge,
+            center_point=Point(
+                center_result.public.position.x,
+                center_result.public.position.y,
+                center_result.public.position.z,
+            ),
         )
 
         final_point = await self._gantry_mover.move_to(
@@ -105,10 +154,10 @@ class TouchTipImplementation(
             waypoints=touch_waypoints,
             speed=touch_speed,
         )
-        final_deck_point = DeckPoint.construct(
+        final_deck_point = DeckPoint.model_construct(
             x=final_point.x, y=final_point.y, z=final_point.z
         )
-        state_update.set_pipette_location(
+        state_update = center_result.state_update.set_pipette_location(
             pipette_id=pipette_id,
             new_labware_id=labware_id,
             new_well_name=well_name,
@@ -121,12 +170,12 @@ class TouchTipImplementation(
         )
 
 
-class TouchTip(BaseCommand[TouchTipParams, TouchTipResult, ErrorOccurrence]):
+class TouchTip(BaseCommand[TouchTipParams, TouchTipResult, StallOrCollisionError]):
     """Touch up tip command model."""
 
     commandType: TouchTipCommandType = "touchTip"
     params: TouchTipParams
-    result: Optional[TouchTipResult]
+    result: Optional[TouchTipResult] = None
 
     _ImplementationCls: Type[TouchTipImplementation] = TouchTipImplementation
 

opentrons/protocol_engine/commands/unsafe/unsafe_blow_out_in_place.py

@@ -10,6 +10,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ..pipetting_common import PipetteIdMixin, FlowRateMixin
 from ...resources import ensure_ot3_hardware
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.hardware_control.types import Axis
@@ -66,9 +67,11 @@ class UnsafeBlowOutInPlaceImplementation(
         await self._pipetting.blow_out_in_place(
             pipette_id=params.pipetteId, flow_rate=params.flowRate
         )
+        state_update = update_types.StateUpdate()
+        state_update.set_fluid_empty(pipette_id=params.pipetteId)
 
         return SuccessData(
-            public=UnsafeBlowOutInPlaceResult(),
+            public=UnsafeBlowOutInPlaceResult(), state_update=state_update
         )
 
 

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -1,13 +1,16 @@
 """Command models to drop tip in place while plunger positions are unknown."""
+
 from __future__ import annotations
-from opentrons.protocol_engine.state.update_types import StateUpdate
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import Field, BaseModel
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.hardware_control.types import Axis
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from ..pipetting_common import PipetteIdMixin
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
@@ -21,16 +24,21 @@ if TYPE_CHECKING:
 UnsafeDropTipInPlaceCommandType = Literal["unsafe/dropTipInPlace"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class UnsafeDropTipInPlaceParams(PipetteIdMixin):
     """Payload required to drop a tip in place even if the plunger position is not known."""
 
-    homeAfter: Optional[bool] = Field(
+    homeAfter: bool | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Whether to home this pipette's plunger after dropping the tip."
             " You should normally leave this unspecified to let the robot choose"
             " a safe default depending on its hardware."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -77,6 +85,7 @@ class UnsafeDropTipInPlaceImplementation(
         state_update.update_pipette_tip_state(
             pipette_id=params.pipetteId, tip_geometry=None
         )
+        state_update.set_fluid_unknown(pipette_id=params.pipetteId)
 
         return SuccessData(
             public=UnsafeDropTipInPlaceResult(), state_update=state_update

opentrons/protocol_engine/commands/unsafe/unsafe_engage_axes.py

@@ -52,10 +52,7 @@ class UnsafeEngageAxesImplementation(
         """Enable exes."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.engage_axes(
-            [
-                self._gantry_mover.motor_axis_to_hardware_axis(axis)
-                for axis in params.axes
-            ]
+            self._gantry_mover.motor_axes_to_present_hardware_axes(params.axes)
         )
         return SuccessData(
             public=UnsafeEngageAxesResult(),

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -58,10 +58,7 @@ class UpdatePositionEstimatorsImplementation(
         """Update axis position estimators from their encoders."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.update_axis_position_estimations(
-            [
-                self._gantry_mover.motor_axis_to_hardware_axis(axis)
-                for axis in params.axes
-            ]
+            self._gantry_mover.motor_axes_to_present_hardware_axes(params.axes)
         )
         return SuccessData(
             public=UpdatePositionEstimatorsResult(),

opentrons/protocol_engine/commands/verify_tip_presence.py

@@ -1,8 +1,9 @@
 """Verify tip presence command request, result and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
 
 from pydantic import Field, BaseModel
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from .pipetting_common import PipetteIdMixin
@@ -18,14 +19,20 @@ if TYPE_CHECKING:
 VerifyTipPresenceCommandType = Literal["verifyTipPresence"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class VerifyTipPresenceParams(PipetteIdMixin):
     """Payload required for a VerifyTipPresence command."""
 
     expectedState: TipPresenceStatus = Field(
         ..., description="The expected tip presence status on the pipette."
     )
-    followSingularSensor: Optional[InstrumentSensorId] = Field(
-        default=None, description="The sensor id to follow if the other can be ignored."
+    followSingularSensor: InstrumentSensorId | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The sensor id to follow if the other can be ignored.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -77,7 +84,7 @@ class VerifyTipPresence(
 
     commandType: VerifyTipPresenceCommandType = "verifyTipPresence"
     params: VerifyTipPresenceParams
-    result: Optional[VerifyTipPresenceResult]
+    result: Optional[VerifyTipPresenceResult] = None
 
     _ImplementationCls: Type[
         VerifyTipPresenceImplementation

opentrons/protocol_engine/commands/wait_for_duration.py

@@ -1,7 +1,9 @@
 """Wait for duration command request, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
@@ -14,13 +16,18 @@ if TYPE_CHECKING:
 WaitForDurationCommandType = Literal["waitForDuration"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class WaitForDurationParams(BaseModel):
     """Payload required to pause the protocol."""
 
     seconds: float = Field(..., description="Duration, in seconds, to wait for.")
-    message: Optional[str] = Field(
+    message: str | SkipJsonSchema[None] = Field(
         None,
         description="A user-facing message associated with the pause",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -53,7 +60,7 @@ class WaitForDuration(
 
     commandType: WaitForDurationCommandType = "waitForDuration"
     params: WaitForDurationParams
-    result: Optional[WaitForDurationResult]
+    result: Optional[WaitForDurationResult] = None
 
     _ImplementationCls: Type[
         WaitForDurationImplementation

opentrons/protocol_engine/commands/wait_for_resume.py

@@ -1,7 +1,9 @@
 """Wait for resume command request, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
@@ -16,12 +18,17 @@ if TYPE_CHECKING:
 WaitForResumeCommandType = Literal["waitForResume", "pause"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class WaitForResumeParams(BaseModel):
     """Payload required to pause the protocol."""
 
-    message: Optional[str] = Field(
+    message: str | SkipJsonSchema[None] = Field(
         None,
         description="A user-facing message associated with the pause",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -54,7 +61,7 @@ class WaitForResume(
 
     commandType: WaitForResumeCommandType = "waitForResume"
     params: WaitForResumeParams
-    result: Optional[WaitForResumeResult]
+    result: Optional[WaitForResumeResult] = None
 
     _ImplementationCls: Type[WaitForResumeImplementation] = WaitForResumeImplementation
 

opentrons/protocol_engine/errors/__init__.py

@@ -24,6 +24,7 @@ from .exceptions import (
     LabwareIsTipRackError,
     LabwareIsAdapterError,
     TouchTipDisabledError,
+    TouchTipIncompatibleArgumentsError,
     WellDoesNotExistError,
     PipetteNotLoadedError,
     ModuleNotLoadedError,
@@ -78,6 +79,9 @@ from .exceptions import (
     OperationLocationNotInWellError,
     InvalidDispenseVolumeError,
     StorageLimitReachedError,
+    InvalidLiquidError,
+    LiquidClassDoesNotExistError,
+    LiquidClassRedefinitionError,
 )
 
 from .error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
@@ -107,6 +111,7 @@ __all__ = [
     "LabwareIsTipRackError",
     "LabwareIsAdapterError",
     "TouchTipDisabledError",
+    "TouchTipIncompatibleArgumentsError",
     "WellDoesNotExistError",
     "PipetteNotLoadedError",
     "ModuleNotLoadedError",
@@ -138,6 +143,7 @@ __all__ = [
     "InvalidTargetSpeedError",
     "InvalidBlockVolumeError",
     "InvalidHoldTimeError",
+    "InvalidLiquidError",
     "InvalidWavelengthError",
     "CannotPerformModuleAction",
     "ResumeFromRecoveryNotAllowedError",
@@ -164,4 +170,6 @@ __all__ = [
     "OperationLocationNotInWellError",
     "InvalidDispenseVolumeError",
     "StorageLimitReachedError",
+    "LiquidClassDoesNotExistError",
+    "LiquidClassRedefinitionError",
 ]

opentrons/protocol_engine/errors/error_occurrence.py

@@ -4,7 +4,7 @@ from logging import getLogger
 from datetime import datetime
 from textwrap import dedent
 from typing import Any, Dict, Mapping, List, Type, Union, Optional, Sequence
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ConfigDict
 from opentrons_shared_data.errors.codes import ErrorCodes
 from .exceptions import ProtocolEngineError
 from opentrons_shared_data.errors.exceptions import EnumeratedError
@@ -29,7 +29,7 @@ class ErrorOccurrence(BaseModel):
             wrappedErrors = [
                 cls.from_failed(id, createdAt, err) for err in error.wrapping
             ]
-        return cls.construct(
+        return cls.model_construct(
             id=id,
             createdAt=createdAt,
             errorType=type(error).__name__,
@@ -39,6 +39,21 @@ class ErrorOccurrence(BaseModel):
             wrappedErrors=wrappedErrors,
         )
 
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any], model: object) -> None:
+        """Append the schema to make the errorCode appear required.
+
+        `errorCode`, `wrappedErrors`, and `errorInfo` have defaults because they are not included in earlier
+        versions of this model, _and_ this model is loaded directly from
+        the on-robot store. That means that, without a default, it will
+        fail to parse. Once a default is defined, the automated schema will
+        mark this as a non-required field, which is misleading as this is
+        a response from the server to the client and it will always have an
+        errorCode defined. This hack is required because it informs the client
+        that it does not, in fact, have to account for a missing errorCode, wrappedError, or errorInfo.
+        """
+        schema["required"].extend(["errorCode", "wrappedErrors", "errorInfo"])
+
     id: str = Field(..., description="Unique identifier of this error occurrence.")
     createdAt: datetime = Field(..., description="When the error occurred.")
 
@@ -145,23 +160,7 @@ class ErrorOccurrence(BaseModel):
         default=[], description="Errors that may have caused this one."
     )
 
-    class Config:
-        """Customize configuration for this model."""
-
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any], model: object) -> None:
-            """Append the schema to make the errorCode appear required.
-
-            `errorCode`, `wrappedErrors`, and `errorInfo` have defaults because they are not included in earlier
-            versions of this model, _and_ this model is loaded directly from
-            the on-robot store. That means that, without a default, it will
-            fail to parse. Once a default is defined, the automated schema will
-            mark this as a non-required field, which is misleading as this is
-            a response from the server to the client and it will always have an
-            errorCode defined. This hack is required because it informs the client
-            that it does not, in fact, have to account for a missing errorCode, wrappedError, or errorInfo.
-            """
-            schema["required"].extend(["errorCode", "wrappedErrors", "errorInfo"])
+    model_config = ConfigDict(json_schema_extra=schema_extra)
 
 
 # TODO (tz, 7-12-23): move this to exceptions.py when we stop relaying on ErrorOccurrence.
@@ -180,4 +179,4 @@ class ProtocolCommandFailedError(ProtocolEngineError):
         self.original_error = original_error
 
 
-ErrorOccurrence.update_forward_refs()
+ErrorOccurrence.model_rebuild()

opentrons/protocol_engine/errors/exceptions.py

@@ -244,6 +244,19 @@ class LiquidDoesNotExistError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class InvalidLiquidError(ProtocolEngineError):
+    """Raised when attempting to add a liquid with an invalid property."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build an InvalidLiquidError."""
+        super().__init__(ErrorCodes.INVALID_PROTOCOL_DATA, message, details, wrapping)
+
+
 class LabwareDefinitionDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a labware definition that does not exist."""
 
@@ -348,6 +361,19 @@ class TouchTipDisabledError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class TouchTipIncompatibleArgumentsError(ProtocolEngineError):
+    """Raised when touch tip is used with both a custom radius and a mmFromEdge argument."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a TouchTipIncompatibleArgumentsError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class WellDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a well that does not exist."""
 
@@ -1155,3 +1181,27 @@ class StorageLimitReachedError(ProtocolEngineError):
     ) -> None:
         """Build an StorageLimitReached."""
         super().__init__(ErrorCodes.GENERAL_ERROR, message, detail, wrapping)
+
+
+class LiquidClassDoesNotExistError(ProtocolEngineError):
+    """Raised when referencing a liquid class that has not been loaded."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
+class LiquidClassRedefinitionError(ProtocolEngineError):
+    """Raised when attempting to load a liquid class that conflicts with a liquid class already loaded."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)

opentrons/protocol_engine/execution/command_executor.py

@@ -188,7 +188,7 @@ class CommandExecutor:
                     "completedAt": self._model_utils.get_timestamp(),
                     "notes": note_tracker.get_notes(),
                 }
-                succeeded_command = running_command.copy(update=update)
+                succeeded_command = running_command.model_copy(update=update)
                 self._action_dispatcher.dispatch(
                     SucceedCommandAction(
                         command=succeeded_command,