opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_engine/commands/thermocycler/set_target_lid_temperature.py

@@ -1,26 +1,35 @@
-"""Command models to start heating a Thermocycler's lid."""
+"""Command models for heating a Thermocycler's lid."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
+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
-
+    from opentrons.protocol_engine.execution import EquipmentHandler, TaskHandler
 
 SetTargetLidTemperatureCommandType = Literal["thermocycler/setTargetLidTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class SetTargetLidTemperatureParams(BaseModel):
-    """Input parameters to set a Thermocycler's target lid temperature."""
+    """Input parameters to  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.")
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Id for the background task that manages the temperature.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetLidTemperatureResult(BaseModel):
@@ -30,29 +39,37 @@ class SetTargetLidTemperatureResult(BaseModel):
         ...,
         description="The target lid temperature that was set after validation.",
     )
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="The task id for the setTargetBlockTemperature",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetLidTemperatureImpl(
     AbstractCommandImpl[
-        SetTargetLidTemperatureParams, SuccessData[SetTargetLidTemperatureResult]
+        SetTargetLidTemperatureParams,
+        SuccessData[SetTargetLidTemperatureResult],
     ]
 ):
-    """Execution implementation of a Thermocycler's set lid temperature command."""
+    """Execution implementation of a Thermocycler's  to set lid temperature command."""
 
     def __init__(
         self,
         state_view: StateView,
         equipment: EquipmentHandler,
+        task_handler: TaskHandler,
         **unused_dependencies: object,
     ) -> None:
         self._state_view = state_view
         self._equipment = equipment
+        self._task_handler = task_handler
 
     async def execute(
         self,
         params: SetTargetLidTemperatureParams,
     ) -> SuccessData[SetTargetLidTemperatureResult]:
-        """Set a Thermocycler's target lid temperature."""
+        """To set a Thermocycler's target lid temperature."""
         thermocycler_state = self._state_view.modules.get_thermocycler_module_substate(
             params.moduleId
         )
@@ -63,22 +80,34 @@ class SetTargetLidTemperatureImpl(
             thermocycler_state.module_id
         )
 
-        if thermocycler_hardware is not None:
-            await thermocycler_hardware.set_target_lid_temperature(target_temperature)
-
+        async def set_target_lid_temperature(task_handler: TaskHandler) -> None:
+            if thermocycler_hardware is not None:
+                async with task_handler.synchronize_cancel_latest(
+                    thermocycler_state.module_id + "-lid"
+                ):
+                    await thermocycler_hardware.set_target_lid_temperature(
+                        target_temperature
+                    )
+                    await thermocycler_hardware.wait_for_lid_target()
+
+        task = await self._task_handler.create_task(
+            task_function=set_target_lid_temperature, id=params.taskId
+        )
         return SuccessData(
             public=SetTargetLidTemperatureResult(
-                targetLidTemperature=target_temperature
+                targetLidTemperature=target_temperature, taskId=task.id
             ),
         )
 
 
 class SetTargetLidTemperature(
     BaseCommand[
-        SetTargetLidTemperatureParams, SetTargetLidTemperatureResult, ErrorOccurrence
+        SetTargetLidTemperatureParams,
+        SetTargetLidTemperatureResult,
+        ErrorOccurrence,
     ]
 ):
