arcsecond 3.17.0__tar.gz → 3.17.2__tar.gz

{arcsecond-3.17.0 → arcsecond-3.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arcsecond
-Version: 3.17.0
+Version: 3.17.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.17.0 → arcsecond-3.17.2}/arcsecond/hosting/utils.py

@@ -42,8 +42,10 @@ def _read_env_value(key, env_path=None):
 
 
 def _get_random_secret_key():
-    # No '%' to avoid interpolation surprises
-    chars = "abcdefghijklmnopqrstuvwxyz0123456789!@#$^&*(-_=+)"
+    # The value lands unquoted in .env, which Compose interpolates: '$name'
+    # would be swallowed (with a "variable is not set" warning) and '%' is
+    # unsafe in configparser-style readers. Neither belongs in the alphabet.
+    chars = "abcdefghijklmnopqrstuvwxyz0123456789!@#^&*(-_=+)"
     return "".join(secrets.choice(chars) for _ in range(50))
 
 

{arcsecond-3.17.0 → arcsecond-3.17.2}/arcsecond/imagesources/commands.py

@@ -40,6 +40,7 @@ import sys
 import time
 import urllib.request
 from string import Template
+from typing import Optional
 from urllib.parse import urlsplit
 
 import click
@@ -275,12 +276,25 @@ def _list_registered(kinds, noun: str, add_example: str):
 
     click.echo(click.style(f"Registered {noun}s ({len(cameras)}):\n", bold=True))
     _print_table(
-        [(c.id, c.display_kind, c.target, c.label or "") for c in cameras],
-        ("ID", "KIND", "CAMERA", "NAME"),
+        [
+            (c.id, c.display_kind, c.target, _describe_specs(c), c.label or "")
+            for c in cameras
+        ],
+        ("ID", "KIND", "CAMERA", "DETAILS", "NAME"),
     )
     click.echo(f"\nForget one with:  {_forget_example(kinds)} <ID>")
 
 
+def _describe_specs(camera: Camera) -> str:
+    """A camera's resolution and frame rate, as recorded when it was added."""
+    specs = camera.specs or {}
+    width, height, fps = specs.get("width"), specs.get("height"), specs.get("fps")
+    if not (width and height):
+        return ""
+    size = f"{width}×{height}"
+    return f"{size}, {fps:.0f} fps" if fps else size
+
+
 def _detect_example(kinds) -> str:
     return "arcsecond allsky detect" if ALLSKY in kinds else "arcsecond webcam detect"
 
@@ -506,9 +520,12 @@ def webcam_add_cmd(camera, label):
 
     if target.isdigit():
         index = int(target)
+        # One probe, used for both jobs: telling the operator if nothing is
+        # there, and recording the camera's resolution while it is open.
+        device = _probe_index(index)
         _add(
-            Camera(id="", kind=USB, index=index, label=label),
-            absent_note=lambda: _index_absent_note(index),
+            Camera(id="", kind=USB, index=index, label=label, specs=_specs(device)),
+            absent_note=lambda: None if device else _nothing_at_index(index),
         )
         return
 
@@ -534,24 +551,53 @@ def webcam_add_cmd(camera, label):
     _add(Camera(id="", kind=NET, url=target, label=label))
 
 
-def _index_absent_note(index: int):
-    """A note if nothing is at that index — the camera is registered either way.
+def _probe_index(index: int):
+    """The device at ``index`` right now, or None.
 
-    A webcam that is unplugged right now is still a camera the operator owns,
-    and refusing to register it would mean re-typing the command later. Saying
-    nothing would let a typo sit unnoticed until the proxy failed to open it.
+    Returns None rather than raising when OpenCV is missing or the probe
+    fails: not knowing what is plugged in is a reason to say less, not a
+    reason to refuse to register a camera.
     """
     try:
         from .sources.opencv import detect_webcams
 
-        found = {d.identity for d in detect_webcams()}
+        for device in detect_webcams():
+            if device.identity == ("usb", index):
+                return device
     except Exception:
         return None
-    if ("usb", index) in found:
+    return None
+
+
+def _specs(device) -> Optional[dict]:
+    """Resolution and frame rate, as measured while the device was open.
+
+    Recorded so that listing a camera can report them without opening it —
+    `/detect` must stay answerable when a camera is busy or unplugged.
+    """
+    if device is None:
         return None
+    extra = device.extra or {}
+    specs = {
+        "width": extra.get("width"),
+        "height": extra.get("height"),
+        "fps": extra.get("fps"),
+    }
+    kept = {k: v for k, v in specs.items() if v}
+    return kept or None
+
+
+def _nothing_at_index(index: int) -> str:
+    """Said when a camera is registered while nothing is plugged in at its index.
+
+    It is registered either way: a webcam that is unplugged right now is still
+    a camera the operator owns, and refusing would mean re-typing the command
+    later. Saying nothing would let a typo sit unnoticed until the proxy failed
+    to open it.
+    """
     return (
         f"nothing is at device index {index} right now. It stays registered — "
-        "plug it in and it will be served."
+        "plug it in, then re-run this command to record its resolution."
     )
 
 

{arcsecond-3.17.0 → arcsecond-3.17.2}/arcsecond/imagesources/registry.py

@@ -34,7 +34,12 @@ def build_source(camera: Camera) -> FrameSource:
     ``store.expanded``.
     """
     if camera.kind == USB:
