pyobs-aravis 2.0.0.dev15__tar.gz → 2.0.0.dev16__tar.gz

pyobs_aravis-2.0.0.dev16/.github/workflows/dependabot-automerge.yml

@@ -0,0 +1,24 @@
+name: Dependabot auto-merge
+
+on: pull_request
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.user.login == 'dependabot[bot]' }}
+    steps:
+      - name: Fetch Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2
+        with:
+          compat-lookup: true
+      - name: Enable auto-merge for patch and minor updates
+        if: ${{ steps.metadata.outputs.update-type == 'version-update:semver-patch' || steps.metadata.outputs.update-type == 'version-update:semver-minor' }}
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-aravis
-Version: 2.0.0.dev15
+Version: 2.0.0.dev16
 Summary: pyobs module for Aravis cameras
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/pyobs_aravis/aravis.py

@@ -209,14 +209,53 @@ class Camera(object):
         if not buf:
             return None
         pixel_format = buf.get_image_pixel_format()
+        # The pixel format value packs total bits per pixel into bits 16-23 (see
+        # ARV_PIXEL_FORMAT_BIT_PER_PIXEL) and a component count category into bits 24-31
+        # (1 = single-plane mono/Bayer, 2 = multi-component colour). Mono 10/12/14-bit depths
+        # are stored in 16-bit samples (bits_per_pixel == 16), so they need no special case here.
         bits_per_pixel = pixel_format >> 16 & 0xFF
-        if bits_per_pixel == 8:
-            INTP = ctypes.POINTER(ctypes.c_uint8)
+        num_components = pixel_format >> 24 & 0xFF
+        height = buf.get_image_height()
+        width = buf.get_image_width()
+
+        if num_components == 1:
+            # mono or Bayer: one sample per pixel
+            if bits_per_pixel == 8:
+                INTP = ctypes.POINTER(ctypes.c_uint8)
+            elif bits_per_pixel == 16:
+                INTP = ctypes.POINTER(ctypes.c_uint16)
+            else:
+                raise AravisException(
+                    "Unsupported pixel format %#x (%d bits per pixel)" % (pixel_format, bits_per_pixel)
+                )
+            shape = (height, width)
+        elif num_components == 2:
+            # colour: interleaved channels; reshape to (height, width, channels) rather than
+            # flattening every channel into a single mono array
+            if pixel_format in (Aravis.PIXEL_FORMAT_RGB_8_PACKED, Aravis.PIXEL_FORMAT_BGR_8_PACKED):
+                INTP = ctypes.POINTER(ctypes.c_uint8)
+                shape = (height, width, 3)
+            elif pixel_format in (Aravis.PIXEL_FORMAT_RGBA_8_PACKED, Aravis.PIXEL_FORMAT_BGRA_8_PACKED):
+                INTP = ctypes.POINTER(ctypes.c_uint8)
+                shape = (height, width, 4)
+            elif pixel_format in (
+                Aravis.PIXEL_FORMAT_RGB_10_PACKED,
+                Aravis.PIXEL_FORMAT_BGR_10_PACKED,
+                Aravis.PIXEL_FORMAT_RGB_12_PACKED,
+                Aravis.PIXEL_FORMAT_BGR_12_PACKED,
+            ):
+                INTP = ctypes.POINTER(ctypes.c_uint16)
+                shape = (height, width, 3)
+            else:
+                raise AravisException(
+                    "Unsupported pixel format %#x (%d bits per pixel)" % (pixel_format, bits_per_pixel)
+                )
         else:
-            INTP = ctypes.POINTER(ctypes.c_uint16)
+            raise AravisException("Unsupported pixel format %#x (%d bits per pixel)" % (pixel_format, bits_per_pixel))
+
         addr = buf.get_data()
         ptr = ctypes.cast(addr, INTP)
-        im = np.ctypeslib.as_array(ptr, (buf.get_image_height(), buf.get_image_width()))
+        im = np.ctypeslib.as_array(ptr, shape)
         im = im.copy()
         return im
 
@@ -260,11 +299,19 @@ class Camera(object):
         self.cam.stop_acquisition()
 
     def shutdown(self):
-        # Delete the objects on shutdown: socket will be closed!
+        # Explicitly stop acquisition, then release the Aravis objects. stop_acquisition()
+        # tells the camera to stop streaming; dropping the stream/device/camera releases our
+        # GObject references so the underlying GigE socket is closed when the device is
+        # finalized. Serialized against try_pop_frame() by self._lock, so a poll in a
+        # background thread can't be mid-read while we tear the objects down.
         with self._lock:
             if self._closed:
                 return
             self._closed = True
+            try:
+                self.cam.stop_acquisition()
+            except Exception:
+                self.logger.exception("Error stopping acquisition during shutdown.")
             del self.stream
             del self.dev
             del self.cam

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/pyobs_aravis/araviscamera.py

@@ -51,6 +51,11 @@ class AravisCamera(BaseVideo, IExposureTime):
         self._camera: aravis.Camera | None = None
         self._settings: dict[str, Any] = {} if settings is None else settings
         self._camera_lock = asyncio.Lock()
