arcsecond 3.17.2__tar.gz → 3.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arcsecond
-Version: 3.17.2
+Version: 3.18.0
 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.2 → arcsecond-3.18.0}/arcsecond/imagesources/commands.py

@@ -8,7 +8,9 @@ Three commands, three jobs, and no overlap between them:
                        not a separate thing to learn: same list, same ``add``,
                        same ``forget``, and the URL is simply what you pass to
                        ``add`` instead of a device index.
-``arcsecond allsky``   the same, for all-sky cameras writing JPEGs to disk.
+``arcsecond allsky``   the same, for all-sky cameras: the JPEG their software
+                       keeps up to date, given as a path when that software
+                       runs here and as an address when it runs elsewhere.
 ``arcsecond proxy``    starting and inspecting the one proxy that serves
                        everything registered above.
 
@@ -47,6 +49,7 @@ import click
 
 from . import detection, runtime, store
 from .sources.network import (
+    HTTP_SCHEMES,
     RTSP_SCHEMES,
     SUPPORTED_SCHEMES,
     build_network_source,
@@ -639,13 +642,15 @@ def webcam_test_cmd(camera, timeout):
         _test_usb(registered)
         return
 
-    if registered is not None and registered.kind == NET:
+    # Every camera registered by address is tested the same way, whether it is
+    # a network camera or an all-sky camera published over HTTP.
+    if registered is not None and registered.url:
         _test_url(_expand_env_vars(registered.url), timeout, suggest=False)
         return
 
     if registered is not None:
         _fail(
-            f"{registered.id} is an all-sky camera.",
+            f"{registered.id} is an all-sky camera writing to this machine.",
             f"\nIt reads images from {registered.target} — check that path directly.",
         )
 
@@ -798,27 +803,54 @@ def allsky_detect_cmd():
     name="add",
     help=(
         "Register an all-sky camera, so that the proxy serves it.\n\n"
-        "PATH is the JPEG your all-sky software keeps up to date. It may be a "
-        "fixed file, a symlink, or a glob — with a glob, the newest matching "
-        "file wins.\n\n"
+        "TARGET is the JPEG your all-sky software keeps up to date. Give a path "
+        "when that software runs on this machine — a fixed file, a symlink, or "
+        "a glob, in which case the newest matching file wins — or an "
+        "`http://...` address when it runs on another machine and publishes "
+        "the image. Write a password as ${VARIABLE} to keep it out of your "
+        "shell history: only the variable name is written to disk.\n\n"
         "Prints the camera's id. That id is the only handle you need "
         "afterwards, and it does not change."
     ),
 )
-@click.argument("path")
+@click.argument("target")
 @click.option("--label", default=None, help="A name for yourself, e.g. 'Roof'.")
-def allsky_add_cmd(path, label):
-    target = path.strip()
+def allsky_add_cmd(target, label):
+    target = target.strip()
     if not target:
-        _fail("give the path to the JPEG your all-sky software writes.")
+        _fail("give the path or address of the JPEG your all-sky software writes.")
 
-    if urlsplit(target).scheme.lower() in SUPPORTED_SCHEMES:
+    scheme = urlsplit(target).scheme.lower()
+
+    if scheme in RTSP_SCHEMES:
         _fail(
-            "an all-sky camera is registered by path, not by address.",
-            "\nA camera reached over the network is a webcam:  "
+            "an all-sky camera is registered by the JPEG it publishes, not by a "
+            "video stream.",
+            "\nA camera sending video is a webcam:  "
             f"arcsecond webcam add '{target}'",
         )
 
+    if scheme in HTTP_SCHEMES:
+        # Expanded only to validate it — what is stored is what was typed, so a
+        # password stays a variable name on disk. Doing it here is what makes an
+        # unset variable a complaint about the line just typed, rather than a
+        # camera quietly missing from the next `proxy start`.
+        _expand_env_vars(target)
+        _add(Camera(id="", kind=ALLSKY, url=target, label=label))
+        return
+
+    # A single letter is a Windows drive, not a scheme: `C:\allsky\latest.jpg`
+    # is a path and must stay one. Anything longer was meant as an address, and
+    # registering it as a filename would only fail later, out of sight.
+    if len(scheme) > 1:
+        _fail(
+            f"{target!r} is not a path, and {scheme}:// is not an address the "
+            "proxy can read.",
+            "\nAn all-sky camera is registered by path:  "
+            "arcsecond allsky add /srv/allsky/latest.jpg",
+            "or by address:  arcsecond allsky add http://sky.local/latest.jpg",
+        )
+
     # Registered whether or not the file is there yet: all-sky software often
     # writes its first image only at dusk, and refusing until then would mean
     # coming back to retype this.

