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

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(

opentrons/protocol_engine/commands/touch_tip.py

@@ -4,6 +4,8 @@ from pydantic import Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.state import update_types
+
 from ..errors import TouchTipDisabledError, LabwareIsTipRackError
 from ..types import DeckPoint
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
@@ -16,7 +18,7 @@ from .pipetting_common import (
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, GantryMover
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 TouchTipCommandType = Literal["touchTip"]
@@ -48,7 +50,7 @@ class TouchTipResult(DestinationPositionResult):
 
 
 class TouchTipImplementation(
-    AbstractCommandImpl[TouchTipParams, SuccessData[TouchTipResult, None]]
+    AbstractCommandImpl[TouchTipParams, SuccessData[TouchTipResult]]
 ):
     """Touch tip command implementation."""
 
@@ -63,14 +65,14 @@ class TouchTipImplementation(
         self._movement = movement
         self._gantry_mover = gantry_mover
 
-    async def execute(
-        self, params: TouchTipParams
-    ) -> SuccessData[TouchTipResult, None]:
+    async def execute(self, params: TouchTipParams) -> SuccessData[TouchTipResult]:
         """Touch tip to sides of a well using the requested pipette."""
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
 
+        state_update = update_types.StateUpdate()
+
         if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
             raise TouchTipDisabledError(
                 f"Touch tip not allowed on labware {labware_id}"
@@ -98,14 +100,24 @@ class TouchTipImplementation(
             center_point=center_point,
         )
 
-        x, y, z = await self._gantry_mover.move_to(
+        final_point = await self._gantry_mover.move_to(
             pipette_id=pipette_id,
             waypoints=touch_waypoints,
             speed=touch_speed,
         )
+        final_deck_point = DeckPoint.construct(
+            x=final_point.x, y=final_point.y, z=final_point.z
+        )
+        state_update.set_pipette_location(
+            pipette_id=pipette_id,
+            new_labware_id=labware_id,
+            new_well_name=well_name,
+            new_deck_point=final_deck_point,
+        )
 
         return SuccessData(
-            public=TouchTipResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+            public=TouchTipResult(position=final_deck_point),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/unsafe/__init__.py

@@ -31,6 +31,24 @@ from .unsafe_engage_axes import (
     UnsafeEngageAxesCreate,
 )
 
+from .unsafe_ungrip_labware import (
+    UnsafeUngripLabwareCommandType,
+    UnsafeUngripLabwareParams,
+    UnsafeUngripLabwareResult,
+    UnsafeUngripLabware,
+    UnsafeUngripLabwareCreate,
+)
+
+
+from .unsafe_place_labware import (
+    UnsafePlaceLabwareCommandType,
+    UnsafePlaceLabwareParams,
+    UnsafePlaceLabwareResult,
+    UnsafePlaceLabware,
+    UnsafePlaceLabwareCreate,
+)
+
+
 __all__ = [
     # Unsafe blow-out-in-place command models
     "UnsafeBlowOutInPlaceCommandType",
@@ -56,4 +74,16 @@ __all__ = [
     "UnsafeEngageAxesResult",
     "UnsafeEngageAxes",
     "UnsafeEngageAxesCreate",
+    # Unsafe ungrip labware
+    "UnsafeUngripLabwareCommandType",
+    "UnsafeUngripLabwareParams",
+    "UnsafeUngripLabwareResult",
+    "UnsafeUngripLabware",
+    "UnsafeUngripLabwareCreate",
+    # Unsafe place labware
+    "UnsafePlaceLabwareCommandType",
+    "UnsafePlaceLabwareParams",
+    "UnsafePlaceLabwareResult",
+    "UnsafePlaceLabware",
+    "UnsafePlaceLabwareCreate",
 ]

opentrons/protocol_engine/commands/unsafe/unsafe_blow_out_in_place.py

@@ -16,7 +16,7 @@ from opentrons.hardware_control.types import Axis
 
 if TYPE_CHECKING:
     from ...execution import PipettingHandler
-    from ...state import StateView
+    from ...state.state import StateView
 
 
 UnsafeBlowOutInPlaceCommandType = Literal["unsafe/blowOutInPlace"]
@@ -36,7 +36,7 @@ class UnsafeBlowOutInPlaceResult(BaseModel):
 
 class UnsafeBlowOutInPlaceImplementation(
     AbstractCommandImpl[
-        UnsafeBlowOutInPlaceParams, SuccessData[UnsafeBlowOutInPlaceResult, None]
+        UnsafeBlowOutInPlaceParams, SuccessData[UnsafeBlowOutInPlaceResult]
     ]
 ):
     """UnsafeBlowOutInPlace command implementation."""
@@ -54,7 +54,7 @@ class UnsafeBlowOutInPlaceImplementation(
 
     async def execute(
         self, params: UnsafeBlowOutInPlaceParams
-    ) -> SuccessData[UnsafeBlowOutInPlaceResult, None]:
+    ) -> SuccessData[UnsafeBlowOutInPlaceResult]:
         """Blow-out without moving the pipette even when position is unknown."""
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         pipette_location = self._state_view.motion.get_pipette_location(
@@ -67,7 +67,9 @@ class UnsafeBlowOutInPlaceImplementation(
             pipette_id=params.pipetteId, flow_rate=params.flowRate
         )
 
-        return SuccessData(public=UnsafeBlowOutInPlaceResult(), private=None)
+        return SuccessData(
+            public=UnsafeBlowOutInPlaceResult(),
+        )
 
 
 class UnsafeBlowOutInPlace(