opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/__init__.py

@@ -14,6 +14,7 @@ and/or schema generation.
 """
 
 from . import absorbance_reader
+from . import flex_stacker
 from . import heater_shaker
 from . import magnetic_module
 from . import temperature_module
@@ -60,6 +61,14 @@ from .aspirate import (
     AspirateCommandType,
 )
 
+from .aspirate_while_tracking import (
+    AspirateWhileTracking,
+    AspirateWhileTrackingParams,
+    AspirateWhileTrackingCreate,
+    AspirateWhileTrackingResult,
+    AspirateWhileTrackingCommandType,
+)
+
 from .aspirate_in_place import (
     AspirateInPlace,
     AspirateInPlaceParams,
@@ -92,6 +101,14 @@ from .dispense import (
     DispenseCommandType,
 )
 
+from .dispense_while_tracking import (
+    DispenseWhileTracking,
+    DispenseWhileTrackingParams,
+    DispenseWhileTrackingCreate,
+    DispenseWhileTrackingResult,
+    DispenseWhileTrackingCommandType,
+)
+
 from .dispense_in_place import (
     DispenseInPlace,
     DispenseInPlaceParams,
@@ -380,26 +397,26 @@ from .liquid_probe import (
     TryLiquidProbeCommandType,
 )
 
-from .evotip_seal_pipette import (
-    EvotipSealPipette,
-    EvotipSealPipetteParams,
-    EvotipSealPipetteCreate,
-    EvotipSealPipetteResult,
-    EvotipSealPipetteCommandType,
+from .seal_pipette_to_tip import (
+    SealPipetteToTip,
+    SealPipetteToTipParams,
+    SealPipetteToTipCreate,
+    SealPipetteToTipResult,
+    SealPipetteToTipCommandType,
 )
-from .evotip_unseal_pipette import (
-    EvotipUnsealPipette,
-    EvotipUnsealPipetteParams,
-    EvotipUnsealPipetteCreate,
-    EvotipUnsealPipetteResult,
-    EvotipUnsealPipetteCommandType,
+from .unseal_pipette_from_tip import (
+    UnsealPipetteFromTip,
+    UnsealPipetteFromTipParams,
+    UnsealPipetteFromTipCreate,
+    UnsealPipetteFromTipResult,
+    UnsealPipetteFromTipCommandType,
 )
-from .evotip_dispense import (
-    EvotipDispense,
-    EvotipDispenseParams,
-    EvotipDispenseCreate,
-    EvotipDispenseResult,
-    EvotipDispenseCommandType,
+from .pressure_dispense import (
+    PressureDispense,
+    PressureDispenseParams,
+    PressureDispenseCreate,
+    PressureDispenseResult,
+    PressureDispenseCommandType,
 )
 
 __all__ = [
@@ -435,6 +452,12 @@ __all__ = [
     "AspirateParams",
     "AspirateResult",
     "AspirateCommandType",
+    # aspirate while tracking command models
+    "AspirateWhileTracking",
+    "AspirateWhileTrackingCreate",
+    "AspirateWhileTrackingParams",
+    "AspirateWhileTrackingResult",
+    "AspirateWhileTrackingCommandType",
     # aspirate in place command models
     "AspirateInPlace",
     "AspirateInPlaceCreate",
@@ -459,6 +482,12 @@ __all__ = [
     "DispenseParams",
     "DispenseResult",
     "DispenseCommandType",
+    # dispense while tracking command models
+    "DispenseWhileTracking",
+    "DispenseWhileTrackingCreate",
+    "DispenseWhileTrackingParams",
+    "DispenseWhileTrackingResult",
+    "DispenseWhileTrackingCommandType",
     # dispense in place command models
     "DispenseInPlace",
     "DispenseInPlaceCreate",
@@ -636,6 +665,7 @@ __all__ = [
     # hardware control command models
     # hardware module command bundles
     "absorbance_reader",
+    "flex_stacker",
     "heater_shaker",
     "magnetic_module",
     "temperature_module",
@@ -692,22 +722,22 @@ __all__ = [
     "TryLiquidProbeCreate",
     "TryLiquidProbeResult",
     "TryLiquidProbeCommandType",
-    # evotip seal command bundle
-    "EvotipSealPipette",
-    "EvotipSealPipetteParams",
-    "EvotipSealPipetteCreate",
-    "EvotipSealPipetteResult",
-    "EvotipSealPipetteCommandType",
-    # evotip unseal command bundle
-    "EvotipUnsealPipette",
-    "EvotipUnsealPipetteParams",
-    "EvotipUnsealPipetteCreate",
-    "EvotipUnsealPipetteResult",
-    "EvotipUnsealPipetteCommandType",
-    # evotip dispense command bundle
-    "EvotipDispense",
-    "EvotipDispenseParams",
-    "EvotipDispenseCreate",
-    "EvotipDispenseResult",
-    "EvotipDispenseCommandType",
+    # seal command bundle
+    "SealPipetteToTip",
+    "SealPipetteToTipParams",
+    "SealPipetteToTipCreate",
+    "SealPipetteToTipResult",
+    "SealPipetteToTipCommandType",
+    # unseal command bundle
+    "UnsealPipetteFromTip",
+    "UnsealPipetteFromTipParams",
+    "UnsealPipetteFromTipCreate",
+    "UnsealPipetteFromTipResult",
+    "UnsealPipetteFromTipCommandType",
+    # pressure dispense command bundle
+    "PressureDispense",
+    "PressureDispenseParams",
+    "PressureDispenseCreate",
+    "PressureDispenseResult",
+    "PressureDispenseCommandType",
 ]

opentrons/protocol_engine/commands/absorbance_reader/__init__.py

@@ -33,7 +33,6 @@ from .read import (
 
 
 __all__ = [
-    "MoveLidResult",
     # absorbanace_reader/closeLid
     "CloseLidCommandType",
     "CloseLidParams",

opentrons/protocol_engine/commands/air_gap_in_place.py

@@ -14,6 +14,7 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .command import (
     AbstractCommandImpl,
@@ -84,9 +85,8 @@ class AirGapInPlaceImplementation(
             PipetteNotReadyToAirGapError: pipette plunger is not ready.
         """
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
-            pipette_id=params.pipetteId,
+            pipette_id=params.pipetteId
         )
