opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -0,0 +1,171 @@
+"""Command models to execute a Thermocycler profile."""
+from __future__ import annotations
+from typing import List, Optional, TYPE_CHECKING, overload, Union, Any
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+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"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+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: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Amount of liquid in uL of the most-full well"
+        " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
+    )
+
+
+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] = None
+
+    _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

@@ -0,0 +1,124 @@
+"""Command models to execute a Thermocycler profile."""
+from __future__ import annotations
+from typing import List, Optional, TYPE_CHECKING, Any
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.hardware_control.modules.types import ThermocyclerStep
+
+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
+
+
+RunProfileCommandType = Literal["thermocycler/runProfile"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class RunProfileStepParams(BaseModel):
+    """Input parameters for an individual Thermocycler profile step."""
+
+    celsius: float = Field(..., description="Target temperature in °C.")
+    holdSeconds: float = Field(
+        ..., description="Time to hold target temperature at in seconds."
+    )
+
+
+class RunProfileParams(BaseModel):
+    """Input parameters to run a Thermocycler profile."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler.")
+    profile: List[RunProfileStepParams] = Field(
+        ...,
+        description="Array of profile steps with target temperature and temperature hold time.",
+    )
+    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Amount of liquid in uL of the most-full well"
+        " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class RunProfileResult(BaseModel):
+    """Result data from running a Thermocycler profile."""
+
+
+class RunProfileImpl(
+    AbstractCommandImpl[RunProfileParams, SuccessData[RunProfileResult]]
+):
+    """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: RunProfileParams) -> SuccessData[RunProfileResult]:
+        """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
+        )
+
+        steps = [
+            ThermocyclerStep(
+                temperature=thermocycler_state.validate_target_block_temperature(
+                    profile_step.celsius
+                ),
+                hold_time_seconds=profile_step.holdSeconds,
+            )
+            for profile_step in params.profile
+        ]
+
+        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.cycle_temperatures(
+                steps=steps, repetitions=1, volume=target_volume
+            )
+
+        return SuccessData(
+            public=RunProfileResult(),
+        )
+
+
+class RunProfile(BaseCommand[RunProfileParams, RunProfileResult, ErrorOccurrence]):
+    """A command to execute a Thermocycler profile run."""
+
+    commandType: RunProfileCommandType = "thermocycler/runProfile"
+    params: RunProfileParams
+    result: Optional[RunProfileResult] = None
+
+    _ImplementationCls: Type[RunProfileImpl] = RunProfileImpl
+
+
+class RunProfileCreate(BaseCommandCreate[RunProfileParams]):
+    """A request to execute a Thermocycler profile run."""
+
+    commandType: RunProfileCommandType = "thermocycler/runProfile"
+    params: RunProfileParams
+
+    _CommandCls: Type[RunProfile] = RunProfile

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -0,0 +1,140 @@
+"""Command models to start heating a Thermocycler's block."""
+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
+
+
+SetTargetBlockTemperatureCommandType = Literal["thermocycler/setTargetBlockTemperature"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class SetTargetBlockTemperatureParams(BaseModel):
+    """Input parameters to set a Thermocycler's target block temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler Module.")
+    celsius: float = Field(..., description="Target temperature in °C.")
+    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Amount of liquid in uL of the most-full well"
+        " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
+    )
+    holdTimeSeconds: float | SkipJsonSchema[None] = Field(
+        None,
+        description="Amount of time, in seconds, to hold the temperature for."
+        " If specified, a waitForBlockTemperature command will block until"
+        " the given hold time has elapsed.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class SetTargetBlockTemperatureResult(BaseModel):
+    """Result data from setting a Thermocycler's target block temperature."""
+
+    targetBlockTemperature: float = Field(
+        ...,
+        description="The target block temperature that was set after validation.",
+    )
+
+
+class SetTargetBlockTemperatureImpl(
+    AbstractCommandImpl[
+        SetTargetBlockTemperatureParams,
+        SuccessData[SetTargetBlockTemperatureResult],
+    ]
+):
+    """Execution implementation of a Thermocycler's set block 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: SetTargetBlockTemperatureParams,
+    ) -> SuccessData[SetTargetBlockTemperatureResult]:
+        """Set a Thermocycler's target block temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+        target_temperature = thermocycler_state.validate_target_block_temperature(
+            params.celsius
+        )
+        target_volume: Optional[float]
+        if params.blockMaxVolumeUl is not None:
+            target_volume = thermocycler_state.validate_max_block_volume(
+                params.blockMaxVolumeUl
+            )
+        else:
+            target_volume = None
+        hold_time: Optional[float]
+        if params.holdTimeSeconds is not None:
+            hold_time = thermocycler_state.validate_hold_time(params.holdTimeSeconds)
+        else:
+            hold_time = None
+
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.set_target_block_temperature(
+                target_temperature, volume=target_volume, hold_time_seconds=hold_time
+            )
+
+        return SuccessData(
+            public=SetTargetBlockTemperatureResult(
+                targetBlockTemperature=target_temperature
+            ),
+        )
+
+
+class SetTargetBlockTemperature(
+    BaseCommand[
+        SetTargetBlockTemperatureParams,
+        SetTargetBlockTemperatureResult,
+        ErrorOccurrence,
+    ]
+):
+    """A command to set a Thermocycler's target block temperature."""
+
+    commandType: SetTargetBlockTemperatureCommandType = (
+        "thermocycler/setTargetBlockTemperature"
+    )
+    params: SetTargetBlockTemperatureParams
+    result: Optional[SetTargetBlockTemperatureResult] = None
+
+    _ImplementationCls: Type[
+        SetTargetBlockTemperatureImpl
+    ] = SetTargetBlockTemperatureImpl
+
+
+class SetTargetBlockTemperatureCreate(
+    BaseCommandCreate[SetTargetBlockTemperatureParams]
+):
+    """A request to create a Thermocycler's set block temperature command."""
+
+    commandType: SetTargetBlockTemperatureCommandType = (
+        "thermocycler/setTargetBlockTemperature"
+    )
+    params: SetTargetBlockTemperatureParams
+
+    _CommandCls: Type[SetTargetBlockTemperature] = SetTargetBlockTemperature