{arcsecond-3.17.2 → arcsecond-3.18.0}/arcsecond/imagesources/detection.py

@@ -14,10 +14,11 @@ A camera is matched to a probe result on its *identity* (device index, URL,
 path), never on its id — an id is a name given at registration, and a device
 nobody has registered yet does not have one.
 
-Network cameras cannot be discovered: there is no protocol to ask a subnet
-which of it is a camera, so a network camera is never *new*. It can still be
-confirmed present or reported missing, and that is done with a plain TCP
-connection to the address rather than by pulling a frame. Opening an RTSP
+A camera registered by address cannot be discovered: there is no protocol to
+ask a subnet which of it is a camera, so neither a network camera nor an
+all-sky camera published over HTTP is ever *new*. Either can still be confirmed
+present or reported missing, and that is done with a plain TCP connection to
+the address rather than by pulling a frame. Opening an RTSP
 stream to decide takes seconds per camera and can wake hardware that would
 rather be left alone; ``arcsecond webcam test`` is there for when the question
 really is "does this send me a picture?".
@@ -34,7 +35,7 @@ from urllib.parse import urlsplit
 
 from .sources.base import DetectedDevice
 from .sources.filewatch import detect_allsky
-from .store import ALLSKY, NET, USB, Camera
+from .store import ALLSKY, USB, Camera
 
 logger = logging.getLogger(__name__)
 
@@ -96,7 +97,7 @@ def _network_endpoint(url: str) -> Optional[tuple]:
 
 
 def _is_reachable(camera: Camera, timeout: float) -> tuple:
-    """``(reachable, why)`` for one network camera.
+    """``(reachable, why)`` for one camera registered by address.
 
     Only the address is contacted, and the answer never contains the URL's
     password: ``Camera.target`` is redacted, and the endpoint printed here is
@@ -169,11 +170,14 @@ def _settle_allsky(camera: Camera) -> tuple:
 def _settle_unmatched(camera: Camera, check_network: bool, reachability: dict) -> tuple:
     """``(present, why)`` for a registered camera no probe accounted for.
 
-    A network camera was never going to be found by probing, and an all-sky
-    camera writing to a path outside the well-known list was not either — so
-    neither is missing merely for having gone unprobed.
+    A camera reached over the network was never going to be found by probing,
+    and an all-sky camera writing to a path outside the well-known list was not
+    either — so neither is missing merely for having gone unprobed.
+
+    Which check applies follows the address, not the kind: an all-sky camera
+    registered by URL is confirmed the way every other camera at an address is.
     """
-    if camera.kind == NET:
+    if camera.url:
         if not check_network:
             return True, "not contacted"
         return reachability[camera.id]