-        return OpenCVWebcamSource(camera.index, source_id=camera.id, label=camera.label)
+        return OpenCVWebcamSource(
+            camera.index,
+            source_id=camera.id,
+            label=camera.label,
+            specs=camera.specs,
+        )
     if camera.kind == NET:
         return build_network_source(camera.id, camera.url, camera.label)
     if camera.kind == ALLSKY:

{arcsecond-3.17.0 → arcsecond-3.17.2}/arcsecond/imagesources/sources/opencv.py

@@ -51,8 +51,10 @@ class OpenCVWebcamSource(FrameSource):
         index: int,
         source_id: Optional[str] = None,
         label: Optional[str] = None,
+        specs: Optional[dict] = None,
     ):
         self.index = index
+        self.specs = specs or {}
         # Registered cameras pass their own short id. The fallback only exists
         # for probing a device that nobody has registered yet.
         self.id = source_id or f"usb:{index}"
@@ -100,14 +102,15 @@ class OpenCVWebcamSource(FrameSource):
         self._cap = None
 
     def info(self) -> SourceInfo:
-        # Width/height/fps are only known once opened, and listing must not
-        # open anything — `arcsecond webcam detect` is what reports those.
-        return SourceInfo(
-            id=self.id,
-            kind=self.kind,
-            label=self.label,
-            extra={"transport": "usb", "index": self.index},
-        )
+        # Width, height and fps are only knowable by opening the device, and
+        # listing must not open anything — one camera being busy would hold the
+        # answer up for every other. They are measured once, when the camera is
+        # registered, and reported from the store here.
+        extra = {"transport": "usb", "index": self.index}
+        for key in ("width", "height", "fps"):
+            if self.specs.get(key):
+                extra[key] = self.specs[key]
+        return SourceInfo(id=self.id, kind=self.kind, label=self.label, extra=extra)
 
 
 def detect_webcams(max_index: int = _MAX_PROBE) -> list[DetectedDevice]:

{arcsecond-3.17.0 → arcsecond-3.17.2}/arcsecond/imagesources/store.py

@@ -91,6 +91,11 @@ class Camera:
     index: Optional[int] = None  # usb
     url: Optional[str] = None  # net
     path: Optional[str] = None  # allsky
+    # What probing learned about a USB camera: width, height, fps. Recorded at
+    # registration, when the device is opened anyway, so that listing it later
+    # can report them without opening anything. Absent for a camera registered
+    # while unplugged, and for the kinds that have no such thing.
+    specs: Optional[dict] = None
 
     @property
     def identity(self) -> tuple:
@@ -134,6 +139,8 @@ class Camera:
         entry: dict = {"kind": self.kind}
         if self.kind == USB:
             entry["index"] = self.index
+            if self.specs:
+                entry["specs"] = self.specs
         elif self.kind == NET:
             entry["url"] = self.url
         else:
@@ -154,7 +161,14 @@ def camera_from_json(cam_id: str, entry: dict) -> Optional[Camera]:
         index = entry.get("index")
         if not isinstance(index, int):
             return None
-        return Camera(id=cam_id, kind=USB, index=index, label=label)
+        specs = entry.get("specs")
+        return Camera(
+            id=cam_id,
+            kind=USB,
+            index=index,
+            label=label,
+            specs=specs if isinstance(specs, dict) else None,
+        )
     if kind == NET:
         url = entry.get("url")
         if not url:
@@ -345,8 +359,17 @@ def add(camera: Camera, path: Optional[Path] = None) -> tuple[Camera, bool]:
 
     for existing in stored.values():
         if existing.identity == camera.identity:
