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

opentrons/protocol_engine/state/preconditions.py

@@ -0,0 +1,59 @@
+"""Command precondition state and store resource."""
+from dataclasses import dataclass
+
+from opentrons.protocol_engine.actions.get_state_update import get_state_updates
+from opentrons.protocol_engine.state import update_types
+from opentrons.protocol_engine.types import CommandPreconditions, PreconditionTypes
+
+from ._abstract_store import HasState, HandlesActions
+from ..actions import Action
+
+
+@dataclass
+class CommandPreconditionState:
+    """State of Engine command precondition references."""
+
+    preconditions: CommandPreconditions
+
+
+class CommandPreconditionStore(HasState[CommandPreconditionState], HandlesActions):
+    """Command Precondition container."""
+
+    _state: CommandPreconditionState
+
+    def __init__(self) -> None:
+        """Initialize a Command Precondition store and its state."""
+        self._state = CommandPreconditionState(
+            preconditions=CommandPreconditions(isCameraUsed=False)
+        )
+
+    def handle_action(self, action: Action) -> None:
+        """Modify state in reaction to an action."""
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
+
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.precondition_update != update_types.NO_CHANGE:
+            for key in state_update.precondition_update.preconditions:
+                if key == PreconditionTypes.IS_CAMERA_USED:
+                    self._state.preconditions.isCameraUsed = (
+                        state_update.precondition_update.preconditions[key]
+                    )
+
+
+class CommandPreconditionView:
+    """Read-only engine created Command Precondition state view."""
+
+    _state: CommandPreconditionState
+
+    def __init__(self, state: CommandPreconditionState) -> None:
+        """Initialize the view of Command Precondition state.
+
+        Arguments:
+            state: Command precondition dataclass used for tracking preconditions used during a protocol.
+        """
+        self._state = state
+
+    def get_precondition(self) -> CommandPreconditions:
+        """Get the Command Preconditions currently set by a protocol."""
+        return self._state.preconditions

opentrons/protocol_engine/state/state.py

@@ -35,6 +35,12 @@ from .config import Config
 from .state_summary import StateSummary
 from ..types import DeckConfigurationType
 from .tasks import TaskState, TaskView, TaskStore
+from .preconditions import (
+    CommandPreconditionState,
+    CommandPreconditionStore,
+    CommandPreconditionView,
+)
+from .camera import CameraState, CameraView, CameraStore
 
 
 _ParamsT = ParamSpec("_ParamsT")
@@ -56,6 +62,8 @@ class State:
     wells: WellState
     files: FileState
     tasks: TaskState
+    preconditions: CommandPreconditionState
+    camera: CameraState
 
 
 class StateView(HasState[State]):
@@ -76,6 +84,8 @@ class StateView(HasState[State]):
     _files: FileView
     _config: Config
     _tasks: TaskView
+    _preconditions: CommandPreconditionView
+    _camera: CameraView
 
     @property
     def commands(self) -> CommandView:
@@ -142,6 +152,16 @@ class StateView(HasState[State]):
         """Get ProtocolEngine configuration."""
         return self._config
 
+    @property
+    def preconditions(self) -> CommandPreconditionView:
+        """Get state view selectors for command preconditions."""
+        return self._preconditions
+
+    @property
+    def camera(self) -> CameraView:
+        """Get state view for the Camera."""
+        return self._camera
+
     @property
     def tasks(self) -> TaskView:
         """Get state view selectors for task state."""
@@ -171,6 +191,7 @@ class StateView(HasState[State]):
                 for liquid_class_id, liquid_class_record in self._liquid_classes.get_all().items()
             ],
             tasks=self._tasks.get_summary(),
+            cameraSettings=self._camera.get_enablement_settings(),
         )
 
 
@@ -241,6 +262,8 @@ class StateStore(StateView, ActionHandler):
         self._well_store = WellStore()
         self._file_store = FileStore()
         self._task_store = TaskStore()
+        self._precondition_store = CommandPreconditionStore()
+        self._camera_store = CameraStore()
 
         self._substores: List[HandlesActions] = [
             self._command_store,
@@ -254,6 +277,8 @@ class StateStore(StateView, ActionHandler):
             self._well_store,
             self._file_store,
             self._task_store,
+            self._precondition_store,
+            self._camera_store,
         ]
         self._config = config
         self._change_notifier = change_notifier or ChangeNotifier()
@@ -378,6 +403,8 @@ class StateStore(StateView, ActionHandler):
             wells=self._well_store.state,
             files=self._file_store.state,
             tasks=self._task_store.state,
