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

opentrons/protocol_engine/types/deck_configuration.py

@@ -6,7 +6,10 @@ from enum import Enum
 
 from opentrons.types import DeckSlotName
 
-from opentrons_shared_data.module.types import ModuleType as SharedDataModuleType
+from opentrons_shared_data.module.types import (
+    ModuleType as SharedDataModuleType,
+    ModuleOrientation,
+)
 from opentrons_shared_data.deck.types import SlotDefV3
 from opentrons_shared_data.labware.types import LocatingFeatures
 
@@ -57,6 +60,7 @@ class AddressableArea:
     position: AddressableOffsetVector
     compatible_module_types: List[SharedDataModuleType]
     features: LocatingFeatures
+    orientation: ModuleOrientation
 
 
 # TODO make the below some sort of better type

opentrons/protocol_engine/types/instrument.py

@@ -1,5 +1,5 @@
 """Protocol Engine types to do with instruments."""
-
+import enum
 from typing import Union
 
 from dataclasses import dataclass
@@ -45,3 +45,10 @@ class InstrumentOffsetVector(BaseModel):
     x: float
     y: float
     z: float
+
+
+class GripperMoveType(enum.Enum):
+    """Types of gripper movement."""
+
+    PICK_UP_LABWARE = enum.auto()
+    DROP_LABWARE = enum.auto()

opentrons/protocol_engine/types/labware.py

@@ -2,16 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Optional, Union
+from typing import Optional
 from dataclasses import dataclass
 from datetime import datetime
 
 from pydantic import BaseModel, Field
 
-from opentrons_shared_data.labware.labware_definition import (
-    LabwareDefinition,
-)
-
 from .location import LabwareLocation
 from .labware_offset_location import (
     LegacyLabwareOffsetLocation,
@@ -19,8 +15,6 @@ from .labware_offset_location import (
 )
 from .labware_offset_vector import LabwareOffsetVector
 from .util import Vec3f
-from .module import ModuleDefinition
-from .deck_configuration import DeckLocationDefinition
 
 
 @dataclass(frozen=True)
@@ -126,12 +120,6 @@ class LoadedLabware(BaseModel):
     )
 
 
-LabwareParentDefinition = Union[
-    DeckLocationDefinition, ModuleDefinition, LabwareDefinition
-]
-"""Information pertaining to a labware's parent (deck slot, module, or another labware) location."""
-
-
 @dataclass(frozen=True)
 class LabwareWellId:
     """Designates a well in a labware."""

opentrons/protocol_engine/types/module.py

@@ -21,6 +21,7 @@ from opentrons_shared_data.labware.types import LocatingFeatures
 
 from opentrons.hardware_control.modules import (
     ModuleType as ModuleType,
+    ModuleModel as HardwareModuleModel,
 )
 
 from .location import DeckSlotLocation
@@ -43,6 +44,11 @@ class ModuleModel(str, Enum):
     ABSORBANCE_READER_V1 = "absorbanceReaderV1"
     FLEX_STACKER_MODULE_V1 = "flexStackerModuleV1"
 
+    @classmethod
+    def from_hardware(cls, hardware_model: HardwareModuleModel) -> "ModuleModel":
+        """Convert from the hardware model representation."""
+        return cls(hardware_model.value)
+
     def as_type(self) -> ModuleType:
         """Get the ModuleType of this model."""
         if ModuleModel.is_temperature_module_model(self):
@@ -193,6 +199,10 @@ class ModuleDefinition(BaseModel):
         ...,
     )
 
+    orientation: Dict[str, str] = Field(
+        ...,
+    )
+
     compatibleWith: List[ModuleModel] = Field(
         ...,
     )

opentrons/protocol_engine/types/tasks.py

@@ -0,0 +1,38 @@
+"""Types for Tasks."""
+from datetime import datetime
+from opentrons.protocol_engine.errors import ErrorOccurrence
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class _BaseTask:
+    """A base task representation."""
+
+    id: str
+    createdAt: datetime
+
+
+@dataclass
+class Task(_BaseTask):
+    """A task representation."""
+
+    asyncioTask: asyncio.Task[None]
+
+
+@dataclass
+class FinishedTask(_BaseTask):
+    """A finished task representation."""
+
+    finishedAt: datetime
+    error: ErrorOccurrence | None
+
+
+@dataclass
+class TaskSummary:
+    """Task info for use in summary lists."""
+
+    id: str
+    createdAt: datetime
+    finishedAt: datetime | None = None
+    error: ErrorOccurrence | None = None

