opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/temperature_module/set_target_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 SetTargetTemperatureCommandType = Literal["temperatureModule/setTargetTemperature"]
@@ -34,7 +34,7 @@ class SetTargetTemperatureResult(BaseModel):
 
 class SetTargetTemperatureImpl(
     AbstractCommandImpl[
-        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult, None]
+        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult]
     ]
 ):
     """Execution implementation of a Temperature Module's set temperature command."""
@@ -50,7 +50,7 @@ class SetTargetTemperatureImpl(
 
     async def execute(
         self, params: SetTargetTemperatureParams
-    ) -> SuccessData[SetTargetTemperatureResult, None]:
+    ) -> SuccessData[SetTargetTemperatureResult]:
         """Set a Temperature Module's target temperature."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         module_substate = self._state_view.modules.get_temperature_module_substate(
@@ -69,7 +69,6 @@ class SetTargetTemperatureImpl(
             await temp_hardware_module.start_set_temperature(celsius=validated_temp)
         return SuccessData(
             public=SetTargetTemperatureResult(targetTemperature=validated_temp),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/temperature_module/wait_for_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 WaitForTemperatureCommandType = Literal["temperatureModule/waitForTemperature"]
@@ -35,9 +35,7 @@ class WaitForTemperatureResult(BaseModel):
 
 
 class WaitForTemperatureImpl(
-    AbstractCommandImpl[
-        WaitForTemperatureParams, SuccessData[WaitForTemperatureResult, None]
-    ]
+    AbstractCommandImpl[WaitForTemperatureParams, SuccessData[WaitForTemperatureResult]]
 ):
     """Execution implementation of Temperature Module's wait for temperature command."""
 
@@ -52,7 +50,7 @@ class WaitForTemperatureImpl(
 
     async def execute(
         self, params: WaitForTemperatureParams
-    ) -> SuccessData[WaitForTemperatureResult, None]:
+    ) -> SuccessData[WaitForTemperatureResult]:
         """Wait for a Temperature Module's target temperature."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         module_substate = self._state_view.modules.get_temperature_module_substate(
@@ -74,7 +72,9 @@ class WaitForTemperatureImpl(
             await temp_hardware_module.await_temperature(
                 awaiting_temperature=target_temp
             )
-        return SuccessData(public=WaitForTemperatureResult(), private=None)
+        return SuccessData(
+            public=WaitForTemperatureResult(),
+        )
 
 
 class WaitForTemperature(

opentrons/protocol_engine/commands/thermocycler/__init__.py

@@ -73,6 +73,16 @@ from .run_profile import (
     RunProfileCreate,
 )
 
+from .run_extended_profile import (
+    RunExtendedProfileCommandType,
+    RunExtendedProfileParams,
+    RunExtendedProfileResult,
+    RunExtendedProfile,
+    RunExtendedProfileCreate,
+    ProfileCycle,
+    ProfileStep,
+)
+
 
 __all__ = [
     # Set target block temperature command models
@@ -130,4 +140,13 @@ __all__ = [
     "RunProfileResult",
     "RunProfile",
     "RunProfileCreate",
+    # Run extended profile command models.
+    "RunExtendedProfileCommandType",
+    "RunExtendedProfileParams",
+    "RunExtendedProfileStepParams",
+    "RunExtendedProfileResult",
+    "RunExtendedProfile",
+    "RunExtendedProfileCreate",
+    "ProfileCycle",
+    "ProfileStep",
 ]

opentrons/protocol_engine/commands/thermocycler/close_lid.py

@@ -7,10 +7,11 @@ from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 from opentrons.protocol_engine.types import MotorAxis
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 
@@ -27,9 +28,7 @@ class CloseLidResult(BaseModel):
     """Result data from closing a Thermocycler's lid."""
 
 