+        # Serializes access to self._camera between the SDK threads spawned by _run_blocking:
+        # the background poll thread (_wait_for_frame) reads frames from the camera while
+        # _open_camera/_close_camera set/tear down the same object, and those run on other
+        # daemon threads rather than the event loop, so the async _camera_lock can't cover them.
+        self._device_lock = threading.Lock()
         self._buffers = buffers
         self._exposure_time: float = 0.0
 
@@ -83,25 +88,27 @@ class AravisCamera(BaseVideo, IExposureTime):
         from . import aravis
 
         log.info("Connecting to camera %s...", self._camera_device_name)
-        self._camera = aravis.Camera(self._camera_device_name)  # type: ignore[assignment]
-        log.info("Connected.")
+        with self._device_lock:
+            self._camera = aravis.Camera(self._camera_device_name)  # type: ignore[assignment]
+            log.info("Connected.")
 
-        for key, value in self._settings.items():
-            log.info("Setting value %s=%s...", key, value)
-            self._camera.set_feature(key, value)  # type: ignore[union-attr]
+            for key, value in self._settings.items():
+                log.info("Setting value %s=%s...", key, value)
+                self._camera.set_feature(key, value)  # type: ignore[union-attr]
 
-        self._camera.start_acquisition_continuous(nb_buffers=self._buffers)  # type: ignore[union-attr]
+            self._camera.start_acquisition_continuous(nb_buffers=self._buffers)  # type: ignore[union-attr]
 
     def _close_camera(self) -> None:
         """Close camera."""
-        if self._camera is not None:
-            log.info("Closing camera...")
-            try:
-                self._camera.stop_acquisition()  # type: ignore[union-attr]
-                self._camera.shutdown()  # type: ignore[union-attr]
-            except Exception:
-                log.exception("Error closing camera.")
-        self._camera = None
+        with self._device_lock:
+            if self._camera is not None:
+                log.info("Closing camera...")
+                try:
+                    self._camera.stop_acquisition()  # type: ignore[union-attr]
+                    self._camera.shutdown()  # type: ignore[union-attr]
+                except Exception:
+                    log.exception("Error closing camera.")
+            self._camera = None
 
     @staticmethod
     async def _run_blocking(func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT) -> bool:
@@ -178,8 +185,8 @@ class AravisCamera(BaseVideo, IExposureTime):
     async def _wait_for_frame(self, timeout: float = _FRAME_WAIT_TIMEOUT) -> npt.NDArray[Any] | None:
         """Waits for the next frame without blocking the event loop.
 
-        Polls pop_frame() from a background thread (see _run_blocking) rather than polling it
-        directly from the async loop with a sleep in between each attempt -- pop_frame() is
+        Polls try_pop_frame() from a background thread (see _run_blocking) rather than polling it
+        directly from the async loop with a sleep in between each attempt -- try_pop_frame() is
         assumed non-blocking in the common case, but if the underlying aravis/GLib call ever
         doesn't honor that (camera hiccup, network stall for GigE Vision), polling it directly
         would freeze the whole module for as long as that lasts, repeatedly, for the module's
@@ -192,10 +199,16 @@ class AravisCamera(BaseVideo, IExposureTime):
         result: list[npt.NDArray[Any]] = []
 
         def _poll() -> None:
-            camera = self._camera
-            while camera is not None:
-                frame = camera.pop_frame()  # type: ignore[union-attr]
-                # pop_frame() can return a non-None array that's empty along axis 0 instead of
+            while True:
+                # Hold the device lock only for the (non-blocking) try_pop_frame() call and the
+                # camera reference check, so _close_camera() running on another thread can take the
+                # lock between polls and tear the camera down without racing a mid-frame read.
+                with self._device_lock:
+                    camera = self._camera
+                    if camera is None:
+                        return
+                    frame = camera.try_pop_frame()  # type: ignore[union-attr]
+                # try_pop_frame() can return a non-None array that's empty along axis 0 instead of
                 # None -- treat that the same as "not ready yet" rather than a real frame
                 if frame is not None and frame.size != 0:  # type: ignore[union-attr]
                     result.append(frame)  # type: ignore[arg-type]
@@ -214,7 +227,13 @@ class AravisCamera(BaseVideo, IExposureTime):
             exposure_time: Exposure time in seconds.
         """
         await self.activate_camera()
-        self._camera.set_exposure_time(exposure_time * 1e6)  # type: ignore[union-attr]
+
+        def _set() -> None:
+            # take the device lock so this can't race _close_camera() tearing down self._camera
+            with self._device_lock:
+                self._camera.set_exposure_time(exposure_time * 1e6)  # type: ignore[union-attr]
+
+        await self._run_blocking(_set)
         self._exposure_time = exposure_time
         await self.comm.set_state(IExposureTime, ExposureTimeState(exposure_time=exposure_time))
 

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/pyobs_aravis/gui.py

@@ -1,6 +1,8 @@
 import asyncio
 import sys
-from typing import Any
+import threading
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 import qasync  # type: ignore
 from astropy.io import fits
@@ -10,15 +12,38 @@ from PySide6 import QtWidgets  # type: ignore[import-untyped]
 
 from . import aravis
 