opentrons/protocol_engine/commands/thermocycler/set_target_lid_temperature.py

@@ -0,0 +1,100 @@
+"""Command models to start 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
+
+
+SetTargetLidTemperatureCommandType = Literal["thermocycler/setTargetLidTemperature"]
+
+
+class SetTargetLidTemperatureParams(BaseModel):
+    """Input parameters to set a Thermocycler's target lid temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler Module.")
+    celsius: float = Field(..., description="Target temperature in °C.")
+
+
+class SetTargetLidTemperatureResult(BaseModel):
+    """Result data from setting a Thermocycler's target lid temperature."""
+
+    targetLidTemperature: float = Field(
+        ...,
+        description="The target lid temperature that was set after validation.",
+    )
+
+
+class SetTargetLidTemperatureImpl(
+    AbstractCommandImpl[
+        SetTargetLidTemperatureParams, SuccessData[SetTargetLidTemperatureResult]
+    ]
+):
+    """Execution implementation of a Thermocycler's set lid 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: SetTargetLidTemperatureParams,
+    ) -> SuccessData[SetTargetLidTemperatureResult]:
+        """Set a Thermocycler's target lid temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+        target_temperature = thermocycler_state.validate_target_lid_temperature(
+            params.celsius
+        )
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.set_target_lid_temperature(target_temperature)
+
+        return SuccessData(
+            public=SetTargetLidTemperatureResult(
+                targetLidTemperature=target_temperature
+            ),
+        )
+
+
+class SetTargetLidTemperature(
+    BaseCommand[
+        SetTargetLidTemperatureParams, SetTargetLidTemperatureResult, ErrorOccurrence
+    ]
+):
+    """A command to set a Thermocycler's target lid temperature."""
+
+    commandType: SetTargetLidTemperatureCommandType = (
+        "thermocycler/setTargetLidTemperature"
+    )
+    params: SetTargetLidTemperatureParams
+    result: Optional[SetTargetLidTemperatureResult] = None
+
+    _ImplementationCls: Type[SetTargetLidTemperatureImpl] = SetTargetLidTemperatureImpl
+
+
+class SetTargetLidTemperatureCreate(BaseCommandCreate[SetTargetLidTemperatureParams]):
+    """A request to create a Thermocycler's set lid temperature command."""
+
+    commandType: SetTargetLidTemperatureCommandType = (
+        "thermocycler/setTargetLidTemperature"
+    )
+    params: SetTargetLidTemperatureParams
+
+    _CommandCls: Type[SetTargetLidTemperature] = SetTargetLidTemperature

opentrons/protocol_engine/commands/thermocycler/wait_for_block_temperature.py

@@ -0,0 +1,93 @@
+"""Command models to wait for 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
+
+
+WaitForBlockTemperatureCommandType = Literal["thermocycler/waitForBlockTemperature"]
+
+
+class WaitForBlockTemperatureParams(BaseModel):
+    """Input parameters to wait for Thermocycler's target block temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Thermocycler Module.")
+
+
+class WaitForBlockTemperatureResult(BaseModel):
+    """Result data from wait for Thermocycler's target block temperature."""
+
+
+class WaitForBlockTemperatureImpl(
+    AbstractCommandImpl[
+        WaitForBlockTemperatureParams, SuccessData[WaitForBlockTemperatureResult]
+    ]
+):
+    """Execution implementation of Thermocycler's wait for block 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: WaitForBlockTemperatureParams,
+    ) -> SuccessData[WaitForBlockTemperatureResult]:
+        """Wait for a Thermocycler's target block temperature."""
+        thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
+            params.moduleId
+        )
+
+        # Raises error if no target temperature
+        thermocycler_state.get_target_block_temperature()
+
+        thermocycler_hardware = self._equipment.get_module_hardware_api(
+            thermocycler_state.module_id
+        )
+
+        if thermocycler_hardware is not None:
+            await thermocycler_hardware.wait_for_block_target()
+
+        return SuccessData(
+            public=WaitForBlockTemperatureResult(),
+        )
+
+
+class WaitForBlockTemperature(
+    BaseCommand[
+        WaitForBlockTemperatureParams, WaitForBlockTemperatureResult, ErrorOccurrence
+    ]
+):
+    """A command to wait for a Thermocycler's target block temperature."""
+
+    commandType: WaitForBlockTemperatureCommandType = (
+        "thermocycler/waitForBlockTemperature"
+    )
+    params: WaitForBlockTemperatureParams
+    result: Optional[WaitForBlockTemperatureResult] = None
+
+    _ImplementationCls: Type[WaitForBlockTemperatureImpl] = WaitForBlockTemperatureImpl
+
+
+class WaitForBlockTemperatureCreate(BaseCommandCreate[WaitForBlockTemperatureParams]):
+    """A request to create Thermocycler's wait for block temperature command."""
+
+    commandType: WaitForBlockTemperatureCommandType = (
+        "thermocycler/waitForBlockTemperature"
+    )
+    params: WaitForBlockTemperatureParams
+
+    _CommandCls: Type[WaitForBlockTemperature] = WaitForBlockTemperature