-class CloseLidImpl(
-    AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResult, None]]
-):
+class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResult]]):
     """Execution implementation of a Thermocycler's close lid command."""
 
     def __init__(
@@ -43,10 +42,10 @@ class CloseLidImpl(
         self._equipment = equipment
         self._movement = movement
 
-    async def execute(
-        self, params: CloseLidParams
-    ) -> SuccessData[CloseLidResult, None]:
+    async def execute(self, params: CloseLidParams) -> SuccessData[CloseLidResult]:
         """Close a Thermocycler's lid."""
+        state_update = update_types.StateUpdate()
+
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
         )
@@ -61,11 +60,12 @@ class CloseLidImpl(
             MotorAxis.Y,
         ] + self._state_view.motion.get_robot_mount_axes()
         await self._movement.home(axes=axes_to_home)
+        state_update.clear_all_pipette_locations()
 
         if thermocycler_hardware is not None:
             await thermocycler_hardware.close()
 
-        return SuccessData(public=CloseLidResult(), private=None)
+        return SuccessData(public=CloseLidResult(), state_update=state_update)
 
 
 class CloseLid(BaseCommand[CloseLidParams, CloseLidResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/thermocycler/deactivate_block.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -27,7 +27,7 @@ class DeactivateBlockResult(BaseModel):
 
 
 class DeactivateBlockImpl(
-    AbstractCommandImpl[DeactivateBlockParams, SuccessData[DeactivateBlockResult, None]]
+    AbstractCommandImpl[DeactivateBlockParams, SuccessData[DeactivateBlockResult]]
 ):
     """Execution implementation of a Thermocycler's deactivate block command."""
 
@@ -42,7 +42,7 @@ class DeactivateBlockImpl(
 
     async def execute(
         self, params: DeactivateBlockParams
-    ) -> SuccessData[DeactivateBlockResult, None]:
+    ) -> SuccessData[DeactivateBlockResult]:
         """Unset a Thermocycler's target block temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -54,7 +54,9 @@ class DeactivateBlockImpl(
         if thermocycler_hardware is not None:
             await thermocycler_hardware.deactivate_block()
 
-        return SuccessData(public=DeactivateBlockResult(), private=None)
+        return SuccessData(
+            public=DeactivateBlockResult(),
+        )
 
 
 class DeactivateBlock(

opentrons/protocol_engine/commands/thermocycler/deactivate_lid.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -27,7 +27,7 @@ class DeactivateLidResult(BaseModel):
 
 
 class DeactivateLidImpl(
-    AbstractCommandImpl[DeactivateLidParams, SuccessData[DeactivateLidResult, None]]
+    AbstractCommandImpl[DeactivateLidParams, SuccessData[DeactivateLidResult]]
 ):
     """Execution implementation of a Thermocycler's deactivate lid command."""
 
@@ -42,7 +42,7 @@ class DeactivateLidImpl(
 
     async def execute(
         self, params: DeactivateLidParams
-    ) -> SuccessData[DeactivateLidResult, None]:
+    ) -> SuccessData[DeactivateLidResult]:
         """Unset a Thermocycler's target lid temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -54,7 +54,9 @@ class DeactivateLidImpl(
         if thermocycler_hardware is not None:
             await thermocycler_hardware.deactivate_lid()
 
-        return SuccessData(public=DeactivateLidResult(), private=None)
+        return SuccessData(
+            public=DeactivateLidResult(),
+        )
 
 
 class DeactivateLid(

opentrons/protocol_engine/commands/thermocycler/open_lid.py

@@ -6,11 +6,12 @@ from typing_extensions import Literal, Type
 from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...state import update_types
 from ...errors.error_occurrence import ErrorOccurrence
 from opentrons.protocol_engine.types import MotorAxis
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 
@@ -27,7 +28,7 @@ class OpenLidResult(BaseModel):
     """Result data from opening a Thermocycler's lid."""
 
 
-class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult, None]]):
+class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]):
     """Execution implementation of a Thermocycler's open lid command."""
 
     def __init__(
@@ -41,8 +42,10 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult,
         self._equipment = equipment
         self._movement = movement
 
-    async def execute(self, params: OpenLidParams) -> SuccessData[OpenLidResult, None]:
+    async def execute(self, params: OpenLidParams) -> SuccessData[OpenLidResult]:
         """Open a Thermocycler's lid."""
+        state_update = update_types.StateUpdate()
+
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
         )