+_T = TypeVar("_T")
+
+
+async def _run_blocking(func: Callable[[], _T]) -> _T:
+    """Run a blocking aravis/GLib call in a daemon thread, mirroring AravisCamera._run_blocking.
+
+    The default ThreadPoolExecutor (what run_in_executor(None, ...) uses) is deliberately
+    avoided here: its worker threads are non-daemon, so a hung GigE call would block interpreter
+    shutdown instead of just this call. A fresh daemon thread per call has the same drawback the
+    module accepts for the same reason.
+    """
+    loop = asyncio.get_running_loop()
+    future: asyncio.Future[_T] = loop.create_future()
+
+    def _wrapper() -> None:
+        try:
+            result = func()
+        except BaseException as exc:
+            loop.call_soon_threadsafe(future.set_exception, exc)
+        else:
+            loop.call_soon_threadsafe(future.set_result, result)
+
+    threading.Thread(target=_wrapper, daemon=True).start()
+    return await future
+
 
 class MainWindow(QtWidgets.QMainWindow):
     def __init__(self, device: str) -> None:
         super().__init__()
         self.setWindowTitle(f"Aravis Camera — {device}")
 
-        self.camera = aravis.Camera(device)
-        self.camera.start_acquisition_continuous()
-
+        self.camera: aravis.Camera | None = None
         self._last_frame: NDArray[Any] | None = None
         self._preview_task: asyncio.Task[None] | None = None
 
@@ -29,7 +54,6 @@ class MainWindow(QtWidgets.QMainWindow):
         controls = QtWidgets.QGroupBox("Camera")
         controls_layout = QtWidgets.QVBoxLayout(controls)
         self.exposure_time = ExposureTimeWidget()
-        self.exposure_time.spin_exposure_time.setValue(self.camera.get_exposure_time() / 1e6)
         self.exposure_time.exposure_time_changed.connect(self._exposure_time_changed)
         controls_layout.addWidget(self.exposure_time)
         self.expose = ExposeWidget(can_abort_exposure=False)
@@ -42,33 +66,49 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.expose.expose_clicked.connect(self._expose_clicked)
 
+        self._init_task = asyncio.ensure_future(self._init_camera(device))
+
+    async def _init_camera(self, device: str) -> None:
+        # Camera construction + start_acquisition_continuous are blocking (GigE discovery and
+        # handshake can take seconds), so run them off the Qt thread rather than in __init__.
+        self.camera = await _run_blocking(lambda: aravis.Camera(device))
+        await _run_blocking(self.camera.start_acquisition_continuous)
+        exposure_time = await _run_blocking(self.camera.get_exposure_time)
+        self.exposure_time.spin_exposure_time.setValue(exposure_time / 1e6)
         self._preview_task = asyncio.ensure_future(self._live_preview())
 
-    def _exposure_time_changed(self, value: float) -> None:
-        self.camera.set_exposure_time(value * 1e6)
+    @qasync.asyncSlot(float)  # type: ignore
+    async def _exposure_time_changed(self, value: float) -> None:
+        if self.camera is not None:
+            await _run_blocking(lambda: self.camera.set_exposure_time(value * 1e6))
 
     async def _live_preview(self) -> None:
-        loop = asyncio.get_running_loop()
         while True:
-            self._last_frame = await loop.run_in_executor(None, self.camera.pop_frame)  # type: ignore
+            if self.camera is None:
+                await asyncio.sleep(0.05)
+                continue
+            self._last_frame = await _run_blocking(self.camera.pop_frame)
             self.display.set_data(fits.PrimaryHDU(self._last_frame))
             await asyncio.sleep(0.05)
 
     @qasync.asyncSlot(int)  # type: ignore
     async def _expose_clicked(self, count: int) -> None:
+        if self.camera is None:
+            return
         self.expose.start_exposure(self.exposure_time.value)
-        loop = asyncio.get_running_loop()
         for _ in range(count):
-            self._last_frame = await loop.run_in_executor(None, self.camera.pop_frame)  # type: ignore
+            self._last_frame = await _run_blocking(self.camera.pop_frame)
         if self._last_frame is not None:
             self.display.set_data(fits.PrimaryHDU(self._last_frame))
         self.expose.set_exposures_left()
 
     def closeEvent(self, event: Any) -> None:
+        self._init_task.cancel()
         if self._preview_task is not None:
             self._preview_task.cancel()
-        self.camera.stop_acquisition()
-        self.camera.shutdown()
+        if self.camera is not None:
+            self.camera.stop_acquisition()
+            self.camera.shutdown()
         super().closeEvent(event)
 
 

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-aravis"
-version = "2.0.0.dev15"
+version = "2.0.0.dev16"
 description = "pyobs module for Aravis cameras"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"

{pyobs_aravis-2.0.0.dev15 → pyobs_aravis-2.0.0.dev16}/uv.lock

@@ -2320,7 +2320,7 @@ wheels = [
 
 [[package]]
 name = "pyobs-aravis"
-version = "2.0.0.dev15"
+version = "2.0.0.dev16"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },