opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/temperature_module/set_target_temperature.py

@@ -0,0 +1,97 @@
+"""Command models to start heating a Temperature 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["temperatureModule/setTargetTemperature"]
+
+
+class SetTargetTemperatureParams(BaseModel):
+    """Input parameters to set a Temperature Module's target temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Temperature Module.")
+    celsius: float = Field(..., description="Target temperature in °C.")
+
+
+class SetTargetTemperatureResult(BaseModel):
+    """Result data from setting a Temperature Module's target temperature."""
+
+    targetTemperature: float = Field(
+        ...,
+        description="The target temperature that was set after validation "
+        "and type conversion (if any).",
+    )
+
+
+class SetTargetTemperatureImpl(
+    AbstractCommandImpl[
+        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult]
+    ]
+):
+    """Execution implementation of a Temperature Module'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 Temperature Module's target temperature."""
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        module_substate = self._state_view.modules.get_temperature_module_substate(
+            module_id=params.moduleId
+        )
+
+        # Verify temperature from temperature module view
+        validated_temp = module_substate.validate_target_temperature(params.celsius)
+
+        # Allow propagation of ModuleNotAttachedError.
+        temp_hardware_module = self._equipment.get_module_hardware_api(
+            module_substate.module_id
+        )
+
+        if temp_hardware_module is not None:
+            await temp_hardware_module.start_set_temperature(celsius=validated_temp)
+        return SuccessData(
+            public=SetTargetTemperatureResult(targetTemperature=validated_temp),
+        )
+
+
+class SetTargetTemperature(
+    BaseCommand[SetTargetTemperatureParams, SetTargetTemperatureResult, ErrorOccurrence]
+):
+    """A command to set a Temperature Module's target temperature."""
+
+    commandType: SetTargetTemperatureCommandType = (
+        "temperatureModule/setTargetTemperature"
+    )
+    params: SetTargetTemperatureParams
+    result: Optional[SetTargetTemperatureResult] = None
+
+    _ImplementationCls: Type[SetTargetTemperatureImpl] = SetTargetTemperatureImpl
+
+
+class SetTargetTemperatureCreate(BaseCommandCreate[SetTargetTemperatureParams]):
+    """A request to create a Temperature Module's set temperature command."""
+
+    commandType: SetTargetTemperatureCommandType = (
+        "temperatureModule/setTargetTemperature"
+    )
+    params: SetTargetTemperatureParams
+
+    _CommandCls: Type[SetTargetTemperature] = SetTargetTemperature

opentrons/protocol_engine/commands/temperature_module/wait_for_temperature.py

@@ -0,0 +1,104 @@
+"""Command models to wait for target temperature of a Temperature Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING, Any
+
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+WaitForTemperatureCommandType = Literal["temperatureModule/waitForTemperature"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class WaitForTemperatureParams(BaseModel):
+    """Input parameters to wait for a Temperature Module's target temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Temperature Module.")
+    celsius: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Target temperature in °C. If not specified, will "
+        "default to the module's target temperature. "
+        "Specifying a celsius parameter other than the target temperature "
+        "could lead to unpredictable behavior and hence is not "
+        "recommended for use. This parameter can be removed in a "
+        "future version without prior notice.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class WaitForTemperatureResult(BaseModel):
+    """Result data from waiting for a Temperature Module's target temperature."""
+
+
+class WaitForTemperatureImpl(
+    AbstractCommandImpl[WaitForTemperatureParams, SuccessData[WaitForTemperatureResult]]
+):
+    """Execution implementation of Temperature Module's wait for 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: WaitForTemperatureParams
+    ) -> 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(
+            module_id=params.moduleId
+        )
+
+        if params.celsius is None:
+            # Raises error if no target temperature
+            target_temp = module_substate.get_plate_target_temperature()
+        else:
+            target_temp = module_substate.validate_target_temperature(params.celsius)
+
+        # Allow propagation of ModuleNotAttachedError.
+        temp_hardware_module = self._equipment.get_module_hardware_api(
+            module_substate.module_id
+        )
+
+        if temp_hardware_module is not None:
+            await temp_hardware_module.await_temperature(
+                awaiting_temperature=target_temp
+            )
+        return SuccessData(
+            public=WaitForTemperatureResult(),
+        )
+
+
+class WaitForTemperature(
+    BaseCommand[WaitForTemperatureParams, WaitForTemperatureResult, ErrorOccurrence]
+):
+    """A command to wait for a Temperature Module's target temperature."""
+
+    commandType: WaitForTemperatureCommandType = "temperatureModule/waitForTemperature"
+    params: WaitForTemperatureParams
+    result: Optional[WaitForTemperatureResult] = None
+
+    _ImplementationCls: Type[WaitForTemperatureImpl] = WaitForTemperatureImpl
+
+
+class WaitForTemperatureCreate(BaseCommandCreate[WaitForTemperatureParams]):
+    """A request to create a Temperature Module's wait for temperature command."""
+
+    commandType: WaitForTemperatureCommandType = "temperatureModule/waitForTemperature"
+    params: WaitForTemperatureParams
+
+    _CommandCls: Type[WaitForTemperature] = WaitForTemperature