+            # Re-registering the same camera is how its label and its measured
+            # resolution get refreshed — a camera that was unplugged the first
+            # time, or that has been set to a different mode since.
+            changed = False
             if camera.label and camera.label != existing.label:
                 existing.label = camera.label
+                changed = True
+            if camera.specs and camera.specs != existing.specs:
+                existing.specs = camera.specs
+                changed = True
+            if changed:
                 data["cameras"][existing.id] = existing.to_json()
                 save(data, path)
             return existing, False
@@ -403,7 +426,11 @@ def expanded(cameras: list[Camera], expand) -> list[Camera]:
             continue
         usable.append(
             Camera(
-                id=camera.id, kind=NET, url=url, label=camera.label, path=camera.path
+                id=camera.id,
+                kind=NET,
+                url=url,
+                label=camera.label,
+                path=camera.path,
             )
         )
     return usable

{arcsecond-3.17.0 → arcsecond-3.17.2}/pyproject.toml

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

arcsecond-3.17.2/tests/test_hosting_utils_secret_key.py

@@ -0,0 +1,10 @@
+from arcsecond.hosting.utils import _get_random_secret_key
+
+
+def test_secret_key_has_no_compose_interpolation_characters():
+    # Compose interpolates '$name' inside .env; '%' trips configparser readers.
+    for _ in range(200):
+        key = _get_random_secret_key()
+        assert len(key) == 50
+        assert "$" not in key
+        assert "%" not in key

{arcsecond-3.17.0 → arcsecond-3.17.2}/tests/test_imagesources_commands.py

@@ -641,3 +641,76 @@ def test_a_proxy_is_only_stopped_once_its_process_is_gone(monkeypatch):
     assert commands._has_exited(8765, 4711) is False
     alive["gone"] = True
     assert commands._has_exited(8765, 4711) is True
+
+
+# ---------------------------------------------------------------------------
+# Resolution and frame rate
+# ---------------------------------------------------------------------------
+
+
+def _device(index=0, width=1280, height=720, fps=30.0):
+    return DetectedDevice(
+        kind="usb",
+        identity=("usb", index),
+        label=f"USB webcam #{index}",
+        extra={"index": index, "width": width, "height": height, "fps": fps},
+    )
+
+
+def test_add_records_what_it_measured_while_the_device_was_open(cli, monkeypatch):
+    monkeypatch.setattr(
+        "arcsecond.imagesources.sources.opencv.detect_webcams",
+        lambda *a, **k: [_device()],
+    )
+    _run(cli, webcam, ["add", "0"])
+    (camera,) = store.all_cameras()
+    assert camera.specs == {"width": 1280, "height": 720, "fps": 30.0}
+
+
+def test_listing_shows_the_resolution_without_probing(cli, monkeypatch):
+    monkeypatch.setattr(
+        "arcsecond.imagesources.sources.opencv.detect_webcams",
+        lambda *a, **k: [_device()],
+    )
+    _run(cli, webcam, ["add", "0"])
+
+    def explode(*a, **k):
+        raise AssertionError("listing probed the hardware")
+
+    monkeypatch.setattr("arcsecond.imagesources.sources.opencv.detect_webcams", explode)
+    assert "1280×720, 30 fps" in _run(cli, webcam, []).output
+
+
+def test_a_camera_added_while_unplugged_says_how_to_fill_them_in(cli, monkeypatch):
+    _no_webcams(monkeypatch)
+    result = _run(cli, webcam, ["add", "0"])
+    assert "re-run this command to record its resolution" in result.output
+    assert store.all_cameras()[0].specs is None
+
+
+def test_re_adding_once_plugged_in_records_the_resolution(cli, monkeypatch):
+    _no_webcams(monkeypatch)
+    _run(cli, webcam, ["add", "0"])
+    monkeypatch.setattr(
+        "arcsecond.imagesources.sources.opencv.detect_webcams",
+        lambda *a, **k: [_device()],
+    )
+    result = _run(cli, webcam, ["add", "0"])
+    assert "Already registered" in result.output
+    assert store.all_cameras()[0].specs["width"] == 1280
+
+
+def test_the_proxy_is_given_the_recorded_resolution(cli, monkeypatch):
+    """It is what /detect reports, and what the backend shows the operator."""
+    monkeypatch.setattr(
+        "arcsecond.imagesources.sources.opencv.detect_webcams",
+        lambda *a, **k: [_device()],
+    )
+    _run(cli, webcam, ["add", "0"])
+
+    started = {}
+    monkeypatch.setattr(
+        "arcsecond.imagesources.proxy.run", lambda **k: started.update(k)
+    )
+    _run(cli, proxy, ["start", "--foreground"])
+    assert started["cameras"][0].specs == {"width": 1280, "height": 720, "fps": 30.0}

