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

opentrons/protocol_engine/commands/aspirate_while_tracking.py

@@ -13,7 +13,7 @@ from .pipetting_common import (
     aspirate_while_tracking,
 )
 from .movement_common import (
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
     DestinationPositionResult,
     StallOrCollisionError,
     move_to_well,
@@ -45,7 +45,7 @@ class AspirateWhileTrackingParams(
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
 ):
     """Parameters required to aspirate from a specific well."""
 
@@ -107,14 +107,20 @@ class AspirateWhileTrackingImplementation(
             )
         state_update = StateUpdate()
 
+        end_point = self._state_view.geometry.get_well_position(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.trackToLocation,
+            operation_volume=-params.volume,
+            pipette_id=params.pipetteId,
+        )
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
-            well_location=params.wellLocation,
-            operation_volume=-params.volume,
+            well_location=params.trackFromLocation,
         )
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):
@@ -128,6 +134,7 @@ class AspirateWhileTrackingImplementation(
             well_name=params.wellName,
             volume=params.volume,
             flow_rate=params.flowRate,
+            end_point=end_point,
             location_if_error={
                 "retryLocation": (
                     move_result.public.position.x,
@@ -138,7 +145,48 @@ class AspirateWhileTrackingImplementation(
             command_note_adder=self._command_note_adder,
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            movement_delay=params.movement_delay,
         )
+        if isinstance(aspirate_result, DefinedErrorData):
+            if isinstance(aspirate_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=aspirate_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+            elif isinstance(aspirate_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=aspirate_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+
         position_after_aspirate = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -147,21 +195,6 @@ class AspirateWhileTrackingImplementation(
             y=position_after_aspirate.y,
             z=position_after_aspirate.z,
         )
-        if isinstance(aspirate_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=aspirate_result.public,
-                state_update=aspirate_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=AspirateWhileTrackingResult(
                 volume=aspirate_result.public.volume,

opentrons/protocol_engine/commands/capture_image.py

@@ -0,0 +1,302 @@
+"""Command models to capture an image with a camera."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING, Tuple, Any
+from datetime import datetime
+
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons_shared_data.data_files import MimeType
+from opentrons.system.camera import (
+    CONTRAST_DEFAULT,
+    BRIGHTNESS_DEFAULT,
+    SATURATION_DEFAULT,
+    ZOOM_MIN,
+    ZOOM_MAX,
+    ZOOM_DEFAULT,
+    RESOLUTION_MIN,
+    RESOLUTION_MAX,
+    RESOLUTION_DEFAULT,
+)
+from ..types import PreconditionTypes
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors import (
+    CameraDisabledError,
+    CameraSettingsInvalidError,
+    FileNameInvalidError,
+)
+from ..errors.error_occurrence import ErrorOccurrence
+
+from ..resources.file_provider import (
+    ImageCaptureCmdFileNameMetadata,
+)
+from ..resources import FileProvider
+from ..resources.file_provider import SPECIAL_CHARACTERS
+from ..resources import CameraProvider
+from ..resources.camera_provider import ImageParameters
+from ..state import update_types
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+CaptureImageCommandType = Literal["captureImage"]
+
+
+class CaptureImageParams(BaseModel):
+    """Input parameters for an image capture."""
+
+    fileName: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Optional file name to use when storing the results of an Image Capture.",
+        json_schema_extra=_remove_default,
+    )
+    resolution: Optional[Tuple[int, int]] = Field(
+        None,
+        description="Width by height resolution in pixels for the image to be captured with.",
+    )
+    zoom: Optional[float] = Field(
+        None,
+        description="Multiplier to use when cropping and scaling a captured image. Scale is 1.0 to 2.0.",
+    )
+    pan: Optional[Tuple[int, int]] = Field(
+        None,
+        description="X/Y (pixels) position to pan to for a given zoom. Default is the center of the image.",
+    )
+    contrast: Optional[float] = Field(
+        None,
+        description="The contrast to use when processing an image. Scale is 0% to 100%.",
+    )
+    brightness: Optional[float] = Field(
+        None,
+        description="The brightness to use when processing an image. Scale is 0% to 100%.",
+    )
+    saturation: Optional[float] = Field(
+        None,
+        description="The saturation to use when processing an image. Scale is 0% to 100%.",
+    )
+
+
+class CaptureImageResult(BaseModel):
+    """Result data from running an image capture."""
+
+    fileId: Optional[str] = Field(
+        None,
+        description="File ID for image files output as a result of an image capture action.",
+    )
+    resolution: Tuple[int, int] = Field(
+        ...,
+        description="Width by height resolution in pixels the image was captured with.",
+    )
+    zoom: float = Field(
+        ...,
+        description="Multiplier used when cropping and scaling the captured image. Scale is 1.0 to 2.0.",
+    )
+    pan: Optional[Tuple[int, int]] = Field(
+        None,
+        description="X/Y (pixels) position panned to.",
+    )
+    contrast: float = Field(
+        ...,
+        description="The contrast used when processing the image. Scale is 0% to 100%.",
+    )
+    brightness: float = Field(
+        ...,
+        description="The brightness used when processing the image. Scale is 0% to 100%.",
+    )
+    saturation: float = Field(
+        ...,
+        description="The saturation used when processing the image. Scale is 0% to 100%.",
+    )
+
+
+def _converted_image_params(params: CaptureImageParams) -> ImageParameters:
+    return ImageParameters(
+        resolution=params.resolution,
+        zoom=params.zoom,
+        pan=params.pan,
+        contrast=(
+            (params.contrast / 100) * 2.0 if params.contrast is not None else None
+        ),
+        brightness=(
+            int(((params.brightness * 256) // 100) - 128) * -1
+            if params.brightness is not None
+            else None
+        ),
+        saturation=(
+            (params.saturation / 100) * 2.0 if params.saturation is not None else None
+        ),
+    )
+
+
+def _revert_image_parameters(
+    file_id: Optional[str], image_params: ImageParameters
+) -> CaptureImageResult:
+    contrast = (
+        image_params.contrast if image_params.contrast is not None else CONTRAST_DEFAULT
+    )
+    brightness = (
+        image_params.brightness
+        if image_params.brightness is not None
+        else BRIGHTNESS_DEFAULT
+    )
+    saturation = (
+        image_params.saturation
+        if image_params.saturation is not None
+        else SATURATION_DEFAULT
+    )
+    # todo (chb, 2025-10-29): Eventually we will have override defaults that can be passed into the Camera state, load those if they exist
+
+    return CaptureImageResult(
+        fileId=file_id,
+        resolution=image_params.resolution
+        if image_params.resolution is not None
+        else RESOLUTION_DEFAULT,
+        zoom=image_params.zoom if image_params.zoom is not None else ZOOM_DEFAULT,
+        pan=image_params.pan,
+        contrast=(contrast / 2) * 100.0,
+        brightness=round((((brightness * -1) + 128) * 100) / 256),
+        saturation=(saturation / 2) * 100.0,
+    )
+
+
+def _validate_image_params(params: CaptureImageParams) -> None:
+    # Validate the filename param provided to fail analysis
+    if params.fileName is not None and set(SPECIAL_CHARACTERS).intersection(
+        set(params.fileName)
+    ):
+        raise FileNameInvalidError(
+            message=f"Capture image filename cannot contain character(s): {SPECIAL_CHARACTERS.intersection(set(params.fileName))}"
+        )
+
+    # Validate the image filter parameters
+    if params.zoom is not None and (params.zoom < ZOOM_MIN or params.zoom > ZOOM_MAX):
+        raise CameraSettingsInvalidError(
+            message="Capture image zoom must be a valid value from 1.0X to 2.0X zoom."
+        )
+    if params.resolution is not None and (
+        params.resolution[0] < RESOLUTION_MIN[0]
+        or params.resolution[1] < RESOLUTION_MIN[1]
+        or params.resolution[0] > RESOLUTION_MAX[0]
+        or params.resolution[1] > RESOLUTION_MAX[1]
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image resolution must be a valid resolution from 240p through 8K resolutuon."
+        )
+    if params.brightness is not None and (
+        params.brightness < 0 or params.brightness > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image brightness must be a percentage from 0% to 100%."
+        )
+    if params.contrast is not None and (params.contrast < 0 or params.contrast > 100):
+        raise CameraSettingsInvalidError(
+            message="Capture image contrast must be a percentage from 0% to 100%."
+        )
+    if params.saturation is not None and (
+        params.saturation < 0 or params.saturation > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image saturation must be a percentage from 0% to 100%."
+        )
+
+
+class CaptureImageImpl(
+    AbstractCommandImpl[CaptureImageParams, SuccessData[CaptureImageResult]]
+):
+    """Execution implementation of an image capture."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        file_provider: FileProvider,
+        camera_provider: CameraProvider,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._file_provider = file_provider
+        self._camera_provider = camera_provider
+
+    async def execute(
+        self, params: CaptureImageParams
+    ) -> SuccessData[CaptureImageResult]:
+        """Initiate an image capture with a camera."""
+        state_update = update_types.StateUpdate()
+        state_update.precondition_update = update_types.PreconditionUpdate(
+            {PreconditionTypes.IS_CAMERA_USED: True}
+        )
+
+        # Validate that the provided parameters are all acceptable. We do this here and in system/camera.py to ensure analysis fails properly.
+        _validate_image_params(params)
+
+        # Handle capturing an image with the CameraProvider - Engine camera settings take priority
+        camera_settings = await self._camera_provider.get_camera_settings()
+        engine_camera_settings = self._state_view.camera.get_enablement_settings()
+        if (
+            engine_camera_settings is None and camera_settings.cameraEnabled is False
+        ) or (
+            engine_camera_settings is not None
+            and engine_camera_settings.cameraEnabled is False
+        ):
+            raise CameraDisabledError(
+                "Cannot capture image because Camera is disabled."
+            )
+
+        parameters = _converted_image_params(params=params)
+        camera_data = await self._camera_provider.capture_image(
+            self._state_view.config.robot_type, parameters
+        )
+
+        # Conditionally save file if camera data was returned - in simulation we don't return anything.
+        file_id: str | None = None
+        if camera_data:
+            this_cmd_id = self._state_view.commands.get_running_command_id()
+            prev_cmd = self._state_view.commands.get_most_recently_finalized_command()
+            prev_cmd_id = prev_cmd.command.id if prev_cmd is not None else None
+
+            file_info = await self._file_provider.write_file(
+                data=camera_data,
+                mime_type=MimeType.IMAGE_JPEG,
+                command_metadata=ImageCaptureCmdFileNameMetadata(
+                    step_number=len(self._state_view.commands.get_all()),
+                    command_timestamp=datetime.now(),
+                    base_filename=params.fileName,
+                    command_id=this_cmd_id or "",
+                    prev_command_id=prev_cmd_id or "",
+                ),
+            )
+            file_id = file_info.id
+            state_update.files_added = update_types.FilesAddedUpdate(file_ids=[file_id])
+
+        result = _revert_image_parameters(file_id=file_id, image_params=parameters)
+
+        return SuccessData(
+            public=result,
+            state_update=state_update,
+        )
+
+
+class CaptureImage(
+    BaseCommand[CaptureImageParams, CaptureImageResult, ErrorOccurrence]
+):
+    """A command to execute an Absorbance Reader measurement."""
+
+    commandType: CaptureImageCommandType = "captureImage"
+    params: CaptureImageParams
+    result: Optional[CaptureImageResult] = None
+
+    _ImplementationCls: Type[CaptureImageImpl] = CaptureImageImpl
+
+
+class CaptureImageCreate(BaseCommandCreate[CaptureImageParams]):
+    """A request to execute an Absorbance Reader measurement."""
+
+    commandType: CaptureImageCommandType = "captureImage"
+    params: CaptureImageParams
+
+    _CommandCls: Type[CaptureImage] = CaptureImage

opentrons/protocol_engine/commands/command.py

@@ -178,6 +178,7 @@ class AbstractCommandImpl(
         hardware_api: HardwareControlAPI,
         equipment: execution.EquipmentHandler,
         file_provider: execution.FileProvider,
+        camera_provider: execution.CameraProvider,
         movement: execution.MovementHandler,
         gantry_mover: execution.GantryMover,
         labware_movement: execution.LabwareMovementHandler,
@@ -185,6 +186,7 @@ class AbstractCommandImpl(
         tip_handler: execution.TipHandler,
         run_control: execution.RunControlHandler,
         rail_lights: execution.RailLightsHandler,
+        task_handler: execution.TaskHandler,
         model_utils: ModelUtils,
         status_bar: execution.StatusBarHandler,
         command_note_adder: CommandNoteAdder,

opentrons/protocol_engine/commands/command_unions.py

@@ -267,6 +267,22 @@ from .wait_for_duration import (
     WaitForDurationCommandType,
 )
 
+from .create_timer import (
+    CreateTimer,
+    CreateTimerCreate,
+    CreateTimerParams,
+    CreateTimerResult,
+    CreateTimerCommandType,
+)
+
+from .wait_for_tasks import (
+    WaitForTasks,
+    WaitForTasksCreate,
+    WaitForTasksParams,
+    WaitForTasksResult,
+    WaitForTasksCommandType,
+)
+
 from .pick_up_tip import (
     PickUpTip,
     PickUpTipParams,
@@ -372,6 +388,14 @@ from .get_next_tip import (
     GetNextTipCommandType,
 )
 
+from .set_tip_state import (
+    SetTipState,
+    SetTipStateCreate,
+    SetTipStateParams,
+    SetTipStateResult,
+    SetTipStateCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -417,6 +441,14 @@ from .identify_module import (
     IdentifyModuleCommandType,
 )
 
+from .capture_image import (
+    CaptureImage,
+    CaptureImageParams,
+    CaptureImageCreate,
+    CaptureImageResult,
+    CaptureImageCommandType,
+)
+
 Command = Annotated[
     Union[
         AirGapInPlace,
@@ -454,6 +486,8 @@ Command = Annotated[
         PrepareToAspirate,
         WaitForResume,
         WaitForDuration,
+        WaitForTasks,
+        CreateTimer,
         PickUpTip,
         SavePosition,
         SetRailLights,
@@ -462,15 +496,18 @@ Command = Annotated[
         VerifyTipPresence,
         GetTipPresence,
         GetNextTip,
+        SetTipState,
         LiquidProbe,
         TryLiquidProbe,
         SealPipetteToTip,
         PressureDispense,
         UnsealPipetteFromTip,
+        CaptureImage,
         heater_shaker.WaitForTemperature,
         heater_shaker.SetTargetTemperature,
         heater_shaker.DeactivateHeater,
         heater_shaker.SetAndWaitForShakeSpeed,
+        heater_shaker.SetShakeSpeed,
         heater_shaker.DeactivateShaker,
         heater_shaker.OpenLabwareLatch,
         heater_shaker.CloseLabwareLatch,
@@ -488,6 +525,7 @@ Command = Annotated[
         thermocycler.OpenLid,
         thermocycler.CloseLid,
         thermocycler.RunProfile,
+        thermocycler.StartRunExtendedProfile,
         thermocycler.RunExtendedProfile,
         absorbance_reader.CloseLid,
         absorbance_reader.OpenLid,
@@ -557,6 +595,8 @@ CommandParams = Union[
     PrepareToAspirateParams,
     WaitForResumeParams,
     WaitForDurationParams,
+    WaitForTasksParams,
+    CreateTimerParams,
     PickUpTipParams,
     SavePositionParams,
     SetRailLightsParams,
@@ -565,15 +605,18 @@ CommandParams = Union[
     VerifyTipPresenceParams,
     GetTipPresenceParams,
     GetNextTipParams,
+    SetTipStateParams,
     LiquidProbeParams,
     TryLiquidProbeParams,
     SealPipetteToTipParams,
     PressureDispenseParams,
     UnsealPipetteFromTipParams,
+    CaptureImageParams,
     heater_shaker.WaitForTemperatureParams,
     heater_shaker.SetTargetTemperatureParams,
     heater_shaker.DeactivateHeaterParams,
     heater_shaker.SetAndWaitForShakeSpeedParams,
+    heater_shaker.SetShakeSpeedParams,
     heater_shaker.DeactivateShakerParams,
     heater_shaker.OpenLabwareLatchParams,
     heater_shaker.CloseLabwareLatchParams,
@@ -591,6 +634,7 @@ CommandParams = Union[
     thermocycler.OpenLidParams,
     thermocycler.CloseLidParams,
     thermocycler.RunProfileParams,
+    thermocycler.StartRunExtendedProfileParams,
     thermocycler.RunExtendedProfileParams,
     absorbance_reader.CloseLidParams,
     absorbance_reader.OpenLidParams,
@@ -658,6 +702,8 @@ CommandType = Union[
     PrepareToAspirateCommandType,
     WaitForResumeCommandType,
     WaitForDurationCommandType,
+    WaitForTasksCommandType,
+    CreateTimerCommandType,
     PickUpTipCommandType,
     SavePositionCommandType,
     SetRailLightsCommandType,
@@ -666,15 +712,18 @@ CommandType = Union[
     VerifyTipPresenceCommandType,
     GetTipPresenceCommandType,
     GetNextTipCommandType,
+    SetTipStateCommandType,
     LiquidProbeCommandType,
     TryLiquidProbeCommandType,
     SealPipetteToTipCommandType,
     PressureDispenseCommandType,
     UnsealPipetteFromTipCommandType,
+    CaptureImageCommandType,
     heater_shaker.WaitForTemperatureCommandType,
     heater_shaker.SetTargetTemperatureCommandType,
     heater_shaker.DeactivateHeaterCommandType,
     heater_shaker.SetAndWaitForShakeSpeedCommandType,
+    heater_shaker.SetShakeSpeedCommandType,
     heater_shaker.DeactivateShakerCommandType,
     heater_shaker.OpenLabwareLatchCommandType,
     heater_shaker.CloseLabwareLatchCommandType,
@@ -692,6 +741,7 @@ CommandType = Union[
     thermocycler.OpenLidCommandType,
     thermocycler.CloseLidCommandType,
     thermocycler.RunProfileCommandType,
+    thermocycler.StartRunExtendedProfileCommandType,
     thermocycler.RunExtendedProfileCommandType,
     absorbance_reader.CloseLidCommandType,
     absorbance_reader.OpenLidCommandType,
@@ -760,6 +810,8 @@ CommandCreate = Annotated[
         PrepareToAspirateCreate,
         WaitForResumeCreate,
         WaitForDurationCreate,
+        WaitForTasksCreate,
+        CreateTimerCreate,
         PickUpTipCreate,
         SavePositionCreate,
         SetRailLightsCreate,
@@ -768,15 +820,18 @@ CommandCreate = Annotated[
         VerifyTipPresenceCreate,
         GetTipPresenceCreate,
         GetNextTipCreate,
+        SetTipStateCreate,
         LiquidProbeCreate,
         TryLiquidProbeCreate,
         SealPipetteToTipCreate,
         PressureDispenseCreate,
         UnsealPipetteFromTipCreate,
+        CaptureImageCreate,
         heater_shaker.WaitForTemperatureCreate,
         heater_shaker.SetTargetTemperatureCreate,
         heater_shaker.DeactivateHeaterCreate,
         heater_shaker.SetAndWaitForShakeSpeedCreate,
+        heater_shaker.SetShakeSpeedCreate,
         heater_shaker.DeactivateShakerCreate,
         heater_shaker.OpenLabwareLatchCreate,
         heater_shaker.CloseLabwareLatchCreate,
@@ -794,6 +849,7 @@ CommandCreate = Annotated[
         thermocycler.OpenLidCreate,
         thermocycler.CloseLidCreate,
         thermocycler.RunProfileCreate,
+        thermocycler.StartRunExtendedProfileCreate,
         thermocycler.RunExtendedProfileCreate,
         absorbance_reader.CloseLidCreate,
         absorbance_reader.OpenLidCreate,
@@ -870,6 +926,8 @@ CommandResult = Union[
     PrepareToAspirateResult,
     WaitForResumeResult,
     WaitForDurationResult,
+    WaitForTasksResult,
+    CreateTimerResult,
     PickUpTipResult,
     SavePositionResult,
     SetRailLightsResult,
@@ -878,15 +936,18 @@ CommandResult = Union[
     VerifyTipPresenceResult,
     GetTipPresenceResult,
     GetNextTipResult,
+    SetTipStateResult,
     LiquidProbeResult,
     TryLiquidProbeResult,
     SealPipetteToTipResult,
     PressureDispenseResult,
     UnsealPipetteFromTipResult,
+    CaptureImageResult,
     heater_shaker.WaitForTemperatureResult,
     heater_shaker.SetTargetTemperatureResult,
     heater_shaker.DeactivateHeaterResult,
     heater_shaker.SetAndWaitForShakeSpeedResult,
+    heater_shaker.SetShakeSpeedResult,
     heater_shaker.DeactivateShakerResult,
     heater_shaker.OpenLabwareLatchResult,
     heater_shaker.CloseLabwareLatchResult,
@@ -904,6 +965,7 @@ CommandResult = Union[
     thermocycler.OpenLidResult,
     thermocycler.CloseLidResult,
     thermocycler.RunProfileResult,
+    thermocycler.StartRunExtendedProfileResult,
     thermocycler.RunExtendedProfileResult,
     absorbance_reader.CloseLidResult,
     absorbance_reader.OpenLidResult,