@@ -212,7 +216,7 @@ def report(
 
     unmatched = [c for c in registered if c.id not in matched]
     reachability = _reachability(
-        [c for c in unmatched if c.kind == NET and check_network], timeout
+        [c for c in unmatched if c.url and check_network], timeout
     )
 
     for camera in unmatched:

{arcsecond-3.17.2 → arcsecond-3.18.0}/arcsecond/imagesources/proxy.py

@@ -30,6 +30,12 @@ proxy covers every camera it can reach. They are not a separate kind on the
 wire — ``kind`` is ``webcam`` for both, and ``extra.transport`` says whether it
 is reached over ``usb``, ``rtsp`` or ``http``.
 
+An all-sky camera is the same story: ``kind`` is ``allsky`` whether its image
+is read from a file on this host or fetched from another machine over HTTP,
+and ``extra.transport`` is ``file`` or ``http`` accordingly. A client that
+knows what an all-sky camera is therefore needs no change to see one running
+on the observatory PC next door.
+
 The backend reads the ``LIVE_IMAGE_PROXY_URL`` environment variable
 (``WEBCAM_PROXY_URL`` is accepted as a deprecated fallback). When set, it
 delegates detection and streaming to this proxy.

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

@@ -20,7 +20,7 @@ from typing import Optional
 
 from .sources.base import FrameSource, SourceInfo
 from .sources.filewatch import FileWatchSource
-from .sources.network import build_network_source
+from .sources.network import build_allsky_source, build_network_source
 from .sources.opencv import OpenCVWebcamSource
 from .store import ALLSKY, NET, USB, Camera
 
@@ -31,7 +31,10 @@ def build_source(camera: Camera) -> FrameSource:
     """The right :class:`FrameSource` for ``camera``.
 
     ``camera.url`` must already have had its ``${VARIABLE}`` expanded — see
-    ``store.expanded``.
+    ``store.expanded``. An all-sky camera carries a URL instead of a path when
+    its software runs on another machine and publishes the image over HTTP;
+    either way it is served as one kind, ``allsky``, and ``extra.transport``
+    says which of the two it is.
     """
     if camera.kind == USB:
         return OpenCVWebcamSource(
@@ -43,6 +46,8 @@ def build_source(camera: Camera) -> FrameSource:
     if camera.kind == NET:
         return build_network_source(camera.id, camera.url, camera.label)
     if camera.kind == ALLSKY:
+        if camera.url:
+            return build_allsky_source(camera.id, camera.url, camera.label)
         return FileWatchSource(camera.id, camera.path, camera.label)
     raise KeyError(f"Unknown camera kind: {camera.kind!r}")
 

{arcsecond-3.17.2 → arcsecond-3.18.0}/arcsecond/imagesources/sources/network.py

@@ -8,6 +8,10 @@ Two transports, chosen from the URL scheme:
     http:// https://   JPEG bytes passed through untouched, either a still
                        image fetched repeatedly or an MJPEG stream
 
+An all-sky camera whose software runs on another machine publishes its JPEG
+over HTTP, and is fetched by exactly the same code — see ``AllSkyHTTPSource``,
+which differs from a webcam only in what it calls itself and how often it asks.
+
 Camera URLs often carry a password. Nothing here ever lets one out: every
 place a URL is logged, reported or put in an error message goes through
 ``redact_url`` first. That matters because the proxy forwards error text
@@ -31,6 +35,10 @@ SUPPORTED_SCHEMES = RTSP_SCHEMES + HTTP_SCHEMES
 
 _RTSP_FRAME_INTERVAL = 0.1  # seconds → ~10 fps, same as the USB webcam source
 _SNAPSHOT_INTERVAL = 1.0  # seconds — still-image cameras rarely update faster
+# All-sky software writes one image every 30-120 seconds, so asking every
+# second would be sixty questions for one answer. Kept in step with the
+# file-watch source, which polls a local all-sky image at the same cadence.
+_ALLSKY_SNAPSHOT_INTERVAL = 5.0  # seconds
 _JPEG_QUALITY = 60  # 0-100, only used on the RTSP path
 _CONNECT_TIMEOUT = 10.0  # seconds
 _READ_TIMEOUT = 30.0  # seconds without a byte before we call the stream dead
@@ -271,6 +279,40 @@ class HTTPImageSource(FrameSource):
         )
 
 
+class AllSkyHTTPSource(HTTPImageSource):
+    """An all-sky camera that publishes its JPEG over HTTP.
+
+    Fetched exactly like any other HTTP camera — conditional requests, and a
+    digest comparison for a server offering neither ETag nor Last-Modified —
+    so a sky that has not changed is never sent on twice. What differs is what
+    it calls itself and how often it asks: an all-sky camera reached over the
+    network is an all-sky camera still, just as a webcam is a webcam whether
+    it arrives over USB or over RTSP.
+    """
+
+    kind = "allsky"
+    poll_interval = _ALLSKY_SNAPSHOT_INTERVAL
+
+
+def build_allsky_source(
+    source_id: str, url: str, label: Optional[str] = None
+) -> FrameSource:
+    """The source for an all-sky camera registered by address.
+
+    HTTP only. An all-sky camera is registered by the JPEG its software
+    publishes, and an RTSP address is a video stream — `arcsecond allsky add`
+    turns one away with the command that does take it, so reaching this with
+    one would be a bug rather than something an operator typed.
+    """
+    scheme = urlsplit(url).scheme.lower()
+    if scheme not in HTTP_SCHEMES:
+        raise KeyError(
+            f"{redact_url(url)} cannot be served as an all-sky camera. "
+            f"Expected one of: {', '.join(s + '://' for s in HTTP_SCHEMES)}."
+        )
+    return AllSkyHTTPSource(source_id, url, label)
+
+
 def build_network_source(
     source_id: str, url: str, label: Optional[str] = None
 ) -> FrameSource:

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

@@ -16,10 +16,18 @@ The file lives next to the CLI's own configuration, in
       "cameras": {
         "k3f": {"kind": "usb",    "index": 0},
         "p9x": {"kind": "net",    "url": "rtsp://admin:${DOME_PW}@10.0.0.4/s"},
-        "r4t": {"kind": "allsky", "path": "/srv/allsky/latest.jpg"}
+        "r4t": {"kind": "allsky", "path": "/srv/allsky/latest.jpg"},
+        "w8n": {"kind": "allsky", "url": "http://sky.local/latest.jpg"}
       }
     }
 
