opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/heater_shaker/wait_for_temperature.py

@@ -0,0 +1,102 @@
+"""Command models to wait for a Heater-Shaker Module's target temperature."""
+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["heaterShaker/waitForTemperature"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class WaitForTemperatureParams(BaseModel):
+    """Input parameters to wait for a Heater-Shaker's target temperature."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker 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 Heater-Shaker's target temperature."""
+
+
+class WaitForTemperatureImpl(
+    AbstractCommandImpl[WaitForTemperatureParams, SuccessData[WaitForTemperatureResult]]
+):
+    """Execution implementation of a Heater-Shaker'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 Heater-Shaker's target temperature to be reached."""
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        if params.celsius is None:
+            # Raises error if no target temperature
+            target_temp = hs_module_substate.get_plate_target_temperature()
+        else:
+            target_temp = hs_module_substate.validate_target_temperature(params.celsius)
+
+        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.await_temperature(awaiting_temperature=target_temp)
+
+        return SuccessData(
+            public=WaitForTemperatureResult(),
+        )
+
+
+class WaitForTemperature(
+    BaseCommand[WaitForTemperatureParams, WaitForTemperatureResult, ErrorOccurrence]
+):
+    """A command to wait for a Heater-Shaker's target temperature to be reached."""
+
+    commandType: WaitForTemperatureCommandType = "heaterShaker/waitForTemperature"
+    params: WaitForTemperatureParams
+    result: Optional[WaitForTemperatureResult] = None
+
+    _ImplementationCls: Type[WaitForTemperatureImpl] = WaitForTemperatureImpl
+
+
+class WaitForTemperatureCreate(BaseCommandCreate[WaitForTemperatureParams]):
+    """A request to create a Heater-Shaker's wait for temperature command."""
+
+    commandType: WaitForTemperatureCommandType = "heaterShaker/waitForTemperature"
+    params: WaitForTemperatureParams
+
+    _CommandCls: Type[WaitForTemperature] = WaitForTemperature

opentrons/protocol_engine/commands/home.py

@@ -0,0 +1,100 @@
+"""Home command payload, result, and implementation models."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, List, Type, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from typing_extensions import Literal
+
+from opentrons.types import MountType
+from ..state import update_types
+from ..types import MotorAxis
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ..execution import MovementHandler
+
+
+HomeCommandType = Literal["home"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class HomeParams(BaseModel):
+    """Payload required for a Home command."""
+
+    axes: List[MotorAxis] | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "Axes to return to their home positions. If omitted,"
+            " will home all motors. Extra axes may be implicitly homed"
+            " to ensure accurate homing of the explicitly specified axes."
+        ),
+        json_schema_extra=_remove_default,
+    )
+    skipIfMountPositionOk: MountType | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "If this parameter is provided, the gantry will only be homed if the"
+            " specified mount has an invalid position. If omitted, the homing action"
+            " will be executed unconditionally."
+        ),
+        json_schema_extra=_remove_default,
+    )
+
+
+class HomeResult(BaseModel):
+    """Result data from the execution of a Home command."""
+
+
+class HomeImplementation(AbstractCommandImpl[HomeParams, SuccessData[HomeResult]]):
+    """Home command implementation."""
+
+    def __init__(self, movement: MovementHandler, **kwargs: object) -> None:
+        self._movement = movement
+
+    async def execute(self, params: HomeParams) -> SuccessData[HomeResult]:
+        """Home some or all motors to establish positional accuracy."""
+        state_update = update_types.StateUpdate()
+
+        if (
+            params.skipIfMountPositionOk is None
+            or not await self._movement.check_for_valid_position(
+                mount=params.skipIfMountPositionOk
+            )
+        ):
+            await self._movement.home(axes=params.axes)
+
+        # todo(mm, 2024-09-17): Clearing all pipette locations *unconditionally* is to
+        # preserve prior behavior, but we might only want to do this if we actually home.
+        state_update.clear_all_pipette_locations()
+
+        return SuccessData(public=HomeResult(), state_update=state_update)
+
+
+class Home(BaseCommand[HomeParams, HomeResult, ErrorOccurrence]):
+    """Command to send some (or all) motors to their home positions.
+
+    Homing a motor re-establishes positional accuracy the first time a motor
+    is used, or any time the motor "loses" its position, for example, after
+    a halt or after a collision.
+    """
+
+    commandType: HomeCommandType = "home"
+    params: HomeParams
+    result: Optional[HomeResult] = None
+
+    _ImplementationCls: Type[HomeImplementation] = HomeImplementation
+
+
+class HomeCreate(BaseCommandCreate[HomeParams]):
+    """Data to create a Home command."""
+
+    commandType: HomeCommandType = "home"
+    params: HomeParams
+
+    _CommandCls: Type[Home] = Home

opentrons/protocol_engine/commands/identify_module.py

@@ -0,0 +1,86 @@
+"""Command models to pulse the light on a module for identification."""
+
+from __future__ import annotations
+
+from __future__ import annotations
+from typing import Optional, Literal, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+from ..types import ModuleModel
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+IdentifyModuleCommandType = Literal["identifyModule"]
+
+
+class IdentifyModuleParams(BaseModel):
+    """The parameters defining the module to be identified."""
+
+    model: ModuleModel = Field(..., description="The model of the module")
+    moduleId: str = Field(..., description="Unique ID of the module")
+    start: bool = Field(..., description="Start or stop identify")
+    color: Optional[str] = Field(None, description="Optional color to identify module")
+
+
+class IdentifyModuleResult(BaseModel):
+    """Result data from an IdentifyModule command."""
+
+
+class IdentifyModuleImpl(
+    AbstractCommandImpl[IdentifyModuleParams, SuccessData[IdentifyModuleResult]]
+):
+    """Implementation of an IdentifyModule command."""
+
+    def __init__(
+        self, state_view: StateView, equipment: EquipmentHandler, **kwargs: object
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(
+        self, params: IdentifyModuleParams
+    ) -> SuccessData[IdentifyModuleResult]:
+        """Execute the IdentifyModule command."""
+        # ONLY flex stacker has support for identify module command...for now
+        if params.model == ModuleModel.FLEX_STACKER_MODULE_V1:
+            module_substate = self._state_view.modules.get_flex_stacker_substate(
+                module_id=params.moduleId
+            )
+            module_hw = self._equipment.get_module_hardware_api(
+                module_substate.module_id
+            )
+            if module_hw is not None:
+                await module_hw.identify(params.start, params.color)
+        else:
+            raise NotImplementedError(
+                f"IdentifyModule is not supported for {params.model}"
+            )
+
+        return SuccessData(public=IdentifyModuleResult())
+
+
+class IdentifyModule(
+    BaseCommand[IdentifyModuleParams, IdentifyModuleResult, ErrorOccurrence]
+):
+    """A command to identify a module."""
+
+    commandType: IdentifyModuleCommandType = "identifyModule"
+    params: IdentifyModuleParams
+    result: Optional[IdentifyModuleResult] = None
+
+    _ImplementationCls: Type[IdentifyModuleImpl] = IdentifyModuleImpl
+
+
+class IdentifyModuleCreate(BaseCommandCreate[IdentifyModuleParams]):
+    """A request to execute an IdentifyModule command."""
+
+    commandType: IdentifyModuleCommandType = "identifyModule"
+    params: IdentifyModuleParams
+
+    _CommandCls: Type[IdentifyModule] = IdentifyModule

opentrons/protocol_engine/commands/labware_handling_common.py

@@ -0,0 +1,29 @@
+"""Helpers for commands that alter the position of labware."""
+
+from pydantic import BaseModel, Field
+
+from ..types import LabwareLocationSequence
+
+
+class LabwareHandlingResultMixin(BaseModel):
+    """A result for commands that create a labware entity."""
+
+    labwareId: str = Field(..., description="The id of the labware.")
+    locationSequence: LabwareLocationSequence | None = Field(
+        None,
+        description=(
+            "The full location down to the deck on which this labware exists."
+            " The reason this can be `null` or omitted is just backwards compatibility,"
+            " for older runs and analyses. This should always be present"
+            " for new runs and analyses, even for labware whose location is off-deck."
+        ),
+    )
+
+
+class LabwarePositionResultMixin(LabwareHandlingResultMixin):
+    """A result for commands that create an offsetable labware entity."""
+
+    offsetId: str | None = Field(
+        None,
+        description="An ID referencing the labware offset that will apply to this labware in this location.",
+    )