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

opentrons/protocol_engine/commands/evotip_seal_pipette.py

@@ -0,0 +1,331 @@
+"""Seal evotip resin tip command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import Field, BaseModel
+from typing import TYPE_CHECKING, Optional, Type, Union
+from opentrons.types import MountType
+from opentrons.protocol_engine.types import MotorAxis
+from typing_extensions import Literal
+
+from opentrons.protocol_engine.errors import UnsupportedLabwareForActionError
+from ..resources import ModelUtils, labware_validation
+from ..types import PickUpTipWellLocation, FluidKind, AspiratedFluid
+from .pipetting_common import (
+    PipetteIdMixin,
+)
+from .movement_common import (
+    DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.types import Axis
+from ..state.update_types import StateUpdate
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from ..execution import (
+        MovementHandler,
+        TipHandler,
+        GantryMover,
+        PipettingHandler,
+    )
+
+
+EvotipSealPipetteCommandType = Literal["evotipSealPipette"]
+_PREP_DISTANCE_DEFAULT = 8.25
+_PRESS_DISTANCE_DEFAULT = 3.5
+_EJECTOR_PUSH_MM_DEFAULT = 7.0
+_SAFE_TOP_VOLUME = 400
+
+
+class TipPickUpParams(BaseModel):
+    """Payload used to specify press-tip parameters for a seal command."""
+
+    prepDistance: float = Field(
+        default=0, description="The distance to move down to fit the tips on."
+    )
+    pressDistance: float = Field(
+        default=0, description="The distance to press on tips."
+    )
+    ejectorPushMm: float = Field(
+        default=0,
+        description="The distance to back off to ensure that the tip presence sensors are not triggered.",
+    )
+
+
+class EvotipSealPipetteParams(PipetteIdMixin):
+    """Payload needed to seal resin tips to a pipette."""
+
+    labwareId: str = Field(..., description="Identifier of labware to use.")
+    wellName: str = Field(..., description="Name of well to use in labware.")
+    wellLocation: PickUpTipWellLocation = Field(
+        default_factory=PickUpTipWellLocation,
+        description="Relative well location at which to pick up the tip.",
+    )
+    tipPickUpParams: Optional[TipPickUpParams] = Field(
+        default=None, description="Specific parameters for "
+    )
+
+
+class EvotipSealPipetteResult(DestinationPositionResult):
+    """Result data from the execution of a EvotipSealPipette."""
+
+    tipVolume: float = Field(
+        0,
+        description="Maximum volume of liquid that the picked up tip can hold, in µL.",
+        ge=0,
+    )
+
+    tipLength: float = Field(
+        0,
+        description="The length of the tip in mm.",
+        ge=0,
+    )
+
+    tipDiameter: float = Field(
+        0,
+        description="The diameter of the tip in mm.",
+        ge=0,
+    )
+
+
+_ExecuteReturn = Union[
+    SuccessData[EvotipSealPipetteResult],
+    DefinedErrorData[StallOrCollisionError],
+]
+
+
+class EvotipSealPipetteImplementation(
+    AbstractCommandImpl[EvotipSealPipetteParams, _ExecuteReturn]
+):
+    """Evotip seal pipette command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        tip_handler: TipHandler,
+        model_utils: ModelUtils,
+        movement: MovementHandler,
+        hardware_api: HardwareControlAPI,
+        gantry_mover: GantryMover,
+        pipetting: PipettingHandler,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._tip_handler = tip_handler
+        self._model_utils = model_utils
+        self._movement = movement
+        self._gantry_mover = gantry_mover
+        self._pipetting = pipetting
+        self._hardware_api = hardware_api
+
+    async def relative_pickup_tip(
+        self,
+        tip_pick_up_params: TipPickUpParams,
+        mount: MountType,
+    ) -> None:
+        """A relative press-fit pick up command using gantry moves."""
+        prep_distance = tip_pick_up_params.prepDistance
+        press_distance = tip_pick_up_params.pressDistance
+        retract_distance = -1 * (prep_distance + press_distance)
+
+        mount_axis = MotorAxis.LEFT_Z if mount == MountType.LEFT else MotorAxis.RIGHT_Z
+
+        # TODO chb, 2025-01-29): Factor out the movement constants and relocate this logic into the hardware controller
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: prep_distance}, speed=10, relative_move=True
+        )
+
+        # Drive mount down for press-fit
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: press_distance},
+            speed=10.0,
+            relative_move=True,
+            expect_stalls=True,
+        )
+        # retract cam : 11.05
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: retract_distance}, speed=5.5, relative_move=True
+        )
+
+    async def cam_action_relative_pickup_tip(
+        self,
+        tip_pick_up_params: TipPickUpParams,
+        mount: MountType,
+    ) -> None:
+        """A cam action pick up command using gantry moves."""
+        prep_distance = tip_pick_up_params.prepDistance
+        press_distance = tip_pick_up_params.pressDistance
+        ejector_push_mm = tip_pick_up_params.ejectorPushMm
+        retract_distance = -1 * (prep_distance + press_distance)
+
+        mount_axis = MotorAxis.LEFT_Z if mount == MountType.LEFT else MotorAxis.RIGHT_Z
+
+        # TODO chb, 2025-01-29): Factor out the movement constants and relocate this logic into the hardware controller
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: -6}, speed=10, relative_move=True
+        )
+
+        # Drive Q down 3mm at fast speed - look into the pick up tip fuinction to find slow and fast: 10.0
+        await self._gantry_mover.move_axes(
+            axis_map={MotorAxis.AXIS_96_CHANNEL_CAM: prep_distance},
+            speed=10.0,
+            relative_move=True,
+        )
+        # 2.8mm at slow speed - cam action pickup speed: 5.5
+        await self._gantry_mover.move_axes(
+            axis_map={MotorAxis.AXIS_96_CHANNEL_CAM: press_distance},
+            speed=5.5,
+            relative_move=True,
+        )
+        # retract cam : 11.05
+        await self._gantry_mover.move_axes(
+            axis_map={MotorAxis.AXIS_96_CHANNEL_CAM: retract_distance},
+            speed=5.5,
+            relative_move=True,
+        )
+
+        # Lower tip presence
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: 2}, speed=10, relative_move=True
+        )
+        await self._gantry_mover.move_axes(
+            axis_map={MotorAxis.AXIS_96_CHANNEL_CAM: ejector_push_mm},
+            speed=5.5,
+            relative_move=True,
+        )
+        await self._gantry_mover.move_axes(
+            axis_map={MotorAxis.AXIS_96_CHANNEL_CAM: -1 * ejector_push_mm},
+            speed=5.5,
+            relative_move=True,
+        )
+
+    async def execute(
+        self, params: EvotipSealPipetteParams
+    ) -> Union[SuccessData[EvotipSealPipetteResult], _ExecuteReturn]:
+        """Move to and pick up a tip using the requested pipette."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        labware_definition = self._state_view.labware.get_definition(params.labwareId)
+        if not labware_validation.is_evotips(labware_definition.parameters.loadName):
+            raise UnsupportedLabwareForActionError(
+                f"Cannot use command: `EvotipSealPipette` with labware: {labware_definition.parameters.loadName}"
+            )
+
+        well_location = self._state_view.geometry.convert_pick_up_tip_well_location(
+            well_location=params.wellLocation
+        )
+        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=well_location,
+        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+
+        # Aspirate to move plunger to a maximum volume position per pipette type
+        tip_geometry = self._state_view.geometry.get_nominal_tip_geometry(
+            pipette_id, labware_id, well_name
+        )
+        if self._state_view.pipettes.get_mount(pipette_id) == MountType.LEFT:
+            await self._hardware_api.home(axes=[Axis.P_L])
+        else:
+            await self._hardware_api.home(axes=[Axis.P_R])
+
+        # Begin relative pickup steps for the resin tips
+
+        channels = self._state_view.tips.get_pipette_active_channels(pipette_id)
+        mount = self._state_view.pipettes.get_mount(pipette_id)
+        tip_pick_up_params = params.tipPickUpParams
+        if tip_pick_up_params is None:
+            tip_pick_up_params = TipPickUpParams(
+                prepDistance=_PREP_DISTANCE_DEFAULT,
+                pressDistance=_PRESS_DISTANCE_DEFAULT,
+                ejectorPushMm=_EJECTOR_PUSH_MM_DEFAULT,
+            )
+
+        if channels != 96:
+            await self.relative_pickup_tip(
+                tip_pick_up_params=tip_pick_up_params,
+                mount=mount,
+            )
+        elif channels == 96:
+            await self.cam_action_relative_pickup_tip(
+                tip_pick_up_params=tip_pick_up_params,
+                mount=mount,
+            )
+        else:
+            tip_geometry = await self._tip_handler.pick_up_tip(
+                pipette_id=pipette_id,
+                labware_id=labware_id,
+                well_name=well_name,
+                do_not_ignore_tip_presence=True,
+            )
+
+        # cache_tip
+        if self._state_view.config.use_virtual_pipettes is False:
+            self._tip_handler.cache_tip(pipette_id, tip_geometry)
+            hw_instr = self._hardware_api.hardware_instruments[mount.to_hw_mount()]
+            if hw_instr is not None:
+                hw_instr.set_current_volume(_SAFE_TOP_VOLUME)
+
+        state_update = StateUpdate()
+        state_update.update_pipette_tip_state(
+            pipette_id=pipette_id,
+            tip_geometry=tip_geometry,
+        )
+
+        state_update.set_fluid_aspirated(
+            pipette_id=pipette_id,
+            fluid=AspiratedFluid(kind=FluidKind.LIQUID, volume=_SAFE_TOP_VOLUME),
+        )
+        return SuccessData(
+            public=EvotipSealPipetteResult(
+                tipVolume=tip_geometry.volume,
+                tipLength=tip_geometry.length,
+                tipDiameter=tip_geometry.diameter,
+                position=move_result.public.position,
+            ),
+            state_update=state_update,
+        )
+
+
+class EvotipSealPipette(
+    BaseCommand[
+        EvotipSealPipetteParams,
+        EvotipSealPipetteResult,
+        StallOrCollisionError,
+    ]
+):
+    """Seal evotip resin tip command model."""
+
+    commandType: EvotipSealPipetteCommandType = "evotipSealPipette"
+    params: EvotipSealPipetteParams
+    result: Optional[EvotipSealPipetteResult] = None
+
+    _ImplementationCls: Type[
+        EvotipSealPipetteImplementation
+    ] = EvotipSealPipetteImplementation
+
+
+class EvotipSealPipetteCreate(BaseCommandCreate[EvotipSealPipetteParams]):
+    """Seal evotip resin tip command creation request model."""
+
+    commandType: EvotipSealPipetteCommandType = "evotipSealPipette"
+    params: EvotipSealPipetteParams
+
+    _CommandCls: Type[EvotipSealPipette] = EvotipSealPipette

opentrons/protocol_engine/commands/evotip_unseal_pipette.py

@@ -0,0 +1,160 @@
+"""Unseal evotip resin tip command request, result, and implementation models."""
+
+from __future__ import annotations
+
+from pydantic import Field
+from typing import TYPE_CHECKING, Optional, Type
+from typing_extensions import Literal
+
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
+from opentrons.protocol_engine.errors import UnsupportedLabwareForActionError
+from opentrons.protocol_engine.types import MotorAxis
+from opentrons.types import MountType
+
+from ..types import DropTipWellLocation
+from .pipetting_common import (
+    PipetteIdMixin,
+)
+from .movement_common import (
+    DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+from ..resources import labware_validation
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from ..execution import MovementHandler, TipHandler, GantryMover
+
+
+EvotipUnsealPipetteCommandType = Literal["evotipUnsealPipette"]
+
+
+class EvotipUnsealPipetteParams(PipetteIdMixin):
+    """Payload required to drop a tip in a specific well."""
+
+    labwareId: str = Field(..., description="Identifier of labware to use.")
+    wellName: str = Field(..., description="Name of well to use in labware.")
+    wellLocation: DropTipWellLocation = Field(
+        default_factory=DropTipWellLocation,
+        description="Relative well location at which to drop the tip.",
+    )
+
+
+class EvotipUnsealPipetteResult(DestinationPositionResult):
+    """Result data from the execution of a DropTip command."""
+
+    pass
+
+
+_ExecuteReturn = (
+    SuccessData[EvotipUnsealPipetteResult] | DefinedErrorData[StallOrCollisionError]
+)
+
+
+class EvotipUnsealPipetteImplementation(
+    AbstractCommandImpl[EvotipUnsealPipetteParams, _ExecuteReturn]
+):
+    """Drop tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        tip_handler: TipHandler,
+        movement: MovementHandler,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._tip_handler = tip_handler
+        self._movement_handler = movement
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
+
+    async def execute(self, params: EvotipUnsealPipetteParams) -> _ExecuteReturn:
+        """Move to and drop a tip using the requested pipette."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        well_location = params.wellLocation
+        labware_definition = self._state_view.labware.get_definition(params.labwareId)
+        if not labware_validation.is_evotips(labware_definition.parameters.loadName):
+            raise UnsupportedLabwareForActionError(
+                f"Cannot use command: `EvotipUnsealPipette` with labware: {labware_definition.parameters.loadName}"
+            )
+        is_partially_configured = self._state_view.pipettes.get_is_partially_configured(
+            pipette_id=pipette_id
+        )
+        tip_drop_location = self._state_view.geometry.get_checked_tip_drop_location(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_location=well_location,
+            partially_configured=is_partially_configured,
+        )
+
+        move_result = await move_to_well(
+            movement=self._movement_handler,
+            model_utils=self._model_utils,
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=tip_drop_location,
+        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+
+        # Move to an appropriate position
+        mount = self._state_view.pipettes.get_mount(pipette_id)
+
+        mount_axis = MotorAxis.LEFT_Z if mount == MountType.LEFT else MotorAxis.RIGHT_Z
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: -14}, speed=10, relative_move=True
+        )
+
+        await self._tip_handler.drop_tip(
+            pipette_id=pipette_id,
+            home_after=None,
+            do_not_ignore_tip_presence=False,
+            ignore_plunger=True,
+        )
+
+        return SuccessData(
+            public=EvotipUnsealPipetteResult(position=move_result.public.position),
+            state_update=move_result.state_update.set_fluid_unknown(
+                pipette_id=pipette_id
+            ).update_pipette_tip_state(pipette_id=params.pipetteId, tip_geometry=None),
+        )
+
+
+class EvotipUnsealPipette(
+    BaseCommand[
+        EvotipUnsealPipetteParams, EvotipUnsealPipetteResult, StallOrCollisionError
+    ]
+):
+    """Evotip unseal command model."""
+
+    commandType: EvotipUnsealPipetteCommandType = "evotipUnsealPipette"
+    params: EvotipUnsealPipetteParams
+    result: Optional[EvotipUnsealPipetteResult] = None
+
+    _ImplementationCls: Type[
+        EvotipUnsealPipetteImplementation
+    ] = EvotipUnsealPipetteImplementation
+
+
+class EvotipUnsealPipetteCreate(BaseCommandCreate[EvotipUnsealPipetteParams]):
+    """Evotip unseal command creation request model."""
+
+    commandType: EvotipUnsealPipetteCommandType = "evotipUnsealPipette"
+    params: EvotipUnsealPipetteParams
+
+    _CommandCls: Type[EvotipUnsealPipette] = EvotipUnsealPipette

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] = None
+
+    _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