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

opentrons/protocol_engine/commands/heater_shaker/wait_for_temperature.py

@@ -1,9 +1,10 @@
 """Command models to wait for a Heater-Shaker Module's target temperature."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
-from typing_extensions import Literal, Type
+from typing import Optional, TYPE_CHECKING, 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.error_occurrence import ErrorOccurrence
@@ -16,11 +17,15 @@ if TYPE_CHECKING:
 WaitForTemperatureCommandType = Literal["heaterShaker/waitForTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class WaitForTemperatureParams(BaseModel):
     """Input parameters to wait for a Heater-Shaker's target temperature."""
 
     moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
-    celsius: Optional[float] = Field(
+    celsius: float | SkipJsonSchema[None] = Field(
         None,
         description="Target temperature in °C. If not specified, will "
         "default to the module's target temperature. "
@@ -28,6 +33,7 @@ class WaitForTemperatureParams(BaseModel):
         "could lead to unpredictable behavior and hence is not "
         "recommended for use. This parameter can be removed in a "
         "future version without prior notice.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -82,7 +88,7 @@ class WaitForTemperature(
 
     commandType: WaitForTemperatureCommandType = "heaterShaker/waitForTemperature"
     params: WaitForTemperatureParams
-    result: Optional[WaitForTemperatureResult]
+    result: Optional[WaitForTemperatureResult] = None
 
     _ImplementationCls: Type[WaitForTemperatureImpl] = WaitForTemperatureImpl
 

opentrons/protocol_engine/commands/home.py

@@ -1,7 +1,10 @@
 """Home command payload, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, List, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, List, Type
+from pydantic.json_schema import SkipJsonSchema
+
 from typing_extensions import Literal
 
 from opentrons.types import MountType
@@ -17,24 +20,30 @@ if TYPE_CHECKING:
 HomeCommandType = Literal["home"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class HomeParams(BaseModel):
     """Payload required for a Home command."""
 
-    axes: Optional[List[MotorAxis]] = Field(
+    axes: List[MotorAxis] | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Axes to return to their home positions. If omitted,"
             " will home all motors. Extra axes may be implicitly homed"
             " to ensure accurate homing of the explicitly specified axes."
         ),
+        json_schema_extra=_remove_default,
     )
-    skipIfMountPositionOk: Optional[MountType] = Field(
+    skipIfMountPositionOk: MountType | SkipJsonSchema[None] = Field(
         None,
         description=(
             "If this parameter is provided, the gantry will only be homed if the"
             " specified mount has an invalid position. If omitted, the homing action"
             " will be executed unconditionally."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -77,7 +86,7 @@ class Home(BaseCommand[HomeParams, HomeResult, ErrorOccurrence]):
 
     commandType: HomeCommandType = "home"
     params: HomeParams
-    result: Optional[HomeResult]
+    result: Optional[HomeResult] = None
 
     _ImplementationCls: Type[HomeImplementation] = HomeImplementation
 

opentrons/protocol_engine/commands/liquid_probe.py

@@ -1,10 +1,11 @@
 """The liquidProbe and tryLiquidProbe commands."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, NamedTuple, Optional, Type, Union
-from typing_extensions import Literal
+from typing import TYPE_CHECKING, NamedTuple, Optional, Type, Union, Any
 
+from typing_extensions import Literal
 from pydantic import Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.protocol_engine.state import update_types
 from opentrons.protocol_engine.errors.exceptions import (
@@ -12,6 +13,7 @@ from opentrons.protocol_engine.errors.exceptions import (
     PipetteNotReadyToAspirateError,
     TipNotEmptyError,
     IncompleteLabwareDefinitionError,
+    TipNotAttachedError,
 )
 from opentrons.types import MountType
 from opentrons_shared_data.errors.exceptions import (
@@ -23,8 +25,12 @@ from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
     PipetteIdMixin,
+)
+from .movement_common import (
     WellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -42,6 +48,10 @@ if TYPE_CHECKING:
     from ..state.state import StateView
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 LiquidProbeCommandType = Literal["liquidProbe"]
 TryLiquidProbeCommandType = Literal["tryLiquidProbe"]
 
@@ -77,20 +87,23 @@ class LiquidProbeResult(DestinationPositionResult):
 class TryLiquidProbeResult(DestinationPositionResult):
     """Result data from the execution of a `tryLiquidProbe` command."""
 
-    z_position: Optional[float] = Field(
+    z_position: float | SkipJsonSchema[None] = Field(
         ...,
         description=(
             "The Z coordinate, in mm, of the found liquid in deck space."
             " If no liquid was found, `null` or omitted."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
 _LiquidProbeExecuteReturn = Union[
     SuccessData[LiquidProbeResult],
-    DefinedErrorData[LiquidNotFoundError],
+    DefinedErrorData[LiquidNotFoundError] | DefinedErrorData[StallOrCollisionError],
 ]
-_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult]
+_TryLiquidProbeExecuteReturn = (
+    SuccessData[TryLiquidProbeResult] | DefinedErrorData[StallOrCollisionError]
+)
 
 
 class _ExecuteCommonResult(NamedTuple):
@@ -107,13 +120,12 @@ async def _execute_common(
     state_view: StateView,
     movement: MovementHandler,
     pipetting: PipettingHandler,
+    model_utils: ModelUtils,
     params: _CommonParams,
-) -> _ExecuteCommonResult:
+) -> _ExecuteCommonResult | DefinedErrorData[StallOrCollisionError]:
     pipette_id = params.pipetteId
     labware_id = params.labwareId
     well_name = params.wellName
-
-    state_update = update_types.StateUpdate()
     if (
         "pressure"
         not in state_view.pipettes.get_config(pipette_id).available_sensors.sensors
@@ -122,6 +134,11 @@ async def _execute_common(
             "Pressure sensor not available for this pipette"
         )
 
+    if not state_view.pipettes.get_nozzle_configuration_supports_lld(pipette_id):
+        raise TipNotAttachedError(
+            "Either the front right or back left nozzle must have a tip attached to probe liquid height."
+        )
+
     # May raise TipNotAttachedError.
     aspirated_volume = state_view.pipettes.get_aspirated_volume(pipette_id)
 
@@ -145,20 +162,16 @@ async def _execute_common(
         )
 
     # liquid_probe process start position
-    position = await movement.move_to_well(
+    move_result = await move_to_well(
+        movement=movement,
+        model_utils=model_utils,
         pipette_id=pipette_id,
         labware_id=labware_id,
         well_name=well_name,
         well_location=params.wellLocation,
     )
-    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:
         z_pos = await pipetting.liquid_probe_in_place(
             pipette_id=pipette_id,
@@ -168,11 +181,15 @@ async def _execute_common(
         )
     except PipetteLiquidNotFoundError as exception:
         return _ExecuteCommonResult(
-            z_pos_or_error=exception, state_update=state_update, deck_point=deck_point
+            z_pos_or_error=exception,
+            state_update=move_result.state_update,
+            deck_point=move_result.public.position,
         )
     else:
         return _ExecuteCommonResult(
-            z_pos_or_error=z_pos, state_update=state_update, deck_point=deck_point
+            z_pos_or_error=z_pos,
+            state_update=move_result.state_update,
+            deck_point=move_result.public.position,
         )
 
 
@@ -210,9 +227,16 @@ class LiquidProbeImplementation(
             MustHomeError: as an undefined error, if the plunger is not in a valid
                 position.
         """
-        z_pos_or_error, state_update, deck_point = await _execute_common(
-            self._state_view, self._movement, self._pipetting, params
+        result = await _execute_common(
+            state_view=self._state_view,
+            movement=self._movement,
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+            params=params,
         )
+        if isinstance(result, DefinedErrorData):
+            return result
+        z_pos_or_error, state_update, deck_point = result
         if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
             state_update.set_liquid_probed(
                 labware_id=params.labwareId,
@@ -286,9 +310,16 @@ class TryLiquidProbeImplementation(
         found, `tryLiquidProbe` returns a success result with `z_position=null` instead
         of a defined error.
         """
-        z_pos_or_error, state_update, deck_point = await _execute_common(
-            self._state_view, self._movement, self._pipetting, params
+        result = await _execute_common(
+            state_view=self._state_view,
+            movement=self._movement,
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+            params=params,
         )
+        if isinstance(result, DefinedErrorData):
+            return result
+        z_pos_or_error, state_update, deck_point = result
 
         if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
             z_pos = None
@@ -320,7 +351,11 @@ class TryLiquidProbeImplementation(
 
 
 class LiquidProbe(
-    BaseCommand[LiquidProbeParams, LiquidProbeResult, LiquidNotFoundError]
+    BaseCommand[
+        LiquidProbeParams,
+        LiquidProbeResult,
+        LiquidNotFoundError | StallOrCollisionError,
+    ]
 ):
     """The model for a full `liquidProbe` command."""
 
@@ -332,7 +367,7 @@ class LiquidProbe(
 
 
 class TryLiquidProbe(
-    BaseCommand[TryLiquidProbeParams, TryLiquidProbeResult, ErrorOccurrence]
+    BaseCommand[TryLiquidProbeParams, TryLiquidProbeResult, StallOrCollisionError]
 ):
     """The model for a full `tryLiquidProbe` command."""
 

opentrons/protocol_engine/commands/load_labware.py

@@ -1,7 +1,9 @@
 """Load labware command request, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
@@ -29,6 +31,10 @@ if TYPE_CHECKING:
 LoadLabwareCommandType = Literal["loadLabware"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class LoadLabwareParams(BaseModel):
     """Payload required to load a labware into a slot."""
 
@@ -48,18 +54,20 @@ class LoadLabwareParams(BaseModel):
         ...,
         description="The labware definition version.",
     )
-    labwareId: Optional[str] = Field(
+    labwareId: str | SkipJsonSchema[None] = Field(
         None,
         description="An optional ID to assign to this labware. If None, an ID "
         "will be generated.",
+        json_schema_extra=_remove_default,
     )
-    displayName: Optional[str] = Field(
+    displayName: str | SkipJsonSchema[None] = Field(
         None,
         description="An optional user-specified display name "
         "or label for this labware.",
         # NOTE: v4/5 JSON protocols will always have a displayName which will be the
         #  user-specified label OR the displayName property of the labware's definition.
         # TODO: Make sure v6 JSON protocols don't do that.
+        json_schema_extra=_remove_default,
     )
 
 
@@ -104,6 +112,8 @@ class LoadLabwareImplementation(
         self, params: LoadLabwareParams
     ) -> SuccessData[LoadLabwareResult]:
         """Load definition and calibration data necessary for a labware."""
+        state_update = StateUpdate()
+
         # TODO (tz, 8-15-2023): extend column validation to column 1 when working
         # on https://opentrons.atlassian.net/browse/RSS-258 and completing
         # https://opentrons.atlassian.net/browse/RSS-255
@@ -128,10 +138,12 @@ class LoadLabwareImplementation(
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 area_name
             )
+            state_update.set_addressable_area_used(area_name)
         elif isinstance(params.location, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.location.slotName.id
             )
+            state_update.set_addressable_area_used(params.location.slotName.id)
 
         verified_location = self._state_view.geometry.ensure_location_not_occupied(
             params.location
@@ -144,8 +156,6 @@ class LoadLabwareImplementation(
             labware_id=params.labwareId,
         )
 
-        state_update = StateUpdate()
-
         state_update.set_loaded_labware(
             labware_id=loaded_labware.labware_id,
             offset_id=loaded_labware.offsetId,
@@ -162,6 +172,19 @@ class LoadLabwareImplementation(
                 top_labware_definition=loaded_labware.definition,
                 bottom_labware_id=verified_location.labwareId,
             )
+            # Validate load location is valid for lids
+            if (
+                labware_validation.validate_definition_is_lid(
+                    definition=loaded_labware.definition
+                )
+                and loaded_labware.definition.compatibleParentLabware is not None
+                and self._state_view.labware.get_load_name(verified_location.labwareId)
+                not in loaded_labware.definition.compatibleParentLabware
+            ):
+                raise ValueError(
+                    f"Labware Lid {params.loadName} may not be loaded on parent labware {self._state_view.labware.get_display_name(verified_location.labwareId)}."
+                )
+
         # Validate labware for the absorbance reader
         elif isinstance(params.location, ModuleLocation):
             module = self._state_view.modules.get(params.location.moduleId)
@@ -169,7 +192,6 @@ class LoadLabwareImplementation(
                 self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
                     loaded_labware.definition
                 )
-
         return SuccessData(
             public=LoadLabwareResult(
                 labwareId=loaded_labware.labware_id,
@@ -185,7 +207,7 @@ class LoadLabware(BaseCommand[LoadLabwareParams, LoadLabwareResult, ErrorOccurre
 
     commandType: LoadLabwareCommandType = "loadLabware"
     params: LoadLabwareParams
-    result: Optional[LoadLabwareResult]
+    result: Optional[LoadLabwareResult] = None
 
     _ImplementationCls: Type[LoadLabwareImplementation] = LoadLabwareImplementation
 

opentrons/protocol_engine/commands/load_lid.py

@@ -0,0 +1,146 @@
+"""Load lid command request, result, and implementation models."""
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, Type
+from typing_extensions import Literal
+
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+from ..errors import LabwareCannotBeStackedError, LabwareIsNotAllowedInLocationError
+from ..resources import labware_validation
+from ..types import (
+    LabwareLocation,
+    OnLabwareLocation,
+)
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from ..execution import EquipmentHandler
+
+
+LoadLidCommandType = Literal["loadLid"]
+
+
+class LoadLidParams(BaseModel):
+    """Payload required to load a lid onto a labware."""
+
+    location: LabwareLocation = Field(
+        ...,
+        description="Labware the lid should be loaded onto.",
+    )
+    loadName: str = Field(
+        ...,
+        description="Name used to reference a lid labware definition.",
+    )
+    namespace: str = Field(
+        ...,
+        description="The namespace the lid labware definition belongs to.",
+    )
+    version: int = Field(
+        ...,
+        description="The lid labware definition version.",
+    )
+
+
+class LoadLidResult(BaseModel):
+    """Result data from the execution of a LoadLabware command."""
+
+    labwareId: str = Field(
+        ...,
+        description="An ID to reference this lid labware in subsequent commands.",
+    )
+    definition: LabwareDefinition = Field(
+        ...,
+        description="The full definition data for this lid labware.",
+    )
+
+
+class LoadLidImplementation(
+    AbstractCommandImpl[LoadLidParams, SuccessData[LoadLidResult]]
+):
+    """Load lid command implementation."""
+
+    def __init__(
+        self, equipment: EquipmentHandler, state_view: StateView, **kwargs: object
+    ) -> None:
+        self._equipment = equipment
+        self._state_view = state_view
+
+    async def execute(self, params: LoadLidParams) -> SuccessData[LoadLidResult]:
+        """Load definition and calibration data necessary for a lid."""
+        if not isinstance(params.location, OnLabwareLocation):
+            raise LabwareIsNotAllowedInLocationError(
+                "Lid Labware is only allowed to be loaded on top of a labware. Try `load_lid_stack(...)` to load lids without parent labware."
+            )
+
+        verified_location = self._state_view.geometry.ensure_location_not_occupied(
+            params.location
+        )
+        loaded_labware = await self._equipment.load_labware(
+            load_name=params.loadName,
+            namespace=params.namespace,
+            version=params.version,
+            location=verified_location,
+            labware_id=None,
+        )
+
+        # TODO(chb 2024-12-12) these validation checks happen after the labware is loaded, because they rely on
+        #   on the definition. In practice this will not cause any issues since they will raise protocol ending
+        #   exception, but for correctness should be refactored to do this check beforehand.
+        if not labware_validation.validate_definition_is_lid(loaded_labware.definition):
+            raise LabwareCannotBeStackedError(
+                f"Labware {params.loadName} is not a Lid and cannot be loaded onto {self._state_view.labware.get_display_name(params.location.labwareId)}."
+            )
+
+        state_update = StateUpdate()
+
+        # In the case of lids being loaded on top of other labware, set the parent labware's lid
+        state_update.set_lid(
+            parent_labware_id=params.location.labwareId,
+            lid_id=loaded_labware.labware_id,
+        )
+
+        state_update.set_loaded_labware(
+            labware_id=loaded_labware.labware_id,
+            offset_id=loaded_labware.offsetId,
+            definition=loaded_labware.definition,
+            location=verified_location,
+            display_name=None,
+        )
+
+        if isinstance(verified_location, OnLabwareLocation):
+            self._state_view.labware.raise_if_labware_cannot_be_stacked(
+                top_labware_definition=loaded_labware.definition,
+                bottom_labware_id=verified_location.labwareId,
+            )
+
+        return SuccessData(
+            public=LoadLidResult(
+                labwareId=loaded_labware.labware_id,
+                definition=loaded_labware.definition,
+            ),
+            state_update=state_update,
+        )
+
+
+class LoadLid(BaseCommand[LoadLidParams, LoadLidResult, ErrorOccurrence]):
+    """Load lid command resource model."""
+
+    commandType: LoadLidCommandType = "loadLid"
+    params: LoadLidParams
+    result: Optional[LoadLidResult]
+
+    _ImplementationCls: Type[LoadLidImplementation] = LoadLidImplementation
+
+
+class LoadLidCreate(BaseCommandCreate[LoadLidParams]):
+    """Load lid command creation request."""
+
+    commandType: LoadLidCommandType = "loadLid"
+    params: LoadLidParams
+
+    _CommandCls: Type[LoadLid] = LoadLid