opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/commands/heater_shaker/__init__.py

@@ -0,0 +1,102 @@
+"""Heater-Shaker Module protocol commands."""
+
+from .wait_for_temperature import (
+    WaitForTemperature,
+    WaitForTemperatureCreate,
+    WaitForTemperatureParams,
+    WaitForTemperatureResult,
+    WaitForTemperatureCommandType,
+)
+
+from .set_target_temperature import (
+    SetTargetTemperature,
+    SetTargetTemperatureCreate,
+    SetTargetTemperatureParams,
+    SetTargetTemperatureResult,
+    SetTargetTemperatureCommandType,
+)
+
+from .deactivate_heater import (
+    DeactivateHeater,
+    DeactivateHeaterCreate,
+    DeactivateHeaterParams,
+    DeactivateHeaterResult,
+    DeactivateHeaterCommandType,
+)
+
+from .set_and_wait_for_shake_speed import (
+    SetAndWaitForShakeSpeed,
+    SetAndWaitForShakeSpeedCreate,
+    SetAndWaitForShakeSpeedParams,
+    SetAndWaitForShakeSpeedResult,
+    SetAndWaitForShakeSpeedCommandType,
+)
+
+from .deactivate_shaker import (
+    DeactivateShaker,
+    DeactivateShakerCreate,
+    DeactivateShakerParams,
+    DeactivateShakerResult,
+    DeactivateShakerCommandType,
+)
+
+from .open_labware_latch import (
+    OpenLabwareLatch,
+    OpenLabwareLatchCreate,
+    OpenLabwareLatchParams,
+    OpenLabwareLatchResult,
+    OpenLabwareLatchCommandType,
+)
+
+from .close_labware_latch import (
+    CloseLabwareLatch,
+    CloseLabwareLatchCreate,
+    CloseLabwareLatchParams,
+    CloseLabwareLatchResult,
+    CloseLabwareLatchCommandType,
+)
+
+__all__ = [
+    # heaterShaker/waitForTemperature
+    "WaitForTemperature",
+    "WaitForTemperatureCreate",
+    "WaitForTemperatureParams",
+    "WaitForTemperatureResult",
+    "WaitForTemperatureCommandType",
+    # heaterShaker/setTargetTemperature
+    "SetTargetTemperature",
+    "SetTargetTemperatureCreate",
+    "SetTargetTemperatureParams",
+    "SetTargetTemperatureResult",
+    "SetTargetTemperatureCommandType",
+    # heaterShaker/deactivateHeater
+    "DeactivateHeater",
+    "DeactivateHeaterCreate",
+    "DeactivateHeaterParams",
+    "DeactivateHeaterResult",
+    "DeactivateHeaterCommandType",
+    # heaterShaker/setAndWaitForShakeSpeed
+    "SetAndWaitForShakeSpeed",
+    "SetAndWaitForShakeSpeedCreate",
+    "SetAndWaitForShakeSpeedParams",
+    "SetAndWaitForShakeSpeedResult",
+    "SetAndWaitForShakeSpeedCommandType",
+    # heaterShaker/deactivateShaker
+    "DeactivateShaker",
+    "DeactivateShakerCreate",
+    "DeactivateShakerParams",
+    "DeactivateShakerResult",
+    "DeactivateShakerCommandType",
+    # heaterShaker/openLabwareLatch
+    "OpenLabwareLatch",
+    "OpenLabwareLatchCreate",
+    "OpenLabwareLatchParams",
+    "OpenLabwareLatchResult",
+    "OpenLabwareLatchCommandType",
+    # heaterShaker/closeLabwareLatch
+    "CloseLabwareLatch",
+    "CloseLabwareLatchCreate",
+    "CloseLabwareLatchParams",
+    "CloseLabwareLatchResult",
+    "CloseLabwareLatchCommandType",
+]

opentrons/protocol_engine/commands/heater_shaker/close_labware_latch.py

