opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/__init__.py

@@ -20,6 +20,7 @@ from . import temperature_module
 from . import thermocycler
 from . import calibration
 from . import unsafe
+from . import robot
 
 from .hash_command_params import hash_protocol_command_params
 from .generate_command_schema import generate_command_schema
@@ -34,13 +35,23 @@ from .command import (
 
 from .command_unions import (
     Command,
+    CommandAdapter,
     CommandParams,
     CommandCreate,
+    CommandCreateAdapter,
     CommandResult,
     CommandType,
     CommandDefinedErrorData,
 )
 
+from .air_gap_in_place import (
+    AirGapInPlace,
+    AirGapInPlaceParams,
+    AirGapInPlaceCreate,
+    AirGapInPlaceResult,
+    AirGapInPlaceCommandType,
+)
+
 from .aspirate import (
     Aspirate,
     AspirateParams,
@@ -138,6 +149,15 @@ from .load_liquid import (
     LoadLiquidImplementation,
 )
 
+from .load_liquid_class import (
+    LoadLiquidClass,
+    LoadLiquidClassParams,
+    LoadLiquidClassCreate,
+    LoadLiquidClassResult,
+    LoadLiquidClassCommandType,
+    LoadLiquidClassImplementation,
+)
+
 from .load_module import (
     LoadModule,
     LoadModuleParams,
@@ -154,6 +174,22 @@ from .load_pipette import (
     LoadPipetteCommandType,
 )
 
+from .load_lid_stack import (
+    LoadLidStack,
+    LoadLidStackParams,
+    LoadLidStackCreate,
+    LoadLidStackResult,
+    LoadLidStackCommandType,
+)
+
+from .load_lid import (
+    LoadLid,
+    LoadLidParams,
+    LoadLidCreate,
+    LoadLidResult,
+    LoadLidCommandType,
+)
+
 from .move_labware import (
     MoveLabware,
     MoveLabwareParams,
@@ -323,6 +359,14 @@ from .verify_tip_presence import (
     VerifyTipPresenceCommandType,
 )
 
+from .get_next_tip import (
+    GetNextTip,
+    GetNextTipCreate,
+    GetNextTipParams,
+    GetNextTipResult,
+    GetNextTipCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -336,11 +380,35 @@ from .liquid_probe import (
     TryLiquidProbeCommandType,
 )
 
+from .evotip_seal_pipette import (
+    EvotipSealPipette,
+    EvotipSealPipetteParams,
+    EvotipSealPipetteCreate,
+    EvotipSealPipetteResult,
+    EvotipSealPipetteCommandType,
+)
+from .evotip_unseal_pipette import (
+    EvotipUnsealPipette,
+    EvotipUnsealPipetteParams,
+    EvotipUnsealPipetteCreate,
+    EvotipUnsealPipetteResult,
+    EvotipUnsealPipetteCommandType,
+)
+from .evotip_dispense import (
+    EvotipDispense,
+    EvotipDispenseParams,
+    EvotipDispenseCreate,
+    EvotipDispenseResult,
+    EvotipDispenseCommandType,
+)
+
 __all__ = [
     # command type unions
     "Command",
+    "CommandAdapter",
     "CommandParams",
     "CommandCreate",
+    "CommandCreateAdapter",
     "CommandResult",
     "CommandType",
     "CommandPrivateResult",
@@ -355,6 +423,12 @@ __all__ = [
     "hash_protocol_command_params",
     # command schema generation
     "generate_command_schema",
+    # air gap command models
+    "AirGapInPlace",
+    "AirGapInPlaceCreate",
+    "AirGapInPlaceParams",
+    "AirGapInPlaceResult",
+    "AirGapInPlaceCommandType",
     # aspirate command models
     "Aspirate",
     "AspirateCreate",
@@ -440,6 +514,20 @@ __all__ = [
     "LoadPipetteResult",
     "LoadPipetteCommandType",
     "LoadPipettePrivateResult",
+    # load lid stack command models
+    "LoadLidStack",
+    "LoadLidStackCreate",
+    "LoadLidStackParams",
+    "LoadLidStackResult",
+    "LoadLidStackCommandType",
+    "LoadLidStackPrivateResult",
+    # load lid command models
+    "LoadLid",
+    "LoadLidCreate",
+    "LoadLidParams",
+    "LoadLidResult",
+    "LoadLidCommandType",
+    "LoadLidPrivateResult",
     # move labware command models
     "MoveLabware",
     "MoveLabwareCreate",
@@ -538,6 +626,14 @@ __all__ = [
     "LoadLiquidParams",
     "LoadLiquidResult",
     "LoadLiquidCommandType",
+    # load liquid class command models
+    "LoadLiquidClass",
+    "LoadLiquidClassParams",
+    "LoadLiquidClassCreate",
+    "LoadLiquidClassResult",
+    "LoadLiquidClassImplementation",
+    "LoadLiquidClassCommandType",
+    # hardware control command models
     # hardware module command bundles
     "absorbance_reader",
     "heater_shaker",
@@ -548,6 +644,7 @@ __all__ = [
     "calibration",
     # unsafe command bundle
     "unsafe",
+    "robot",
     # configure pipette volume command bundle
     "ConfigureForVolume",
     "ConfigureForVolumeCreate",
@@ -578,6 +675,12 @@ __all__ = [
     "VerifyTipPresenceParams",
     "VerifyTipPresenceResult",
     "VerifyTipPresenceCommandType",
+    # get next tip command bundle
+    "GetNextTip",
+    "GetNextTipCreate",
+    "GetNextTipParams",
+    "GetNextTipResult",
+    "GetNextTipCommandType",
     # liquid probe command bundle
     "LiquidProbe",
     "LiquidProbeParams",
@@ -589,4 +692,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",
 ]

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -60,7 +60,6 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
         hardware_lid_status = AbsorbanceReaderLidStatus.OFF
         if not self._state_view.config.use_virtual_modules:
             abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
-
             if abs_reader is not None:
                 hardware_lid_status = await abs_reader.get_current_lid_status()
             else:
@@ -95,7 +94,6 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
                     deck_slot=self._state_view.modules.get_location(
                         params.moduleId
                     ).slotName,
-                    deck_type=self._state_view.config.deck_type,
                     model=absorbance_model,
                 )
             )
@@ -134,7 +132,7 @@ class CloseLid(BaseCommand[CloseLidParams, CloseLidResult, ErrorOccurrence]):
 
     commandType: CloseLidCommandType = "absorbanceReader/closeLid"
     params: CloseLidParams
-    result: Optional[CloseLidResult]
+    result: Optional[CloseLidResult] = None
 
     _ImplementationCls: Type[CloseLidImpl] = CloseLidImpl
 

opentrons/protocol_engine/commands/absorbance_reader/initialize.py

@@ -1,9 +1,10 @@
 """Command models to initialize an Absorbance Reader."""
 from __future__ import annotations
-from typing import List, Optional, Literal, TYPE_CHECKING
+from typing import List, Optional, Literal, TYPE_CHECKING, Any
 from typing_extensions import Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.drivers.types import ABSMeasurementMode
 from opentrons.protocol_engine.types import ABSMeasureMode
@@ -11,6 +12,7 @@ from opentrons.protocol_engine.types import ABSMeasureMode
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import InvalidWavelengthError
+from ...state import update_types
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
@@ -20,6 +22,10 @@ if TYPE_CHECKING:
 InitializeCommandType = Literal["absorbanceReader/initialize"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class InitializeParams(BaseModel):
     """Input parameters to initialize an absorbance reading."""
 
@@ -28,8 +34,10 @@ class InitializeParams(BaseModel):
         ..., description="Initialize single or multi measurement mode."
     )
     sampleWavelengths: List[int] = Field(..., description="Sample wavelengths in nm.")
-    referenceWavelength: Optional[int] = Field(
-        None, description="Optional reference wavelength in nm."
+    referenceWavelength: int | SkipJsonSchema[None] = Field(
+        None,
+        description="Optional reference wavelength in nm.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -53,6 +61,7 @@ class InitializeImpl(
 
     async def execute(self, params: InitializeParams) -> SuccessData[InitializeResult]:
         """Initiate a single absorbance measurement."""
+        state_update = update_types.StateUpdate()
         abs_reader_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
@@ -113,17 +122,22 @@ class InitializeImpl(
                 reference_wavelength=params.referenceWavelength,
             )
 
-        return SuccessData(
-            public=InitializeResult(),
+        state_update.initialize_absorbance_reader(
+            abs_reader_substate.module_id,
+            params.measureMode,
+            params.sampleWavelengths,
+            params.referenceWavelength,
         )
 
+        return SuccessData(public=InitializeResult(), state_update=state_update)
+
 
 class Initialize(BaseCommand[InitializeParams, InitializeResult, ErrorOccurrence]):
     """A command to initialize an Absorbance Reader."""
 
     commandType: InitializeCommandType = "absorbanceReader/initialize"
     params: InitializeParams
-    result: Optional[InitializeResult]
+    result: Optional[InitializeResult] = None
 
     _ImplementationCls: Type[InitializeImpl] = InitializeImpl
 

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -91,7 +91,6 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
                     deck_slot=self._state_view.modules.get_location(
                         params.moduleId
                     ).slotName,
-                    deck_type=self._state_view.config.deck_type,
                     model=absorbance_model,
                 )
             )
@@ -134,7 +133,7 @@ class OpenLid(BaseCommand[OpenLidParams, OpenLidResult, ErrorOccurrence]):
 
     commandType: OpenLidCommandType = "absorbanceReader/openLid"
     params: OpenLidParams
-    result: Optional[OpenLidResult]
+    result: Optional[OpenLidResult] = None
 
     _ImplementationCls: Type[OpenLidImpl] = OpenLidImpl
 

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,
@@ -167,15 +182,26 @@ class ReadAbsorbanceImpl(
                     )
                     file_ids.append(file_id)
 
+                state_update.files_added = update_types.FilesAddedUpdate(
+                    file_ids=file_ids
+                )
                 # 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,
         )
 
 
@@ -186,7 +212,7 @@ class ReadAbsorbance(
 
     commandType: ReadAbsorbanceCommandType = "absorbanceReader/read"
     params: ReadAbsorbanceParams
-    result: Optional[ReadAbsorbanceResult]
+    result: Optional[ReadAbsorbanceResult] = None
 
     _ImplementationCls: Type[ReadAbsorbanceImpl] = ReadAbsorbanceImpl
 

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] = None
+
+    _ImplementationCls: Type[AirGapInPlaceImplementation] = AirGapInPlaceImplementation
+
+
+class AirGapInPlaceCreate(BaseCommandCreate[AirGapInPlaceParams]):
+    """AirGapInPlace command request model."""
+
+    commandType: AirGapInPlaceCommandType = "airGapInPlace"
+    params: AirGapInPlaceParams
+
+    _CommandCls: Type[AirGapInPlace] = AirGapInPlace