-
         if not ready_to_aspirate:
             raise PipetteNotReadyToAspirateError(
                 "Pipette cannot air gap in place because of a previous blow out."
@@ -103,6 +103,7 @@ class AirGapInPlaceImplementation(
                 volume=params.volume,
                 flow_rate=params.flowRate,
                 command_note_adder=self._command_note_adder,
+                correction_volume=params.correctionVolume or DEFAULT_CORRECTION_VOLUME,
             )
         except PipetteOverpressureError as e:
             return DefinedErrorData(

opentrons/protocol_engine/commands/aspirate.py

@@ -12,6 +12,7 @@ from .pipetting_common import (
     BaseLiquidHandlingResult,
     aspirate_in_place,
     prepare_for_aspirate,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .movement_common import (
     LiquidHandlingWellLocationMixin,
@@ -47,7 +48,10 @@ AspirateCommandType = Literal["aspirate"]
 
 
 class AspirateParams(
-    PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
+    PipetteIdMixin,
+    AspirateVolumeMixin,
+    FlowRateMixin,
+    LiquidHandlingWellLocationMixin,
 ):
     """Parameters required to aspirate from a specific well."""
 
@@ -148,7 +152,6 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                 labware_id=labware_id,
                 well_name=well_name,
             )
-
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
@@ -179,6 +182,7 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
             command_note_adder=self._command_note_adder,
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            correction_volume=params.correctionVolume or DEFAULT_CORRECTION_VOLUME,
         )
         state_update.append(aspirate_result.state_update)
         if isinstance(aspirate_result, DefinedErrorData):

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -13,6 +13,7 @@ from .pipetting_common import (
     BaseLiquidHandlingResult,
     OverpressureError,
     aspirate_in_place,
+    DEFAULT_CORRECTION_VOLUME,
 )
 from .command import (
     AbstractCommandImpl,
@@ -82,7 +83,7 @@ class AspirateInPlaceImplementation(
             PipetteNotReadyToAspirateError: pipette plunger is not ready.
         """
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
-            pipette_id=params.pipetteId,
+            pipette_id=params.pipetteId
         )
         if not ready_to_aspirate:
             raise PipetteNotReadyToAspirateError(
@@ -108,6 +109,7 @@ class AspirateInPlaceImplementation(
             command_note_adder=self._command_note_adder,
             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/aspirate_while_tracking.py

@@ -0,0 +1,210 @@
+"""Aspirate command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Union
+from typing_extensions import Literal
+
+from .pipetting_common import (
+    OverpressureError,
+    PipetteIdMixin,
+    AspirateVolumeMixin,
+    FlowRateMixin,
+    BaseLiquidHandlingResult,
+    aspirate_while_tracking,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
+    DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+from ..state.update_types import StateUpdate
+from ..errors.exceptions import PipetteNotReadyToAspirateError
+from opentrons.hardware_control import HardwareControlAPI
+from ..state.update_types import CLEAR
+from ..types import DeckPoint
+
+if TYPE_CHECKING:
+    from ..execution import PipettingHandler, GantryMover, MovementHandler
+    from ..resources import ModelUtils
+    from ..state.state import StateView
+    from ..notes import CommandNoteAdder
+
+
+AspirateWhileTrackingCommandType = Literal["aspirateWhileTracking"]
+
+
+class AspirateWhileTrackingParams(
+    PipetteIdMixin,
+    AspirateVolumeMixin,
+    FlowRateMixin,
+    LiquidHandlingWellLocationMixin,
+):
+    """Parameters required to aspirate from a specific well."""
+
+    pass
+
+
+class AspirateWhileTrackingResult(BaseLiquidHandlingResult, DestinationPositionResult):
+    """Result data from execution of an Aspirate command."""
+
+    pass
+
+
+_ExecuteReturn = Union[
+    SuccessData[AspirateWhileTrackingResult],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
+]
+
+
+class AspirateWhileTrackingImplementation(
+    AbstractCommandImpl[AspirateWhileTrackingParams, _ExecuteReturn]
+):
+    """AspirateWhileTracking command implementation."""
+
+    def __init__(
+        self,
+        pipetting: PipettingHandler,
+        state_view: StateView,
+        hardware_api: HardwareControlAPI,
+        command_note_adder: CommandNoteAdder,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        movement: MovementHandler,
+        **kwargs: object,
+    ) -> None:
+        self._pipetting = pipetting
+        self._state_view = state_view
+        self._hardware_api = hardware_api
+        self._command_note_adder = command_note_adder
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
+        self._movement = movement
+
+    async def execute(self, params: AspirateWhileTrackingParams) -> _ExecuteReturn:
+        """Move to and aspirate from the requested well.
+
+        Raises:
+            TipNotAttachedError: if no tip is attached to the pipette.
+            PipetteNotReadyToAspirateError: pipette plunger is not ready.
+        """
+        ready_to_aspirate = self._state_view.pipettes.get_ready_to_aspirate(
+            pipette_id=params.pipetteId
+        )
+        if not ready_to_aspirate:
+            raise PipetteNotReadyToAspirateError(
+                "Pipette cannot aspirate while tracking because of a previous blow out."
+                " The first aspirate following a blow-out must be from a specific well"
+                " so the plunger can be reset in a known safe position."
+            )
+        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,
+            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
+            )
+
+        aspirate_result = await aspirate_while_tracking(
+            pipette_id=params.pipetteId,
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            location_if_error={
+                "retryLocation": (
+                    move_result.public.position.x,
+                    move_result.public.position.y,
+                    move_result.public.position.z,
+                )
+            },
+            command_note_adder=self._command_note_adder,
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+        )
+        position_after_aspirate = await self._gantry_mover.get_position(
+            params.pipetteId
+        )
+        result_deck_point = DeckPoint.model_construct(
+            x=position_after_aspirate.x,
+            y=position_after_aspirate.y,
+            z=position_after_aspirate.z,
+        )
+        if isinstance(aspirate_result, DefinedErrorData):
+            return DefinedErrorData(
+                public=aspirate_result.public,
+                state_update=aspirate_result.state_update.set_liquid_operated(
+                    labware_id=params.labwareId,
+                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                        params.labwareId,
+                        params.wellName,
+                        params.pipetteId,
+                    ),
+                    volume_added=CLEAR,
+                ),
+                state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+            )
+
+        return SuccessData(
+            public=AspirateWhileTrackingResult(
+                volume=aspirate_result.public.volume,
+                position=result_deck_point,
+            ),
+            state_update=aspirate_result.state_update.set_liquid_operated(
+                labware_id=params.labwareId,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+                volume_added=-aspirate_result.public.volume
+                * self._state_view.geometry.get_nozzles_per_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+            ),
+        )
+
+
+class AspirateWhileTracking(
+    BaseCommand[
+        AspirateWhileTrackingParams,
+        AspirateWhileTrackingResult,
+        OverpressureError | StallOrCollisionError,
+    ]
+):
+    """AspirateWhileTracking command model."""
+
+    commandType: AspirateWhileTrackingCommandType = "aspirateWhileTracking"
+    params: AspirateWhileTrackingParams
+    result: Optional[AspirateWhileTrackingResult] = None
+
+    _ImplementationCls: Type[
+        AspirateWhileTrackingImplementation
+    ] = AspirateWhileTrackingImplementation
+
+
+class AspirateWhileTrackingCreate(BaseCommandCreate[AspirateWhileTrackingParams]):
+    """Create aspirateWhileTracking command request model."""
+
+    commandType: AspirateWhileTrackingCommandType = "aspirateWhileTracking"
+    params: AspirateWhileTrackingParams
+
+    _CommandCls: Type[AspirateWhileTracking] = AspirateWhileTracking

opentrons/protocol_engine/commands/blow_out.py

@@ -115,6 +115,8 @@ class BlowOutImplementation(AbstractCommandImpl[BlowOutParams, _ExecuteReturn]):
                 public=BlowOutResult(position=move_result.public.position),
                 state_update=StateUpdate.reduce(
                     move_result.state_update, blow_out_result.state_update
+                ).set_pipette_ready_to_aspirate(
+                    pipette_id=params.pipetteId, ready_to_aspirate=False
                 ),
             )
 

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
+            ),
         )