opentrons 8.1.0__py2.py3-none-any.whl → 8.2.0__py2.py3-none-any.whl

opentrons/protocol_engine/protocol_engine.py

@@ -6,7 +6,6 @@ from opentrons.protocol_engine.actions.actions import (
     ResumeFromRecoveryAction,
     SetErrorRecoveryPolicyAction,
 )
-from opentrons.protocol_engine.error_recovery_policy import ErrorRecoveryPolicy
 
 from opentrons.protocols.models import LabwareDefinition
 from opentrons.hardware_control import HardwareControlAPI
@@ -19,8 +18,9 @@ from opentrons_shared_data.errors import (
 
 from .errors import ProtocolCommandFailedError, ErrorOccurrence, CommandNotAllowedError
 from .errors.exceptions import EStopActivatedError
+from .error_recovery_policy import ErrorRecoveryPolicy
 from . import commands, slot_standardization
-from .resources import ModelUtils, ModuleDataProvider
+from .resources import ModelUtils, ModuleDataProvider, FileProvider
 from .types import (
     LabwareOffset,
     LabwareOffsetCreate,
@@ -38,7 +38,8 @@ from .execution import (
     DoorWatcher,
     HardwareStopper,
 )
-from .state import StateStore, StateView
+from .state.state import StateStore, StateView
+from .state.update_types import StateUpdate
 from .plugins import AbstractPlugin, PluginStarter
 from .actions import (
     ActionDispatcher,
@@ -87,41 +88,31 @@ class ProtocolEngine:
         self,
         hardware_api: HardwareControlAPI,
         state_store: StateStore,
-        action_dispatcher: Optional[ActionDispatcher] = None,
-        plugin_starter: Optional[PluginStarter] = None,
+        action_dispatcher: ActionDispatcher,
+        plugin_starter: PluginStarter,
+        model_utils: ModelUtils,
+        hardware_stopper: HardwareStopper,
+        door_watcher: DoorWatcher,
+        module_data_provider: ModuleDataProvider,
+        file_provider: FileProvider,
         queue_worker: Optional[QueueWorker] = None,
-        model_utils: Optional[ModelUtils] = None,
-        hardware_stopper: Optional[HardwareStopper] = None,
-        door_watcher: Optional[DoorWatcher] = None,
-        module_data_provider: Optional[ModuleDataProvider] = None,
     ) -> None:
         """Initialize a ProtocolEngine instance.
 
         Must be called while an event loop is active.
 
-        This constructor does not inject provider implementations.
+        This constructor is only for `ProtocolEngine` unit tests.
         Prefer the `create_protocol_engine()` factory function.
         """
         self._hardware_api = hardware_api
+        self._file_provider = file_provider
         self._state_store = state_store
-        self._model_utils = model_utils or ModelUtils()
-        self._action_dispatcher = action_dispatcher or ActionDispatcher(
-            sink=self._state_store
-        )
-        self._plugin_starter = plugin_starter or PluginStarter(
-            state=self._state_store,
-            action_dispatcher=self._action_dispatcher,
-        )
-        self._hardware_stopper = hardware_stopper or HardwareStopper(
-            hardware_api=hardware_api,
-            state_store=state_store,
-        )
-        self._door_watcher = door_watcher or DoorWatcher(
-            state_store=state_store,
-            hardware_api=hardware_api,
-            action_dispatcher=self._action_dispatcher,
-        )
-        self._module_data_provider = module_data_provider or ModuleDataProvider()
+        self._model_utils = model_utils
+        self._action_dispatcher = action_dispatcher
+        self._plugin_starter = plugin_starter
+        self._hardware_stopper = hardware_stopper
+        self._door_watcher = door_watcher
+        self._module_data_provider = module_data_provider
         self._queue_worker = queue_worker
         if self._queue_worker:
             self._queue_worker.start()
@@ -183,11 +174,35 @@ class ProtocolEngine:
         self._action_dispatcher.dispatch(action)
         self._hardware_api.pause(HardwarePauseType.PAUSE)
 
-    def resume_from_recovery(self) -> None:
-        """Resume normal protocol execution after the engine was `AWAITING_RECOVERY`."""
+    def resume_from_recovery(self, reconcile_false_positive: bool) -> None:
+        """Resume normal protocol execution after the engine was `AWAITING_RECOVERY`.
+
+        If `reconcile_false_positive` is `False`, the engine will continue naively from
+        whatever state the error left it in. (Each defined error individually documents
+        exactly how it affects state.) This is appropriate for client-driven error
+        recovery, where the client wants predictable behavior from the engine.
+
+        If `reconcile_false_positive` is `True`, the engine may apply additional fixups
+        to its state to try to get the rest of the run to just work, assuming the error
+        was a false-positive.
+
+        For example, a `tipPhysicallyMissing` error from a `pickUpTip` would normally
+        leave the engine state without a tip on the pipette. If `reconcile_false_positive=True`,
+        the engine will set the pipette to have that missing tip before continuing, so
+        subsequent path planning, aspirates, dispenses, etc. will work as if nothing
+        went wrong.
+        """
+        if reconcile_false_positive:
+            state_update = (
+                self._state_store.commands.get_state_update_for_false_positive()
+            )
+        else:
+            state_update = StateUpdate()  # Empty/no-op.
+
         action = self._state_store.commands.validate_action_allowed(
-            ResumeFromRecoveryAction()
+            ResumeFromRecoveryAction(state_update)
         )
+
         self._action_dispatcher.dispatch(action)
 
     def add_command(
@@ -609,6 +624,7 @@ class ProtocolEngine:
         assert self._queue_worker is None
         self._queue_worker = create_queue_worker(
             hardware_api=self._hardware_api,
+            file_provider=self._file_provider,
             state_store=self._state_store,
             action_dispatcher=self._action_dispatcher,
             command_generator=command_generator,

opentrons/protocol_engine/resources/__init__.py

@@ -9,6 +9,7 @@ from .model_utils import ModelUtils
 from .deck_data_provider import DeckDataProvider, DeckFixedLabware
 from .labware_data_provider import LabwareDataProvider
 from .module_data_provider import ModuleDataProvider
+from .file_provider import FileProvider
 from .ot3_validation import ensure_ot3_hardware
 
 
@@ -18,6 +19,7 @@ __all__ = [
     "DeckDataProvider",
     "DeckFixedLabware",
     "ModuleDataProvider",
+    "FileProvider",
     "ensure_ot3_hardware",
     "pipette_data_provider",
     "labware_validation",

opentrons/protocol_engine/resources/deck_data_provider.py

@@ -13,7 +13,12 @@ from opentrons_shared_data.deck.types import DeckDefinitionV5
 from opentrons.protocols.models import LabwareDefinition
 from opentrons.types import DeckSlotName
 
-from ..types import DeckSlotLocation, DeckType
+from ..types import (
+    DeckSlotLocation,
+    DeckType,
+    LabwareLocation,
+    DeckConfigurationType,
+)
 from .labware_data_provider import LabwareDataProvider
 
 
@@ -23,7 +28,7 @@ class DeckFixedLabware:
     """A labware fixture that is always present on a deck."""
 
     labware_id: str
-    location: DeckSlotLocation
+    location: LabwareLocation
     definition: LabwareDefinition
 
 
@@ -51,7 +56,9 @@ class DeckDataProvider:
 
     async def get_deck_fixed_labware(
         self,
+        load_fixed_trash: bool,
         deck_definition: DeckDefinitionV5,
+        deck_configuration: Optional[DeckConfigurationType] = None,
     ) -> List[DeckFixedLabware]:
         """Get a list of all labware fixtures from a given deck definition."""
         labware: List[DeckFixedLabware] = []
@@ -61,8 +68,15 @@ class DeckDataProvider:
             load_name = cast(Optional[str], fixture.get("labware"))
             slot = cast(Optional[str], fixture.get("slot"))
 
-            if load_name is not None and slot is not None:
-                location = DeckSlotLocation(slotName=DeckSlotName.from_primitive(slot))
+            if (
+                load_fixed_trash
+                and load_name is not None
+                and slot is not None
+                and slot in DeckSlotName._value2member_map_
+            ):
+                deck_slot_location = DeckSlotLocation(
+                    slotName=DeckSlotName.from_primitive(slot)
+                )
                 definition = await self._labware_data.get_labware_definition(
                     load_name=load_name,
                     namespace="opentrons",
@@ -73,7 +87,7 @@ class DeckDataProvider:
                     DeckFixedLabware(
                         labware_id=labware_id,
                         definition=definition,
-                        location=location,
+                        location=deck_slot_location,
                     )
                 )
 

opentrons/protocol_engine/resources/file_provider.py

@@ -0,0 +1,161 @@
+"""File interaction resource provider."""
+from datetime import datetime
+from typing import List, Optional, Callable, Awaitable, Dict
+from pydantic import BaseModel
+from ..errors import StorageLimitReachedError
+
+
+MAXIMUM_CSV_FILE_LIMIT = 400
+
+
+class GenericCsvTransform:
+    """Generic CSV File Type data for rows of data to be seperated by a delimeter."""
+
+    filename: str
+    rows: List[List[str]]
+    delimiter: str = ","
+
+    @staticmethod
+    def build(
+        filename: str, rows: List[List[str]], delimiter: str = ","
+    ) -> "GenericCsvTransform":
+        """Build a Generic CSV datatype class."""
+        if "." in filename and not filename.endswith(".csv"):
+            raise ValueError(
+                f"Provided filename {filename} invalid. Only CSV file format is accepted."
+            )
+        elif "." not in filename:
+            filename = f"{filename}.csv"
+        csv = GenericCsvTransform()
+        csv.filename = filename
+        csv.rows = rows
+        csv.delimiter = delimiter
+        return csv
+
+
+class ReadData(BaseModel):
+    """Read Data type containing the wavelength for a Plate Reader read alongside the Measurement Data of that read."""
+
+    wavelength: int
+    data: Dict[str, float]
+
+
+class PlateReaderData(BaseModel):
+    """Data from a Opentrons Plate Reader Read. Can be converted to CSV template format."""
+
+    read_results: List[ReadData]
+    reference_wavelength: Optional[int] = None
+    start_time: datetime
+    finish_time: datetime
+    serial_number: str
+
+    def build_generic_csv(  # noqa: C901
+        self, filename: str, measurement: ReadData
+    ) -> GenericCsvTransform:
+        """Builds a CSV compatible object containing Plate Reader Measurements.
+
+        This will also automatically reformat the provided filename to include the wavelength of those measurements.
+        """
+        plate_alpharows = ["A", "B", "C", "D", "E", "F", "G", "H"]
+        rows = []
+
+        rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
+        for i in range(8):
+            row = [plate_alpharows[i]]
+            for j in range(12):
+                row.append(str(measurement.data[f"{plate_alpharows[i]}{j+1}"]))
+            rows.append(row)
+        for i in range(3):
+            rows.append([])
+        rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
+        for i in range(8):
+            row = [plate_alpharows[i]]
+            for j in range(12):
+                row.append("")
+            rows.append(row)
+        for i in range(3):
+            rows.append([])
+        rows.append(
+            [
+                "",
+                "ID",
+                "Well",
+                "Absorbance (OD)",
+                "Mean Absorbance (OD)",
+                "Absorbance %CV",
+            ]
+        )
+        for i in range(3):
+            rows.append([])
+        rows.append(
+            [
+                "",
+                "ID",
+                "Well",
+                "Absorbance (OD)",
+                "Mean Absorbance (OD)",
+                "Dilution Factor",
+                "Absorbance %CV",
+            ]
+        )
+        rows.append(["1", "Sample 1", "", "", "", "1", "", "", "", "", "", ""])
+        for i in range(3):
+            rows.append([])
+
+        # end of file metadata
+        rows.append(["Protocol"])
+        rows.append(["Assay"])
+        rows.append(["Sample Wavelength (nm)", str(measurement.wavelength)])
+        if self.reference_wavelength is not None:
+            rows.append(["Reference Wavelength (nm)", str(self.reference_wavelength)])
+        rows.append(["Serial No.", self.serial_number])
+        rows.append(
+            ["Measurement started at", self.start_time.strftime("%m %d %H:%M:%S %Y")]
+        )
+        rows.append(
+            ["Measurement finished at", self.finish_time.strftime("%m %d %H:%M:%S %Y")]
+        )
+
+        # Ensure the filename adheres to ruleset contains the wavelength for a given measurement
+        if filename.endswith(".csv"):
+            filename = filename[:-4]
+        filename = filename + str(measurement.wavelength) + "nm.csv"
+
+        return GenericCsvTransform.build(
+            filename=filename,
+            rows=rows,
+            delimiter=",",
+        )
+
+
+class FileProvider:
+    """Provider class to wrap file read write interactions to the data files directory in the engine."""
+
+    def __init__(
+        self,
+        data_files_write_csv_callback: Optional[
+            Callable[[GenericCsvTransform], Awaitable[str]]
+        ] = None,
+        data_files_filecount: Optional[Callable[[], Awaitable[int]]] = None,
+    ) -> None:
+        """Initialize the interface callbacks of the File Provider for data file handling within the Protocol Engine.
+
+        Params:
+            data_files_write_csv_callback: Callback to write a CSV file to the data files directory and add it to the database.
+            data_files_filecount: Callback to check the amount of data files already present in the data files directory.
+        """
+        self._data_files_write_csv_callback = data_files_write_csv_callback
+        self._data_files_filecount = data_files_filecount
+
+    async def write_csv(self, write_data: GenericCsvTransform) -> str:
+        """Writes the provided CSV object to a file in the Data Files directory. Returns the File ID of the file created."""
+        if self._data_files_filecount is not None:
+            file_count = await self._data_files_filecount()
+            if file_count >= MAXIMUM_CSV_FILE_LIMIT:
+                raise StorageLimitReachedError(
+                    f"Not enough space to store file {write_data.filename}."
+                )
+            if self._data_files_write_csv_callback is not None:
+                return await self._data_files_write_csv_callback(write_data)
+        # If we are in an analysis or simulation state, return an empty file ID
+        return ""

opentrons/protocol_engine/resources/fixture_validation.py

@@ -29,7 +29,12 @@ def is_drop_tip_waste_chute(addressable_area_name: str) -> bool:
 
 def is_trash(addressable_area_name: str) -> bool:
     """Check if an addressable area is a trash bin."""
-    return addressable_area_name in {"movableTrash", "fixedTrash", "shortFixedTrash"}
+    return any(
+        [
+            s in addressable_area_name
+            for s in {"movableTrash", "fixedTrash", "shortFixedTrash"}
+        ]
+    )
 
 
 def is_staging_slot(addressable_area_name: str) -> bool:
@@ -46,3 +51,8 @@ def is_deck_slot(addressable_area_name: str) -> bool:
     except ValueError:
         return False
     return True
+
+
+def is_abs_reader(addressable_area_name: str) -> bool:
+    """Check if an addressable area is an absorbance plate reader area."""
+    return "absorbanceReaderV1" in addressable_area_name

opentrons/protocol_engine/resources/labware_validation.py

@@ -9,6 +9,11 @@ def is_flex_trash(load_name: str) -> bool:
     return load_name == "opentrons_1_trash_3200ml_fixed"
 
 
+def is_absorbance_reader_lid(load_name: str) -> bool:
+    """Check if a labware is an absorbance reader lid."""
+    return load_name == "opentrons_flex_lid_absorbance_plate_reader_module"
+
+
 def validate_definition_is_labware(definition: LabwareDefinition) -> bool:
     """Validate that one of the definition's allowed roles is `labware`.
 
@@ -22,6 +27,11 @@ def validate_definition_is_adapter(definition: LabwareDefinition) -> bool:
     return LabwareRole.adapter in definition.allowedRoles
 
 
+def validate_definition_is_lid(definition: LabwareDefinition) -> bool:
+    """Validate that one of the definition's allowed roles is `lid`."""
+    return LabwareRole.lid in definition.allowedRoles
+
+
 def validate_labware_can_be_stacked(
     top_labware_definition: LabwareDefinition, below_labware_load_name: str
 ) -> bool:

opentrons/protocol_engine/state/__init__.py

@@ -1,71 +1 @@
 """Protocol engine state module."""
-
-from .state import State, StateStore, StateView
-from .state_summary import StateSummary
-from .config import Config
-from .commands import (
-    CommandState,
-    CommandView,
-    CommandSlice,
-    CommandErrorSlice,
-    CommandPointer,
-)
-from .command_history import CommandEntry
-from .labware import LabwareState, LabwareView
-from .pipettes import PipetteState, PipetteView, HardwarePipette
-from .modules import ModuleState, ModuleView, HardwareModule
-from .module_substates import (
-    MagneticModuleId,
-    MagneticModuleSubState,
-    HeaterShakerModuleId,
-    HeaterShakerModuleSubState,
-    TemperatureModuleId,
-    TemperatureModuleSubState,
-    ThermocyclerModuleId,
-    ThermocyclerModuleSubState,
-    ModuleSubStateType,
-)
-from .geometry import GeometryView
-from .motion import MotionView, PipetteLocationData
-
-__all__ = [
-    # top level state value and interfaces
-    "State",
-    "StateStore",
-    "StateView",
-    "StateSummary",
-    # static engine configuration
-    "Config",
-    # command state and values
-    "CommandState",
-    "CommandView",
-    "CommandSlice",
-    "CommandErrorSlice",
-    "CommandPointer",
-    "CommandEntry",
-    # labware state and values
-    "LabwareState",
-    "LabwareView",
-    # pipette state and values
-    "PipetteState",
-    "PipetteView",
-    "HardwarePipette",
-    # module state and values
-    "ModuleState",
-    "ModuleView",
-    "HardwareModule",
-    "MagneticModuleId",
-    "MagneticModuleSubState",
-    "HeaterShakerModuleId",
-    "HeaterShakerModuleSubState",
-    "TemperatureModuleId",
-    "TemperatureModuleSubState",
-    "ThermocyclerModuleId",
-    "ThermocyclerModuleSubState",
-    "ModuleSubStateType",
-    # computed geometry state
-    "GeometryView",
-    # computed motion state
-    "MotionView",
-    "PipetteLocationData",
-]

opentrons/protocol_engine/state/addressable_areas.py

@@ -43,7 +43,7 @@ from ..actions import (
     AddAddressableAreaAction,
 )
 from .config import Config
-from .abstract_store import HasState, HandlesActions
+from ._abstract_store import HasState, HandlesActions
 
 
 @dataclass

opentrons/protocol_engine/state/command_history.py

@@ -24,6 +24,9 @@ class CommandHistory:
     _all_command_ids: List[str]
     """All command IDs, in insertion order."""
 
+    _all_command_ids_but_fixit_command_ids: List[str]
+    """All command IDs besides fixit command intents, in insertion order."""
+
     _commands_by_id: Dict[str, CommandEntry]
     """All command resources, in insertion order, mapped by their unique IDs."""
 
@@ -44,6 +47,7 @@ class CommandHistory:
 
     def __init__(self) -> None:
         self._all_command_ids = []
+        self._all_command_ids_but_fixit_command_ids = []
         self._queued_command_ids = OrderedSet()
         self._queued_setup_command_ids = OrderedSet()
         self._queued_fixit_command_ids = OrderedSet()
@@ -97,13 +101,26 @@ class CommandHistory:
             for command_id in self._all_command_ids
         ]
 
+    def get_filtered_command_ids(self, include_fixit_commands: bool) -> List[str]:
+        """Get all fixit command IDs."""
+        if include_fixit_commands:
+            return self._all_command_ids
+        else:
+            return self._all_command_ids_but_fixit_command_ids
+
     def get_all_ids(self) -> List[str]:
         """Get all command IDs."""
         return self._all_command_ids
 
-    def get_slice(self, start: int, stop: int) -> List[Command]:
-        """Get a list of commands between start and stop."""
+    def get_slice(
+        self, start: int, stop: int, command_ids: Optional[list[str]] = None
+    ) -> List[Command]:
+        """Get a list of commands between start and stop.""" """Get a list of commands between start and stop."""
         commands = self._all_command_ids[start:stop]
+        selected_command_ids = (
+            command_ids if command_ids is not None else self._all_command_ids
+        )
+        commands = selected_command_ids[start:stop]
         return [self._commands_by_id[command].command for command in commands]
 
     def get_tail_command(self) -> Optional[CommandEntry]:
@@ -230,6 +247,8 @@ class CommandHistory:
         """Create or update a command entry."""
         if command_id not in self._commands_by_id:
             self._all_command_ids.append(command_id)
+            if command_entry.command.intent != CommandIntent.FIXIT:
+                self._all_command_ids_but_fixit_command_ids.append(command_id)
         self._commands_by_id[command_id] = command_entry
 
     def _add_to_queue(self, command_id: str) -> None: