pyobs-aravis 2.0.0.dev7__tar.gz → 2.0.0.dev9__tar.gz

{pyobs_aravis-2.0.0.dev7 → pyobs_aravis-2.0.0.dev9}/PKG-INFO

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

{pyobs_aravis-2.0.0.dev7 → pyobs_aravis-2.0.0.dev9}/pyobs_aravis/araviscamera.py

@@ -16,6 +16,11 @@ log = logging.getLogger(__name__)
 # rather than let a single dead camera freeze the whole module.
 _SDK_CALL_TIMEOUT = 5.0
 
+# pop_frame() is polled from _capture() and is expected to legitimately take a while (up to the
+# camera's own frame interval/exposure time), unlike the other SDK calls above -- a much more
+# generous timeout than _SDK_CALL_TIMEOUT, so normal operation never trips it.
+_FRAME_WAIT_TIMEOUT = 30.0
+
 
 class AravisCamera(BaseVideo, IExposureTime):
     """A pyobs module for Aravis cameras."""
@@ -57,7 +62,18 @@ class AravisCamera(BaseVideo, IExposureTime):
 
         await BaseVideo.open(self)
 
-        ids: list[str] = aravis.get_device_ids()  # type: ignore[assignment]
+        # device discovery is a blocking, network-based scan (GigE Vision/USB3 Vision devices
+        # reply to a broadcast query) that can take multiple seconds -- run it like the other
+        # aravis/GLib calls (see _run_blocking) instead of freezing the whole module's event
+        # loop, and with it, the ability to respond to any other module, for that long
+        ids: list[str] = []
+
+        def _list_device_ids() -> None:
+            ids.extend(aravis.get_device_ids())  # type: ignore[arg-type]
+
+        if not await self._run_blocking(_list_device_ids):
+            raise TimeoutError(f"Timed out listing available cameras after {_SDK_CALL_TIMEOUT}s.")
+
         if self._camera_device_name not in ids:
             raise ValueError("Could not find given device name in list of available cameras.")
 
@@ -142,10 +158,10 @@ class AravisCamera(BaseVideo, IExposureTime):
                     await asyncio.sleep(0.1)
                     continue
 
-                frame: npt.NDArray[Any] = self._camera.pop_frame()  # type: ignore[union-attr]
-                while frame is None:
-                    await asyncio.sleep(0.01)
-                    frame = self._camera.pop_frame()  # type: ignore[union-attr]
+                frame = await self._wait_for_frame()
+                if frame is None:
+                    # camera went away, or the wait timed out -- back off and retry
+                    continue
 
                 if time.time() - last < self._interval:
                     await asyncio.sleep(0.01)
@@ -157,6 +173,38 @@ class AravisCamera(BaseVideo, IExposureTime):
             except Exception:
                 await asyncio.sleep(1)
 
+    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
+        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
+        entire runtime. Runs the whole "poll until ready" loop as a single blocking call instead,
+        so only one thread gets spawned per delivered frame rather than one per 10ms poll.
+
+        Returns:
+            The next frame, or None if the camera disappeared mid-wait or the wait timed out.
+        """
+        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
+                # 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]
+                    return
+                time.sleep(0.01)
+
+        if not await self._run_blocking(_poll, timeout=timeout):
+            log.error("Timed out waiting for a frame after %.1fs.", timeout)
+            return None
+        return result[0] if result else None
+
     async def set_exposure_time(self, exposure_time: float, **kwargs: Any) -> None:
         """Set the exposure time in seconds.
 

{pyobs_aravis-2.0.0.dev7 → pyobs_aravis-2.0.0.dev9}/pyproject.toml

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

{pyobs_aravis-2.0.0.dev7 → pyobs_aravis-2.0.0.dev9}/uv.lock

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