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

opentrons/protocol_engine/commands/heater_shaker/open_labware_latch.py

@@ -96,7 +96,7 @@ class OpenLabwareLatch(
 
     commandType: OpenLabwareLatchCommandType = "heaterShaker/openLabwareLatch"
     params: OpenLabwareLatchParams
-    result: Optional[OpenLabwareLatchResult]
+    result: Optional[OpenLabwareLatchResult] = None
 
     _ImplementationCls: Type[OpenLabwareLatchImpl] = OpenLabwareLatchImpl
 

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -109,7 +109,7 @@ class SetAndWaitForShakeSpeed(
         "heaterShaker/setAndWaitForShakeSpeed"
     )
     params: SetAndWaitForShakeSpeedParams
-    result: Optional[SetAndWaitForShakeSpeedResult]
+    result: Optional[SetAndWaitForShakeSpeedResult] = None
 
     _ImplementationCls: Type[SetAndWaitForShakeSpeedImpl] = SetAndWaitForShakeSpeedImpl
 

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -76,7 +76,7 @@ class SetTargetTemperature(
 
     commandType: SetTargetTemperatureCommandType = "heaterShaker/setTargetTemperature"
     params: SetTargetTemperatureParams
-    result: Optional[SetTargetTemperatureResult]
+    result: Optional[SetTargetTemperatureResult] = None
 
     _ImplementationCls: Type[SetTargetTemperatureImpl] = SetTargetTemperatureImpl
 

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,18 +13,26 @@ from opentrons.protocol_engine.errors.exceptions import (
     PipetteNotReadyToAspirateError,
     TipNotEmptyError,
     IncompleteLabwareDefinitionError,
+    TipNotAttachedError,
 )
 from opentrons.types import MountType
 from opentrons_shared_data.errors.exceptions import (
     PipetteLiquidNotFoundError,
+    UnsupportedHardwareCommand,
+    PipetteOverpressureError,
 )
 
 from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
     PipetteIdMixin,
+    OverpressureError,
+)
+from .movement_common import (
     WellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -36,11 +45,15 @@ from .command import (
 from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from ..execution import MovementHandler, PipettingHandler
+    from ..execution import MovementHandler, PipettingHandler, GantryMover
     from ..resources import ModelUtils
     from ..state.state import StateView
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 LiquidProbeCommandType = Literal["liquidProbe"]
 TryLiquidProbeCommandType = Literal["tryLiquidProbe"]
 
@@ -76,43 +89,64 @@ 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]
+    | DefinedErrorData[OverpressureError],
 ]
-_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult]
+_TryLiquidProbeExecuteReturn = (
+    SuccessData[TryLiquidProbeResult]
+    | DefinedErrorData[StallOrCollisionError]
+    | DefinedErrorData[OverpressureError]
+)
 
 
 class _ExecuteCommonResult(NamedTuple):
     # If the probe succeeded, the z_pos that it returned.
     # Or, if the probe found no liquid, the error representing that,
     # so calling code can propagate those details up.
-    z_pos_or_error: float | PipetteLiquidNotFoundError
+    z_pos_or_error: float | PipetteLiquidNotFoundError | PipetteOverpressureError
 
     state_update: update_types.StateUpdate
     deck_point: DeckPoint
 
 
-async def _execute_common(
+async def _execute_common(  # noqa: C901
     state_view: StateView,
     movement: MovementHandler,
+    gantry_mover: GantryMover,
     pipetting: PipettingHandler,
+    model_utils: ModelUtils,
     params: _CommonParams,
-) -> _ExecuteCommonResult:
+) -> _ExecuteCommonResult | DefinedErrorData[StallOrCollisionError] | DefinedErrorData[
+    OverpressureError
+]:
     pipette_id = params.pipetteId
     labware_id = params.labwareId
     well_name = params.wellName
+    if (
+        "pressure"
+        not in state_view.pipettes.get_config(pipette_id).available_sensors.sensors
+    ):
+        raise UnsupportedHardwareCommand(
+            "Pressure sensor not available for this pipette"
+        )
 