+An all-sky camera carries a path when its software writes to this machine, and
+a URL when that software runs elsewhere and publishes the image over HTTP. That
+says how the image is fetched, not what kind of camera it is — the same way a
+webcam is one kind whether it arrives over a USB cable or over RTSP. A store
+holding one is still version 2: an older CLI ignores such an entry rather than
+losing it, since it rewrites the entries it does not understand untouched.
+
 Identifiers
 -----------
 Each camera gets a three-character id — ``k3f``, ``p9x`` — and that id is the
@@ -81,7 +89,9 @@ class SourceStoreError(Exception):
 class Camera:
     """One registered camera.
 
-    Exactly one of ``index`` / ``url`` / ``path`` is set, according to ``kind``.
+    Exactly one of ``index`` / ``url`` / ``path`` is set: an index for a USB
+    webcam, a path for an all-sky camera writing to this machine, and a URL for
+    a network camera or for an all-sky camera reached over HTTP.
     ``url`` is the URL as typed, with any ``${VARIABLE}`` still in place.
     """
 
@@ -89,8 +99,8 @@ class Camera:
     kind: str
     label: Optional[str] = None
     index: Optional[int] = None  # usb
-    url: Optional[str] = None  # net
-    path: Optional[str] = None  # allsky
+    url: Optional[str] = None  # net, and allsky published over HTTP
+    path: Optional[str] = None  # allsky writing to this machine
     # 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
@@ -109,17 +119,20 @@ class Camera:
             return (USB, self.index)
         if self.kind == NET:
             return (NET, self.url)
-        return (ALLSKY, self.path)
+        # The same URL registered as an all-sky camera and as a webcam is two
+        # registrations, not one: the kind is part of what was asked for, and
+        # each is served at its own cadence.
+        return (ALLSKY, self.url or self.path)
 
     @property
     def target(self) -> str:
         """Where the camera is, in one line, safe to print."""
         if self.kind == USB:
             return f"device index {self.index}"
-        if self.kind == NET:
+        if self.url:
             from .sources.network import redact_url
 
-            return redact_url(self.url or "")
+            return redact_url(self.url)
         return self.path or ""
 
     @property
@@ -141,7 +154,7 @@ class Camera:
             entry["index"] = self.index
             if self.specs:
                 entry["specs"] = self.specs
-        elif self.kind == NET:
+        elif self.url:
             entry["url"] = self.url
         else:
             entry["path"] = self.path
@@ -174,6 +187,9 @@ def camera_from_json(cam_id: str, entry: dict) -> Optional[Camera]:
         if not url:
             return None
         return Camera(id=cam_id, kind=NET, url=url, label=label)
+    url = entry.get("url")
+    if url:
+        return Camera(id=cam_id, kind=ALLSKY, url=url, label=label)
     path = entry.get("path")
     if not path:
         return None
