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

opentrons/protocol_engine/commands/generate_command_schema.py

@@ -1,24 +1,17 @@
 """Generate a JSON schema against which all create commands statically validate."""
+
 import json
-import pydantic
 import argparse
 import sys
-from opentrons.protocol_engine.commands.command_unions import CommandCreate
-
-
-class CreateCommandUnion(pydantic.BaseModel):
-    """Model that validates a union of all CommandCreate models."""
-
-    __root__: CommandCreate
+from opentrons.protocol_engine.commands.command_unions import CommandCreateAdapter
 
 
 def generate_command_schema(version: str) -> str:
     """Generate a JSON Schema that all valid create commands can validate against."""
-    raw_json_schema = CreateCommandUnion.schema_json()
-    schema_as_dict = json.loads(raw_json_schema)
+    schema_as_dict = CommandCreateAdapter.json_schema(mode="validation")
     schema_as_dict["$id"] = f"opentronsCommandSchemaV{version}"
     schema_as_dict["$schema"] = "http://json-schema.org/draft-07/schema#"
-    return json.dumps(schema_as_dict, indent=2)
+    return json.dumps(schema_as_dict, indent=2, sort_keys=True)
 
 
 if __name__ == "__main__":

opentrons/protocol_engine/commands/get_next_tip.py

@@ -0,0 +1,134 @@
+"""Get next tip command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Any, Optional, Type, List, Literal, Union
+
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.types import NozzleConfigurationType
+
+from ..errors import ErrorOccurrence
+from ..types import NextTipInfo, NoTipAvailable, NoTipReason
+from .pipetting_common import PipetteIdMixin
+
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+GetNextTipCommandType = Literal["getNextTip"]
+
+
+class GetNextTipParams(PipetteIdMixin):
+    """Payload needed to resolve the next available tip."""
+
+    labwareIds: List[str] = Field(
+        ...,
+        description="Labware ID(s) of tip racks to resolve next available tip(s) from"
+        " Labware IDs will be resolved sequentially",
+    )
+    startingTipWell: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Name of starting tip rack 'well'."
+        " This only applies to the first tip rack in the list provided in labwareIDs",
+        json_schema_extra=_remove_default,
+    )
+
+
+class GetNextTipResult(BaseModel):
+    """Result data from the execution of a GetNextTip."""
+
+    nextTipInfo: Union[NextTipInfo, NoTipAvailable] = Field(
+        ...,
+        description="Labware ID and well name of next available tip for a pipette,"
+        " or information why no tip could be resolved.",
+    )
+
+
+class GetNextTipImplementation(
+    AbstractCommandImpl[GetNextTipParams, SuccessData[GetNextTipResult]]
+):
+    """Get next tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+
+    async def execute(self, params: GetNextTipParams) -> SuccessData[GetNextTipResult]:
+        """Get the next available tip for the requested pipette."""
+        pipette_id = params.pipetteId
+        starting_tip_name = params.startingTipWell
+
+        num_tips = self._state_view.tips.get_pipette_active_channels(pipette_id)
+        nozzle_map = self._state_view.tips.get_pipette_nozzle_map(pipette_id)
+
+        if (
+            starting_tip_name is not None
+            and nozzle_map.configuration != NozzleConfigurationType.FULL
+        ):
+            # This is to match the behavior found in PAPI, but also because we don't have logic to automatically find
+            # the next tip with partial configuration and a starting tip. This will never work for a 96-channel due to
+            # x-axis overlap, but could eventually work with 8-channel if we better define starting tip USED or CLEAN
+            # state when starting a protocol to prevent accidental tip pick-up with starting non-full tip racks.
+            return SuccessData(
+                public=GetNextTipResult(
+                    nextTipInfo=NoTipAvailable(
+                        noTipReason=NoTipReason.STARTING_TIP_WITH_PARTIAL,
+                        message="Cannot automatically resolve next tip with starting tip and partial tip configuration.",
+                    )
+                )
+            )
+
+        next_tip: Union[NextTipInfo, NoTipAvailable]
+        for labware_id in params.labwareIds:
+            well_name = self._state_view.tips.get_next_tip(
+                labware_id=labware_id,
+                num_tips=num_tips,
+                starting_tip_name=starting_tip_name,
+                nozzle_map=nozzle_map,
+            )
+            if well_name is not None:
+                next_tip = NextTipInfo(labwareId=labware_id, tipStartingWell=well_name)
+                break
+            # After the first tip rack is exhausted, starting tip no longer applies
+            starting_tip_name = None
+        else:
+            next_tip = NoTipAvailable(
+                noTipReason=NoTipReason.NO_AVAILABLE_TIPS,
+                message="No available tips for given pipette, nozzle configuration and provided tip racks.",
+            )
+
+        return SuccessData(public=GetNextTipResult(nextTipInfo=next_tip))
+
+
+class GetNextTip(BaseCommand[GetNextTipParams, GetNextTipResult, ErrorOccurrence]):
+    """Get next tip command model."""
+
+    commandType: GetNextTipCommandType = "getNextTip"
+    params: GetNextTipParams
+    result: Optional[GetNextTipResult]
+
+    _ImplementationCls: Type[GetNextTipImplementation] = GetNextTipImplementation
+
+
+class GetNextTipCreate(BaseCommandCreate[GetNextTipParams]):
+    """Get next tip command creation request model."""
+
+    commandType: GetNextTipCommandType = "getNextTip"
+    params: GetNextTipParams
+
+    _CommandCls: Type[GetNextTip] = GetNextTip