-    state_update = update_types.StateUpdate()
+    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)
@@ -137,21 +171,18 @@ 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:
+        current_position = await gantry_mover.get_position(params.pipetteId)
         z_pos = await pipetting.liquid_probe_in_place(
             pipette_id=pipette_id,
             labware_id=labware_id,
@@ -160,11 +191,42 @@ 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,
+        )
+    except PipetteOverpressureError as e:
+        return DefinedErrorData(
+            public=OverpressureError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+                errorInfo=(
+                    {
+                        # This is here bc its not optional in the type but we are not using the retry location for this case
+                        "retryLocation": (
+                            current_position.x,
+                            current_position.y,
+                            current_position.z,
+                        )
+                    }
+                ),
+            ),
+            state_update=move_result.state_update.set_fluid_unknown(
+                pipette_id=pipette_id
+            ),
         )
     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,
         )
 
 
@@ -177,12 +239,14 @@ class LiquidProbeImplementation(
         self,
         state_view: StateView,
         movement: MovementHandler,
+        gantry_mover: GantryMover,
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
+        self._gantry_mover = gantry_mover
         self._pipetting = pipetting
         self._model_utils = model_utils
 
@@ -202,10 +266,20 @@ 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,
+            gantry_mover=self._gantry_mover,
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+            params=params,
         )
-        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+        if isinstance(result, DefinedErrorData):
+            return result
+        z_pos_or_error, state_update, deck_point = result
+        if isinstance(
+            z_pos_or_error, (PipetteLiquidNotFoundError, PipetteOverpressureError)
+        ):
             state_update.set_liquid_probed(
                 labware_id=params.labwareId,
                 well_name=params.wellName,
@@ -262,12 +336,14 @@ class TryLiquidProbeImplementation(
         self,
         state_view: StateView,
         movement: MovementHandler,
+        gantry_mover: GantryMover,
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
+        self._gantry_mover = gantry_mover
         self._pipetting = pipetting
         self._model_utils = model_utils
 
@@ -278,11 +354,21 @@ 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,
+            gantry_mover=self._gantry_mover,
+            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):
+        if isinstance(
+            z_pos_or_error, (PipetteLiquidNotFoundError, PipetteOverpressureError)
+        ):
             z_pos = None
             well_volume: float | update_types.ClearType = update_types.CLEAR
         else:
@@ -312,25 +398,33 @@ class TryLiquidProbeImplementation(
 
 
 class LiquidProbe(
-    BaseCommand[LiquidProbeParams, LiquidProbeResult, LiquidNotFoundError]
+    BaseCommand[
+        LiquidProbeParams,
+        LiquidProbeResult,
+        LiquidNotFoundError | StallOrCollisionError | OverpressureError,
+    ]
 ):
     """The model for a full `liquidProbe` command."""
 
     commandType: LiquidProbeCommandType = "liquidProbe"
     params: LiquidProbeParams
-    result: Optional[LiquidProbeResult]
+    result: Optional[LiquidProbeResult] = None
 
     _ImplementationCls: Type[LiquidProbeImplementation] = LiquidProbeImplementation
 
 
 class TryLiquidProbe(
-    BaseCommand[TryLiquidProbeParams, TryLiquidProbeResult, ErrorOccurrence]
+    BaseCommand[
+        TryLiquidProbeParams,
+        TryLiquidProbeResult,
+        StallOrCollisionError | OverpressureError,
+    ]
 ):
     """The model for a full `tryLiquidProbe` command."""
 
     commandType: TryLiquidProbeCommandType = "tryLiquidProbe"
     params: TryLiquidProbeParams
-    result: Optional[TryLiquidProbeResult]
+    result: Optional[TryLiquidProbeResult] = None
 
     _ImplementationCls: Type[
         TryLiquidProbeImplementation

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)
@@ -170,6 +193,10 @@ class LoadLabwareImplementation(
                     loaded_labware.definition
                 )
 
+        self._state_view.labware.raise_if_labware_cannot_be_ondeck(
+            location=params.location, labware_definition=loaded_labware.definition
+        )
+
         return SuccessData(
             public=LoadLabwareResult(
                 labwareId=loaded_labware.labware_id,
@@ -185,7 +212,7 @@ class LoadLabware(BaseCommand[LoadLabwareParams, LoadLabwareResult, ErrorOccurre
 
     commandType: LoadLabwareCommandType = "loadLabware"
     params: LoadLabwareParams
-    result: Optional[LoadLabwareResult]
+    result: Optional[LoadLabwareResult] = None
 
     _ImplementationCls: Type[LoadLabwareImplementation] = LoadLabwareImplementation