opentrons/protocol_engine/commands/thermocycler/__init__.py

@@ -0,0 +1,152 @@
+"""Command models for Thermocycler commands."""
+
+from .set_target_block_temperature import (
+    SetTargetBlockTemperatureCommandType,
+    SetTargetBlockTemperatureParams,
+    SetTargetBlockTemperatureResult,
+    SetTargetBlockTemperature,
+    SetTargetBlockTemperatureCreate,
+)
+
+from .wait_for_block_temperature import (
+    WaitForBlockTemperatureCommandType,
+    WaitForBlockTemperatureParams,
+    WaitForBlockTemperatureResult,
+    WaitForBlockTemperature,
+    WaitForBlockTemperatureCreate,
+)
+
+from .set_target_lid_temperature import (
+    SetTargetLidTemperatureCommandType,
+    SetTargetLidTemperatureParams,
+    SetTargetLidTemperatureResult,
+    SetTargetLidTemperature,
+    SetTargetLidTemperatureCreate,
+)
+
+from .wait_for_lid_temperature import (
+    WaitForLidTemperatureCommandType,
+    WaitForLidTemperatureParams,
+    WaitForLidTemperatureResult,
+    WaitForLidTemperature,
+    WaitForLidTemperatureCreate,
+)
+
+from .deactivate_block import (
+    DeactivateBlockCommandType,
+    DeactivateBlockParams,
+    DeactivateBlockResult,
+    DeactivateBlock,
+    DeactivateBlockCreate,
+)
+
+from .deactivate_lid import (
+    DeactivateLidCommandType,
+    DeactivateLidParams,
+    DeactivateLidResult,
+    DeactivateLid,
+    DeactivateLidCreate,
+)
+
+from .open_lid import (
+    OpenLidCommandType,
+    OpenLidParams,
+    OpenLidResult,
+    OpenLid,
+    OpenLidCreate,
+)
+
+from .close_lid import (
+    CloseLidCommandType,
+    CloseLidParams,
+    CloseLidResult,
+    CloseLid,
+    CloseLidCreate,
+)
+
+from .run_profile import (
+    RunProfileCommandType,
+    RunProfileParams,
+    RunProfileStepParams,
+    RunProfileResult,
+    RunProfile,
+    RunProfileCreate,
+)
+
+from .run_extended_profile import (
+    RunExtendedProfileCommandType,
+    RunExtendedProfileParams,
+    RunExtendedProfileResult,
+    RunExtendedProfile,
+    RunExtendedProfileCreate,
+    ProfileCycle,
+    ProfileStep,
+)
+
+
+__all__ = [
+    # Set target block temperature command models
+    "SetTargetBlockTemperatureCommandType",
+    "SetTargetBlockTemperatureParams",
+    "SetTargetBlockTemperatureResult",
+    "SetTargetBlockTemperature",
+    "SetTargetBlockTemperatureCreate",
+    # Wait for block temperature command models
+    "WaitForBlockTemperatureCommandType",
+    "WaitForBlockTemperatureParams",
+    "WaitForBlockTemperatureResult",
+    "WaitForBlockTemperature",
+    "WaitForBlockTemperatureCreate",
+    # Set target lid temperature command models
+    "SetTargetLidTemperatureCommandType",
+    "SetTargetLidTemperatureParams",
+    "SetTargetLidTemperatureResult",
+    "SetTargetLidTemperature",
+    "SetTargetLidTemperatureCreate",
+    # Wait for lid temperature command models
+    "WaitForLidTemperatureCommandType",
+    "WaitForLidTemperatureParams",
+    "WaitForLidTemperatureResult",
+    "WaitForLidTemperature",
+    "WaitForLidTemperatureCreate",
+    # Deactivate block command models
+    "DeactivateBlockCommandType",
+    "DeactivateBlockParams",
+    "DeactivateBlockResult",
+    "DeactivateBlock",
+    "DeactivateBlockCreate",
+    # Deactivate lid command models
+    "DeactivateLidCommandType",
+    "DeactivateLidParams",
+    "DeactivateLidResult",
+    "DeactivateLid",
+    "DeactivateLidCreate",
+    # Open lid command models
+    "OpenLidCommandType",
+    "OpenLidParams",
+    "OpenLidResult",
+    "OpenLid",
+    "OpenLidCreate",
+    # Close lid command models
+    "CloseLidCommandType",
+    "CloseLidParams",
+    "CloseLidResult",
+    "CloseLid",
+    "CloseLidCreate",
+    # Run profile command models,
+    "RunProfileCommandType",
+    "RunProfileParams",
+    "RunProfileStepParams",
+    "RunProfileResult",
+    "RunProfile",
+    "RunProfileCreate",
+    # Run extended profile command models.
+    "RunExtendedProfileCommandType",
+    "RunExtendedProfileParams",
+    "RunExtendedProfileStepParams",
+    "RunExtendedProfileResult",
+    "RunExtendedProfile",
+    "RunExtendedProfileCreate",
+    "ProfileCycle",
+    "ProfileStep",
+]