@@ -0,0 +1,83 @@
+"""Command models to close the Heater-Shaker Module's labware latch."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+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
+
+
+CloseLabwareLatchCommandType = Literal["heaterShaker/closeLabwareLatch"]
+
+
+class CloseLabwareLatchParams(BaseModel):
+    """Input parameters to close a Heater-Shaker Module's labware latch."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+
+
+class CloseLabwareLatchResult(BaseModel):
+    """Result data from closing a Heater-Shaker's labware latch."""
+
+
+class CloseLabwareLatchImpl(
+    AbstractCommandImpl[CloseLabwareLatchParams, SuccessData[CloseLabwareLatchResult]]
+):
+    """Execution implementation of a Heater-Shaker's close labware latch 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: CloseLabwareLatchParams
+    ) -> SuccessData[CloseLabwareLatchResult]:
+        """Close a Heater-Shaker's labware latch."""
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.close_labware_latch()
+
+        return SuccessData(
+            public=CloseLabwareLatchResult(),
+        )
+
+
+class CloseLabwareLatch(
+    BaseCommand[CloseLabwareLatchParams, CloseLabwareLatchResult, ErrorOccurrence]
+):
+    """A command to close a Heater-Shaker's latch."""
+
+    commandType: CloseLabwareLatchCommandType = "heaterShaker/closeLabwareLatch"
+    params: CloseLabwareLatchParams
+    result: Optional[CloseLabwareLatchResult] = None
+
+    _ImplementationCls: Type[CloseLabwareLatchImpl] = CloseLabwareLatchImpl
+
+
+class CloseLabwareLatchCreate(BaseCommandCreate[CloseLabwareLatchParams]):
+    """A request to create a Heater-Shaker's close latch command."""
+
+    commandType: CloseLabwareLatchCommandType = "heaterShaker/closeLabwareLatch"
+    params: CloseLabwareLatchParams
+
+    _CommandCls: Type[CloseLabwareLatch] = CloseLabwareLatch

opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py

@@ -0,0 +1,82 @@
+"""Command models to stop heating Heater-Shaker Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+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
+
+
+DeactivateHeaterCommandType = Literal["heaterShaker/deactivateHeater"]
+
+
+class DeactivateHeaterParams(BaseModel):
+    """Input parameters to unset a Heater-Shaker's target temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+
+
+class DeactivateHeaterResult(BaseModel):
+    """Result data from unsetting a Heater-Shaker's target temperature."""
+
+
+class DeactivateHeaterImpl(
+    AbstractCommandImpl[DeactivateHeaterParams, SuccessData[DeactivateHeaterResult]]
+):
+    """Execution implementation of a Heater-Shaker's deactivate heater 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: DeactivateHeaterParams
+    ) -> SuccessData[DeactivateHeaterResult]:
+        """Unset a Heater-Shaker's target temperature."""
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.deactivate_heater()
+
+        return SuccessData(
+            public=DeactivateHeaterResult(),
+        )
+
+
+class DeactivateHeater(
+    BaseCommand[DeactivateHeaterParams, DeactivateHeaterResult, ErrorOccurrence]
+):
+    """A command to unset a Heater-Shaker's target temperature."""
+
+    commandType: DeactivateHeaterCommandType = "heaterShaker/deactivateHeater"
+    params: DeactivateHeaterParams
+    result: Optional[DeactivateHeaterResult] = None
+
+    _ImplementationCls: Type[DeactivateHeaterImpl] = DeactivateHeaterImpl
+
+
+class DeactivateHeaterCreate(BaseCommandCreate[DeactivateHeaterParams]):
+    """A request to create a Heater-Shaker's deactivate heater command."""
+
+    commandType: DeactivateHeaterCommandType = "heaterShaker/deactivateHeater"
+    params: DeactivateHeaterParams
+
+    _CommandCls: Type[DeactivateHeater] = DeactivateHeater

opentrons/protocol_engine/commands/heater_shaker/deactivate_shaker.py

@@ -0,0 +1,84 @@
+"""Command models to deactivate shaker for the Heater-Shaker Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+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
+
+DeactivateShakerCommandType = Literal["heaterShaker/deactivateShaker"]
+
+
+class DeactivateShakerParams(BaseModel):
+    """Input parameters to deactivate shaker for a Heater-Shaker Module."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+
+
+class DeactivateShakerResult(BaseModel):
+    """Result data from deactivating shaker for a Heater-Shaker."""
+
+
+class DeactivateShakerImpl(
+    AbstractCommandImpl[DeactivateShakerParams, SuccessData[DeactivateShakerResult]]
+):
+    """Execution implementation of a Heater-Shaker's deactivate shaker 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: DeactivateShakerParams
+    ) -> SuccessData[DeactivateShakerResult]:
+        """Deactivate shaker for a Heater-Shaker."""
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        hs_module_substate.raise_if_labware_latch_not_closed()
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.deactivate_shaker()
+
+        return SuccessData(
+            public=DeactivateShakerResult(),
+        )
+
+
+class DeactivateShaker(
+    BaseCommand[DeactivateShakerParams, DeactivateShakerResult, ErrorOccurrence]
+):
+    """A command to deactivate shaker for a Heater-Shaker."""
+
+    commandType: DeactivateShakerCommandType = "heaterShaker/deactivateShaker"
+    params: DeactivateShakerParams
+    result: Optional[DeactivateShakerResult] = None
+
+    _ImplementationCls: Type[DeactivateShakerImpl] = DeactivateShakerImpl
+
+
+class DeactivateShakerCreate(BaseCommandCreate[DeactivateShakerParams]):
+    """A request to create a Heater-Shaker's deactivate shaker command."""
+
+    commandType: DeactivateShakerCommandType = "heaterShaker/deactivateShaker"
+    params: DeactivateShakerParams
+
+    _CommandCls: Type[DeactivateShaker] = DeactivateShaker

