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

opentrons/protocol_engine/commands/absorbance_reader/read.py

@@ -1,10 +1,11 @@
 """Command models to read absorbance."""
 from __future__ import annotations
 from datetime import datetime
-from typing import Optional, Dict, TYPE_CHECKING, List
-from typing_extensions import Literal, Type
+from typing import Optional, Dict, TYPE_CHECKING, List, Any
 
+from typing_extensions import Literal, Type
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors import CannotPerformModuleAction, StorageLimitReachedError
@@ -16,12 +17,17 @@ from ...resources.file_provider import (
     MAXIMUM_CSV_FILE_LIMIT,
 )
 from ...resources import FileProvider
+from ...state import update_types
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 ReadAbsorbanceCommandType = Literal["absorbanceReader/read"]
 
 
@@ -29,9 +35,10 @@ class ReadAbsorbanceParams(BaseModel):
     """Input parameters for an absorbance reading."""
 
     moduleId: str = Field(..., description="Unique ID of the Absorbance Reader.")
-    fileName: Optional[str] = Field(
+    fileName: str | SkipJsonSchema[None] = Field(
         None,
         description="Optional file name to use when storing the results of a measurement.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -67,6 +74,7 @@ class ReadAbsorbanceImpl(
         self, params: ReadAbsorbanceParams
     ) -> SuccessData[ReadAbsorbanceResult]:
         """Initiate an absorbance measurement."""
+        state_update = update_types.StateUpdate()
         abs_reader_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
@@ -117,7 +125,9 @@ class ReadAbsorbanceImpl(
                     )
                     asbsorbance_result[wavelength] = converted_values
                     transform_results.append(
-                        ReadData.construct(wavelength=wavelength, data=converted_values)
+                        ReadData.model_construct(
+                            wavelength=wavelength, data=converted_values
+                        )
                     )
         # Handle the virtual module case for data creation (all zeroes)
         elif self._state_view.config.use_virtual_modules:
@@ -131,22 +141,27 @@ class ReadAbsorbanceImpl(
                     )
                     asbsorbance_result[wavelength] = converted_values
                     transform_results.append(
-                        ReadData.construct(wavelength=wavelength, data=converted_values)
+                        ReadData.model_construct(
+                            wavelength=wavelength, data=converted_values
+                        )
                     )
             else:
                 raise CannotPerformModuleAction(
                     "Plate Reader data cannot be requested with a module that has not been initialized."
                 )
 
+        state_update.set_absorbance_reader_data(
+            module_id=abs_reader_substate.module_id, read_result=asbsorbance_result
+        )
         # TODO (cb, 10-17-2024): FILE PROVIDER - Some day we may want to break the file provider behavior into a seperate API function.
         # When this happens, we probably will to have the change the command results handler we utilize to track file IDs in engine.
         # Today, the action handler for the FileStore looks for a ReadAbsorbanceResult command action, this will need to be delinked.
 
         # Begin interfacing with the file provider if the user provided a filename
-        file_ids = []
+        file_ids: list[str] = []
         if params.fileName is not None:
             # Create the Plate Reader Transform
-            plate_read_result = PlateReaderData.construct(
+            plate_read_result = PlateReaderData.model_construct(
                 read_results=transform_results,
                 reference_wavelength=abs_reader_substate.reference_wavelength,
                 start_time=start_time,
@@ -170,12 +185,20 @@ class ReadAbsorbanceImpl(
                 # Return success data to api
                 return SuccessData(
                     public=ReadAbsorbanceResult(
-                        data=asbsorbance_result, fileIds=file_ids
+                        data=asbsorbance_result,
+                        fileIds=file_ids,
                     ),
+                    state_update=state_update,
                 )
 
+        state_update.files_added = update_types.FilesAddedUpdate(file_ids=file_ids)
+
         return SuccessData(
-            public=ReadAbsorbanceResult(data=asbsorbance_result, fileIds=file_ids),
+            public=ReadAbsorbanceResult(
+                data=asbsorbance_result,
+                fileIds=file_ids,
+            ),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/air_gap_in_place.py

@@ -0,0 +1,160 @@
+"""AirGap in place command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Union
+from typing_extensions import Literal
+
+from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+
+from opentrons.hardware_control import HardwareControlAPI
+
+from .pipetting_common import (
+    PipetteIdMixin,
+    AspirateVolumeMixin,
+    FlowRateMixin,
+    BaseLiquidHandlingResult,
+    OverpressureError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from ..errors.error_occurrence import ErrorOccurrence
+from ..errors.exceptions import PipetteNotReadyToAspirateError
+from ..state.update_types import StateUpdate
+from ..types import AspiratedFluid, FluidKind
+
+if TYPE_CHECKING:
+    from ..execution import PipettingHandler, GantryMover
+    from ..resources import ModelUtils
+    from ..state.state import StateView
+    from ..notes import CommandNoteAdder
+
+AirGapInPlaceCommandType = Literal["airGapInPlace"]
+
+
+class AirGapInPlaceParams(PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin):
+    """Payload required to air gap in place."""
+
+    pass
+
+
+class AirGapInPlaceResult(BaseLiquidHandlingResult):
+    """Result data from the execution of a AirGapInPlace command."""
+
+    pass
+
+
+_ExecuteReturn = Union[
+    SuccessData[AirGapInPlaceResult],
+    DefinedErrorData[OverpressureError],
+]
+
+
+class AirGapInPlaceImplementation(
+    AbstractCommandImpl[AirGapInPlaceParams, _ExecuteReturn]
+):
+    """AirGapInPlace command implementation."""
+
+    def __init__(
+        self,
+        pipetting: PipettingHandler,
+        hardware_api: HardwareControlAPI,
+        state_view: StateView,
+        command_note_adder: CommandNoteAdder,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        **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
+
+    async def execute(self, params: AirGapInPlaceParams) -> _ExecuteReturn:
+        """Air gap without moving the pipette.
+
+        Raises:
+            TipNotAttachedError: if no tip is attached to the pipette.
+            PipetteNotReadyToAirGapError: pipette plunger is not ready.
+        """
+        ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
+            pipette_id=params.pipetteId,
+        )
+
+        if not ready_to_aspirate:
+            raise PipetteNotReadyToAspirateError(
+                "Pipette cannot air gap in place 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()
+
+        try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
+            volume = await self._pipetting.aspirate_in_place(
+                pipette_id=params.pipetteId,
+                volume=params.volume,
+                flow_rate=params.flowRate,
+                command_note_adder=self._command_note_adder,
+            )
+        except PipetteOverpressureError as e:
+            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,
+                            )
+                        }
+                    ),
+                ),
+                state_update=state_update,
+            )
+        else:
+            state_update.set_fluid_aspirated(
+                pipette_id=params.pipetteId,
+                fluid=AspiratedFluid(kind=FluidKind.AIR, volume=volume),
+            )
+            return SuccessData(
+                public=AirGapInPlaceResult(volume=volume),
+                state_update=state_update,
+            )
+
+
+class AirGapInPlace(
+    BaseCommand[AirGapInPlaceParams, AirGapInPlaceResult, OverpressureError]
+):
+    """AirGapInPlace command model."""
+
+    commandType: AirGapInPlaceCommandType = "airGapInPlace"
+    params: AirGapInPlaceParams
+    result: Optional[AirGapInPlaceResult]
+
+    _ImplementationCls: Type[AirGapInPlaceImplementation] = AirGapInPlaceImplementation
+
+
+class AirGapInPlaceCreate(BaseCommandCreate[AirGapInPlaceParams]):
+    """AirGapInPlace command request model."""
+
+    commandType: AirGapInPlaceCommandType = "airGapInPlace"
+    params: AirGapInPlaceParams
+
+    _CommandCls: Type[AirGapInPlace] = AirGapInPlace

opentrons/protocol_engine/commands/aspirate.py

@@ -1,7 +1,7 @@
 """Aspirate command request, result, and implementation models."""
+
 from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 from typing_extensions import Literal
 
 from .pipetting_common import (
@@ -9,9 +9,15 @@ from .pipetting_common import (
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
+    aspirate_in_place,
+    prepare_for_aspirate,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -20,12 +26,15 @@ from .command import (
     DefinedErrorData,
     SuccessData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
 
 from ..state.update_types import StateUpdate, CLEAR
-from ..types import WellLocation, WellOrigin, CurrentWell, DeckPoint
+from ..types import (
+    WellLocation,
+    WellOrigin,
+    CurrentWell,
+)
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
@@ -53,7 +62,7 @@ class AspirateResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 _ExecuteReturn = Union[
     SuccessData[AspirateResult],
-    DefinedErrorData[OverpressureError],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
 ]
 
 
@@ -86,23 +95,51 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
+        well_location = params.wellLocation
+
+        state_update = StateUpdate()
+
+        final_location = self._state_view.geometry.get_well_position(
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=well_location,
+            operation_volume=-params.volume,
+            pipette_id=pipette_id,
+        )
 
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
             pipette_id=pipette_id
         )
 
         current_well = None
-        state_update = StateUpdate()
 
         if not ready_to_aspirate:
-            await self._movement.move_to_well(
+            move_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=WellLocation(origin=WellOrigin.TOP),
             )
+            state_update.append(move_result.state_update)
+            if isinstance(move_result, DefinedErrorData):
+                return DefinedErrorData(move_result.public, state_update=state_update)
 
-            await self._pipetting.prepare_for_aspirate(pipette_id=pipette_id)
+            prepare_result = await prepare_for_aspirate(
+                pipette_id=pipette_id,
+                pipetting=self._pipetting,
+                model_utils=self._model_utils,
+                # Note that the retryLocation is the final location, inside the liquid,
+                # because that's where we'd want the client to try re-aspirating if this
+                # command fails and the run enters error recovery.
+                location_if_error={"retryLocation": final_location},
+            )
+            state_update.append(prepare_result.state_update)
+            if isinstance(prepare_result, DefinedErrorData):
+                return DefinedErrorData(
+                    public=prepare_result.public, state_update=state_update
+                )
 
             # set our current deck location to the well now that we've made
             # an intermediate move for the "prepare for aspirate" step
@@ -112,71 +149,84 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                 well_name=well_name,
             )
 
-        position = await self._movement.move_to_well(
+        move_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,
+            well_location=well_location,
             current_well=current_well,
             operation_volume=-params.volume,
         )
-        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
-        state_update.set_pipette_location(
+        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_in_place(
             pipette_id=pipette_id,
-            new_labware_id=labware_id,
-            new_well_name=well_name,
-            new_deck_point=deck_point,
+            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,
         )
-
-        try:
-            volume_aspirated = await self._pipetting.aspirate_in_place(
-                pipette_id=pipette_id,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                command_note_adder=self._command_note_adder,
-            )
-        except PipetteOverpressureError as e:
+        state_update.append(aspirate_result.state_update)
+        if isinstance(aspirate_result, DefinedErrorData):
             state_update.set_liquid_operated(
                 labware_id=labware_id,
-                well_name=well_name,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    labware_id,
+                    well_name,
+                    params.pipetteId,
+                ),
                 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": (position.x, position.y, position.z)},
-                ),
-                state_update=state_update,
-            )
-        else:
-            state_update.set_liquid_operated(
-                labware_id=labware_id,
-                well_name=well_name,
-                volume_added=-volume_aspirated,
-            )
-            return SuccessData(
-                public=AspirateResult(
-                    volume=volume_aspirated,
-                    position=deck_point,
-                ),
-                state_update=state_update,
+                public=aspirate_result.public, state_update=state_update
             )
 
+        state_update.set_liquid_operated(
+            labware_id=labware_id,
+            well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                labware_id, well_name, pipette_id
+            ),
+            volume_added=-aspirate_result.public.volume
+            * self._state_view.geometry.get_nozzles_per_well(
+                labware_id,
+                well_name,
+                params.pipetteId,
+            ),
+        )
 
-class Aspirate(BaseCommand[AspirateParams, AspirateResult, OverpressureError]):
+        return SuccessData(
+            public=AspirateResult(
+                volume=aspirate_result.public.volume,
+                position=move_result.public.position,
+            ),
+            state_update=state_update,
+        )
+
+
+class Aspirate(
+    BaseCommand[
+        AspirateParams, AspirateResult, OverpressureError | StallOrCollisionError
+    ]
+):
     """Aspirate command model."""
 
     commandType: AspirateCommandType = "aspirate"
     params: AspirateParams
-    result: Optional[AspirateResult]
+    result: Optional[AspirateResult] = None
 
     _ImplementationCls: Type[AspirateImplementation] = AspirateImplementation
 

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union
 from typing_extensions import Literal
 
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
-
 from opentrons.hardware_control import HardwareControlAPI
 
 from .pipetting_common import (
@@ -14,6 +12,7 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
+    aspirate_in_place,
 )
 from .command import (
     AbstractCommandImpl,
@@ -22,9 +21,8 @@ from .command import (
     SuccessData,
     DefinedErrorData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
 from ..errors.exceptions import PipetteNotReadyToAspirateError
-from ..state.update_types import StateUpdate, CLEAR
+from ..state.update_types import CLEAR
 from ..types import CurrentWell
 
 if TYPE_CHECKING:
@@ -83,8 +81,6 @@ class AspirateInPlaceImplementation(
             TipNotAttachedError: if no tip is attached to the pipette.
             PipetteNotReadyToAspirateError: pipette plunger is not ready.
         """
-        state_update = StateUpdate()
-
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
             pipette_id=params.pipetteId,
         )
@@ -95,63 +91,71 @@ class AspirateInPlaceImplementation(
                 " so the plunger can be reset in a known safe position."
             )
 
-        current_location = self._state_view.pipettes.get_current_location()
         current_position = await self._gantry_mover.get_position(params.pipetteId)
+        current_location = self._state_view.pipettes.get_current_location()
 
-        try:
-            volume = await self._pipetting.aspirate_in_place(
-                pipette_id=params.pipetteId,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                command_note_adder=self._command_note_adder,
-            )
-        except PipetteOverpressureError as e:
+        result = await aspirate_in_place(
+            pipette_id=params.pipetteId,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            location_if_error={
+                "retryLocation": (
+                    current_position.x,
+                    current_position.y,
+                    current_position.z,
+                )
+            },
+            command_note_adder=self._command_note_adder,
+            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,
+                return SuccessData(
+                    public=AspirateInPlaceResult(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=-result.public.volume
+                        * self._state_view.geometry.get_nozzles_per_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                    ),
+                )
+            else:
+                return SuccessData(
+                    public=AspirateInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update,
                 )
-            return SuccessData(
-                public=AspirateInPlaceResult(volume=volume),
-                state_update=state_update,
-            )
 
 
 class AspirateInPlace(
@@ -161,7 +165,7 @@ class AspirateInPlace(
 
     commandType: AspirateInPlaceCommandType = "aspirateInPlace"
     params: AspirateInPlaceParams
-    result: Optional[AspirateInPlaceResult]
+    result: Optional[AspirateInPlaceResult] = None
 
     _ImplementationCls: Type[
         AspirateInPlaceImplementation