opentrons/protocol_engine/commands/thermocycler/close_lid.py

@@ -0,0 +1,87 @@
+"""Command models to close a Thermocycler's lid."""
+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
+from opentrons.protocol_engine.types import MotorAxis
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
+
+
+CloseLidCommandType = Literal["thermocycler/closeLid"]
+
+
+class CloseLidParams(BaseModel):
+    """Input parameters to close a Thermocycler's lid."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+
+
+class CloseLidResult(BaseModel):
+    """Result data from closing a Thermocycler's lid."""
+
+
+class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResult]]):
+    """Execution implementation of a Thermocycler's close lid 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: 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
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        # move the pipettes and gantry over the trash
+        # do not home plunger axes because pipettes may be holding liquid
+        axes_to_home = [
+            MotorAxis.X,
+            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(), state_update=state_update)
+
+
+class CloseLid(BaseCommand[CloseLidParams, CloseLidResult, ErrorOccurrence]):
+    """A command to close a Thermocycler's lid."""
+
+    commandType: CloseLidCommandType = "thermocycler/closeLid"
+    params: CloseLidParams
+    result: Optional[CloseLidResult] = None
+
+    _ImplementationCls: Type[CloseLidImpl] = CloseLidImpl
+
+
+class CloseLidCreate(BaseCommandCreate[CloseLidParams]):
+    """A request to close a Thermocycler's lid."""
+
+    commandType: CloseLidCommandType = "thermocycler/closeLid"
+    params: CloseLidParams
+
+    _CommandCls: Type[CloseLid] = CloseLid

opentrons/protocol_engine/commands/thermocycler/deactivate_block.py

