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

opentrons/protocol_engine/commands/dispense_in_place.py

@@ -1,10 +1,10 @@
 """Dispense-in-place command request, result, and implementation models."""
+
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, Optional, Type, Union, Any
 from typing_extensions import Literal
 from pydantic import Field
-
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+from pydantic.json_schema import SkipJsonSchema
 
 from .pipetting_common import (
     PipetteIdMixin,
@@ -12,6 +12,7 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
+    dispense_in_place,
 )
 from .command import (
     AbstractCommandImpl,
@@ -20,8 +21,7 @@ from .command import (
     SuccessData,
     DefinedErrorData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
-from ..state.update_types import StateUpdate, CLEAR
+from ..state.update_types import CLEAR
 from ..types import CurrentWell
 
 if TYPE_CHECKING:
@@ -33,12 +33,17 @@ if TYPE_CHECKING:
 DispenseInPlaceCommandType = Literal["dispenseInPlace"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DispenseInPlaceParams(PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin):
     """Payload required to dispense in place."""
 
-    pushOut: Optional[float] = Field(
+    pushOut: float | SkipJsonSchema[None] = Field(
         None,
         description="push the plunger a small amount farther than necessary for accurate low-volume dispensing",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -74,63 +79,78 @@ class DispenseInPlaceImplementation(
 
     async def execute(self, params: DispenseInPlaceParams) -> _ExecuteReturn:
         """Dispense without moving the pipette."""
-        state_update = StateUpdate()
         current_location = self._state_view.pipettes.get_current_location()
         current_position = await self._gantry_mover.get_position(params.pipetteId)
-        try:
-            volume = await self._pipetting.dispense_in_place(
-                pipette_id=params.pipetteId,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                push_out=params.pushOut,
-            )
-        except PipetteOverpressureError as e:
+        result = await dispense_in_place(
+            pipette_id=params.pipetteId,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            push_out=params.pushOut,
+            location_if_error={
+                "retryLocation": (
+                    current_position.x,
+                    current_position.y,
+                    current_position.z,
+                )
+            },
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+        )
+        if isinstance(result, DefinedErrorData):
             if (
                 isinstance(current_location, CurrentWell)
                 and current_location.pipette_id == params.pipetteId
             ):
-                state_update.set_liquid_operated(
-                    labware_id=current_location.labware_id,
-                    well_name=current_location.well_name,
-                    volume_added=CLEAR,
-                )
-            return DefinedErrorData(
-                public=OverpressureError(
-                    id=self._model_utils.generate_id(),
-                    createdAt=self._model_utils.get_timestamp(),
-                    wrappedErrors=[
-                        ErrorOccurrence.from_failed(
-                            id=self._model_utils.generate_id(),
-                            createdAt=self._model_utils.get_timestamp(),
-                            error=e,
-                        )
-                    ],
-                    errorInfo=(
-                        {
-                            "retryLocation": (
-                                current_position.x,
-                                current_position.y,
-                                current_position.z,
-                            )
-                        }
+                return DefinedErrorData(
+                    public=result.public,
+                    state_update=result.state_update.set_liquid_operated(
+                        labware_id=current_location.labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
                     ),
-                ),
-                state_update=state_update,
-            )
+                    state_update_if_false_positive=result.state_update_if_false_positive,
+                )
+            else:
+                return result
         else:
             if (
                 isinstance(current_location, CurrentWell)
                 and current_location.pipette_id == params.pipetteId
             ):
-                state_update.set_liquid_operated(
-                    labware_id=current_location.labware_id,
-                    well_name=current_location.well_name,
-                    volume_added=volume,
+                volume_added = (
+                    self._state_view.pipettes.get_liquid_dispensed_by_ejecting_volume(
+                        pipette_id=params.pipetteId, volume=result.public.volume
+                    )
+                )
+                if volume_added is not None:
+                    volume_added *= self._state_view.geometry.get_nozzles_per_well(
+                        current_location.labware_id,
+                        current_location.well_name,
+                        params.pipetteId,
+                    )
+                return SuccessData(
+                    public=DispenseInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update.set_liquid_operated(
+                        labware_id=current_location.labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                        volume_added=volume_added
+                        if volume_added is not None
+                        else CLEAR,
+                    ),
+                )
+            else:
+                return SuccessData(
+                    public=DispenseInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update,
                 )
-            return SuccessData(
-                public=DispenseInPlaceResult(volume=volume),
-                state_update=state_update,
-            )
 
 
 class DispenseInPlace(
@@ -140,7 +160,7 @@ class DispenseInPlace(
 
     commandType: DispenseInPlaceCommandType = "dispenseInPlace"
     params: DispenseInPlaceParams
-    result: Optional[DispenseInPlaceResult]
+    result: Optional[DispenseInPlaceResult] = None
 
     _ImplementationCls: Type[
         DispenseInPlaceImplementation

opentrons/protocol_engine/commands/drop_tip.py

@@ -1,20 +1,27 @@
 """Drop tip command request, result, and implementation models."""
+
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
 
 from pydantic import Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
+
 from typing_extensions import Literal
 
 from opentrons.protocol_engine.errors.exceptions import TipAttachedError
 from opentrons.protocol_engine.resources.model_utils import ModelUtils
 
-from ..state import update_types
-from ..types import DropTipWellLocation, DeckPoint
+from ..state.update_types import StateUpdate
+from ..types import DropTipWellLocation
 from .pipetting_common import (
     PipetteIdMixin,
-    DestinationPositionResult,
     TipPhysicallyAttachedError,
 )
+from .movement_common import (
+    DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
+)
 from .command import (
     AbstractCommandImpl,
     BaseCommand,
@@ -32,6 +39,10 @@ if TYPE_CHECKING:
 DropTipCommandType = Literal["dropTip"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DropTipParams(PipetteIdMixin):
     """Payload required to drop a tip in a specific well."""
 
@@ -41,15 +52,16 @@ class DropTipParams(PipetteIdMixin):
         default_factory=DropTipWellLocation,
         description="Relative well location at which to drop the tip.",
     )
-    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,
     )
-    alternateDropLocation: Optional[bool] = Field(
+    alternateDropLocation: bool | SkipJsonSchema[None] = Field(
         False,
         description=(
             "Whether to alternate location where tip is dropped within the labware."
@@ -58,6 +70,7 @@ class DropTipParams(PipetteIdMixin):
             " labware well."
             " If False, the tip will be dropped at the top center of the well."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -68,7 +81,9 @@ class DropTipResult(DestinationPositionResult):
 
 
 _ExecuteReturn = (
-    SuccessData[DropTipResult] | DefinedErrorData[TipPhysicallyAttachedError]
+    SuccessData[DropTipResult]
+    | DefinedErrorData[TipPhysicallyAttachedError]
+    | DefinedErrorData[StallOrCollisionError]
 )
 
 
@@ -95,8 +110,6 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
         well_name = params.wellName
         home_after = params.homeAfter
 
-        state_update = update_types.StateUpdate()
-
         if params.alternateDropLocation:
             well_location = self._state_view.geometry.get_next_tip_drop_location(
                 labware_id=labware_id,
@@ -116,19 +129,16 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             partially_configured=is_partially_configured,
         )
 
-        position = await self._movement_handler.move_to_well(
+        move_result = await move_to_well(
+            movement=self._movement_handler,
+            model_utils=self._model_utils,
             pipette_id=pipette_id,
             labware_id=labware_id,
             well_name=well_name,
             well_location=tip_drop_location,
         )
-        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.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,
-        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
 
         try:
             await self._tip_handler.drop_tip(
@@ -145,33 +155,44 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                         error=exception,
                     )
                 ],
-                errorInfo={"retryLocation": position},
-            )
-            state_update_if_false_positive = update_types.StateUpdate()
-            state_update_if_false_positive.update_pipette_tip_state(
-                pipette_id=params.pipetteId, tip_geometry=None
+                errorInfo={
+                    "retryLocation": (
+                        move_result.public.position.x,
+                        move_result.public.position.y,
+                        move_result.public.position.z,
+                    )
+                },
             )
             return DefinedErrorData(
                 public=error,
-                state_update=state_update,
-                state_update_if_false_positive=state_update_if_false_positive,
+                state_update=StateUpdate.reduce(
+                    StateUpdate(), move_result.state_update
+                ).set_fluid_unknown(pipette_id=pipette_id),
+                state_update_if_false_positive=move_result.state_update.update_pipette_tip_state(
+                    pipette_id=params.pipetteId, tip_geometry=None
+                ),
             )
         else:
-            state_update.update_pipette_tip_state(
-                pipette_id=params.pipetteId, tip_geometry=None
-            )
             return SuccessData(
-                public=DropTipResult(position=deck_point),
-                state_update=state_update,
+                public=DropTipResult(position=move_result.public.position),
+                state_update=move_result.state_update.set_fluid_unknown(
+                    pipette_id=pipette_id
+                ).update_pipette_tip_state(
+                    pipette_id=params.pipetteId, tip_geometry=None
+                ),
             )
 
 
-class DropTip(BaseCommand[DropTipParams, DropTipResult, TipPhysicallyAttachedError]):
+class DropTip(
+    BaseCommand[
+        DropTipParams, DropTipResult, TipPhysicallyAttachedError | StallOrCollisionError
+    ]
+):
     """Drop tip command model."""
 
     commandType: DropTipCommandType = "dropTip"
     params: DropTipParams
-    result: Optional[DropTipResult]
+    result: Optional[DropTipResult] = None
 
     _ImplementationCls: Type[DropTipImplementation] = DropTipImplementation
 

opentrons/protocol_engine/commands/drop_tip_in_place.py

@@ -1,7 +1,10 @@
 """Drop tip in place 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 .command import (
@@ -24,16 +27,21 @@ if TYPE_CHECKING:
 DropTipInPlaceCommandType = Literal["dropTipInPlace"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DropTipInPlaceParams(PipetteIdMixin):
     """Payload required to drop a tip in place."""
 
-    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,
     )
 
 
@@ -79,6 +87,7 @@ class DropTipInPlaceImplementation(
             state_update_if_false_positive.update_pipette_tip_state(
                 pipette_id=params.pipetteId, tip_geometry=None
             )
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
             error = TipPhysicallyAttachedError(
                 id=self._model_utils.generate_id(),
                 createdAt=self._model_utils.get_timestamp(),
@@ -97,6 +106,7 @@ class DropTipInPlaceImplementation(
                 state_update_if_false_positive=state_update_if_false_positive,
             )
         else:
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
             state_update.update_pipette_tip_state(
                 pipette_id=params.pipetteId, tip_geometry=None
             )
@@ -110,7 +120,7 @@ class DropTipInPlace(
 
     commandType: DropTipInPlaceCommandType = "dropTipInPlace"
     params: DropTipInPlaceParams
-    result: Optional[DropTipInPlaceResult]
+    result: Optional[DropTipInPlaceResult] = None
 
     _ImplementationCls: Type[
         DropTipInPlaceImplementation

opentrons/protocol_engine/commands/generate_command_schema.py

@@ -1,24 +1,17 @@
 """Generate a JSON schema against which all create commands statically validate."""
+
 import json
-import pydantic
 import argparse
 import sys
-from opentrons.protocol_engine.commands.command_unions import CommandCreate
-
-
-class CreateCommandUnion(pydantic.BaseModel):
-    """Model that validates a union of all CommandCreate models."""
-
-    __root__: CommandCreate
+from opentrons.protocol_engine.commands.command_unions import CommandCreateAdapter
 
 
 def generate_command_schema(version: str) -> str:
     """Generate a JSON Schema that all valid create commands can validate against."""
-    raw_json_schema = CreateCommandUnion.schema_json()
-    schema_as_dict = json.loads(raw_json_schema)
+    schema_as_dict = CommandCreateAdapter.json_schema(mode="validation")
     schema_as_dict["$id"] = f"opentronsCommandSchemaV{version}"
     schema_as_dict["$schema"] = "http://json-schema.org/draft-07/schema#"
-    return json.dumps(schema_as_dict, indent=2)
+    return json.dumps(schema_as_dict, indent=2, sort_keys=True)
 
 
 if __name__ == "__main__":

opentrons/protocol_engine/commands/get_next_tip.py

@@ -0,0 +1,134 @@
+"""Get next tip command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Any, Optional, Type, List, Literal, Union
+
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.types import NozzleConfigurationType
+
+from ..errors import ErrorOccurrence
+from ..types import NextTipInfo, NoTipAvailable, NoTipReason
+from .pipetting_common import PipetteIdMixin
+
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+GetNextTipCommandType = Literal["getNextTip"]
+
+
+class GetNextTipParams(PipetteIdMixin):
+    """Payload needed to resolve the next available tip."""
+
+    labwareIds: List[str] = Field(
+        ...,
+        description="Labware ID(s) of tip racks to resolve next available tip(s) from"
+        " Labware IDs will be resolved sequentially",
+    )
+    startingTipWell: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Name of starting tip rack 'well'."
+        " This only applies to the first tip rack in the list provided in labwareIDs",
+        json_schema_extra=_remove_default,
+    )
+
+
+class GetNextTipResult(BaseModel):
+    """Result data from the execution of a GetNextTip."""
+
+    nextTipInfo: Union[NextTipInfo, NoTipAvailable] = Field(
+        ...,
+        description="Labware ID and well name of next available tip for a pipette,"
+        " or information why no tip could be resolved.",
+    )
+
+
+class GetNextTipImplementation(
+    AbstractCommandImpl[GetNextTipParams, SuccessData[GetNextTipResult]]
+):
+    """Get next tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+
+    async def execute(self, params: GetNextTipParams) -> SuccessData[GetNextTipResult]:
+        """Get the next available tip for the requested pipette."""
+        pipette_id = params.pipetteId
+        starting_tip_name = params.startingTipWell
+
+        num_tips = self._state_view.tips.get_pipette_active_channels(pipette_id)
+        nozzle_map = self._state_view.tips.get_pipette_nozzle_map(pipette_id)
+
+        if (
+            starting_tip_name is not None
+            and nozzle_map.configuration != NozzleConfigurationType.FULL
+        ):
+            # This is to match the behavior found in PAPI, but also because we don't have logic to automatically find
+            # the next tip with partial configuration and a starting tip. This will never work for a 96-channel due to
+            # x-axis overlap, but could eventually work with 8-channel if we better define starting tip USED or CLEAN
+            # state when starting a protocol to prevent accidental tip pick-up with starting non-full tip racks.
+            return SuccessData(
+                public=GetNextTipResult(
+                    nextTipInfo=NoTipAvailable(
+                        noTipReason=NoTipReason.STARTING_TIP_WITH_PARTIAL,
+                        message="Cannot automatically resolve next tip with starting tip and partial tip configuration.",
+                    )
+                )
+            )
+
+        next_tip: Union[NextTipInfo, NoTipAvailable]
+        for labware_id in params.labwareIds:
+            well_name = self._state_view.tips.get_next_tip(
+                labware_id=labware_id,
+                num_tips=num_tips,
+                starting_tip_name=starting_tip_name,
+                nozzle_map=nozzle_map,
+            )
+            if well_name is not None:
+                next_tip = NextTipInfo(labwareId=labware_id, tipStartingWell=well_name)
+                break
+            # After the first tip rack is exhausted, starting tip no longer applies
+            starting_tip_name = None
+        else:
+            next_tip = NoTipAvailable(
+                noTipReason=NoTipReason.NO_AVAILABLE_TIPS,
+                message="No available tips for given pipette, nozzle configuration and provided tip racks.",
+            )
+
+        return SuccessData(public=GetNextTipResult(nextTipInfo=next_tip))
+
+
+class GetNextTip(BaseCommand[GetNextTipParams, GetNextTipResult, ErrorOccurrence]):
+    """Get next tip command model."""
+
+    commandType: GetNextTipCommandType = "getNextTip"
+    params: GetNextTipParams
+    result: Optional[GetNextTipResult]
+
+    _ImplementationCls: Type[GetNextTipImplementation] = GetNextTipImplementation
+
+
+class GetNextTipCreate(BaseCommandCreate[GetNextTipParams]):
+    """Get next tip command creation request model."""
+
+    commandType: GetNextTipCommandType = "getNextTip"
+    params: GetNextTipParams
+
+    _CommandCls: Type[GetNextTip] = GetNextTip

opentrons/protocol_engine/commands/get_tip_presence.py

@@ -71,7 +71,7 @@ class GetTipPresence(
 
     commandType: GetTipPresenceCommandType = "getTipPresence"
     params: GetTipPresenceParams
-    result: Optional[GetTipPresenceResult]
+    result: Optional[GetTipPresenceResult] = None
 
     _ImplementationCls: Type[
         GetTipPresenceImplementation

opentrons/protocol_engine/commands/heater_shaker/close_labware_latch.py

@@ -69,7 +69,7 @@ class CloseLabwareLatch(
 
     commandType: CloseLabwareLatchCommandType = "heaterShaker/closeLabwareLatch"
     params: CloseLabwareLatchParams
-    result: Optional[CloseLabwareLatchResult]
+    result: Optional[CloseLabwareLatchResult] = None
 
     _ImplementationCls: Type[CloseLabwareLatchImpl] = CloseLabwareLatchImpl
 

opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py

@@ -68,7 +68,7 @@ class DeactivateHeater(
 
     commandType: DeactivateHeaterCommandType = "heaterShaker/deactivateHeater"
     params: DeactivateHeaterParams
-    result: Optional[DeactivateHeaterResult]
+    result: Optional[DeactivateHeaterResult] = None
 
     _ImplementationCls: Type[DeactivateHeaterImpl] = DeactivateHeaterImpl
 

opentrons/protocol_engine/commands/heater_shaker/deactivate_shaker.py

@@ -70,7 +70,7 @@ class DeactivateShaker(
 
     commandType: DeactivateShakerCommandType = "heaterShaker/deactivateShaker"
     params: DeactivateShakerParams
-    result: Optional[DeactivateShakerResult]
+    result: Optional[DeactivateShakerResult] = None
 
     _ImplementationCls: Type[DeactivateShakerImpl] = DeactivateShakerImpl
 

opentrons/protocol_engine/commands/heater_shaker/open_labware_latch.py

@@ -96,7 +96,7 @@ class OpenLabwareLatch(
 
     commandType: OpenLabwareLatchCommandType = "heaterShaker/openLabwareLatch"
     params: OpenLabwareLatchParams
-    result: Optional[OpenLabwareLatchResult]
+    result: Optional[OpenLabwareLatchResult] = None
 
     _ImplementationCls: Type[OpenLabwareLatchImpl] = OpenLabwareLatchImpl
 

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -109,7 +109,7 @@ class SetAndWaitForShakeSpeed(
         "heaterShaker/setAndWaitForShakeSpeed"
     )
     params: SetAndWaitForShakeSpeedParams
-    result: Optional[SetAndWaitForShakeSpeedResult]
+    result: Optional[SetAndWaitForShakeSpeedResult] = None
 
     _ImplementationCls: Type[SetAndWaitForShakeSpeedImpl] = SetAndWaitForShakeSpeedImpl
 

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -76,7 +76,7 @@ class SetTargetTemperature(
 
     commandType: SetTargetTemperatureCommandType = "heaterShaker/setTargetTemperature"
     params: SetTargetTemperatureParams
-    result: Optional[SetTargetTemperatureResult]
+    result: Optional[SetTargetTemperatureResult] = None
 
     _ImplementationCls: Type[SetTargetTemperatureImpl] = SetTargetTemperatureImpl