arcsecond 3.16.1__tar.gz → 3.16.2__tar.gz

{arcsecond-3.16.1 → arcsecond-3.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: arcsecond
-Version: 3.16.1
+Version: 3.16.2
 Summary: CLI for arcsecond.io
 Project-URL: Homepage, https://github.com/arcsecond-io/cli
 Project-URL: Issues, https://github.com/arcsecond-io/cli/issues

{arcsecond-3.16.1 → arcsecond-3.16.2}/arcsecond/hosting/backups.py

@@ -331,7 +331,15 @@ def _run_destination_backups_command(*args, timeout=60):
         return None
     try:
         out = subprocess.run(
-            ["docker", "exec", API_CONTAINER, "python", "manage.py", "destination_backups", *args],
+            [
+                "docker",
+                "exec",
+                API_CONTAINER,
+                "python",
+                "manage.py",
+                "destination_backups",
+                *args,
+            ],
             capture_output=True,
             text=True,
             check=False,
@@ -367,7 +375,9 @@ def _remote_only_items(items, remote_names):
         if not m or name in local_names:
             continue
         try:
-            ts = datetime.strptime(m.group(1), "%Y%m%d-%H%M%S").replace(tzinfo=timezone.utc)
+            ts = datetime.strptime(m.group(1), "%Y%m%d-%H%M%S").replace(
+                tzinfo=timezone.utc
+            )
         except ValueError:
             continue
         result.append((name, ts))

{arcsecond-3.16.1 → arcsecond-3.16.2}/arcsecond/hosting/local.py

@@ -228,7 +228,7 @@ def _extract_optional_service_block(packaged_text, name):
     end_index = next((i for i, line in enumerate(lines) if line.strip() == end), None)
     if begin_index is None or end_index is None or end_index < begin_index:
         return None
-    return lines[begin_index:end_index + 1]
+    return lines[begin_index : end_index + 1]
 
 
 def _with_trailing_newline_like(lines, original_text):
@@ -244,7 +244,7 @@ def _strip_optional_service_block(text, name):
     end_index = next((i for i, line in enumerate(lines) if line.strip() == end), None)
     if begin_index is None or end_index is None or end_index < begin_index:
         return text
-    del lines[begin_index:end_index + 1]
+    del lines[begin_index : end_index + 1]
     # Drop the blank separator the block carried, so strip(splice(x)) == x.
     if begin_index < len(lines) and not lines[begin_index].strip():
         del lines[begin_index]
@@ -297,12 +297,14 @@ def _reconcile_version_header(current_text, expected_text):
     updated = (
         current_text[: current_match.start()]
         + expected_match.group(0)
-        + current_text[current_match.end():]
+        + current_text[current_match.end() :]
     )
     return updated if updated == expected_text else None
 
 
-def write_docker_compose_file(enabled_services=frozenset(), removed_services=frozenset()) -> Path:
+def write_docker_compose_file(
+    enabled_services=frozenset(), removed_services=frozenset()
+) -> Path:
     """
     Materialise the packaged docker-compose.yml in the current directory.
 

{arcsecond-3.16.1 → arcsecond-3.16.2}/arcsecond/imagesources/sources/opencv.py

@@ -7,6 +7,7 @@ Designed for USB webcams attached to the host running the proxy.
 
 import asyncio
 import logging
+import sys
 from typing import Optional
 
 from .base import FrameSource, SourceInfo
@@ -18,6 +19,28 @@ _JPEG_QUALITY = 60  # 0-100
 _MAX_PROBE = 10  # device indices to probe during detection
 
 
+def _capture_backend():
+    """The OpenCV backend to open device *indices* with, for this platform.
+
+    Never ``CAP_ANY``. Left to choose for itself, OpenCV walks its backend list
+    and — on a machine with no camera at that index — ends up at FFMPEG, which
+    interprets an integer index by asking libavdevice to enumerate DirectShow
+    devices. That path is slow, cannot work, and prints a wall of
+    ``Could not enumerate audio only devices`` to stderr for every index probed.
+
+    Pinning the platform's native backend also keeps index numbering stable:
+    detection and ``open()`` must agree on what device index 1 means, and each
+    backend enumerates in its own order.
+    """
+    import cv2
+
+    if sys.platform == "win32":
+        return cv2.CAP_DSHOW
+    if sys.platform == "darwin":
+        return cv2.CAP_AVFOUNDATION
+    return cv2.CAP_V4L2
+
+
 class OpenCVWebcamSource(FrameSource):
     kind = "webcam"
     poll_interval = _FRAME_INTERVAL
@@ -29,10 +52,13 @@ class OpenCVWebcamSource(FrameSource):
         self._cap = None
 
     async def open(self) -> None:
-        import cv2
+        import cv2  # noqa: F401
 
         loop = asyncio.get_running_loop()
-        self._cap = await loop.run_in_executor(None, cv2.VideoCapture, self.index)
+        backend = _capture_backend()
+        self._cap = await loop.run_in_executor(
+            None, cv2.VideoCapture, self.index, backend
+        )
         if not await loop.run_in_executor(None, self._cap.isOpened):
             raise RuntimeError(f"Cannot open webcam at device index {self.index}.")
 
@@ -75,9 +101,10 @@ def detect_webcams(max_index: int = _MAX_PROBE) -> list[SourceInfo]:
     """Blocking probe of device indices 0..max_index-1."""
     import cv2
 
+    backend = _capture_backend()
     found: list[SourceInfo] = []
     for i in range(max_index):
-        cap = cv2.VideoCapture(i)
+        cap = cv2.VideoCapture(i, backend)
         if not cap.isOpened():
             cap.release()
             continue

{arcsecond-3.16.1 → arcsecond-3.16.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arcsecond"
-version = "3.16.1"
+version = "3.16.2"
 authors = [
     { name = "Cedric Foellmi", email = "cedric@arcsecond.io" },
 ]

arcsecond-3.16.2/tests/test_imagesources_webcam.py

@@ -0,0 +1,140 @@
+"""Tests for the OpenCV webcam source (``webcam:``).
+
+The point of most of these is the capture *backend*. Device indices must never
+be opened with ``CAP_ANY``: OpenCV then falls through its backend list to
+FFMPEG, which tries to enumerate DirectShow devices, floods stderr and cannot
+succeed. Detection and ``open()`` must also agree on the backend, or they would
+not agree on what device index 1 refers to.
+"""
+
+import asyncio
+import sys
+from unittest.mock import MagicMock, patch
+
+from arcsecond.imagesources.sources.opencv import (
+    OpenCVWebcamSource,
+    _capture_backend,
+    detect_webcams,
+)
+
+
+def _fake_cv2():
+    cv2 = MagicMock()
+    cv2.CAP_ANY = 0
+    cv2.CAP_DSHOW = 700
+    cv2.CAP_AVFOUNDATION = 1200
+    cv2.CAP_V4L2 = 200
+    cv2.CAP_PROP_FRAME_WIDTH = 3
+    cv2.CAP_PROP_FRAME_HEIGHT = 4
+    cv2.CAP_PROP_FPS = 5
+    cv2.IMWRITE_JPEG_QUALITY = 1
+    cv2.VideoCapture.return_value.isOpened.return_value = True
+    cv2.VideoCapture.return_value.get.return_value = 0
+    return cv2
+
+
+# ---------------------------------------------------------------------------
+# Backend selection
+# ---------------------------------------------------------------------------
+
+
+def test_capture_backend_is_dshow_on_windows():
+    cv2 = _fake_cv2()
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "win32"):
+        assert _capture_backend() == cv2.CAP_DSHOW
+
+
+def test_capture_backend_is_avfoundation_on_macos():
+    cv2 = _fake_cv2()
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "darwin"):
+        assert _capture_backend() == cv2.CAP_AVFOUNDATION
+
+
+def test_capture_backend_is_v4l2_on_linux():
+    cv2 = _fake_cv2()
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "linux"):
+        assert _capture_backend() == cv2.CAP_V4L2
+
+
+def test_capture_backend_is_never_cap_any():
+    cv2 = _fake_cv2()
+    for platform in ("win32", "darwin", "linux", "freebsd14"):
+        with (
+            patch.dict(sys.modules, {"cv2": cv2}),
+            patch.object(sys, "platform", platform),
+        ):
+            assert _capture_backend() != cv2.CAP_ANY
+
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+
+def test_detect_webcams_pins_the_backend_on_every_probe():
+    cv2 = _fake_cv2()
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "win32"):
+        detect_webcams(max_index=3)
+
+    assert cv2.VideoCapture.call_count == 3
+    for i, call in enumerate(cv2.VideoCapture.call_args_list):
+        assert call.args == (i, cv2.CAP_DSHOW)
+
+
+def test_detect_webcams_reports_every_open_index():
+    cv2 = _fake_cv2()
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "linux"):
+        found = detect_webcams(max_index=2)
+
+    assert [i.id for i in found] == ["webcam:0", "webcam:1"]
+    assert all(i.kind == "webcam" for i in found)
+    assert [i.extra["index"] for i in found] == [0, 1]
+
+
+def test_detect_webcams_skips_indices_that_do_not_open():
+    cv2 = _fake_cv2()
+    cv2.VideoCapture.return_value.isOpened.side_effect = [False, True, False]
+
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "linux"):
+        found = detect_webcams(max_index=3)
+
+    assert [i.id for i in found] == ["webcam:1"]
+    # Every probe is released, including the ones that never opened.
+    assert cv2.VideoCapture.return_value.release.call_count == 3
+
+
+def test_detect_webcams_finds_nothing_when_no_device_opens():
+    cv2 = _fake_cv2()
+    cv2.VideoCapture.return_value.isOpened.return_value = False
+
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "win32"):
+        assert detect_webcams(max_index=4) == []
+
+
+# ---------------------------------------------------------------------------
+# Opening a source
+# ---------------------------------------------------------------------------
+
+
+def test_open_uses_the_same_backend_as_detection():
+    cv2 = _fake_cv2()
+    source = OpenCVWebcamSource(2)
+
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "win32"):
+        asyncio.run(source.open())
+
+    cv2.VideoCapture.assert_called_once_with(2, cv2.CAP_DSHOW)
+
+
+def test_open_raises_when_the_device_will_not_open():
+    cv2 = _fake_cv2()
+    cv2.VideoCapture.return_value.isOpened.return_value = False
+    source = OpenCVWebcamSource(0)
+
+    with patch.dict(sys.modules, {"cv2": cv2}), patch.object(sys, "platform", "linux"):
+        try:
+            asyncio.run(source.open())
+        except RuntimeError as e:
+            assert "device index 0" in str(e)
+        else:
+            raise AssertionError("expected open() to raise")

{arcsecond-3.16.1 → arcsecond-3.16.2}/uv.lock

@@ -155,7 +155,7 @@ wheels = [
 
 [[package]]
 name = "arcsecond"
-version = "3.16.1"
+version = "3.16.2"
 source = { editable = "." }
 dependencies = [
     { name = "alpyca" },