@@ -0,0 +1,80 @@
+"""Command models to stop heating a Thermocycler's block."""
+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
+
+
+DeactivateBlockCommandType = Literal["thermocycler/deactivateBlock"]
+
+
+class DeactivateBlockParams(BaseModel):
+    """Input parameters to unset a Thermocycler's target block temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+
+
+class DeactivateBlockResult(BaseModel):
+    """Result data from unsetting a Thermocycler's target block temperature."""
+
+
+class DeactivateBlockImpl(
+    AbstractCommandImpl[DeactivateBlockParams, SuccessData[DeactivateBlockResult]]
+):
+    """Execution implementation of a Thermocycler's deactivate block 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: DeactivateBlockParams
+    ) -> SuccessData[DeactivateBlockResult]:
+        """Unset a Thermocycler's target block temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.deactivate_block()
+
+        return SuccessData(
+            public=DeactivateBlockResult(),
+        )
+
+
+class DeactivateBlock(
+    BaseCommand[DeactivateBlockParams, DeactivateBlockResult, ErrorOccurrence]
+):
+    """A command to unset a Thermocycler's target block temperature."""
+
+    commandType: DeactivateBlockCommandType = "thermocycler/deactivateBlock"
+    params: DeactivateBlockParams
+    result: Optional[DeactivateBlockResult] = None
+
+    _ImplementationCls: Type[DeactivateBlockImpl] = DeactivateBlockImpl
+
+
+class DeactivateBlockCreate(BaseCommandCreate[DeactivateBlockParams]):
+    """A request to create a Thermocycler's deactivate block command."""
+
+    commandType: DeactivateBlockCommandType = "thermocycler/deactivateBlock"
+    params: DeactivateBlockParams
+
+    _CommandCls: Type[DeactivateBlock] = DeactivateBlock

opentrons/protocol_engine/commands/thermocycler/deactivate_lid.py

@@ -0,0 +1,80 @@
+"""Command models to stop heating a Thermocycler's lid."""
+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
+
+
+DeactivateLidCommandType = Literal["thermocycler/deactivateLid"]
+
+
+class DeactivateLidParams(BaseModel):
+    """Input parameters to unset a Thermocycler's target lid temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+
+
+class DeactivateLidResult(BaseModel):
+    """Result data from unsetting a Thermocycler's target lid temperature."""
+
+
+class DeactivateLidImpl(
+    AbstractCommandImpl[DeactivateLidParams, SuccessData[DeactivateLidResult]]
+):
+    """Execution implementation of a Thermocycler's deactivate lid 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: DeactivateLidParams
+    ) -> SuccessData[DeactivateLidResult]:
+        """Unset a Thermocycler's target lid temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.deactivate_lid()
+
+        return SuccessData(
+            public=DeactivateLidResult(),
+        )
+
+
+class DeactivateLid(
+    BaseCommand[DeactivateLidParams, DeactivateLidResult, ErrorOccurrence]
+):
+    """A command to unset a Thermocycler's target lid temperature."""
+
+    commandType: DeactivateLidCommandType = "thermocycler/deactivateLid"
+    params: DeactivateLidParams
+    result: Optional[DeactivateLidResult] = None
+
+    _ImplementationCls: Type[DeactivateLidImpl] = DeactivateLidImpl
+
+
+class DeactivateLidCreate(BaseCommandCreate[DeactivateLidParams]):
+    """A request to create a Thermocycler's deactivate lid command."""
+
+    commandType: DeactivateLidCommandType = "thermocycler/deactivateLid"
+    params: DeactivateLidParams
+
+    _CommandCls: Type[DeactivateLid] = DeactivateLid

opentrons/protocol_engine/commands/thermocycler/open_lid.py

@@ -0,0 +1,87 @@
+"""Command models to open a Thermocycler's lid."""
+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 ...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.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
+
+
+OpenLidCommandType = Literal["thermocycler/openLid"]
+
+
+class OpenLidParams(BaseModel):
+    """Input parameters to open a Thermocycler's lid."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+
+
+class OpenLidResult(BaseModel):
+    """Result data from opening a Thermocycler's lid."""
+
+
+class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]):
+    """Execution implementation of a Thermocycler's open lid 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: 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
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        # move the pipettes and gantry over the trash
+        # do not home plunger axes because pipettes may be holding liquid
+        axes_to_home = [
+            MotorAxis.X,
+            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(), state_update=state_update)
+
+
+class OpenLid(BaseCommand[OpenLidParams, OpenLidResult, ErrorOccurrence]):
+    """A command to open a Thermocycler's lid."""
+
+    commandType: OpenLidCommandType = "thermocycler/openLid"
+    params: OpenLidParams
+    result: Optional[OpenLidResult] = None
+
+    _ImplementationCls: Type[OpenLidImpl] = OpenLidImpl
+
+
+class OpenLidCreate(BaseCommandCreate[OpenLidParams]):
+    """A request to open a Thermocycler's lid."""
+
+    commandType: OpenLidCommandType = "thermocycler/openLid"
+    params: OpenLidParams
+
+    _CommandCls: Type[OpenLid] = OpenLid