opentrons/protocol_engine/commands/heater_shaker/open_labware_latch.py

@@ -0,0 +1,110 @@
+"""Command models to open the Heater-Shaker Module's labware latch."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
+
+OpenLabwareLatchCommandType = Literal["heaterShaker/openLabwareLatch"]
+
+
+class OpenLabwareLatchParams(BaseModel):
+    """Input parameters to open a Heater-Shaker Module's labware latch."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+
+
+class OpenLabwareLatchResult(BaseModel):
+    """Result data from opening a Heater-Shaker's labware latch."""
+
+    pipetteRetracted: bool = Field(
+        ...,
+        description=(
+            "Whether this command automatically retracted the pipettes"
+            " before opening the latch, to avoid a potential collision."
+        ),
+    )
+
+
+class OpenLabwareLatchImpl(
+    AbstractCommandImpl[OpenLabwareLatchParams, SuccessData[OpenLabwareLatchResult]]
+):
+    """Execution implementation of a Heater-Shaker's open latch labware command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        movement: MovementHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._movement = movement
+
+    async def execute(
+        self, params: OpenLabwareLatchParams
+    ) -> SuccessData[OpenLabwareLatchResult]:
+        """Open a Heater-Shaker's labware latch."""
+        state_update = update_types.StateUpdate()
+
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        hs_module_substate.raise_if_shaking()
+
+        pipette_should_retract = (
+            self._state_view.motion.check_pipette_blocking_hs_latch(
+                hs_module_substate.module_id
+            )
+        )
+        if pipette_should_retract:
+            # Move pipette away if it is close to the heater-shaker
+            # TODO(jbl 2022-07-28) replace home movement with a retract movement
+            await self._movement.home(
+                axes=self._state_view.motion.get_robot_mount_axes()
+            )
+            state_update.clear_all_pipette_locations()
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.open_labware_latch()
+
+        return SuccessData(
+            public=OpenLabwareLatchResult(pipetteRetracted=pipette_should_retract),
+            state_update=state_update,
+        )
+
+
+class OpenLabwareLatch(
+    BaseCommand[OpenLabwareLatchParams, OpenLabwareLatchResult, ErrorOccurrence]
+):
+    """A command to open a Heater-Shaker's labware latch."""
+
+    commandType: OpenLabwareLatchCommandType = "heaterShaker/openLabwareLatch"
+    params: OpenLabwareLatchParams
+    result: Optional[OpenLabwareLatchResult] = None
+
+    _ImplementationCls: Type[OpenLabwareLatchImpl] = OpenLabwareLatchImpl
+
+
+class OpenLabwareLatchCreate(BaseCommandCreate[OpenLabwareLatchParams]):
+    """A request to create a Heater-Shaker's open labware latch command."""
+
+    commandType: OpenLabwareLatchCommandType = "heaterShaker/openLabwareLatch"
+    params: OpenLabwareLatchParams
+
+    _CommandCls: Type[OpenLabwareLatch] = OpenLabwareLatch

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -0,0 +1,125 @@
+"""Command models to set and wait for a shake speed for a Heater-Shaker Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
+
+SetAndWaitForShakeSpeedCommandType = Literal["heaterShaker/setAndWaitForShakeSpeed"]
+
+
+class SetAndWaitForShakeSpeedParams(BaseModel):
+    """Input parameters to set and wait for a shake speed for a Heater-Shaker Module."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+    rpm: float = Field(..., description="Target speed in rotations per minute.")
+
+
+class SetAndWaitForShakeSpeedResult(BaseModel):
+    """Result data from setting and waiting for a Heater-Shaker's shake speed."""
+
+    pipetteRetracted: bool = Field(
+        ...,
+        description=(
+            "Whether this command automatically retracted the pipettes"
+            " before starting the shake, to avoid a potential collision."
+        ),
+    )
+
+
+class SetAndWaitForShakeSpeedImpl(
+    AbstractCommandImpl[
+        SetAndWaitForShakeSpeedParams, SuccessData[SetAndWaitForShakeSpeedResult]
+    ]
+):
+    """Execution implementation of Heater-Shaker's set and wait shake speed command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        movement: MovementHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._movement = movement
+
+    async def execute(
+        self,
+        params: SetAndWaitForShakeSpeedParams,
+    ) -> SuccessData[SetAndWaitForShakeSpeedResult]:
+        """Set and wait for a Heater-Shaker's target shake speed."""
+        state_update = update_types.StateUpdate()
+
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        hs_module_substate.raise_if_labware_latch_not_closed()
+
+        # Verify speed from hs module view
+        validated_speed = hs_module_substate.validate_target_speed(params.rpm)
+
+        pipette_should_retract = (
+            self._state_view.motion.check_pipette_blocking_hs_shaker(
+                hs_module_substate.module_id
+            )
+        )
+        if pipette_should_retract:
+            # Move pipette away if it is close to the heater-shaker
+            # TODO(jbl 2022-07-28) replace home movement with a retract movement
+            await self._movement.home(
+                axes=self._state_view.motion.get_robot_mount_axes()
+            )
+            state_update.clear_all_pipette_locations()
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.set_speed(rpm=validated_speed)
+
+        return SuccessData(
+            public=SetAndWaitForShakeSpeedResult(
+                pipetteRetracted=pipette_should_retract
+            ),
+            state_update=state_update,
+        )
+
+
+class SetAndWaitForShakeSpeed(
+    BaseCommand[
+        SetAndWaitForShakeSpeedParams, SetAndWaitForShakeSpeedResult, ErrorOccurrence
+    ]
+):
+    """A command to set and wait for a Heater-Shaker's shake speed."""
+
+    commandType: SetAndWaitForShakeSpeedCommandType = (
+        "heaterShaker/setAndWaitForShakeSpeed"
+    )
+    params: SetAndWaitForShakeSpeedParams
+    result: Optional[SetAndWaitForShakeSpeedResult] = None
+
+    _ImplementationCls: Type[SetAndWaitForShakeSpeedImpl] = SetAndWaitForShakeSpeedImpl
+
+
+class SetAndWaitForShakeSpeedCreate(BaseCommandCreate[SetAndWaitForShakeSpeedParams]):
+    """A request to create a Heater-Shaker's set and wait for shake speed command."""
+
+    commandType: SetAndWaitForShakeSpeedCommandType = (
+        "heaterShaker/setAndWaitForShakeSpeed"
+    )
+    params: SetAndWaitForShakeSpeedParams
+
+    _CommandCls: Type[SetAndWaitForShakeSpeed] = SetAndWaitForShakeSpeed

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -0,0 +1,90 @@
+"""Command models to start heating a Heater-Shaker Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+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
+
+
+SetTargetTemperatureCommandType = Literal["heaterShaker/setTargetTemperature"]
+
+
+class SetTargetTemperatureParams(BaseModel):
+    """Input parameters to set a Heater-Shaker's target temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+    celsius: float = Field(..., description="Target temperature in °C.")
+
+
+class SetTargetTemperatureResult(BaseModel):
+    """Result data from setting a Heater-Shaker's target temperature."""
+
+
+class SetTargetTemperatureImpl(
+    AbstractCommandImpl[
+        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult]
+    ]
+):
+    """Execution implementation of a Heater-Shaker's set temperature 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: SetTargetTemperatureParams,
+    ) -> SuccessData[SetTargetTemperatureResult]:
+        """Set a Heater-Shaker's target temperature."""
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        # Verify temperature from hs module view
+        validated_temp = hs_module_substate.validate_target_temperature(params.celsius)
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        if hs_hardware_module is not None:
+            await hs_hardware_module.start_set_temperature(validated_temp)
+
+        return SuccessData(
+            public=SetTargetTemperatureResult(),
+        )
+
+
+class SetTargetTemperature(
+    BaseCommand[SetTargetTemperatureParams, SetTargetTemperatureResult, ErrorOccurrence]
+):
+    """A command to set a Heater-Shaker's target temperature."""
+
+    commandType: SetTargetTemperatureCommandType = "heaterShaker/setTargetTemperature"
+    params: SetTargetTemperatureParams
+    result: Optional[SetTargetTemperatureResult] = None
+
+    _ImplementationCls: Type[SetTargetTemperatureImpl] = SetTargetTemperatureImpl
+
+
+class SetTargetTemperatureCreate(BaseCommandCreate[SetTargetTemperatureParams]):
+    """A request to create a Heater-Shaker's set temperature command."""
+
+    commandType: SetTargetTemperatureCommandType = "heaterShaker/setTargetTemperature"
+    params: SetTargetTemperatureParams
+
+    _CommandCls: Type[SetTargetTemperature] = SetTargetTemperature