opentrons 8.3.1a1__py2.py3-none-any.whl → 8.4.0a1__py2.py3-none-any.whl

opentrons/protocol_engine/commands/blow_out_in_place.py

@@ -89,7 +89,10 @@ class BlowOutInPlaceImplementation(
         if isinstance(result, DefinedErrorData):
             return result
         return SuccessData(
-            public=BlowOutInPlaceResult(), state_update=result.state_update
+            public=BlowOutInPlaceResult(),
+            state_update=result.state_update.set_pipette_ready_to_aspirate(
+                pipette_id=params.pipetteId, ready_to_aspirate=False
+            ),
         )
 
 

opentrons/protocol_engine/commands/command_unions.py

@@ -14,8 +14,10 @@ from .pipetting_common import (
     TipPhysicallyAttachedError,
 )
 from .movement_common import StallOrCollisionError
+from .flex_stacker.common import FlexStackerStallOrCollisionError
 
 from . import absorbance_reader
+from . import flex_stacker
 from . import heater_shaker
 from . import magnetic_module
 from . import temperature_module
@@ -57,6 +59,14 @@ from .aspirate_in_place import (
     AspirateInPlaceCommandType,
 )
 
+from .aspirate_while_tracking import (
+    AspirateWhileTracking,
+    AspirateWhileTrackingParams,
+    AspirateWhileTrackingCreate,
+    AspirateWhileTrackingResult,
+    AspirateWhileTrackingCommandType,
+)
+
 from .comment import (
     Comment,
     CommentParams,
@@ -81,6 +91,14 @@ from .dispense import (
     DispenseCommandType,
 )
 
+from .dispense_while_tracking import (
+    DispenseWhileTracking,
+    DispenseWhileTrackingParams,
+    DispenseWhileTrackingCreate,
+    DispenseWhileTrackingResult,
+    DispenseWhileTrackingCommandType,
+)
+
 from .dispense_in_place import (
     DispenseInPlace,
     DispenseInPlaceParams,
@@ -389,10 +407,12 @@ Command = Annotated[
         AirGapInPlace,
         Aspirate,
         AspirateInPlace,
+        AspirateWhileTracking,
         Comment,
         Custom,
         Dispense,
         DispenseInPlace,
+        DispenseWhileTracking,
         BlowOut,
         BlowOutInPlace,
         ConfigureForVolume,
@@ -457,6 +477,14 @@ Command = Annotated[
         absorbance_reader.OpenLid,
         absorbance_reader.Initialize,
         absorbance_reader.ReadAbsorbance,
+        flex_stacker.Retrieve,
+        flex_stacker.Store,
+        flex_stacker.SetStoredLabware,
+        flex_stacker.Fill,
+        flex_stacker.Empty,
+        flex_stacker.CloseLatch,
+        flex_stacker.OpenLatch,
+        flex_stacker.PrepareShuttle,
         calibration.CalibrateGripper,
         calibration.CalibratePipette,
         calibration.CalibrateModule,
@@ -479,6 +507,7 @@ Command = Annotated[
 CommandParams = Union[
     AirGapInPlaceParams,
     AspirateParams,
+    AspirateWhileTrackingParams,
     AspirateInPlaceParams,
     CommentParams,
     ConfigureForVolumeParams,
@@ -486,6 +515,7 @@ CommandParams = Union[
     CustomParams,
     DispenseParams,
     DispenseInPlaceParams,
+    DispenseWhileTrackingParams,
     BlowOutParams,
     BlowOutInPlaceParams,
     DropTipParams,
@@ -548,6 +578,14 @@ CommandParams = Union[
     absorbance_reader.OpenLidParams,
     absorbance_reader.InitializeParams,
     absorbance_reader.ReadAbsorbanceParams,
+    flex_stacker.RetrieveParams,
+    flex_stacker.StoreParams,
+    flex_stacker.SetStoredLabwareParams,
+    flex_stacker.FillParams,
+    flex_stacker.EmptyParams,
+    flex_stacker.CloseLatchParams,
+    flex_stacker.OpenLatchParams,
+    flex_stacker.PrepareShuttleParams,
     calibration.CalibrateGripperParams,
     calibration.CalibratePipetteParams,
     calibration.CalibrateModuleParams,
@@ -568,6 +606,7 @@ CommandParams = Union[
 CommandType = Union[
     AirGapInPlaceCommandType,
     AspirateCommandType,
+    AspirateWhileTrackingCommandType,
     AspirateInPlaceCommandType,
     CommentCommandType,
     ConfigureForVolumeCommandType,
@@ -575,6 +614,7 @@ CommandType = Union[
     CustomCommandType,
     DispenseCommandType,
     DispenseInPlaceCommandType,
+    DispenseWhileTrackingCommandType,
     BlowOutCommandType,
     BlowOutInPlaceCommandType,
     DropTipCommandType,
@@ -637,6 +677,14 @@ CommandType = Union[
     absorbance_reader.OpenLidCommandType,
     absorbance_reader.InitializeCommandType,
     absorbance_reader.ReadAbsorbanceCommandType,
+    flex_stacker.RetrieveCommandType,
+    flex_stacker.StoreCommandType,
+    flex_stacker.SetStoredLabwareCommandType,
+    flex_stacker.FillCommandType,
+    flex_stacker.EmptyCommandType,
+    flex_stacker.CloseLatchCommandType,
+    flex_stacker.OpenLatchCommandType,
+    flex_stacker.PrepareShuttleCommandType,
     calibration.CalibrateGripperCommandType,
     calibration.CalibratePipetteCommandType,
     calibration.CalibrateModuleCommandType,
@@ -658,6 +706,7 @@ CommandCreate = Annotated[
     Union[
         AirGapInPlaceCreate,
         AspirateCreate,
+        AspirateWhileTrackingCreate,
         AspirateInPlaceCreate,
         CommentCreate,
         ConfigureForVolumeCreate,
@@ -665,6 +714,7 @@ CommandCreate = Annotated[
         CustomCreate,
         DispenseCreate,
         DispenseInPlaceCreate,
+        DispenseWhileTrackingCreate,
         BlowOutCreate,
         BlowOutInPlaceCreate,
         DropTipCreate,
@@ -727,6 +777,14 @@ CommandCreate = Annotated[
         absorbance_reader.OpenLidCreate,
         absorbance_reader.InitializeCreate,
         absorbance_reader.ReadAbsorbanceCreate,
+        flex_stacker.RetrieveCreate,
+        flex_stacker.StoreCreate,
+        flex_stacker.SetStoredLabwareCreate,
+        flex_stacker.FillCreate,
+        flex_stacker.EmptyCreate,
+        flex_stacker.CloseLatchCreate,
+        flex_stacker.OpenLatchCreate,
+        flex_stacker.PrepareShuttleCreate,
         calibration.CalibrateGripperCreate,
         calibration.CalibratePipetteCreate,
         calibration.CalibrateModuleCreate,
@@ -756,6 +814,7 @@ CommandAdapter: TypeAdapter[Command] = TypeAdapter(Command)
 CommandResult = Union[
     AirGapInPlaceResult,
     AspirateResult,
+    AspirateWhileTrackingResult,
     AspirateInPlaceResult,
     CommentResult,
     ConfigureForVolumeResult,
@@ -763,6 +822,7 @@ CommandResult = Union[
     CustomResult,
     DispenseResult,
     DispenseInPlaceResult,
+    DispenseWhileTrackingResult,
     BlowOutResult,
     BlowOutInPlaceResult,
     DropTipResult,
@@ -825,6 +885,14 @@ CommandResult = Union[
     absorbance_reader.OpenLidResult,
     absorbance_reader.InitializeResult,
     absorbance_reader.ReadAbsorbanceResult,
+    flex_stacker.RetrieveResult,
+    flex_stacker.StoreResult,
+    flex_stacker.SetStoredLabwareResult,
+    flex_stacker.FillResult,
+    flex_stacker.EmptyResult,
+    flex_stacker.CloseLatchResult,
+    flex_stacker.OpenLatchResult,
+    flex_stacker.PrepareShuttleResult,
     calibration.CalibrateGripperResult,
     calibration.CalibratePipetteResult,
     calibration.CalibrateModuleResult,
@@ -851,6 +919,7 @@ CommandDefinedErrorData = Union[
     DefinedErrorData[LiquidNotFoundError],
     DefinedErrorData[GripperMovementError],
     DefinedErrorData[StallOrCollisionError],
+    DefinedErrorData[FlexStackerStallOrCollisionError],
 ]
 
 

opentrons/protocol_engine/commands/configure_for_volume.py

@@ -74,6 +74,9 @@ class ConfigureForVolumeImplementation(
             config=pipette_result.static_config,
             serial_number=pipette_result.serial_number,
         )
+        state_update.set_pipette_ready_to_aspirate(
+            pipette_result.pipette_id, ready_to_aspirate=False
+        )
 
         return SuccessData(
             public=ConfigureForVolumeResult(),

opentrons/protocol_engine/commands/dispense.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union, Any
 from typing_extensions import Literal
 
-
 from pydantic import Field
 from pydantic.json_schema import SkipJsonSchema
 
@@ -16,6 +15,7 @@ from .pipetting_common import (
     BaseLiquidHandlingResult,
     OverpressureError,
     dispense_in_place,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .movement_common import (
     LiquidHandlingWellLocationMixin,
@@ -100,6 +100,7 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
             labware_id=labware_id,
             well_name=well_name,
             well_location=well_location,
+            operation_volume=volume,
         )
         if isinstance(move_result, DefinedErrorData):
             return move_result
@@ -117,6 +118,7 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
             },
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            correction_volume=params.correctionVolume or DEFAULT_CORRECTION_VOLUME,
         )
 
         if isinstance(dispense_result, DefinedErrorData):

opentrons/protocol_engine/commands/dispense_in_place.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union, Any
 from typing_extensions import Literal
+
 from pydantic import Field
 from pydantic.json_schema import SkipJsonSchema
 
@@ -13,6 +14,7 @@ from .pipetting_common import (
     BaseLiquidHandlingResult,
     OverpressureError,
     dispense_in_place,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .command import (
     AbstractCommandImpl,
@@ -95,6 +97,7 @@ class DispenseInPlaceImplementation(
             },
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            correction_volume=params.correctionVolume or DEFAULT_CORRECTION_VOLUME,
         )
         if isinstance(result, DefinedErrorData):
             if (

opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -0,0 +1,240 @@
+"""Dispense command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Union, Any
+from typing_extensions import Literal
+
+
+from pydantic import Field
+from pydantic.json_schema import SkipJsonSchema
+
+from ..state.update_types import CLEAR, StateUpdate
+from ..types import CurrentWell, DeckPoint
+from .pipetting_common import (
+    PipetteIdMixin,
+    DispenseVolumeMixin,
+    FlowRateMixin,
+    BaseLiquidHandlingResult,
+    OverpressureError,
+    dispense_while_tracking,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
+    DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..execution import PipettingHandler, GantryMover, MovementHandler
+    from ..resources import ModelUtils
+    from ..state.state import StateView
+
+
+DispenseWhileTrackingCommandType = Literal["dispenseWhileTracking"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class DispenseWhileTrackingParams(
+    PipetteIdMixin,
+    DispenseVolumeMixin,
+    FlowRateMixin,
+    LiquidHandlingWellLocationMixin,
+):
+    """Payload required to dispense to a specific well."""
+
+    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,
+    )
+
+
+class DispenseWhileTrackingResult(BaseLiquidHandlingResult, DestinationPositionResult):
+    """Result data from the execution of a Dispense command."""
+
+    pass
+
+
+_ExecuteReturn = Union[
+    SuccessData[DispenseWhileTrackingResult],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
+]
+
+
+class DispenseWhileTrackingImplementation(
+    AbstractCommandImpl[DispenseWhileTrackingParams, _ExecuteReturn]
+):
+    """Dispense command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        pipetting: PipettingHandler,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        movement: MovementHandler,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._pipetting = pipetting
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
+        self._movement = movement
+
+    async def execute(self, params: DispenseWhileTrackingParams) -> _ExecuteReturn:
+        """Move to and dispense to the requested well."""
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
+
+        current_location = self._state_view.pipettes.get_current_location()
+        current_position = await self._gantry_mover.get_position(params.pipetteId)
+        current_well = CurrentWell(
+            pipette_id=params.pipetteId,
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+        )
+        state_update = StateUpdate()
+        move_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
+            pipette_id=params.pipetteId,
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.wellLocation,
+            current_well=current_well,
+            operation_volume=-params.volume,
+        )
+        state_update.append(move_result.state_update)
+        if isinstance(move_result, DefinedErrorData):
+            return DefinedErrorData(
+                public=move_result.public, state_update=state_update
+            )
+
+        dispense_result = await dispense_while_tracking(
+            pipette_id=params.pipetteId,
+            labware_id=labware_id,
+            well_name=well_name,
+            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,
+        )
+        position_after_dispense = await self._gantry_mover.get_position(
+            params.pipetteId
+        )
+        result_deck_point = DeckPoint.model_construct(
+            x=position_after_dispense.x,
+            y=position_after_dispense.y,
+            z=position_after_dispense.z,
+        )
+
+        if isinstance(dispense_result, DefinedErrorData):
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                return DefinedErrorData(
+                    public=dispense_result.public,
+                    state_update=dispense_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_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+            else:
+                return dispense_result
+        else:
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                volume_added = (
+                    self._state_view.pipettes.get_liquid_dispensed_by_ejecting_volume(
+                        pipette_id=params.pipetteId,
+                        volume=dispense_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=DispenseWhileTrackingResult(
+                        volume=dispense_result.public.volume,
+                        position=result_deck_point,
+                    ),
+                    state_update=dispense_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=DispenseWhileTrackingResult(
+                        volume=dispense_result.public.volume,
+                        position=result_deck_point,
+                    ),
+                    state_update=dispense_result.state_update,
+                )
+
+
+class DispenseWhileTracking(
+    BaseCommand[
+        DispenseWhileTrackingParams,
+        DispenseWhileTrackingResult,
+        OverpressureError | StallOrCollisionError,
+    ]
+):
+    """Dispense command model."""
+
+    commandType: DispenseWhileTrackingCommandType = "dispenseWhileTracking"
+    params: DispenseWhileTrackingParams
+    result: Optional[DispenseWhileTrackingResult] = None
+
+    _ImplementationCls: Type[
+        DispenseWhileTrackingImplementation
+    ] = DispenseWhileTrackingImplementation
+
+
+class DispenseWhileTrackingCreate(BaseCommandCreate[DispenseWhileTrackingParams]):
+    """Create dispenseWhileTracking command request model."""
+
+    commandType: DispenseWhileTrackingCommandType = "dispenseWhileTracking"
+    params: DispenseWhileTrackingParams
+
+    _CommandCls: Type[DispenseWhileTracking] = DispenseWhileTracking

opentrons/protocol_engine/commands/drop_tip.py

@@ -35,6 +35,7 @@ if TYPE_CHECKING:
     from ..state.state import StateView
     from ..execution import MovementHandler, TipHandler
 
+from opentrons.hardware_control.types import TipScrapeType
 
 DropTipCommandType = Literal["dropTip"]
 
@@ -72,6 +73,16 @@ class DropTipParams(PipetteIdMixin):
         ),
         json_schema_extra=_remove_default,
     )
+    scrape_tips: bool | SkipJsonSchema[None] = Field(
+        False,
+        description=(
+            "Whether or not to scrape off the tips with the ejector all the way down."
+            " If True, and the target location is a tip rack well, it will move the pipette."
+            " Towards the center of the tip rack with the ejector in the 'drop_tip' position."
+            " If False, no horizontal movement will occur."
+        ),
+        json_schema_extra=_remove_default,
+    )
 
 
 class DropTipResult(DestinationPositionResult):
@@ -140,9 +151,20 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
         if isinstance(move_result, DefinedErrorData):
             return move_result
 
+        scrape_type = TipScrapeType.NONE
+        if (
+            params.scrape_tips
+            and self._state_view.geometry._labware.get_definition(
+                labware_id
+            ).parameters.isTiprack
+        ):
+            if int("".join(filter(str.isdigit, well_name))) <= 6:
+                scrape_type = TipScrapeType.RIGHT_ONE_COL
+            else:
+                scrape_type = TipScrapeType.LEFT_ONE_COL
         try:
             await self._tip_handler.drop_tip(
-                pipette_id=pipette_id, home_after=home_after
+                pipette_id=pipette_id, home_after=home_after, scrape_type=scrape_type
             )
         except TipAttachedError as exception:
             error = TipPhysicallyAttachedError(

opentrons/protocol_engine/commands/evotip_dispense.py

@@ -4,13 +4,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union
 from typing_extensions import Literal
 
-from opentrons.protocol_engine.errors import UnsupportedLabwareForActionError
 from .pipetting_common import (
     PipetteIdMixin,
     FlowRateMixin,
     DispenseVolumeMixin,
     BaseLiquidHandlingResult,
     dispense_in_place,
+    increase_evo_disp_count,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .movement_common import (
     LiquidHandlingWellLocationMixin,
@@ -26,7 +27,6 @@ from .command import (
     DefinedErrorData,
 )
 from ..state.update_types import StateUpdate
-from ..resources import labware_validation
 from ..errors import ProtocolEngineError
 
 if TYPE_CHECKING:
@@ -84,11 +84,6 @@ class EvotipDispenseImplementation(
         labware_id = params.labwareId
         well_name = params.wellName
 
-        labware_definition = self._state_view.labware.get_definition(params.labwareId)
-        if not labware_validation.is_evotips(labware_definition.parameters.loadName):
-            raise UnsupportedLabwareForActionError(
-                f"Cannot use command: `EvotipDispense` with labware: {labware_definition.parameters.loadName}"
-            )
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
@@ -101,6 +96,9 @@ class EvotipDispenseImplementation(
             return move_result
 
         current_position = await self._gantry_mover.get_position(params.pipetteId)
+        await increase_evo_disp_count(
+            pipette_id=params.pipetteId, pipetting=self._pipetting
+        )
         result = await dispense_in_place(
             pipette_id=params.pipetteId,
             volume=params.volume,
@@ -115,6 +113,7 @@ class EvotipDispenseImplementation(
             },
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            correction_volume=params.correctionVolume or DEFAULT_CORRECTION_VOLUME,
         )
         if isinstance(result, DefinedErrorData):
             # TODO (chb, 2025-01-29): Remove this and the OverpressureError returns once disabled for this function