opentrons/protocol_engine/types/tip.py

@@ -1,6 +1,7 @@
 """Protocol Engine types to deal with tips."""
 
 from dataclasses import dataclass
+from enum import Enum
 
 
 @dataclass(frozen=True)
@@ -16,3 +17,11 @@ class TipGeometry:
     length: float
     diameter: float
     volume: float
+
+
+class TipRackWellState(Enum):
+    """The state of a single tip in a tip rack's well."""
+
+    CLEAN = "clean"
+    USED = "used"
+    EMPTY = "empty"

opentrons/protocol_runner/create_simulating_orchestrator.py

@@ -16,11 +16,38 @@ from opentrons_shared_data.robot.types import RobotType
 from .python_protocol_wrappers import SimulatingContextCreator
 from .run_orchestrator import RunOrchestrator
 from .protocol_runner import create_protocol_runner, LiveRunner
+from ..protocol_engine.types import (
+    PostRunHardwareState,
+)
+
+
+class SimulatingRunOrchestrator(RunOrchestrator):
+    """A RunOrchestrator that cleans up its simulating hardware controller.
+
+    This should only be created and returned by create_simulating_orchestrator, unless
+    you are sure it's appropriate to clean up the hardware controller.
+    """
+
+    async def finish(
+        self,
+        error: Exception | None = None,
+        drop_tips_after_run: bool = True,
+        set_run_status: bool = True,
+        post_run_hardware_state: PostRunHardwareState = PostRunHardwareState.HOME_AND_STAY_ENGAGED,
+    ) -> None:
+        """Finish the run and clean up the simulating hardware controller."""
+        await super().finish(
+            error=error,
+            drop_tips_after_run=drop_tips_after_run,
+            set_run_status=set_run_status,
+            post_run_hardware_state=post_run_hardware_state,
+        )
+        await self._hardware_api.clean_up()
 
 
 async def create_simulating_orchestrator(
     robot_type: RobotType, protocol_config: ProtocolConfig
-) -> RunOrchestrator:
+) -> SimulatingRunOrchestrator:
     """Create a RunOrchestrator wired to a simulating HardwareControlAPI.
 
     Example:
@@ -96,7 +123,7 @@ async def create_simulating_orchestrator(
         hardware_api=simulating_hardware_api,
     )
 
-    return RunOrchestrator(
+    return SimulatingRunOrchestrator(
         hardware_api=simulating_hardware_api,
         json_or_python_protocol_runner=runner,
         protocol_engine=protocol_engine,

opentrons/protocol_runner/run_orchestrator.py

@@ -15,7 +15,10 @@ from opentrons_shared_data.robot.types import RobotType
 
 from . import protocol_runner, RunResult, JsonRunner, PythonAndLegacyRunner
 from ..hardware_control import HardwareControlAPI
-from ..hardware_control.modules import AbstractModule as HardwareModuleAPI
+from ..hardware_control.modules import (
+    AbstractModule as HardwareModuleAPI,
+    ModuleModel as HardwareModuleModel,
+)
 from ..protocol_engine import (
     ProtocolEngine,
     CommandCreate,
@@ -85,7 +88,6 @@ class RunOrchestrator:
     def __init__(
         self,
         protocol_engine: ProtocolEngine,
-        # todo(mm, 2024-07-05): This hardware_api param looks unused?
         hardware_api: HardwareControlAPI,
         fixit_runner: protocol_runner.LiveRunner,
         setup_runner: protocol_runner.LiveRunner,
@@ -115,6 +117,8 @@ class RunOrchestrator:
         self._fixit_runner.prepare()
         self._setup_runner.prepare()
         self._protocol_engine.set_and_start_queue_worker(self.command_generator)
+        # used by SimulatingRunOrchestrator to clean up the simulating hardware controller
+        self._hardware_api = hardware_api
 
     @property
     def run_id(self) -> str:
@@ -380,6 +384,18 @@ class RunOrchestrator:
         """Handle an E-stop event from the hardware API."""
         return self._protocol_engine.estop()
 
+    async def asynchronous_module_error(
+        self, module_model: HardwareModuleModel, module_serial: str | None
+    ) -> bool:
+        """Handle an asynchronous module error reported by hardware.
+
+        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.async_module_error(
+            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/api_support/definitions.py

@@ -1,6 +1,6 @@
 from .types import APIVersion
 
-MAX_SUPPORTED_VERSION = APIVersion(2, 26)
+MAX_SUPPORTED_VERSION = APIVersion(2, 27)
 """The maximum supported protocol API version in this release."""
 
 MIN_SUPPORTED_VERSION = APIVersion(2, 0)

opentrons/protocols/api_support/types.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import NamedTuple, TypedDict
+from typing import NamedTuple, TypedDict, Optional
 
 
 class APIVersion(NamedTuple):
@@ -30,3 +30,4 @@ class ThermocyclerStep(ThermocyclerStepBase, total=False):
 
     hold_time_seconds: float
     hold_time_minutes: float
+    ramp_rate: Optional[float]

opentrons/simulate.py

@@ -3,6 +3,7 @@
 This module has functions that provide a console entrypoint for simulating
 a protocol from the command line.
 """
+
 import argparse
 import asyncio
 import atexit
@@ -24,6 +25,7 @@ from typing import (
     BinaryIO,
     Optional,
     Union,
+    Iterator,
 )
 from typing_extensions import Literal
 
@@ -81,6 +83,7 @@ if TYPE_CHECKING:
     from opentrons_shared_data.labware.types import (
         LabwareDefinition as LabwareDefinitionDict,
     )
+    from opentrons.protocol_engine import ProtocolEngine
 
 
 # See Jira RCORE-535.
@@ -309,6 +312,7 @@ def get_protocol_api(
             bundled_labware=bundled_labware,
             bundled_data=bundled_data,
             extra_labware=extra_labware,
+            clean_up_hardware=(hardware_simulator is None),
         )
     else:
         if bundled_labware is not None:
@@ -326,6 +330,7 @@ def get_protocol_api(
             bundled_data=bundled_data,
             extra_labware=extra_labware,
             use_pe_virtual_hardware=use_virtual_hardware,
+            clean_up_hardware=(hardware_simulator is None),
         )
 
     # Intentional difference from execute.get_protocol_api():
@@ -781,13 +786,15 @@ def _create_live_context_non_pe(
     extra_labware: Optional[Dict[str, "LabwareDefinitionDict"]],
     bundled_labware: Optional[Dict[str, "LabwareDefinitionDict"]],
     bundled_data: Optional[Dict[str, bytes]],
+    clean_up_hardware: bool,
 ) -> ProtocolContext:
     """Return a live ProtocolContext.
 
     This controls the robot through the older infrastructure, instead of through Protocol Engine.
     """
     assert api_version < ENGINE_CORE_API_VERSION
-    return protocol_api.create_protocol_context(
+
+    ctx = protocol_api.create_protocol_context(
         api_version=api_version,
         deck_type=deck_type,
         hardware_api=hardware_api,
@@ -795,6 +802,17 @@ def _create_live_context_non_pe(
         bundled_data=bundled_data,
         extra_labware=extra_labware,
     )
+    # Hack: we need to hook the protocol context cleanup in a way that isn't safe to put
+    # in the context generally, so we can do it like this and feel sad
+    original_cleanup = ctx.cleanup
+
+    def _cleanup_hook() -> None:
+        if clean_up_hardware:
+            ctx._hw_manager.hardware.clean_up()
+        original_cleanup()
+
+    ctx.cleanup = _cleanup_hook  # type: ignore[method-assign]
+    return ctx
 
 
 def _create_live_context_pe(
@@ -805,26 +823,40 @@ def _create_live_context_pe(
     extra_labware: Dict[str, "LabwareDefinitionDict"],
     bundled_data: Optional[Dict[str, bytes]],
     use_pe_virtual_hardware: bool = True,
+    clean_up_hardware: bool = True,
 ) -> ProtocolContext:
     """Return a live ProtocolContext that controls the robot through ProtocolEngine."""
     assert api_version >= ENGINE_CORE_API_VERSION
     hardware_api_wrapped = hardware_api.wrapped()
     global _LIVE_PROTOCOL_ENGINE_CONTEXTS
+
+    @contextmanager
+    def _cleanup_hardware_with_engine() -> (
+        Iterator[tuple["ProtocolEngine", asyncio.AbstractEventLoop]]
+    ):
+
+        try:
+            with create_protocol_engine_in_thread(
+                hardware_api=hardware_api_wrapped,
+                config=_get_protocol_engine_config(
+                    robot_type, use_pe_virtual_hardware=use_pe_virtual_hardware
+                ),
+                deck_configuration=None,
+                file_provider=None,
+                error_recovery_policy=error_recovery_policy.never_recover,
+                drop_tips_after_run=False,
+                post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
+                load_fixed_trash=should_load_fixed_trash_labware_for_python_protocol(
+                    api_version
+                ),
+            ) as (engine, loop):
+                yield engine, loop
+        finally:
+            if clean_up_hardware:
+                hardware_api.clean_up()
+
     pe, loop = _LIVE_PROTOCOL_ENGINE_CONTEXTS.enter_context(
-        create_protocol_engine_in_thread(
-            hardware_api=hardware_api_wrapped,
-            config=_get_protocol_engine_config(
-                robot_type, use_pe_virtual_hardware=use_pe_virtual_hardware
-            ),
-            deck_configuration=None,
-            file_provider=None,
-            error_recovery_policy=error_recovery_policy.never_recover,
-            drop_tips_after_run=False,
-            post_run_hardware_state=PostRunHardwareState.STAY_ENGAGED_IN_PLACE,
-            load_fixed_trash=should_load_fixed_trash_labware_for_python_protocol(
-                api_version
-            ),
-        )
+        _cleanup_hardware_with_engine()
     )
 
     # `async def` so we can use loop.run_coroutine_threadsafe() to wait for its completion.
@@ -879,6 +911,7 @@ def _run_file_non_pe(
         extra_labware=extra_labware,
         bundled_labware=bundled_labware,
         bundled_data=bundled_data,
+        clean_up_hardware=False,
     )
 
     scraper = _CommandScraper(logger=logger, level=level, broker=context.broker)

opentrons/system/camera.py

@@ -30,7 +30,7 @@ async def take_picture(filename: Path) -> None:
         pass
 
     if ARCHITECTURE == SystemArchitecture.YOCTO:
-        cmd = f"v4l2-ctl --device /dev/video2 --set-fmt-video=width=1280,height=720,pixelformat=MJPG --stream-mmap --stream-to={str(filename)} --stream-count=1"
+        cmd = f"v4l2-ctl --device /dev/ot_system_camera --set-fmt-video=width=1280,height=720,pixelformat=MJPG --stream-mmap --stream-to={str(filename)} --stream-count=1"
     elif ARCHITECTURE == SystemArchitecture.BUILDROOT:
         cmd = f"ffmpeg -f video4linux2 -s 640x480 -i /dev/video0 -ss 0:0:1 -frames 1 {str(filename)}"
     else:  # HOST

{opentrons-8.7.0a6.dist-info → opentrons-8.7.0a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentrons
-Version: 8.7.0a6
+Version: 8.7.0a7
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Project-URL: opentrons.com, https://www.opentrons.com
 Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
@@ -24,7 +24,7 @@ Requires-Dist: click<9,>=8.0.0
 Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
 Requires-Dist: jsonschema<4.18.0,>=3.0.1
 Requires-Dist: numpy<2,>=1.20.0
-Requires-Dist: opentrons-shared-data==8.7.0a6
+Requires-Dist: opentrons-shared-data==8.7.0a7
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2.0.0
@@ -32,6 +32,6 @@ Requires-Dist: pyserial>=3.5
 Requires-Dist: pyusb==1.2.1
 Requires-Dist: typing-extensions<5,>=4.0.0
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex]==8.7.0a6; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex]==8.7.0a7; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware==8.7.0a6; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware==8.7.0a7; extra == 'ot2-hardware'