-    """A command to set a Thermocycler's target lid temperature."""
+    """A command to  to set a Thermocycler's target lid temperature."""
 
     commandType: SetTargetLidTemperatureCommandType = (
         "thermocycler/setTargetLidTemperature"

opentrons/protocol_engine/commands/thermocycler/start_run_extended_profile.py

@@ -0,0 +1,191 @@
+"""StartRunProfile command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import List, Optional, TYPE_CHECKING, overload, Union, Any
+from typing_extensions import Literal, Type
+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
+from .run_extended_profile import ProfileStep, ProfileCycle
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import (
+        TaskHandler,
+        EquipmentHandler,
+    )
+    from opentrons.protocol_engine.state.module_substates.thermocycler_module_substate import (
+        ThermocyclerModuleSubState,
+    )
+
+StartRunExtendedProfileCommandType = Literal["thermocycler/startRunExtendedProfile"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class StartRunExtendedProfileStepParams(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."
+    )
+    rampRate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="How quickly to change temperature in °C/second.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class StartRunExtendedProfileParams(BaseModel):
+    """Input parameters to run a Thermocycler profile."""
+
+    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,
+    )
+    taskId: str | None = Field(None, description="The id of the profile task")
+
+
+class StartRunExtendedProfileResult(BaseModel):
+    """Result data from running a Thermocycler profile."""
+
+    taskId: str = Field(..., description="The id of the profile task")
+
+
+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,
+        ramp_rate=thermocycler_state.validate_ramp_rate(step.rampRate, step.celsius),
+    )
+
+
+@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 StartRunExtendedProfileImpl(
+    AbstractCommandImpl[
+        StartRunExtendedProfileParams, SuccessData[StartRunExtendedProfileResult]
+    ]
+):
+    """Execution implementation of a Thermocycler's run profile command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        task_handler: TaskHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._task_handler = task_handler
+
+    async def execute(
+        self, params: StartRunExtendedProfileParams
+    ) -> SuccessData[StartRunExtendedProfileResult]:
+        """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
+
+        async def start_run_profile(task_handler: TaskHandler) -> None:
+            if thermocycler_hardware is not None:
+                async with task_handler.synchronize_cancel_latest(
+                    thermocycler_state.module_id + "-block"
+                ):
+                    await thermocycler_hardware.execute_profile(
+                        profile=profile, volume=target_volume
+                    )
+
+        task = await self._task_handler.create_task(
+            task_function=start_run_profile, id=params.taskId
+        )
+
+        return SuccessData(
+            public=StartRunExtendedProfileResult(taskId=task.id),
+        )
+
+
+class StartRunExtendedProfile(
+    BaseCommand[
+        StartRunExtendedProfileParams, StartRunExtendedProfileResult, ErrorOccurrence
+    ]
+):
+    """A command to start the execution of a Thermocycler profile run without waiting for its completion."""
+
+    commandType: StartRunExtendedProfileCommandType = (
+        "thermocycler/startRunExtendedProfile"
+    )
+    params: StartRunExtendedProfileParams
+
+    _ImplementationCls: Type[StartRunExtendedProfileImpl] = StartRunExtendedProfileImpl
+
+
+class StartRunExtendedProfileCreate(BaseCommandCreate[StartRunExtendedProfileParams]):
+    """A request to execute a Thermocycler profile run."""
+
+    commandType: StartRunExtendedProfileCommandType = (
+        "thermocycler/startRunExtendedProfile"
+    )
+    params: StartRunExtendedProfileParams
+
+    _CommandCls: Type[StartRunExtendedProfile] = StartRunExtendedProfile

opentrons/protocol_engine/commands/touch_tip.py

@@ -114,7 +114,7 @@ class TouchTipImplementation(
 
         if self._state_view.labware.get_has_quirk(labware_id, "touchTipDisabled"):
             raise TouchTipDisabledError(
-                f"Touch tip not allowed on labware {labware_id}"
+                f"Touch tip not allowed on labware {self._state_view.labware.get_display_name(labware_id)}"
             )
 
         if self._state_view.labware.is_tiprack(labware_id):

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -14,12 +14,11 @@ from opentrons.protocol_engine.errors.exceptions import (
     CannotPerformGripperAction,
     GripperNotAttachedError,
 )
-from opentrons.types import Point
-
 from ...types import (
     DeckSlotLocation,
     ModuleModel,
     OnDeckLabwareLocation,
+    GripperMoveType,
 )
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
@@ -100,22 +99,6 @@ class UnsafePlaceLabwareImplementation(
             LabwareUri(params.labwareURI)
         )
 
-        # todo(mm, 2024-11-06): This is only correct in the special case of an
-        # absorbance reader lid. Its definition currently puts the offsets for *itself*
-        # in the property that's normally meant for offsets for its *children.*
-        final_offsets = self._state_view.labware.get_child_gripper_offsets(
-            labware_definition=definition, slot_name=None
-        )
-        drop_offset = (
-            Point(
-                final_offsets.dropOffset.x,
-                final_offsets.dropOffset.y,
-                final_offsets.dropOffset.z,
-            )
-            if final_offsets
-            else None
-        )
-
         if isinstance(params.location, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.location.slotName.id
@@ -139,7 +122,7 @@ class UnsafePlaceLabwareImplementation(
         await ot3api.update_axis_position_estimations([Axis.X, Axis.Y])
 
         # Place the labware down
-        await self._start_movement(ot3api, definition, location, drop_offset)
+        await self._start_movement(ot3api, definition, location)
 
         return SuccessData(public=UnsafePlaceLabwareResult())
 
@@ -148,7 +131,6 @@ class UnsafePlaceLabwareImplementation(
         ot3api: OT3HardwareControlAPI,
         labware_definition: LabwareDefinition,
         location: OnDeckLabwareLocation,
-        drop_offset: Optional[Point],
     ) -> None:
         gripper_homed_position = await ot3api.gantry_position(
             mount=OT3Mount.GRIPPER,
@@ -156,13 +138,15 @@ class UnsafePlaceLabwareImplementation(
         )
 
         to_labware_center = self._state_view.geometry.get_labware_grip_point(
-            labware_definition=labware_definition, location=location
+            labware_definition=labware_definition,
+            location=location,
+            move_type=GripperMoveType.DROP_LABWARE,
+            user_additional_offset=None,
         )
 
         movement_waypoints = get_gripper_labware_placement_waypoints(
             to_labware_center=to_labware_center,
             gripper_home_z=gripper_homed_position.z,
-            drop_offset=drop_offset,
         )
 
         # start movement

opentrons/protocol_engine/commands/wait_for_tasks.py

@@ -0,0 +1,98 @@
+"""WaitForTasks command request, result, and implementation models."""
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import Optional, Type, TYPE_CHECKING
+from typing_extensions import Literal
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
+from ..errors.exceptions import TaskFailedError
+
+if TYPE_CHECKING:
+    from ..execution import TaskHandler, RunControlHandler
+    from ..state.state import StateView
+
+
+WaitForTasksCommandType = Literal["waitForTasks"]
+
+
+class WaitForTasksParams(BaseModel):
+    """Payload required to annotate execution with a WaitForTasks."""
+
+    task_ids: list[str] = Field(
+        ...,
+        description="The list of task ids to wait for.",
+    )
+
+
+class WaitForTasksResult(BaseModel):
+    """Result data from the execution of a WaitForTasks command."""
+
+    task_ids: list[str] = Field(
+        ...,
+        description="The list of completed task ids.",
+    )
+
+
+class WaitForTasksImplementation(
+    AbstractCommandImpl[WaitForTasksParams, SuccessData[WaitForTasksResult]]
+):
+    """WaitForTasks command implementation."""
+
+    def __init__(
+        self,
+        task_handler: TaskHandler,
+        run_control: RunControlHandler,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._task_handler = task_handler
+        self._run_control = run_control
+        self._state_view = state_view
+
+    async def execute(
+        self, params: WaitForTasksParams
+    ) -> SuccessData[WaitForTasksResult]:
+        """Checks for existance of task id and then asynchronously waits for the valid, specified tasks to finish."""
+        # Raises the exception if we don't have a valid task id.
+        for task_id in params.task_ids:
+            _ = self._state_view.tasks.get(task_id)
+
+        await self._run_control.wait_for_tasks(params.task_ids)
+
+        failed_tasks = self._state_view.tasks.get_failed_tasks(params.task_ids)
+        if failed_tasks:
+            raise TaskFailedError(
+                message=f"{len(failed_tasks)} tasks failed.",
+                details={"failed_task_ids": failed_tasks},
+                wrapping=[
+                    ProtocolCommandFailedError(
+                        original_error=self._state_view.tasks.get_finished(
+                            task_id
+                        ).error
+                    )
+                    for task_id in failed_tasks
+                ],
+            )
+        return SuccessData(public=WaitForTasksResult(task_ids=params.task_ids))
+
+
+class WaitForTasks(
+    BaseCommand[WaitForTasksParams, WaitForTasksResult, ErrorOccurrence]
+):
+    """WaitForTasks command model."""
+
+    commandType: WaitForTasksCommandType = "waitForTasks"
+    params: WaitForTasksParams
+    result: Optional[WaitForTasksResult] = None
+
+    _ImplementationCls: Type[WaitForTasksImplementation] = WaitForTasksImplementation
+
+
+class WaitForTasksCreate(BaseCommandCreate[WaitForTasksParams]):
+    """WaitForTasks command request model."""
+
+    commandType: WaitForTasksCommandType = "waitForTasks"
+    params: WaitForTasksParams
+
+    _CommandCls: Type[WaitForTasks] = WaitForTasks

opentrons/protocol_engine/create_protocol_engine.py

@@ -11,6 +11,7 @@ from opentrons.protocol_engine.execution.error_recovery_hardware_state_synchroni
 from opentrons.protocol_engine.resources.labware_data_provider import (
     LabwareDataProvider,
 )
+from opentrons.protocol_engine.resources.camera_provider import CameraProvider
 from opentrons.util.async_helpers import async_context_manager_in_thread
 
 from opentrons_shared_data.robot import load as load_robot
@@ -38,6 +39,7 @@ async def create_protocol_engine(
     load_fixed_trash: bool = False,
     deck_configuration: typing.Optional[DeckConfigurationType] = None,
     file_provider: typing.Optional[FileProvider] = None,
+    camera_provider: typing.Optional[CameraProvider] = None,
     notify_publishers: typing.Optional[typing.Callable[[], None]] = None,
 ) -> ProtocolEngine:
     """Create a ProtocolEngine instance.
@@ -50,6 +52,7 @@ async def create_protocol_engine(
         load_fixed_trash: Automatically load fixed trash labware in engine.
         deck_configuration: The initial deck configuration the engine will be instantiated with.
         file_provider: Provides access to robot server file writing procedures for protocol output.
+        camera_provider: Provides access to camera interface with image capture and callbacks.
         notify_publishers: Notifies robot server publishers of internal state change.
     """
     deck_data = DeckDataProvider(config.deck_type)
@@ -83,6 +86,7 @@ async def create_protocol_engine(
     door_watcher = DoorWatcher(state_store, hardware_api, action_dispatcher)
     module_data_provider = ModuleDataProvider()
     file_provider = file_provider or FileProvider()
+    camera_provider = camera_provider or CameraProvider()
 
     pe = ProtocolEngine(
         hardware_api=hardware_api,
@@ -94,6 +98,7 @@ async def create_protocol_engine(
         door_watcher=door_watcher,
         module_data_provider=module_data_provider,
         file_provider=file_provider,
+        camera_provider=camera_provider,
     )
 
     # todo(mm, 2024-11-08): This is a quick hack to support the absorbance reader, which
@@ -121,6 +126,7 @@ def create_protocol_engine_in_thread(
     drop_tips_after_run: bool,
     post_run_hardware_state: PostRunHardwareState,
     load_fixed_trash: bool = False,
+    camera_provider: typing.Optional[CameraProvider] = None,
 ) -> typing.Generator[
     typing.Tuple[ProtocolEngine, asyncio.AbstractEventLoop], None, None
 ]:
@@ -151,6 +157,7 @@ def create_protocol_engine_in_thread(
             drop_tips_after_run,
             post_run_hardware_state,
             load_fixed_trash,
+            camera_provider,
         )
     ) as (
         protocol_engine,
@@ -169,6 +176,7 @@ async def _protocol_engine(
     drop_tips_after_run: bool,
     post_run_hardware_state: PostRunHardwareState,
     load_fixed_trash: bool = False,
+    camera_provider: typing.Optional[CameraProvider] = None,
 ) -> typing.AsyncGenerator[ProtocolEngine, None]:
     protocol_engine = await create_protocol_engine(
         hardware_api=hardware_api,
@@ -179,9 +187,13 @@ async def _protocol_engine(
     )
 
     # TODO(tz, 6-20-2024): This feels like a hack, we should probably return the orchestrator instead of pe.
+
     orchestrator = create_run_orchestrator(
         hardware_api=hardware_api,
         protocol_engine=protocol_engine,
+        camera_provider=camera_provider
+        if camera_provider is not None
+        else CameraProvider(),
     )
     try:
         orchestrator.play(deck_configuration)

opentrons/protocol_engine/engine_support.py

@@ -3,16 +3,19 @@ from . import ProtocolEngine
 from ..hardware_control import HardwareControlAPI
 
 from opentrons.protocol_runner import protocol_runner, RunOrchestrator
+from opentrons.protocol_engine.resources.camera_provider import CameraProvider
 
 
 def create_run_orchestrator(
     hardware_api: HardwareControlAPI,
     protocol_engine: ProtocolEngine,
+    camera_provider: CameraProvider,
 ) -> RunOrchestrator:
     """Create a RunOrchestrator instance."""
     return RunOrchestrator(
         protocol_engine=protocol_engine,
         hardware_api=hardware_api,
+        camera_provider=camera_provider,
         setup_runner=protocol_runner.LiveRunner(
             protocol_engine=protocol_engine,
             hardware_api=hardware_api,

opentrons/protocol_engine/errors/__init__.py

@@ -57,6 +57,7 @@ from .exceptions import (
     InvalidTargetSpeedError,
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
+    InvalidRampRateError,
     InvalidHoldTimeError,
     InvalidWavelengthError,
     CannotPerformModuleAction,
@@ -83,6 +84,7 @@ from .exceptions import (
     OperationLocationNotInWellError,
     InvalidDispenseVolumeError,
     StorageLimitReachedError,
+    FileNameInvalidError,
     InvalidLiquidError,
     LiquidClassDoesNotExistError,
     LiquidClassRedefinitionError,
@@ -90,6 +92,10 @@ from .exceptions import (
     FlexStackerLabwarePoolNotYetDefinedError,
     FlexStackerNotLogicallyEmptyError,
     InvalidLabwarePositionError,
+    InvalidModuleOrientation,
+    CameraCaptureError,
+    CameraDisabledError,
+    CameraSettingsInvalidError,
 )
 
 from .error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
@@ -151,6 +157,7 @@ __all__ = [
     "NoTargetTemperatureSetError",
     "InvalidTargetTemperatureError",
     "InvalidTargetSpeedError",
+    "InvalidRampRateError",
     "InvalidBlockVolumeError",
     "InvalidHoldTimeError",
     "InvalidLiquidError",
@@ -174,6 +181,7 @@ __all__ = [
     "FlexStackerLabwarePoolNotYetDefinedError",
     "FlexStackerNotLogicallyEmptyError",
     "InvalidLabwarePositionError",
+    "InvalidModuleOrientation",
     # error occurrence models
     "ErrorOccurrence",
     "CommandNotAllowedError",
@@ -186,6 +194,10 @@ __all__ = [
     "OperationLocationNotInWellError",
     "InvalidDispenseVolumeError",
     "StorageLimitReachedError",
+    "FileNameInvalidError",
     "LiquidClassDoesNotExistError",
     "LiquidClassRedefinitionError",
+    "CameraCaptureError",
+    "CameraDisabledError",
+    "CameraSettingsInvalidError",
 ]