Merge back 'chore_release-8.8.0' into 'chore_release-pd-8.7.0' (#20304)

Author: ddcc4

api/src/opentrons/system/camera.py

@@ -158,7 +158,7 @@ async def update_live_stream_status(
         and camera_enable_settings.liveStreamEnabled
     ):
         # Check to see if the camera device is available
-        raw_device = str(contents["SOURCE"])[1:-1]
+        raw_device = str(contents["SOURCE"])
         if not os.path.exists(raw_device):
             log.error(
                 f"Opentrons Live Stream cannot sample the camera. No video device found with device path: {raw_device}"

app-shell/build/release-notes.md

@@ -24,6 +24,11 @@ Welcome to the v8.8.0 release of the Opentrons App! This release includes concur
 - An attached pipette no longer descends to attach a calibration probe for Labware Position Check, creating more clearance on the deck.
 - Changed runtime parameters no longer revert to their default values.
 
+### Known Issues
+
+- Error recovery in the app or on the Flex touchscreen can't successfully resolve overpressure errors that occur during a dynamic aspirate or dispense. We recommend canceling the protocol when these errors occur.
+- Images captured in a protocol are not available during the run via USB. Use a different connection type (Wi-Fi or Ethernet), view the images on the touchscreen, or download the images after the run is complete.
+
 ---
 
 ## Opentrons App Changes in 8.7.0

app/src/organisms/ErrorRecoveryFlows/utils/getErrorKind.ts

@@ -26,11 +26,13 @@ export function getErrorKind(
           case 'prepareToAspirate':
             return ERROR_KINDS.OVERPRESSURE_PREPARE_TO_ASPIRATE
           case 'aspirate':
-          case 'aspirateInPlace': {
+          case 'aspirateInPlace':
+          case 'aspirateWhileTracking': {
             return ERROR_KINDS.OVERPRESSURE_WHILE_ASPIRATING
           }
           case 'dispense':
           case 'dispenseInPlace':
+          case 'dispenseWhileTracking':
           case 'blowout':
           case 'blowOutInPlace':
             return ERROR_KINDS.OVERPRESSURE_WHILE_DISPENSING

robot-server/robot_server/app_setup.py

@@ -5,6 +5,8 @@
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.openapi.docs import get_redoc_html
+from fastapi.responses import HTMLResponse
 
 from server_utils.fastapi_utils.server_timing_middleware import server_timing_middleware
 
@@ -36,6 +38,9 @@
 )
 
 
+_REDOC_CDN_URL = "https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js"
+
+
 @contextlib.asynccontextmanager
 async def _lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """The server's startup and shutdown logic.
@@ -108,9 +113,31 @@ async def _lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     # Disable documentation hosting via Swagger UI, normally at /docs.
     # We instead focus on the docs hosted by ReDoc, at /redoc.
     docs_url=None,
+    # redoc_url is replaced by our own /redoc router, below.
+    redoc_url=None,
     lifespan=_lifespan,
 )
 
+
+# This is a workaround for a broken /redoc page in versions of FastAPI <0.115.3.
+# The page loads Redoc from a CDN, and the problem is that the default CDN URL
+# uses a fragile version tag.
+# https://github.com/Redocly/redoc/issues/2743
+# https://github.com/fastapi/fastapi/pull/9700
+@app.get("/redoc", include_in_schema=False)
+async def redoc_html() -> HTMLResponse:  # noqa: D103
+    if app.openapi_url is None:
+        raise RuntimeError(
+            "Couldn't get OpenAPI URL from FastAPI."
+            + " This is probably some kind of misconfiguration."
+        )
+    return get_redoc_html(
+        openapi_url=app.openapi_url,
+        title=app.title,
+        redoc_js_url=_REDOC_CDN_URL,
+    )
+
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=("*"),

robot-server/robot_server/maintenance_runs/maintenance_run_data_manager.py

@@ -19,6 +19,11 @@
 from opentrons.protocol_engine.types import DeckConfigurationType
 
 from robot_server.service.notifications import MaintenanceRunsPublisher
+from opentrons.protocol_engine.resources.camera_provider import (
+    CameraProvider,
+    CameraSettings,
+)
+from opentrons.system import camera
 
 
 def _build_run(
@@ -92,6 +97,7 @@ async def create(
         labware_offsets: Sequence[LabwareOffsetCreate | LegacyLabwareOffsetCreate],
         deck_configuration: DeckConfigurationType,
         notify_publishers: Callable[[], None],
+        camera_provider: CameraProvider,
     ) -> MaintenanceRun:
         """Create a new, current maintenance run.
 
@@ -100,6 +106,7 @@ async def create(
             created_at: Creation datetime.
             labware_offsets: Labware offsets to initialize the engine with.
             notify_publishers: Utilized by the engine to notify publishers of state changes.
+            camera_provider: Utility for accessing image capture and camera settings.
 
         Returns:
             The run resource.
@@ -115,6 +122,13 @@ async def create(
             notify_publishers=notify_publishers,
         )
 
+        await camera.update_live_stream_status(
+            self._run_orchestrator_store._robot_type,
+            True,
+            camera_provider,
+            state_summary.cameraSettings,
+        )
+
         maintenance_run_data = _build_run(
             run_id=run_id,
             created_at=created_at,
@@ -151,11 +165,18 @@ def get(self, run_id: str) -> MaintenanceRun:
             state_summary=state_summary,
         )
 
-    async def delete(self, run_id: str) -> None:
+    async def delete(
+        self,
+        run_id: str,
+        camera_settings: CameraSettings | None,
+        camera_provider: CameraProvider,
+    ) -> None:
         """Delete a maintenance run.
 
         Args:
             run_id: The identifier of the run to remove.
+            camera_settings: Optional set of camera settings form an external run. If None do not attempt to restart the live stream.
+            camera_provider: Utility for accessing image capture and camera settings.
 
         Raises:
             RunConflictError: If deleting the current run, the current run
@@ -166,6 +187,15 @@ async def delete(self, run_id: str) -> None:
             await self._run_orchestrator_store.clear()
             await self._maintenance_runs_publisher.publish_current_maintenance_run_async()
 
+            if camera_settings is not None:
+                # Restart the live stream for the external run when the maintenance run has ended.
+                await camera.update_live_stream_status(
+                    self._run_orchestrator_store._robot_type,
+                    True,
+                    camera_provider,
+                    camera_settings,
+                )
+
         else:
             raise MaintenanceRunNotFoundError(run_id=run_id)
 

robot-server/robot_server/maintenance_runs/router/base_router.py

@@ -35,12 +35,19 @@
 from ..maintenance_run_orchestrator_store import RunConflictError
 from ..maintenance_run_data_manager import MaintenanceRunDataManager
 from ..dependencies import get_maintenance_run_data_manager
+from robot_server.runs.dependencies import get_run_data_manager
+from robot_server.runs.run_data_manager import RunDataManager
 
 from robot_server.deck_configuration.fastapi_dependencies import (
     get_deck_configuration_store,
 )
 from robot_server.deck_configuration.store import DeckConfigurationStore
 from robot_server.service.notifications import get_pe_notify_publishers
+from robot_server.camera.fastapi_dependencies import (
+    get_camera_provider,
+)
+from opentrons.protocol_engine.resources.camera_provider import CameraProvider
+from opentrons.protocol_engine.types import EngineStatus
 
 log = logging.getLogger(__name__)
 base_router = LightRouter()
@@ -157,6 +164,7 @@ async def create_run(
         DeckConfigurationStore, Depends(get_deck_configuration_store)
     ],
     notify_publishers: Annotated[Callable[[], None], Depends(get_pe_notify_publishers)],
+    camera_provider: Annotated[CameraProvider, Depends(get_camera_provider)],
     request_body: Optional[RequestModel[MaintenanceRunCreate]] = None,
 ) -> PydanticResponse[SimpleBody[MaintenanceRun]]:
     """Create a new maintenance run.
@@ -169,6 +177,7 @@ async def create_run(
         is_ok_to_create_maintenance_run: Verify if a maintenance run may be created if a protocol run exists.
         check_estop: Dependency to verify the estop is in a valid state.
         deck_configuration_store: Dependency to fetch the deck configuration.
+        camera_provider: Dependency to provide access to the Camera Settings to the run.
         notify_publishers: Utilized by the engine to notify publishers of state changes.
     """
     if not is_ok_to_create_maintenance_run:
@@ -185,6 +194,7 @@ async def create_run(
         labware_offsets=offsets,
         deck_configuration=deck_configuration,
         notify_publishers=notify_publishers,
+        camera_provider=camera_provider,
     )
 
     log.info(f'Created an empty run "{run_id}"".')
@@ -267,18 +277,36 @@ async def get_run(
 )
 async def remove_run(
     runId: str,
-    run_data_manager: Annotated[
+    maintenance_run_data_manager: Annotated[
         MaintenanceRunDataManager, Depends(get_maintenance_run_data_manager)
     ],
+    run_data_manager: Annotated[RunDataManager, Depends(get_run_data_manager)],
+    camera_provider: Annotated[CameraProvider, Depends(get_camera_provider)],
 ) -> PydanticResponse[SimpleEmptyBody]:
     """Delete a maintenance run by its ID.
 
     Arguments:
         runId: Run ID pulled from URL.
+        maintenance_run_data_manager: Current maintenance run data management.
         run_data_manager: Current run data management.
+        camera_provider: Utility for accessing image capture and camera settings.
     """
     try:
-        await run_data_manager.delete(runId)
+        camera_settings = None
+        if run_data_manager.current_run_id is not None:
+            # Import the camera settings from an external run if one exists
+            state_summary = run_data_manager._get_good_state_summary(
+                run_data_manager.current_run_id
+            )
+            if (
+                state_summary is not None
+                and state_summary.status is not EngineStatus.FINISHING
+            ):
+                camera_settings = state_summary.cameraSettings
+
+        await maintenance_run_data_manager.delete(
+            runId, camera_settings, camera_provider
+        )
 
     except RunConflictError as e:
         raise RunNotIdle().as_error(status.HTTP_409_CONFLICT) from e

robot-server/robot_server/runs/run_data_manager.py

@@ -207,6 +207,7 @@ async def create(
             created_at: Creation datetime.
             labware_offsets: Labware offsets to initialize the engine with.
             deck_configuration: A mapping of fixtures to cutout fixtures the deck will be loaded with.
+            camera_provider: Utility for accessing image capture and camera settings.
             notify_publishers: Utilized by the engine to notify publishers of state changes.
             run_time_param_values: Any runtime parameter values to set.
             run_time_param_paths: Any runtime filepath to set.

robot-server/tests/maintenance_runs/router/conftest.py

@@ -8,6 +8,7 @@
 from robot_server.maintenance_runs.maintenance_run_data_manager import (
     MaintenanceRunDataManager,
 )
+from robot_server.runs.run_data_manager import RunDataManager
 from opentrons.protocol_engine import ProtocolEngine
 from robot_server.deck_configuration.store import DeckConfigurationStore
 
@@ -28,10 +29,16 @@ def mock_protocol_engine(decoy: Decoy) -> ProtocolEngine:
 
 @pytest.fixture
 def mock_maintenance_run_data_manager(decoy: Decoy) -> MaintenanceRunDataManager:
-    """Get a mock RunDataManager."""
+    """Get a mock MaintenanceRunDataManager."""
     return decoy.mock(cls=MaintenanceRunDataManager)
 
 
+@pytest.fixture
+def mock_run_data_manager(decoy: Decoy) -> RunDataManager:
+    """Get a mock RunDataManager."""
+    return decoy.mock(cls=RunDataManager)
+
+
 @pytest.fixture
 def mock_deck_configuration_store(decoy: Decoy) -> DeckConfigurationStore:
     """Get a mock DeckConfigurationStore."""