{arcsecond-3.17.0 → arcsecond-3.17.2}/tests/test_imagesources_store.py

@@ -296,3 +296,74 @@ def test_migration_does_not_expand_the_password(store_file):
     store_file.write_text(json.dumps(V1))
     store.all_cameras(store_file)
     assert "${DOME_CAM_PW}" in store_file.read_text()
+
+
+# ---------------------------------------------------------------------------
+# What probing learned about a USB camera
+#
+# Resolution and frame rate can only be measured by opening the device, and
+# `/detect` must stay answerable while a camera is busy or unplugged. So they
+# are measured once, at registration, and read back from the store afterwards.
+# ---------------------------------------------------------------------------
+
+
+SPECS = {"width": 1280, "height": 720, "fps": 30.0}
+
+
+def test_a_usb_camera_remembers_what_probing_measured(store_file):
+    stored, _ = store.add(Camera(id="", kind=USB, index=0, specs=SPECS), store_file)
+    assert store.find(stored.id, store_file).specs == SPECS
+
+
+def test_specs_survive_the_round_trip_to_disk(store_file):
+    store.add(Camera(id="", kind=USB, index=0, specs=SPECS), store_file)
+    written = json.loads(store_file.read_text())
+    assert written["cameras"][store.all_cameras(store_file)[0].id]["specs"] == SPECS
+
+
+def test_a_camera_registered_while_unplugged_simply_has_none(store_file):
+    stored, _ = store.add(_usb(0), store_file)
+    assert store.find(stored.id, store_file).specs is None
+
+
+def test_re_registering_records_specs_measured_the_second_time(store_file):
+    """Plugging the camera in and re-running `add` is how they get filled in."""
+    first, _ = store.add(_usb(0), store_file)
+    second, created = store.add(
+        Camera(id="", kind=USB, index=0, specs=SPECS), store_file
+    )
+    assert created is False
+    assert second.id == first.id
+    assert store.find(first.id, store_file).specs == SPECS
+
+
+def test_re_registering_without_specs_does_not_wipe_the_recorded_ones(store_file):
+    """A re-run on a machine without OpenCV must not lose what was measured."""
+    stored, _ = store.add(Camera(id="", kind=USB, index=0, specs=SPECS), store_file)
+    store.add(_usb(0), store_file)
+    assert store.find(stored.id, store_file).specs == SPECS
+
+
+def test_specs_are_not_part_of_what_identifies_a_camera(store_file):
+    """A camera switched to another mode is the same camera, not a new one."""
+    first, _ = store.add(Camera(id="", kind=USB, index=0, specs=SPECS), store_file)
+    other = dict(SPECS, width=640, height=480)
+    second, created = store.add(
+        Camera(id="", kind=USB, index=0, specs=other), store_file
+    )
+    assert (created, second.id) == (False, first.id)
+    assert len(store.all_cameras(store_file)) == 1
+    assert store.find(first.id, store_file).specs == other
+
+
+def test_a_malformed_specs_entry_is_ignored_rather_than_fatal(store_file):
+    store_file.write_text(
+        json.dumps(
+            {
+                "version": 2,
+                "cameras": {"aaa": {"kind": "usb", "index": 0, "specs": "1280x720"}},
+            }
+        )
+    )
+    (camera,) = store.all_cameras(store_file)
+    assert camera.specs is None

{arcsecond-3.17.0 → arcsecond-3.17.2}/tests/test_imagesources_webcam.py

@@ -154,3 +154,19 @@ def test_open_raises_when_the_device_will_not_open():
             assert "device index 0" in str(e)
         else:
             raise AssertionError("expected open() to raise")
+
+
+def test_info_reports_the_recorded_resolution_without_opening_anything():
+    source = OpenCVWebcamSource(
+        0, source_id="k3f", specs={"width": 1280, "height": 720, "fps": 30.0}
+    )
+    # No cv2 in sys.modules for this call: reporting must not need the device.
+    extra = source.info().extra
+    assert (extra["width"], extra["height"], extra["fps"]) == (1280, 720, 30.0)
+    assert extra["transport"] == "usb"
+
+
+def test_info_omits_what_was_never_measured():
+    extra = OpenCVWebcamSource(0, source_id="k3f").info().extra
+    assert "width" not in extra and "fps" not in extra
+    assert extra == {"transport": "usb", "index": 0}

{arcsecond-3.17.0 → arcsecond-3.17.2}/uv.lock

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