@@ -412,14 +428,17 @@ def expanded(cameras: list[Camera], expand) -> list[Camera]:
     """
     usable = []
     for camera in cameras:
-        if camera.kind != NET:
+        # Keyed on the URL rather than on the kind: an all-sky camera reached
+        # over HTTP may carry a password in its address just as a network
+        # camera does, and it is stored the same way — unexpanded.
+        if not camera.url:
             usable.append(camera)
             continue
         try:
             url = expand(camera.url)
         except Exception as e:
             logger.warning(
-                "Skipping network camera %r: %s",
+                "Skipping camera %r: %s",
                 camera.id,
                 getattr(e, "message", None) or e,
             )
@@ -427,10 +446,9 @@ def expanded(cameras: list[Camera], expand) -> list[Camera]:
         usable.append(
             Camera(
                 id=camera.id,
-                kind=NET,
+                kind=camera.kind,
                 url=url,
                 label=camera.label,
-                path=camera.path,
             )
         )
     return usable

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

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

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

@@ -192,12 +192,62 @@ def test_a_path_given_to_webcam_add_points_at_allsky(cli):
     assert "arcsecond allsky add" in result.output
 
 
-def test_an_address_given_to_allsky_add_points_at_webcam(cli):
+def test_a_video_stream_given_to_allsky_add_points_at_webcam(cli):
     result = _run(cli, allsky, ["add", "rtsp://cam.local/s"])
     assert result.exit_code == 1
     assert "arcsecond webcam add" in result.output
 
 
+def test_allsky_add_takes_the_address_of_a_published_image(cli):
+    """The all-sky software runs on another machine and publishes over HTTP."""
+    result = _run(cli, allsky, ["add", "http://sky.local/allsky/latest.jpg"])
+    assert result.exit_code == 0
+    (camera,) = store.all_cameras()
+    assert camera.kind == "allsky"
+    assert camera.url == "http://sky.local/allsky/latest.jpg"
+    assert camera.path is None
+
+
+def test_an_all_sky_camera_at_an_address_is_listed_by_allsky_not_webcam(cli):
+    _run(cli, allsky, ["add", "http://sky.local/latest.jpg"])
+    assert "sky.local" in _run(cli, allsky, []).output
+    assert "sky.local" not in _run(cli, webcam, []).output
+
+
+def test_a_windows_path_is_a_path_and_not_an_address(cli):
+    """`C:` is a drive letter; urlsplit calls it a scheme, and it is not one."""
+    result = _run(cli, allsky, ["add", r"C:\allsky\latest.jpg"])
+    assert result.exit_code == 0
+    (camera,) = store.all_cameras()
+    assert camera.path == r"C:\allsky\latest.jpg"
+    assert camera.url is None
+
+
+def test_an_address_allsky_cannot_read_is_refused(cli):
+    result = _run(cli, allsky, ["add", "ftp://sky.local/latest.jpg"])
+    assert result.exit_code == 1
+    assert "http://" in result.output
+    assert store.all_cameras() == []
+
+
+def test_a_password_in_an_all_sky_address_is_never_written_in_the_clear(
+    cli, monkeypatch, tmp_path
+):
+    monkeypatch.setenv("PW", "hunter2")
+    _run(cli, allsky, ["add", "http://sky:${PW}@10.0.0.9/latest.jpg"])
+    written = (tmp_path / "cameras.json").read_text()
+    assert "${PW}" in written
+    assert "hunter2" not in written
+
+
+def test_a_missing_variable_in_an_all_sky_address_registers_nothing(cli, monkeypatch):
+    monkeypatch.delenv("PW", raising=False)
+    result = cli.invoke(allsky, ["add", "http://sky:${PW}@10.0.0.9/latest.jpg"])
+    assert result.exit_code != 0
+    assert "PW" in result.output
+    assert store.all_cameras() == []
+
+
 def test_an_unsupported_scheme_is_refused(cli):
     result = _run(cli, webcam, ["add", "ftp://cam.local/s"])
     assert result.exit_code == 1
@@ -231,6 +281,7 @@ def test_a_missing_variable_is_reported_before_anything_is_registered(cli, monke
         (webcam, ["add", "0"]),
         (webcam, ["add", "rtsp://c/s"]),
         (allsky, ["add", "/a.jpg"]),
+        (allsky, ["add", "http://sky.local/latest.jpg"]),
     ],
 )
 def test_forget_works_for_every_kind_of_camera(cli, monkeypatch, group, add_args):
@@ -363,6 +414,32 @@ def test_allsky_start_points_at_add_and_proxy_start(cli):
     assert "arcsecond proxy start" in result.output
 
 
+def test_testing_an_all_sky_camera_at_an_address_contacts_it(cli, monkeypatch):
+    """It has an address, so `test` can pull an image from it like any other."""
+    tested = {}
+    monkeypatch.setattr(
+        commands, "_test_url", lambda url, timeout, **k: tested.update(url=url)
+    )
+    printed = (
+        _run(cli, allsky, ["add", "http://sky.local/latest.jpg"])
+        .output.split("Registered ")[1]
+        .split()[0]
+    )
+    _run(cli, webcam, ["test", printed])
+    assert tested["url"] == "http://sky.local/latest.jpg"
+
+
+def test_testing_an_all_sky_camera_on_this_disk_names_its_path(cli):
+    printed = (
+        _run(cli, allsky, ["add", "/srv/sky.jpg"])
+        .output.split("Registered ")[1]
+        .split()[0]
+    )
+    result = _run(cli, webcam, ["test", printed])
+    assert result.exit_code == 1
+    assert "/srv/sky.jpg" in result.output
+
+
 def test_netcam_points_at_webcam(cli):
     result = _run(cli, netcam, ["test", "rtsp://cam.local/s"])
     assert result.exit_code == 1

{arcsecond-3.17.2 → arcsecond-3.18.0}/tests/test_imagesources_detection.py

@@ -198,6 +198,35 @@ def test_a_detected_all_sky_camera_that_is_registered_is_not_reported_twice(tmp_
     assert report.missing == []
 
 
+def test_an_all_sky_camera_at_an_address_is_confirmed_by_contacting_it():
+    """It has no path to look at, so it is settled the way any address is."""
+    camera = Camera(id="abc", kind=ALLSKY, url="http://sky.local/latest.jpg")
+    with patch.object(detection, "_is_reachable", return_value=(True, "answering")):
+        with patch.object(detection, "detect_allsky", return_value=[]):
+            report = detection.report([camera], (ALLSKY,))
+    assert report.present == [camera]
+    assert report.new == []
+
+
+def test_an_all_sky_camera_at_an_address_that_is_down_is_missing():
+    camera = Camera(id="abc", kind=ALLSKY, url="http://sky.local/latest.jpg")
+    with patch.object(detection, "_is_reachable", return_value=(False, "no answer")):
+        with patch.object(detection, "detect_allsky", return_value=[]):
+            report = detection.report([camera], (ALLSKY,))
+    assert report.missing == [camera]
+    assert report.detail["abc"] == "no answer"
+
+
+def test_an_all_sky_address_is_never_looked_for_on_this_disk():
+    """The old check called a URL a missing file — the wrong answer entirely."""
+    camera = Camera(id="abc", kind=ALLSKY, url="http://sky.local/latest.jpg")
+    with patch.object(detection, "resolve_allsky_path") as looked_at_disk:
+        with patch.object(detection, "_is_reachable", return_value=(True, "answering")):
+            with patch.object(detection, "detect_allsky", return_value=[]):
+                detection.report([camera], (ALLSKY,))
+    looked_at_disk.assert_not_called()
+
+
 # ---------------------------------------------------------------------------
 # Probing must never take the report down
 # ---------------------------------------------------------------------------

{arcsecond-3.17.2 → arcsecond-3.18.0}/tests/test_imagesources_network.py

@@ -18,11 +18,12 @@ import pytest
 from arcsecond.imagesources.commands import _expand_env_vars
 from arcsecond.imagesources.registry import Registry, build_source
 from arcsecond.imagesources.sources.network import (
+    AllSkyHTTPSource,
     HTTPImageSource,
     RTSPSource,
     redact_url,
 )
-from arcsecond.imagesources.store import NET, USB, Camera
+from arcsecond.imagesources.store import ALLSKY, NET, USB, Camera
 
 JPEG_A = b"\xff\xd8\xff\xe0 first frame \xff\xd9"
 JPEG_B = b"\xff\xd8\xff\xe0 second frame \xff\xd9"
@@ -134,6 +135,70 @@ def test_the_registry_rejects_an_unregistered_camera():
         Registry()._build("abc")
 
 
+# ---------------------------------------------------------------------------
+# All-sky cameras reached over the network
+# ---------------------------------------------------------------------------
+
+SKY_URL = "http://sky.local/allsky/latest.jpg"
+
+
+def _sky_over_http(url=SKY_URL, cam_id="sky"):
+    return Camera(id=cam_id, kind=ALLSKY, url=url)
+
+
+def test_an_all_sky_camera_over_http_is_announced_as_an_all_sky_camera():
+    """The backend must see the same kind wherever the image is fetched from."""
+    from arcsecond.imagesources.sources.filewatch import FileWatchSource
+
+    over_http = build_source(_sky_over_http()).info()
+    on_disk = FileWatchSource("sky", "/srv/allsky/latest.jpg").info()
+
+    assert over_http.kind == on_disk.kind == "allsky"
+    assert over_http.extra["transport"] == "http"
+    assert on_disk.extra["transport"] == "file"
+
+
+def test_the_same_address_is_an_all_sky_camera_or_a_webcam_as_registered():
+    assert build_source(_sky_over_http()).info().kind == "allsky"
+    assert build_source(_netcam(url=SKY_URL)).info().kind == "webcam"
+
+
+def test_an_all_sky_camera_over_http_is_polled_at_its_own_cadence():
+    """One image every 30-120 seconds: asking every second buys nothing."""
+    sky = build_source(_sky_over_http())
+    webcam = build_source(_netcam(url=SKY_URL))
+    assert isinstance(sky, AllSkyHTTPSource)
+    assert sky.poll_interval > webcam.poll_interval
+
+
+def test_the_registry_builds_an_all_sky_camera_from_its_address():
+    registry = Registry(cameras=[_sky_over_http(cam_id="sky")])
+    source = registry._build("sky")
+    assert isinstance(source, AllSkyHTTPSource)
+    assert source.url == SKY_URL
+
+
+def test_the_registry_builds_an_all_sky_camera_from_its_path(tmp_path):
+    from arcsecond.imagesources.sources.filewatch import FileWatchSource
+
+    image = tmp_path / "latest.jpg"
+    registry = Registry(cameras=[Camera(id="sky", kind=ALLSKY, path=str(image))])
+    assert isinstance(registry._build("sky"), FileWatchSource)
+
+
+def test_an_all_sky_address_never_reports_its_password():
+    registry = Registry(
+        cameras=[_sky_over_http(url="http://sky:hunter2@10.0.0.9/latest.jpg")]
+    )
+    assert "hunter2" not in str(registry.infos())
+
+
+def test_a_video_stream_is_not_an_all_sky_camera():
+    """`allsky add` turns one away; reaching the registry with one is a bug."""
+    with pytest.raises(KeyError, match="http"):
+        build_source(_sky_over_http(url="rtsp://sky.local/stream1"))
+
+
 def test_a_usb_and_a_network_camera_live_in_one_registry():
     """One proxy, one id space — whatever the camera is plugged into."""
     from arcsecond.imagesources.sources.opencv import OpenCVWebcamSource

{arcsecond-3.17.2 → arcsecond-3.18.0}/tests/test_imagesources_proxy.py

@@ -104,6 +104,7 @@ def test_every_kind_of_camera_can_be_registered_over_the_endpoint():
             NETCAM,
             {"id": "def", "kind": "usb", "index": 0},
             {"id": "ghi", "kind": "allsky", "path": "/a.jpg"},
+            {"id": "jkl", "kind": "allsky", "url": "http://sky.local/latest.jpg"},
         ]
     }
 
@@ -113,8 +114,8 @@ def test_every_kind_of_camera_can_be_registered_over_the_endpoint():
                 return await r.json(), {c.id for c in registry.cameras}
 
     answer, ids = _run_against_proxy(body)
-    assert answer["added"] == ["abc", "def", "ghi"]
-    assert ids == {"abc", "def", "ghi"}
+    assert answer["added"] == ["abc", "def", "ghi", "jkl"]
+    assert ids == {"abc", "def", "ghi", "jkl"}
 
 
 @pytest.mark.parametrize(

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

@@ -14,6 +14,11 @@ from arcsecond.imagesources.store import ALLSKY, NET, USB, Camera
 RAW_URL = "rtsp://admin:${DOME_CAM_PW}@192.168.1.42:554/stream1"
 EXPANDED_URL = "rtsp://admin:hunter2@192.168.1.42:554/stream1"
 
+# An all-sky camera whose software runs on another machine and publishes the
+# image over HTTP. Registered as an all-sky camera, not as a webcam.
+RAW_SKY_URL = "http://sky:${SKY_PW}@10.0.0.9/allsky/latest.jpg"
+EXPANDED_SKY_URL = "http://sky:hunter2@10.0.0.9/allsky/latest.jpg"
+
 
 @pytest.fixture
 def store_file(tmp_path):
@@ -32,6 +37,10 @@ def _allsky(path="/srv/sky.jpg", label=None):
     return Camera(id="", kind=ALLSKY, path=path, label=label)
 
 
+def _allsky_url(url=RAW_SKY_URL, label=None):
+    return Camera(id="", kind=ALLSKY, url=url, label=label)
+
+
 # ---------------------------------------------------------------------------
 # Identifiers
 # ---------------------------------------------------------------------------
@@ -87,7 +96,7 @@ def test_load_returns_nothing_when_nothing_was_ever_registered(store_file):
     assert store.all_cameras(store_file) == []
 
 
-@pytest.mark.parametrize("camera", [_usb(2), _net(), _allsky()])
+@pytest.mark.parametrize("camera", [_usb(2), _net(), _allsky(), _allsky_url()])
 def test_every_kind_of_camera_round_trips(store_file, camera):
     stored, created = store.add(camera, store_file)
     assert created is True
@@ -169,6 +178,38 @@ def test_a_prefixed_id_is_tolerated(store_file, prefix):
     assert store.find(f"{prefix}:{stored.id}", store_file) == stored
 
 
+def test_an_all_sky_camera_registered_by_address_is_still_an_all_sky_camera(
+    store_file,
+):
+    """The transport says how it is fetched, not what kind of camera it is."""
+    stored, _ = store.add(_allsky_url("http://sky.local/latest.jpg"), store_file)
+    assert stored.kind == ALLSKY
+    assert stored.display_kind == "all-sky"
+    assert [c.id for c in store.cameras_of_kinds((ALLSKY,), store_file)] == [stored.id]
+    assert store.cameras_of_kinds(store.WEBCAM_KINDS, store_file) == []
+
+
+def test_one_address_registered_as_both_kinds_is_two_cameras(store_file):
+    """Asking for an all-sky camera is not the same as asking for a webcam."""
+    url = "http://sky.local/latest.jpg"
+    sky, _ = store.add(_allsky_url(url), store_file)
+    cam, created = store.add(_net(url), store_file)
+    assert created is True
+    assert sky.id != cam.id
+
+
+def test_an_all_sky_address_is_stored_as_an_address_not_a_path(store_file):
+    stored, _ = store.add(_allsky_url("http://sky.local/latest.jpg"), store_file)
+    entry = json.loads(store_file.read_text())["cameras"][stored.id]
+    assert entry == {"kind": "allsky", "url": "http://sky.local/latest.jpg"}
+
+
+def test_an_all_sky_address_never_shows_its_password(store_file):
+    stored, _ = store.add(_allsky_url(EXPANDED_SKY_URL), store_file)
+    assert "hunter2" not in stored.target
+    assert "***" in stored.target
+
+
 def test_cameras_of_kinds_keeps_the_two_groups_apart(store_file):
     usb, _ = store.add(_usb(0), store_file)
     net, _ = store.add(_net(), store_file)
@@ -191,6 +232,16 @@ def test_a_registered_camera_is_expanded_again_on_the_way_back(store_file):
     assert usable.id == stored.id
 
 
+def test_an_all_sky_address_is_expanded_like_any_other(store_file):
+    """A password in an all-sky address is kept out of the file the same way."""
+    stored, _ = store.add(_allsky_url(RAW_SKY_URL), store_file)
+    assert "${SKY_PW}" in store_file.read_text()
+
+    (usable,) = store.expanded([stored], lambda u: EXPANDED_SKY_URL)
+    assert usable.url == EXPANDED_SKY_URL
+    assert usable.kind == ALLSKY
+
+
 def test_a_camera_whose_variable_is_unset_is_skipped_not_fatal(store_file):
     def explode(url):
         raise KeyError("DOME_CAM_PW")

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

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