@@ -57,11 +60,12 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult,
             MotorAxis.Y,
         ] + self._state_view.motion.get_robot_mount_axes()
         await self._movement.home(axes=axes_to_home)
+        state_update.clear_all_pipette_locations()
 
         if thermocycler_hardware is not None:
             await thermocycler_hardware.open()
 
-        return SuccessData(public=OpenLidResult(), private=None)
+        return SuccessData(public=OpenLidResult(), state_update=state_update)
 
 
 class OpenLid(BaseCommand[OpenLidParams, OpenLidResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -0,0 +1,165 @@
+"""Command models to execute a Thermocycler profile."""
+from __future__ import annotations
+from typing import List, Optional, TYPE_CHECKING, overload, Union
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+from opentrons.hardware_control.modules.types import ThermocyclerStep, ThermocyclerCycle
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+    from opentrons.protocol_engine.state.module_substates.thermocycler_module_substate import (
+        ThermocyclerModuleSubState,
+    )
+
+
+RunExtendedProfileCommandType = Literal["thermocycler/runExtendedProfile"]
+
+
+class ProfileStep(BaseModel):
+    """An individual step in a Thermocycler extended profile."""
+
+    celsius: float = Field(..., description="Target temperature in °C.")
+    holdSeconds: float = Field(
+        ..., description="Time to hold target temperature in seconds."
+    )
+
+
+class ProfileCycle(BaseModel):
+    """An individual cycle in a Thermocycler extended profile."""
+
+    steps: List[ProfileStep] = Field(..., description="Steps to repeat.")
+    repetitions: int = Field(..., description="Number of times to repeat the steps.")
+
+
+class RunExtendedProfileParams(BaseModel):
+    """Input parameters for an individual Thermocycler profile step."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+    profileElements: List[Union[ProfileStep, ProfileCycle]] = Field(
+        ...,
+        description="Elements of the profile. Each can be either a step or a cycle.",
+    )
+    blockMaxVolumeUl: Optional[float] = Field(
+        None,
+        description="Amount of liquid in uL of the most-full well"
+        " in labware loaded onto the thermocycler.",
+    )
+
+
+class RunExtendedProfileResult(BaseModel):
+    """Result data from running a Thermocycler profile."""
+
+
+def _transform_profile_step(
+    step: ProfileStep, thermocycler_state: ThermocyclerModuleSubState
+) -> ThermocyclerStep:
+    return ThermocyclerStep(
+        temperature=thermocycler_state.validate_target_block_temperature(step.celsius),
+        hold_time_seconds=step.holdSeconds,
+    )
+
+
+@overload
+def _transform_profile_element(
+    element: ProfileStep, thermocycler_state: ThermocyclerModuleSubState
+) -> ThermocyclerStep:
+    ...
+
+
+@overload
+def _transform_profile_element(
+    element: ProfileCycle, thermocycler_state: ThermocyclerModuleSubState
+) -> ThermocyclerCycle:
+    ...
+
+
+def _transform_profile_element(
+    element: Union[ProfileStep, ProfileCycle],
+    thermocycler_state: ThermocyclerModuleSubState,
+) -> Union[ThermocyclerStep, ThermocyclerCycle]:
+    if isinstance(element, ProfileStep):
+        return _transform_profile_step(element, thermocycler_state)
+    else:
+        return ThermocyclerCycle(
+            steps=[
+                _transform_profile_step(step, thermocycler_state)
+                for step in element.steps
+            ],
+            repetitions=element.repetitions,
+        )
+
+
+class RunExtendedProfileImpl(
+    AbstractCommandImpl[RunExtendedProfileParams, SuccessData[RunExtendedProfileResult]]
+):
+    """Execution implementation of a Thermocycler's run profile command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: RunExtendedProfileParams
+    ) -> SuccessData[RunExtendedProfileResult]:
+        """Run a Thermocycler profile."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        profile = [
+            _transform_profile_element(element, thermocycler_state)
+            for element in params.profileElements
+        ]
+        target_volume: Optional[float]
+        if params.blockMaxVolumeUl is not None:
+            target_volume = thermocycler_state.validate_max_block_volume(
+                params.blockMaxVolumeUl
+            )
+        else:
+            target_volume = None
+
+        if thermocycler_hardware is not None:
+            # TODO(jbl 2022-06-27) hardcoded constant 1 for `repetitions` should be
+            #  moved from HardwareControlAPI to the Python ProtocolContext
+            await thermocycler_hardware.execute_profile(
+                profile=profile, volume=target_volume
+            )
+
+        return SuccessData(
+            public=RunExtendedProfileResult(),
+        )
+
+
+class RunExtendedProfile(
+    BaseCommand[RunExtendedProfileParams, RunExtendedProfileResult, ErrorOccurrence]
+):
+    """A command to execute a Thermocycler profile run."""
+
+    commandType: RunExtendedProfileCommandType = "thermocycler/runExtendedProfile"
+    params: RunExtendedProfileParams
+    result: Optional[RunExtendedProfileResult]
+
+    _ImplementationCls: Type[RunExtendedProfileImpl] = RunExtendedProfileImpl
+
+
+class RunExtendedProfileCreate(BaseCommandCreate[RunExtendedProfileParams]):
+    """A request to execute a Thermocycler profile run."""
+
+    commandType: RunExtendedProfileCommandType = "thermocycler/runExtendedProfile"
+    params: RunExtendedProfileParams
+
+    _CommandCls: Type[RunExtendedProfile] = RunExtendedProfile

opentrons/protocol_engine/commands/thermocycler/run_profile.py

@@ -11,7 +11,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -47,7 +47,7 @@ class RunProfileResult(BaseModel):
 
 
 class RunProfileImpl(
-    AbstractCommandImpl[RunProfileParams, SuccessData[RunProfileResult, None]]
+    AbstractCommandImpl[RunProfileParams, SuccessData[RunProfileResult]]
 ):
     """Execution implementation of a Thermocycler's run profile command."""
 
@@ -60,9 +60,7 @@ class RunProfileImpl(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(
-        self, params: RunProfileParams
-    ) -> SuccessData[RunProfileResult, None]:
+    async def execute(self, params: RunProfileParams) -> SuccessData[RunProfileResult]:
         """Run a Thermocycler profile."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -96,7 +94,9 @@ class RunProfileImpl(
                 steps=steps, repetitions=1, volume=target_volume
             )
 
-        return SuccessData(public=RunProfileResult(), private=None)
+        return SuccessData(
+            public=RunProfileResult(),
+        )
 
 
 class RunProfile(BaseCommand[RunProfileParams, RunProfileResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -46,7 +46,7 @@ class SetTargetBlockTemperatureResult(BaseModel):
 class SetTargetBlockTemperatureImpl(
     AbstractCommandImpl[
         SetTargetBlockTemperatureParams,
-        SuccessData[SetTargetBlockTemperatureResult, None],
+        SuccessData[SetTargetBlockTemperatureResult],
     ]
 ):
     """Execution implementation of a Thermocycler's set block temperature command."""
@@ -63,7 +63,7 @@ class SetTargetBlockTemperatureImpl(
     async def execute(
         self,
         params: SetTargetBlockTemperatureParams,
-    ) -> SuccessData[SetTargetBlockTemperatureResult, None]:
+    ) -> SuccessData[SetTargetBlockTemperatureResult]:
         """Set a Thermocycler's target block temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -97,7 +97,6 @@ class SetTargetBlockTemperatureImpl(
             public=SetTargetBlockTemperatureResult(
                 targetBlockTemperature=target_temperature
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/thermocycler/set_target_lid_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -34,7 +34,7 @@ class SetTargetLidTemperatureResult(BaseModel):
 
 class SetTargetLidTemperatureImpl(
     AbstractCommandImpl[
-        SetTargetLidTemperatureParams, SuccessData[SetTargetLidTemperatureResult, None]
+        SetTargetLidTemperatureParams, SuccessData[SetTargetLidTemperatureResult]
     ]
 ):
     """Execution implementation of a Thermocycler's set lid temperature command."""
@@ -51,7 +51,7 @@ class SetTargetLidTemperatureImpl(
     async def execute(
         self,
         params: SetTargetLidTemperatureParams,
-    ) -> SuccessData[SetTargetLidTemperatureResult, None]:
+    ) -> SuccessData[SetTargetLidTemperatureResult]:
         """Set a Thermocycler's target lid temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -70,7 +70,6 @@ class SetTargetLidTemperatureImpl(
             public=SetTargetLidTemperatureResult(
                 targetLidTemperature=target_temperature
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/thermocycler/wait_for_block_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -28,7 +28,7 @@ class WaitForBlockTemperatureResult(BaseModel):
 
 class WaitForBlockTemperatureImpl(
     AbstractCommandImpl[
-        WaitForBlockTemperatureParams, SuccessData[WaitForBlockTemperatureResult, None]
+        WaitForBlockTemperatureParams, SuccessData[WaitForBlockTemperatureResult]
     ]
 ):
     """Execution implementation of Thermocycler's wait for block temperature command."""
@@ -45,7 +45,7 @@ class WaitForBlockTemperatureImpl(
     async def execute(
         self,
         params: WaitForBlockTemperatureParams,
-    ) -> SuccessData[WaitForBlockTemperatureResult, None]:
+    ) -> SuccessData[WaitForBlockTemperatureResult]:
         """Wait for a Thermocycler's target block temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -61,7 +61,9 @@ class WaitForBlockTemperatureImpl(
         if thermocycler_hardware is not None:
             await thermocycler_hardware.wait_for_block_target()
 
-        return SuccessData(public=WaitForBlockTemperatureResult(), private=None)
+        return SuccessData(
+            public=WaitForBlockTemperatureResult(),
+        )
 
 
 class WaitForBlockTemperature(

opentrons/protocol_engine/commands/thermocycler/wait_for_lid_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -28,7 +28,7 @@ class WaitForLidTemperatureResult(BaseModel):
 
 class WaitForLidTemperatureImpl(
     AbstractCommandImpl[
-        WaitForLidTemperatureParams, SuccessData[WaitForLidTemperatureResult, None]
+        WaitForLidTemperatureParams, SuccessData[WaitForLidTemperatureResult]
     ]
 ):
     """Execution implementation of Thermocycler's wait for lid temperature command."""
@@ -45,7 +45,7 @@ class WaitForLidTemperatureImpl(
     async def execute(
         self,
         params: WaitForLidTemperatureParams,
-    ) -> SuccessData[WaitForLidTemperatureResult, None]:
+    ) -> SuccessData[WaitForLidTemperatureResult]:
         """Wait for a Thermocycler's lid temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
@@ -61,7 +61,9 @@ class WaitForLidTemperatureImpl(
         if thermocycler_hardware is not None:
             await thermocycler_hardware.wait_for_lid_target()
 
-        return SuccessData(public=WaitForLidTemperatureResult(), private=None)
+        return SuccessData(
+            public=WaitForLidTemperatureResult(),
+        )
 
 
 class WaitForLidTemperature(