+            preconditions=self._precondition_store.state,
+            camera=self._camera_store.state,
         )
 
     def _initialize_state(self) -> None:
@@ -397,6 +424,8 @@ class StateStore(StateView, ActionHandler):
         self._wells = WellView(state.wells)
         self._files = FileView(state.files)
         self._tasks = TaskView(state.tasks)
+        self._preconditions = CommandPreconditionView(state.preconditions)
+        self._camera = CameraView(state.camera)
 
         # Derived states
         self._geometry = GeometryView(
@@ -430,6 +459,7 @@ class StateStore(StateView, ActionHandler):
         self._tips._state = next_state.tips
         self._wells._state = next_state.wells
         self._tasks._state = next_state.tasks
+        self._camera._state = next_state.camera
         self._change_notifier.notify()
         if self._notify_robot_server is not None:
             self._notify_robot_server()

opentrons/protocol_engine/state/state_summary.py

@@ -15,6 +15,7 @@ from ..types import (
     WellInfoSummary,
     TaskSummary,
 )
+from ..resources.camera_provider import CameraSettings
 
 
 class StateSummary(BaseModel):
@@ -36,3 +37,4 @@ class StateSummary(BaseModel):
     files: List[str] = Field(default_factory=list)
     liquidClasses: List[LiquidClassRecordWithId] = Field(default_factory=list)
     tasks: List[TaskSummary] = Field(default_factory=list)
+    cameraSettings: Optional[CameraSettings] = None

opentrons/protocol_engine/state/update_types.py

@@ -24,6 +24,7 @@ from opentrons.protocol_engine.types import (
     ModuleModel,
     ModuleDefinition,
     LabwareWellId,
+    PreconditionTypes,
 )
 from opentrons.types import MountType, DeckSlotName
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
@@ -401,6 +402,13 @@ class FilesAddedUpdate:
     file_ids: list[str]
 
 
+@dataclasses.dataclass
+class PreconditionUpdate:
+    """An update that changes command preconditions flags."""
+
+    preconditions: dict[PreconditionTypes, bool]
+
+
 @dataclasses.dataclass
 class AddressableAreaUsedUpdate:
     """An update that says an addressable area has been used."""
@@ -477,6 +485,8 @@ class StateUpdate:
 
     ready_to_aspirate: PipetteAspirateReadyUpdate | NoChangeType = NO_CHANGE
 
+    precondition_update: PreconditionUpdate | NoChangeType = NO_CHANGE
+
     def append(self, other: Self) -> Self:
         """Apply another `StateUpdate` "on top of" this one.
 

opentrons/protocol_engine/types/__init__.py

@@ -25,6 +25,10 @@ from .command_annotations import (
     CustomCommandAnnotation,
     CommandAnnotation,
 )
+from .command_preconditions import (
+    CommandPreconditions,
+    PreconditionTypes,
+)
 from .partial_tip_configuration import (
     AllNozzleLayoutConfiguration,
     SingleNozzleLayoutConfiguration,
@@ -83,6 +87,8 @@ from .location import (
     NonStackedLocation,
     DeckPoint,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
+    AccessibleByGripperLocation,
     OnLabwareLocationSequenceComponent,
     OnModuleLocationSequenceComponent,
     OnAddressableAreaLocationSequenceComponent,
@@ -92,6 +98,7 @@ from .location import (
     LoadableLabwareLocation,
     labware_location_is_system,
     labware_location_is_off_deck,
+    labware_location_is_in_waste_chute,
 )
 from .labware import (
     OverlapOffset,
@@ -166,6 +173,9 @@ __all__ = [
     "SecondOrderCommandAnnotation",
     "CustomCommandAnnotation",
     "CommandAnnotation",
+    # Command preconditions
+    "PreconditionTypes",
+    "CommandPreconditions",
     # Partial tip handling
     "AllNozzleLayoutConfiguration",
     "SingleNozzleLayoutConfiguration",
@@ -229,8 +239,10 @@ __all__ = [
     "NonStackedLocation",
     "DeckPoint",
     "OffDeckLocationType",
-    "SystemLocationType",
+    "WasteChuteLocationType" "SystemLocationType",
     "InStackerHopperLocation",
+    "WASTE_CHUTE_LOCATION",
+    "AccessibleByGripperLocation",
     "OnLabwareLocationSequenceComponent",
     "OnModuleLocationSequenceComponent",
     "OnAddressableAreaLocationSequenceComponent",
@@ -240,6 +252,7 @@ __all__ = [
     "LoadableLabwareLocation",
     "labware_location_is_off_deck",
     "labware_location_is_system",
+    "labware_location_is_in_waste_chute",
     # Labware offset location
     "LegacyLabwareOffsetLocation",
     "LabwareOffsetLocationSequence",

opentrons/protocol_engine/types/command_preconditions.py

@@ -0,0 +1,18 @@
+"""Protocol Engine types dealing with command preconditions."""
+from enum import Enum
+from pydantic import Field, BaseModel
+
+
+class PreconditionTypes(str, Enum):
+    """Precondition types used for identification during state update."""
+
+    IS_CAMERA_USED = "isCameraUsed"
+
+
+class CommandPreconditions(BaseModel):
+    """Preconditions of commands as described in protocol analysis."""
+
+    isCameraUsed: bool = Field(
+        default=False,
+        description="Parameter to determine if a Camera is used in a protocol.",
+    )

opentrons/protocol_engine/types/location.py

@@ -85,8 +85,10 @@ class InStackerHopperLocation(BaseModel):
 
 _OffDeckLocationType = Literal["offDeck"]
 _SystemLocationType = Literal["systemLocation"]
+_WasteChuteLocationType = Literal["wasteChuteLocation"]
 OFF_DECK_LOCATION: _OffDeckLocationType = "offDeck"
 SYSTEM_LOCATION: _SystemLocationType = "systemLocation"
+WASTE_CHUTE_LOCATION: _WasteChuteLocationType = "wasteChuteLocation"
 
 
 def labware_location_is_off_deck(
@@ -103,6 +105,13 @@ def labware_location_is_system(
     return isinstance(location, str) and location == SYSTEM_LOCATION
 
 
+def labware_location_is_in_waste_chute(
+    location: LabwareLocation,
+) -> TypeGuard[_WasteChuteLocationType]:
+    """Check if a location is the waste chute."""
+    return isinstance(location, str) and location == WASTE_CHUTE_LOCATION
+
+
 class OnLabwareLocationSequenceComponent(BaseModel):
     """Labware on another labware."""
 
@@ -137,7 +146,7 @@ class NotOnDeckLocationSequenceComponent(BaseModel):
     """Labware on a system location."""
 
     kind: Literal["notOnDeck"] = "notOnDeck"
-    logicalLocationName: _OffDeckLocationType | _SystemLocationType
+    logicalLocationName: _OffDeckLocationType | _SystemLocationType | _WasteChuteLocationType
 
 
 LabwareLocationSequence = list[
@@ -158,6 +167,7 @@ LabwareLocation = Union[
     _SystemLocationType,
     AddressableAreaLocation,
     InStackerHopperLocation,
+    _WasteChuteLocationType,
 ]
 """Union of all locations where it's legal to keep a labware."""
 
@@ -168,11 +178,15 @@ LoadableLabwareLocation = Union[
     _OffDeckLocationType,
     _SystemLocationType,
     AddressableAreaLocation,
+    _WasteChuteLocationType,
 ]
 """Union of all locations where it's legal to load a labware."""
 
 OnDeckLabwareLocation = Union[
-    DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
+    DeckSlotLocation,
+    ModuleLocation,
+    OnLabwareLocation,
+    AddressableAreaLocation,
 ]
 
 NonStackedLocation = Union[
@@ -181,9 +195,19 @@ NonStackedLocation = Union[
     ModuleLocation,
     _OffDeckLocationType,
     _SystemLocationType,
+    _WasteChuteLocationType,
 ]
 """Union of all locations where it's legal to keep a labware that can't be stacked on another labware"""
 
+AccessibleByGripperLocation = Union[
+    DeckSlotLocation,
+    ModuleLocation,
+    OnLabwareLocation,
+    AddressableAreaLocation,
+    _WasteChuteLocationType,
+]
+"""Union of all locations that a gripper can move things to."""
+
 
 # TODO(mm, 2022-11-07): Deduplicate with Vec3f.
 class DeckPoint(BaseModel):

opentrons/protocol_engine/types/module.py

@@ -303,7 +303,7 @@ class StackerStoredLabwareGroup(BaseModel):
 
 @dataclass
 class StackerPoolDefinition:
-    """Represents an internal configuraiton of stored labware."""
+    """Represents an internal configuration of stored labware."""
 
     primaryLabwareDefinition: LabwareDefinition
     adapterLabwareDefinition: LabwareDefinition | SkipJsonSchema[None] = None

opentrons/protocol_runner/protocol_runner.py

@@ -24,7 +24,7 @@ from opentrons.protocol_engine import (
     Command,
     commands as pe_commands,
 )
-from opentrons.protocol_engine.types import CommandAnnotation
+from opentrons.protocol_engine.types import CommandAnnotation, CommandPreconditions
 from opentrons.protocols.parse import PythonParseMode
 from opentrons.util.async_helpers import asyncio_yield
 from opentrons.util.broker import Broker
@@ -58,6 +58,7 @@ class RunResult(NamedTuple):
     state_summary: StateSummary
     parameters: List[RunTimeParameter]
     command_annotations: List[CommandAnnotation]
+    command_preconditions: Optional[CommandPreconditions]
 
 
 class AbstractRunner(ABC):
@@ -284,11 +285,15 @@ class PythonAndLegacyRunner(AbstractRunner):
         run_data = self._protocol_engine.state_view.get_summary()
         commands = self._protocol_engine.state_view.commands.get_all()
         parameters = self.run_time_parameters
+        preconditions = (
+            self._protocol_engine.state_view.preconditions.get_precondition()
+        )
         return RunResult(
             commands=commands,
             state_summary=run_data,
             parameters=parameters,
             command_annotations=[],
+            command_preconditions=preconditions,
         )
 
 
@@ -403,11 +408,15 @@ class JsonRunner(AbstractRunner):
 
         run_data = self._protocol_engine.state_view.get_summary()
         commands = self._protocol_engine.state_view.commands.get_all()
+        preconditions = (
+            self._protocol_engine.state_view.preconditions.get_precondition()
+        )
         return RunResult(
             commands=commands,
             state_summary=run_data,
             parameters=[],
             command_annotations=self._command_annotations,
+            command_preconditions=preconditions,
         )
 
     async def _add_and_execute_commands(self) -> None:
@@ -479,11 +488,15 @@ class LiveRunner(AbstractRunner):
 
         run_data = self._protocol_engine.state_view.get_summary()
         commands = self._protocol_engine.state_view.commands.get_all()
+        preconditions = (
+            self._protocol_engine.state_view.preconditions.get_precondition()
+        )
         return RunResult(
             commands=commands,
             state_summary=run_data,
             parameters=[],
             command_annotations=[],
+            command_preconditions=preconditions,
         )
 
 

opentrons/protocol_runner/run_orchestrator.py

@@ -43,7 +43,9 @@ from ..protocol_engine.types import (
     CSVRuntimeParamPaths,
     CommandAnnotation,
     ModuleModel,
+    CommandPreconditions,
 )
+from ..protocol_engine.resources.camera_provider import CameraProvider, CameraSettings
 from ..protocol_engine.error_recovery_policy import ErrorRecoveryPolicy
 
 from ..protocol_reader import JsonProtocolConfig, PythonProtocolConfig, ProtocolSource
@@ -84,6 +86,7 @@ class RunOrchestrator:
     _protocol_live_runner: protocol_runner.LiveRunner
     _hardware_api: HardwareControlAPI
     _protocol_engine: ProtocolEngine
+    _camera_provider: Optional[CameraProvider] = None
 
     def __init__(
         self,
@@ -92,6 +95,7 @@ class RunOrchestrator:
         fixit_runner: protocol_runner.LiveRunner,
         setup_runner: protocol_runner.LiveRunner,
         protocol_live_runner: protocol_runner.LiveRunner,
+        camera_provider: Optional[CameraProvider] = None,
         json_or_python_protocol_runner: Optional[
             Union[protocol_runner.PythonAndLegacyRunner, protocol_runner.JsonRunner]
         ] = None,
@@ -106,6 +110,7 @@ class RunOrchestrator:
             setup_runner: LiveRunner for setup commands.
             protocol_live_runner: LiveRunner for protocol commands.
             json_or_python_protocol_runner: JsonRunner/PythonAndLegacyRunner for protocol commands.
+            camera_provider: Provides callbacks to Camera interface.
             run_id: run id if any, associated to the runner/engine.
         """
         self._run_id = run_id
@@ -114,6 +119,7 @@ class RunOrchestrator:
         self._setup_runner = setup_runner
         self._fixit_runner = fixit_runner
         self._protocol_live_runner = protocol_live_runner
+        self._camera_provider = camera_provider
         self._fixit_runner.prepare()
         self._setup_runner.prepare()
         self._protocol_engine.set_and_start_queue_worker(self.command_generator)
@@ -132,6 +138,7 @@ class RunOrchestrator:
         cls,
         hardware_api: HardwareControlAPI,
         protocol_engine: ProtocolEngine,
+        camera_provider: Optional[CameraProvider] = None,
         protocol_config: Optional[
             Union[JsonProtocolConfig, PythonProtocolConfig]
         ] = None,
@@ -169,6 +176,7 @@ class RunOrchestrator:
             hardware_api=hardware_api,
             protocol_engine=protocol_engine,
             protocol_live_runner=protocol_live_runner,
+            camera_provider=camera_provider,
         )
 
     def play(self, deck_configuration: Optional[DeckConfigurationType] = None) -> None:
@@ -237,6 +245,10 @@ class RunOrchestrator:
         """Get protocol run data."""
         return self._protocol_engine.state_view.get_summary()
 
+    def get_preconditions(self) -> CommandPreconditions:
+        """Get the preconditions of a protocol run."""
+        return self._protocol_engine.state_view.preconditions.get_precondition()
+
     def get_loaded_labware_definitions(self) -> List[LabwareDefinition]:
         """Get loaded labware definitions."""
         return self._protocol_engine.state_view.labware.get_loaded_labware_definitions()
@@ -363,6 +375,13 @@ class RunOrchestrator:
         """Add a new labware definition to state."""
         return self._protocol_engine.add_labware_definition(definition)
 
+    def add_camera_enablement_settings(
+        self,
+        enablement_settings: CameraSettings,
+    ) -> CameraSettings:
+        """Add new camera enablement settings."""
+        return self._protocol_engine.add_camera_enablement_settings(enablement_settings)
+
     async def add_command_and_wait_for_interval(
         self,
         command: CommandCreate,
@@ -396,6 +415,18 @@ class RunOrchestrator:
             module_model=ModuleModel.from_hardware(module_model), serial=module_serial
         )
 
+    async def module_disconnected(
+        self, module_model: HardwareModuleModel, module_serial: str | None
+    ) -> bool:
+        """Handle an unexpected module disconnection.
+
+        If this function returns true, the caller should call finish() immediately; if it returns
+        False, the caller should not call finish() until it otherwise would.
+        """
+        return await self._protocol_engine.module_disconnected(
+            module_model=ModuleModel.from_hardware(module_model), serial=module_serial
+        )
+
     async def use_attached_modules(
         self, modules_by_id: Dict[str, HardwareModuleAPI]
     ) -> None:

opentrons/protocols/advanced_control/transfers/transfer_liquid_utils.py

@@ -72,7 +72,7 @@ def raise_if_location_inside_liquid(
 def group_wells_for_multi_channel_transfer(
     targets: Sequence[Well],
     nozzle_map: NozzleMapInterface,
-    target_name: Literal["source", "destination"],
+    target_name: Literal["source", "destination", "tip"],
 ) -> List[Well]:
     """Takes a list of wells and a nozzle map and returns a list of target wells to address every well given
 
@@ -108,7 +108,7 @@ def group_wells_for_multi_channel_transfer(
 def _group_wells_for_nozzle_configuration(  # noqa: C901
     targets: List[Well],
     nozzle_map: NozzleMapInterface,
-    target_name: Literal["source", "destination"],
+    target_name: Literal["source", "destination", "tip"],
 ) -> List[Well]:
     """Groups wells together for a column, row, or full 96 configuration and returns a reduced list of target wells."""
     grouped_wells = []

opentrons/simulate.py

@@ -50,6 +50,7 @@ from opentrons.protocol_engine.create_protocol_engine import (
 from opentrons.protocol_engine import error_recovery_policy
 from opentrons.protocol_engine.state.config import Config
 from opentrons.protocol_engine.types import DeckType, EngineStatus, PostRunHardwareState
+from opentrons.protocol_engine.resources.camera_provider import CameraProvider
 from opentrons.protocol_reader.protocol_source import ProtocolSource
 from opentrons.protocol_runner.protocol_runner import create_protocol_runner, LiveRunner
 from opentrons.protocol_runner import RunOrchestrator
@@ -849,6 +850,7 @@ def _create_live_context_pe(
                 load_fixed_trash=should_load_fixed_trash_labware_for_python_protocol(
                     api_version
                 ),
+                camera_provider=CameraProvider(),
             ) as (engine, loop):
                 yield engine, loop
         finally:
@@ -982,6 +984,7 @@ def _run_file_pe(
             protocol_live_runner=LiveRunner(
                 protocol_engine=protocol_engine, hardware_api=hardware_api_wrapped
             ),
+            camera_provider=CameraProvider(),
         )
 
         # TODO(mm, 2024-08-06): This home is theoretically redundant with Protocol