opentrons/protocol_engine/commands/get_tip_presence.py

@@ -71,7 +71,7 @@ class GetTipPresence(
 
     commandType: GetTipPresenceCommandType = "getTipPresence"
     params: GetTipPresenceParams
-    result: Optional[GetTipPresenceResult]
+    result: Optional[GetTipPresenceResult] = None
 
     _ImplementationCls: Type[
         GetTipPresenceImplementation

opentrons/protocol_engine/commands/heater_shaker/close_labware_latch.py

@@ -69,7 +69,7 @@ class CloseLabwareLatch(
 
     commandType: CloseLabwareLatchCommandType = "heaterShaker/closeLabwareLatch"
     params: CloseLabwareLatchParams
-    result: Optional[CloseLabwareLatchResult]
+    result: Optional[CloseLabwareLatchResult] = None
 
     _ImplementationCls: Type[CloseLabwareLatchImpl] = CloseLabwareLatchImpl
 

opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py

@@ -68,7 +68,7 @@ class DeactivateHeater(
 
     commandType: DeactivateHeaterCommandType = "heaterShaker/deactivateHeater"
     params: DeactivateHeaterParams
-    result: Optional[DeactivateHeaterResult]
+    result: Optional[DeactivateHeaterResult] = None
 
     _ImplementationCls: Type[DeactivateHeaterImpl] = DeactivateHeaterImpl
 

opentrons/protocol_engine/commands/heater_shaker/deactivate_shaker.py

@@ -70,7 +70,7 @@ class DeactivateShaker(
 
     commandType: DeactivateShakerCommandType = "heaterShaker/deactivateShaker"
     params: DeactivateShakerParams
-    result: Optional[DeactivateShakerResult]
+    result: Optional[DeactivateShakerResult] = None
 
     _ImplementationCls: Type[DeactivateShakerImpl] = DeactivateShakerImpl
 

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,24 @@ 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,
 )
 
 from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
     PipetteIdMixin,
+)
+from .movement_common import (
     WellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -41,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"]
 
@@ -76,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):
@@ -106,13 +120,24 @@ 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
+    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,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,
@@ -160,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,
         )
 
 
@@ -202,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,
@@ -278,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
@@ -312,7 +351,11 @@ class TryLiquidProbeImplementation(
 
 
 class LiquidProbe(
-    BaseCommand[LiquidProbeParams, LiquidProbeResult, LiquidNotFoundError]
+    BaseCommand[
+        LiquidProbeParams,
+        LiquidProbeResult,
+        LiquidNotFoundError | StallOrCollisionError,
+    ]
 ):
     """The model for a full `liquidProbe` command."""
 
@@ -324,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