opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -82,7 +82,7 @@ class SetTargetTemperatureImpl(
         async def start_set_temperature(task_handler: TaskHandler) -> None:
             if hs_hardware_module is not None:
                 async with task_handler.synchronize_cancel_previous(
-                    hs_module_substate.module_id
+                    hs_module_substate.module_id + "-temp"
                 ):
                     await hs_hardware_module.start_set_temperature(validated_temp)
                     await hs_hardware_module.await_temperature(validated_temp)

opentrons/protocol_engine/commands/move_labware.py

@@ -38,6 +38,7 @@ from ..types import (
     LabwareLocationSequence,
     NotOnDeckLocationSequenceComponent,
     OFF_DECK_LOCATION,
+    WASTE_CHUTE_LOCATION,
 )
 from ..errors import (
     LabwareMovementNotAllowedError,
@@ -228,9 +229,10 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 )
                 eventual_destination_location_sequence = [
                     NotOnDeckLocationSequenceComponent(
-                        logicalLocationName=OFF_DECK_LOCATION
+                        logicalLocationName=WASTE_CHUTE_LOCATION
                     )
                 ]
+
             elif fixture_validation.is_trash(area_name):
                 # When dropping labware in the trash bins we want to ensure they are lids
                 # and enforce a y-axis drop offset to ensure they fall within the trash bin
@@ -351,7 +353,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             validated_new_loc = self._state_view.geometry.ensure_valid_gripper_location(
                 available_new_location,
             )
-
             user_pick_up_offset = (
                 Point.from_xyz_attrs(params.pickUpOffset)
                 if params.pickUpOffset is not None
@@ -464,7 +465,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             new_location=available_new_location,
             new_offset_id=new_offset_id,
         )
-
         if labware_validation.validate_definition_is_lid(
             definition=self._state_view.labware.get_definition(params.labwareId)
         ):
@@ -498,7 +498,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                     parent_labware_ids=parent_updates,
                     lid_ids=lid_updates,
                 )
-
         return SuccessData(
             public=MoveLabwareResult(
                 offsetId=new_offset_id,

opentrons/protocol_engine/commands/move_to_addressable_area_for_drop_tip.py

@@ -85,7 +85,7 @@ class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
     ignoreTipConfiguration: bool | SkipJsonSchema[None] = Field(
         True,
         description=(
-            "Whether to utilize the critical point of the tip configuraiton when moving to an addressable area."
+            "Whether to utilize the critical point of the tip configuration when moving to an addressable area."
             " If True, this command will ignore the tip configuration and use the center of the entire instrument"
             " as the critical point for movement."
             " If False, this command will use the critical point provided by the current tip configuration."

opentrons/protocol_engine/commands/movement_common.py

@@ -48,8 +48,8 @@ class WellLocationMixin(BaseModel):
     )
 
 
-class LiquidHandlingWellLocationMixin(BaseModel):
-    """Mixin for command requests that take a location that's somewhere in a well."""
+class LiquidHandlingWellMixin(BaseModel):
+    """Base Mixin for command requests that take a well."""
 
     labwareId: str = Field(
         ...,
@@ -59,12 +59,39 @@ class LiquidHandlingWellLocationMixin(BaseModel):
         ...,
         description="Name of well to use in labware.",
     )
+
+
+class LiquidHandlingWellLocationMixin(LiquidHandlingWellMixin):
+    """Mixin for command requests that take a location that's somewhere in a well."""
+
     wellLocation: LiquidHandlingWellLocation = Field(
         default_factory=LiquidHandlingWellLocation,
         description="Relative well location at which to perform the operation",
     )
 
 
+class DynamicLiquidHandlingWellLocationMixin(LiquidHandlingWellMixin):
+    """Mixin for command requests that move between two locations in a well."""
+
+    trackFromLocation: LiquidHandlingWellLocation = Field(
+        default_factory=LiquidHandlingWellLocation,
+        description="Relative well location at which to start the operation",
+    )
+    trackToLocation: LiquidHandlingWellLocation = Field(
+        default_factory=LiquidHandlingWellLocation,
+        description="Relative well location at which to end the operation",
+    )
+    movement_delay: float | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "Optional movement delay in seconds."
+            " When this argument is used, the x/y/z movement will wait movement_delay seconds"
+            " after the pipetting action starts before beginning the x/y/z move."
+        ),
+        json_schema_extra=_remove_default,
+    )
+
+
 class MovementMixin(BaseModel):
     """Mixin for command requests that move a pipette."""
 

opentrons/protocol_engine/commands/pipetting_common.py

@@ -9,10 +9,15 @@ from pydantic import BaseModel, Field
 from opentrons_shared_data.errors import ErrorCodes
 from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
 from opentrons.protocol_engine.types import AspiratedFluid, FluidKind
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+from opentrons_shared_data.errors.exceptions import (
+    PipetteOverpressureError,
+    StallOrCollisionDetectedError,
+)
 from .command import DefinedErrorData, SuccessData
 from opentrons.protocol_engine.state.update_types import StateUpdate
+from opentrons.types import Point
 
+from .movement_common import StallOrCollisionError
 
 if TYPE_CHECKING:
     from ..execution.pipetting import PipettingHandler
@@ -241,11 +246,15 @@ async def aspirate_while_tracking(
     well_name: str,
     volume: float,
     flow_rate: float,
+    end_point: Point,
     location_if_error: ErrorLocationInfo,
     command_note_adder: CommandNoteAdder,
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+    movement_delay: Optional[float] = None,
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an aspirate while tracking microoperation."""
     try:
         volume_aspirated = await pipetting.aspirate_while_tracking(
@@ -254,6 +263,7 @@ async def aspirate_while_tracking(
             well_name=well_name,
             volume=volume,
             flow_rate=flow_rate,
+            end_point=end_point,
             command_note_adder=command_note_adder,
         )
     except PipetteOverpressureError as e:
@@ -272,6 +282,21 @@ async def aspirate_while_tracking(
             ),
             state_update=StateUpdate().set_fluid_unknown(pipette_id=pipette_id),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(
@@ -290,11 +315,15 @@ async def dispense_while_tracking(
     well_name: str,
     volume: float,
     flow_rate: float,
+    end_point: Point,
     push_out: float | None,
     location_if_error: ErrorLocationInfo,
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+    movement_delay: Optional[float] = None,
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an dispense while tracking microoperation."""
     # The current volume won't be none since it passed validation
     current_volume = (
@@ -309,6 +338,7 @@ async def dispense_while_tracking(
             well_name=well_name,
             volume=volume,
             flow_rate=flow_rate,
+            end_point=end_point,
             push_out=push_out,
             is_full_dispense=is_full_dispense,
         )
@@ -332,6 +362,21 @@ async def dispense_while_tracking(
                 pipette_id=pipette_id, ready_to_aspirate=False
             ),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -1,4 +1,4 @@
-"""Command models to start heating a Thermocycler's block."""
+"""Command models for heating a Thermocycler's block."""
 from __future__ import annotations
 from typing import Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
@@ -61,7 +61,7 @@ class SetTargetBlockTemperatureResult(BaseModel):
     )
     taskId: str | SkipJsonSchema[None] = Field(
         None,
-        description="The task id for the setTargetBlockTemperature",
+        description="Id for the background task that manages the temperature.",
         json_schema_extra=_remove_default,
     )
 
@@ -122,13 +122,16 @@ class SetTargetBlockTemperatureImpl(
 
         async def set_target_block_temperature(task_handler: TaskHandler) -> None:
             if thermocycler_hardware is not None:
-                await thermocycler_hardware.set_target_block_temperature(
-                    target_temperature,
-                    volume=target_volume,
-                    hold_time_seconds=hold_time,
-                    ramp_rate=target_ramp_rate,
-                )
-                await thermocycler_hardware.wait_for_block_target()
+                async with task_handler.synchronize_cancel_latest(
+                    thermocycler_state.module_id + "-block"
+                ):
+                    await thermocycler_hardware.set_target_block_temperature(
+                        celsius=target_temperature,
+                        volume=target_volume,
+                        ramp_rate=target_ramp_rate,
+                        hold_time_seconds=hold_time,
+                    )
+                    await thermocycler_hardware.wait_for_block_target()
 
         task = await self._task_handler.create_task(
             task_function=set_target_block_temperature, id=params.taskId

opentrons/protocol_engine/commands/thermocycler/set_target_lid_temperature.py

@@ -1,4 +1,4 @@
-"""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, Any
 from typing_extensions import Literal, Type
@@ -13,7 +13,6 @@ if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, TaskHandler
 
-
 SetTargetLidTemperatureCommandType = Literal["thermocycler/setTargetLidTemperature"]
 
 
@@ -22,7 +21,7 @@ def _remove_default(s: dict[str, Any]) -> 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.")
@@ -49,10 +48,11 @@ class SetTargetLidTemperatureResult(BaseModel):
 
 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,
@@ -69,7 +69,7 @@ class SetTargetLidTemperatureImpl(
         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
         )
@@ -82,10 +82,13 @@ class SetTargetLidTemperatureImpl(
 
         async def set_target_lid_temperature(task_handler: TaskHandler) -> None:
             if thermocycler_hardware is not None:
-                await thermocycler_hardware.set_target_lid_temperature(
-                    target_temperature
-                )
-                await thermocycler_hardware.wait_for_lid_target()
+                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
@@ -99,10 +102,12 @@ class SetTargetLidTemperatureImpl(
 
 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

@@ -150,7 +150,7 @@ class StartRunExtendedProfileImpl(
         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
+                    thermocycler_state.module_id + "-block"
                 ):
                     await thermocycler_hardware.execute_profile(
                         profile=profile, volume=target_volume

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

@@ -84,6 +84,7 @@ from .exceptions import (
     OperationLocationNotInWellError,
     InvalidDispenseVolumeError,
     StorageLimitReachedError,
+    FileNameInvalidError,
     InvalidLiquidError,
     LiquidClassDoesNotExistError,
     LiquidClassRedefinitionError,
@@ -92,6 +93,9 @@ from .exceptions import (
     FlexStackerNotLogicallyEmptyError,
     InvalidLabwarePositionError,
     InvalidModuleOrientation,
+    CameraCaptureError,
+    CameraDisabledError,
+    CameraSettingsInvalidError,
 )
 
 from .error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
@@ -190,6 +194,10 @@ __all__ = [
     "OperationLocationNotInWellError",
     "InvalidDispenseVolumeError",
     "StorageLimitReachedError",
+    "FileNameInvalidError",
     "LiquidClassDoesNotExistError",
     "LiquidClassRedefinitionError",
+    "CameraCaptureError",
+    "CameraDisabledError",
+    "CameraSettingsInvalidError",
 ]

opentrons/protocol_engine/errors/exceptions.py

@@ -1291,6 +1291,19 @@ class StorageLimitReachedError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, detail, wrapping)
 
 
+class FileNameInvalidError(ProtocolEngineError):
+    """Raised to indicate that a file cannot be saved with a given name."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        detail: Optional[Dict[str, str]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build an FileNameInvalidError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, detail, wrapping)
+
+
 class LiquidClassDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a liquid class that has not been loaded."""
 
@@ -1339,6 +1352,18 @@ class FlexStackerLabwarePoolNotYetDefinedError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class LabwarePoolNotCompatibleWithModuleError(ProtocolEngineError):
+    """Raised when attempting to use a labware pool that is incompatible with a module."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class InvalidLabwarePositionError(ProtocolEngineError):
     """Raised when a labware position is internally invalid."""
 
@@ -1361,3 +1386,42 @@ class InvalidModuleOrientation(ProtocolEngineError):
         wrapping: Optional[Sequence[EnumeratedError]] = None,
     ) -> None:
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
+class CameraCaptureError(ProtocolEngineError):
+    """Raised when an Camera Capture attempt fails."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a CameraCaptureError."""
+        super().__init__(ErrorCodes.CAMERA_ERROR, message, details, wrapping)
+
+
+class CameraDisabledError(ProtocolEngineError):
+    """Raised when a Camera was referenced while cameras are disabled."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a CameraDisabledError."""
+        super().__init__(ErrorCodes.CAMERA_ERROR, message, details, wrapping)
+
+
+class CameraSettingsInvalidError(ProtocolEngineError):
+    """Raised when a Camera was given invalid settings."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a CameraSettingsInvalidError."""
+        super().__init__(ErrorCodes.CAMERA_ERROR, message, details, wrapping)

opentrons/protocol_engine/execution/__init__.py

@@ -23,6 +23,7 @@ from .door_watcher import DoorWatcher
 from .status_bar import StatusBarHandler
 from .task_handler import TaskHandler
 from ..resources.file_provider import FileProvider
+from ..resources.camera_provider import CameraProvider
 
 # .thermocycler_movement_flagger omitted from package's public interface.
 
@@ -49,4 +50,5 @@ __all__ = [
     "StatusBarHandler",
     "TaskHandler",
     "FileProvider",
+    "CameraProvider",
 ]