arcsecond 3.18.0__tar.gz → 3.18.2__tar.gz

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

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

@@ -551,7 +551,10 @@ def webcam_add_cmd(camera, label):
             + ".",
         )
 
-    _add(Camera(id="", kind=NET, url=target, label=label))
+    _add(
+        Camera(id="", kind=NET, url=target, label=label),
+        absent_note=lambda: _unreachable_note(expanded),
+    )
 
 
 def _probe_index(index: int):
@@ -590,6 +593,37 @@ def _specs(device) -> Optional[dict]:
     return kept or None
 
 
+def _unreachable_note(url: str) -> Optional[str]:
+    """Said when a camera is registered at an address that does not answer.
+
+    It is registered either way, for the same reason an unplugged webcam is: a
+    camera that is switched off, or on a machine still booting, is one the
+    operator owns. But saying nothing lets a typo — or a name this machine
+    cannot resolve — surface hours later and two machines away, as a camera
+    that is simply blank in Arcsecond.local, instead of as an answer to the
+    line just typed.
+    """
+    reachable, why = detection.is_reachable(url)
+    if reachable:
+        return None
+
+    note = (
+        f"{why}. It stays registered — the proxy will serve it as soon as it "
+        "answers."
+    )
+    host = (urlsplit(url).hostname or "").lower()
+    if host.endswith(".local"):
+        # The failure that is worth explaining rather than merely reporting:
+        # the browser you found the address in resolves .local names over
+        # mDNS, and the proxy asks the machine's resolver, which often cannot.
+        note += (
+            " A .local name is answered by that machine itself over mDNS, "
+            "which not every computer can do — registering its IP address "
+            "instead is the reliable form."
+        )
+    return note
+
+
 def _nothing_at_index(index: int) -> str:
     """Said when a camera is registered while nothing is plugged in at its index.
 
@@ -835,8 +869,11 @@ def allsky_add_cmd(target, label):
         # 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))
+        expanded = _expand_env_vars(target)
+        _add(
+            Camera(id="", kind=ALLSKY, url=target, label=label),
+            absent_note=lambda: _unreachable_note(expanded),
+        )
         return
 
     # A single letter is a Windows drive, not a scheme: `C:\allsky\latest.jpg`

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

@@ -96,20 +96,27 @@ def _network_endpoint(url: str) -> Optional[tuple]:
     return (host, port)
 
 
-def _is_reachable(camera: Camera, timeout: float) -> tuple:
-    """``(reachable, why)`` for one camera registered by address.
+def is_reachable(url: str, timeout: float = NETWORK_TIMEOUT) -> tuple:
+    """``(reachable, why)`` for one camera address.
+
+    Takes the URL rather than the camera because ``add`` asks this about an
+    address that is not registered yet, and ``detect`` about one that is.
 
     Only the address is contacted, and the answer never contains the URL's
-    password: ``Camera.target`` is redacted, and the endpoint printed here is
-    the host and port alone.
+    password: the endpoint named here is the host and port alone.
     """
-    endpoint = _network_endpoint(camera.url or "")
+    endpoint = _network_endpoint(url or "")
     if endpoint is None:
         return False, "the address cannot be read"
     host, port = endpoint
     try:
         with socket.create_connection((host, port), timeout=timeout):
             return True, f"answering on {host}:{port}"
+    except socket.gaierror:
+        # Told apart from a connection that fails: nothing is wrong with the
+        # camera, the name simply does not resolve on this machine, and that
+        # is a different thing to go and fix.
+        return False, f"{host} cannot be resolved"
     except OSError as e:
         return False, f"no answer on {host}:{port} ({e.strerror or e})"
 
@@ -152,7 +159,7 @@ def _reachability(cameras: list[Camera], timeout: float) -> dict:
     if not cameras:
         return {}
     with ThreadPoolExecutor(max_workers=min(8, len(cameras))) as pool:
-        outcomes = pool.map(lambda c: _is_reachable(c, timeout), cameras)
+        outcomes = pool.map(lambda c: is_reachable(c.url or "", timeout), cameras)
         return {camera.id: outcome for camera, outcome in zip(cameras, outcomes)}
 
 

{arcsecond-3.18.0 → arcsecond-3.18.2}/arcsecond/imagesources/sources/filewatch.py

@@ -21,10 +21,21 @@ logger = logging.getLogger(__name__)
 _POLL_INTERVAL = 5.0  # seconds — image cadence is much slower; this is fine
 
 # Common locations to probe at startup. First match wins per software.
+#
+# For Thomas Jacquin's allsky these are its own variables, resolved: since the
+# 2023 rearrangement everything lives under ALLSKY_HOME (``~/allsky``), with
+# ALLSKY_TMP at ``${ALLSKY_HOME}/tmp`` and the local website at
+# ``${ALLSKY_HOME}/html/allsky``. Installs older than that kept the website in
+# ``/var/www/html/allsky`` instead. Beware the ``/current/tmp/`` in the URL its
+# web interface uses: that is a lighttpd alias for ALLSKY_TMP, not a directory,
+# and pasting it in here as a path is how this list went stale before.
 ALLSKY_DISCOVERY_PATHS: list[Path] = [
-    # Thomas Jacquin's allsky (https://github.com/AllskyTeam/allsky)
+    # Thomas Jacquin's allsky (https://github.com/AllskyTeam/allsky).
+    # ALLSKY_TMP first: the capture loop rewrites it every cycle, and it is
+    # there whether or not the local website is enabled.
     Path.home() / "allsky" / "tmp" / "image.jpg",
-    Path("/var/www/html/allsky/current/tmp/image.jpg"),
+    Path.home() / "allsky" / "html" / "allsky" / "image.jpg",
+    Path("/var/www/html/allsky/image.jpg"),
     # indi-allsky (https://github.com/aaronwmorris/indi-allsky)
     Path("/var/lib/indi-allsky/images/latest.jpg"),
     Path.home() / "indi-allsky" / "latest.jpg",

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

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

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

@@ -39,6 +39,15 @@ def cli(tmp_path, monkeypatch):
         )
 
     monkeypatch.setattr(commands.subprocess, "Popen", no_real_processes)
+
+    # `add` checks that an address answers before saying it is registered.
+    # Left alone, every test registering a camera would open a real socket to
+    # a made-up host and wait out the timeout — 2 seconds each, and a suite
+    # whose result depends on what the network does. Reachable is the quiet
+    # default; the tests about the note say otherwise for themselves.
+    monkeypatch.setattr(
+        commands.detection, "is_reachable", lambda url, **k: (True, "answering")
+    )
     return CliRunner()
 
 
@@ -230,6 +239,71 @@ def test_an_address_allsky_cannot_read_is_refused(cli):
     assert store.all_cameras() == []
 
 
+def test_an_address_that_does_not_answer_is_registered_with_a_note(cli, monkeypatch):
+    """A camera that is off is still a camera — but the operator is told now."""
+    monkeypatch.setattr(
+        commands.detection,
+        "is_reachable",
+        lambda url, **k: (False, "no answer on 10.0.0.9:80 (Connection refused)"),
+    )
+    result = _run(cli, allsky, ["add", "http://10.0.0.9/latest.jpg"])
+    assert result.exit_code == 0
+    assert "Note:" in result.output
+    assert "no answer on 10.0.0.9:80" in result.output
+    assert len(store.all_cameras()) == 1
+
+
+def test_an_address_that_answers_says_nothing_extra(cli):
+    result = _run(cli, allsky, ["add", "http://10.0.0.9/latest.jpg"])
+    assert "Note:" not in result.output
+
+
+def test_a_local_name_that_will_not_resolve_explains_itself(cli, monkeypatch):
+    """The failure worth explaining: the browser resolves .local, we may not."""
+    monkeypatch.setattr(
+        commands.detection,
+        "is_reachable",
+        lambda url, **k: (False, "skykot.local cannot be resolved"),
+    )
+    result = _run(cli, allsky, ["add", "http://skykot.local/current/tmp/image.jpg"])
+    assert "mDNS" in result.output
+    assert "IP address" in result.output
+
+
+def test_a_network_camera_that_does_not_answer_is_noted_too(cli, monkeypatch):
+    monkeypatch.setattr(
+        commands.detection, "is_reachable", lambda url, **k: (False, "no answer")
+    )
+    result = _run(cli, webcam, ["add", "rtsp://cam.local/s"])
+    assert result.exit_code == 0
+    assert "Note:" in result.output
+
+
+def test_the_address_contacted_is_the_one_with_the_password_filled_in(cli, monkeypatch):
+    """The check must reach the real camera, not `${VARIABLE}` as a hostname."""
+    monkeypatch.setenv("PW", "hunter2")
+    asked = []
+    monkeypatch.setattr(
+        commands.detection,
+        "is_reachable",
+        lambda url, **k: (asked.append(url), (True, "answering"))[1],
+    )
+    _run(cli, allsky, ["add", "http://sky:${PW}@10.0.0.9/latest.jpg"])
+    assert asked == ["http://sky:hunter2@10.0.0.9/latest.jpg"]
+
+
+def test_re_running_an_add_does_not_contact_the_camera_again(cli, monkeypatch):
+    """Re-running a line from history should be quiet, and cost nothing."""
+    _run(cli, allsky, ["add", "http://10.0.0.9/latest.jpg"])
+    monkeypatch.setattr(
+        commands.detection,
+        "is_reachable",
+        lambda url, **k: (_ for _ in ()).throw(AssertionError("contacted again")),
+    )
+    result = _run(cli, allsky, ["add", "http://10.0.0.9/latest.jpg"])
+    assert "Already registered" in result.output
+
+
 def test_a_password_in_an_all_sky_address_is_never_written_in_the_clear(
     cli, monkeypatch, tmp_path
 ):

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

@@ -106,7 +106,7 @@ def test_all_sky_detection_ignores_webcams():
 
 def test_a_reachable_network_camera_is_present():
     camera = Camera(id="abc", kind=NET, url="rtsp://cam.local/s")
-    with patch.object(detection, "_is_reachable", return_value=(True, "answering")):
+    with patch.object(detection, "is_reachable", return_value=(True, "answering")):
         report = _report([camera])
     assert report.present == [camera]
     assert report.new == []
@@ -114,7 +114,7 @@ def test_a_reachable_network_camera_is_present():
 
 def test_an_unreachable_network_camera_is_missing_with_a_reason():
     camera = Camera(id="abc", kind=NET, url="rtsp://cam.local/s")
-    with patch.object(detection, "_is_reachable", return_value=(False, "no answer")):
+    with patch.object(detection, "is_reachable", return_value=(False, "no answer")):
         report = _report([camera])
     assert report.missing == [camera]
     assert report.detail["abc"] == "no answer"
@@ -122,19 +122,38 @@ def test_an_unreachable_network_camera_is_missing_with_a_reason():
 
 def test_no_network_says_so_rather_than_guessing():
     camera = Camera(id="abc", kind=NET, url="rtsp://cam.local/s")
-    with patch.object(detection, "_is_reachable", side_effect=AssertionError("called")):
+    with patch.object(detection, "is_reachable", side_effect=AssertionError("called")):
         report = _report([camera], check_network=False)
     assert report.present == [camera]
     assert report.detail["abc"] == "not contacted"
 
 
 def test_reachability_never_leaks_the_password():
-    camera = Camera(id="abc", kind=NET, url="rtsp://admin:hunter2@127.0.0.1:1/s")
-    reachable, why = detection._is_reachable(camera, timeout=0.2)
+    url = "rtsp://admin:hunter2@127.0.0.1:1/s"
+    reachable, why = detection.is_reachable(url, timeout=0.2)
     assert reachable is False
     assert "hunter2" not in why
 
 
+def test_a_name_that_does_not_resolve_says_so(monkeypatch):
+    """Distinct from a refused connection: the camera may be perfectly fine."""
+    import socket as socket_module
+
+    def no_such_name(*a, **k):
+        raise socket_module.gaierror(-2, "Name or service not known")
+
+    monkeypatch.setattr(detection.socket, "create_connection", no_such_name)
+    reachable, why = detection.is_reachable("http://skykot.local/image.jpg")
+    assert reachable is False
+    assert why == "skykot.local cannot be resolved"
+
+
+def test_an_address_that_cannot_be_read_is_not_contacted():
+    reachable, why = detection.is_reachable("http://")
+    assert reachable is False
+    assert why == "the address cannot be read"
+
+
 @pytest.mark.parametrize(
     "url,expected",
     [
@@ -201,7 +220,7 @@ def test_a_detected_all_sky_camera_that_is_registered_is_not_reported_twice(tmp_
 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, "is_reachable", return_value=(True, "answering")):
         with patch.object(detection, "detect_allsky", return_value=[]):
             report = detection.report([camera], (ALLSKY,))
     assert report.present == [camera]
@@ -210,7 +229,7 @@ def test_an_all_sky_camera_at_an_address_is_confirmed_by_contacting_it():
 
 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, "is_reachable", return_value=(False, "no answer")):
         with patch.object(detection, "detect_allsky", return_value=[]):
             report = detection.report([camera], (ALLSKY,))
     assert report.missing == [camera]
@@ -221,12 +240,41 @@ 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, "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 the well-known locations
+# ---------------------------------------------------------------------------
+
+
+def test_an_image_at_a_well_known_location_is_detected(tmp_path, monkeypatch):
+    from arcsecond.imagesources.sources import filewatch
+
+    image = tmp_path / "image.jpg"
+    image.write_bytes(b"x")
+    monkeypatch.setattr(filewatch, "ALLSKY_DISCOVERY_PATHS", [image])
+
+    (device,) = filewatch.detect_allsky()
+    assert device.identity == (ALLSKY, str(image))
+    assert device.extra["path"] == str(image)
+
+
+def test_a_well_known_location_with_nothing_at_it_is_not_reported(
+    tmp_path, monkeypatch
+):
+    """Probing reports what is there — an empty list is an answer, not a fault."""
+    from arcsecond.imagesources.sources import filewatch
+
+    monkeypatch.setattr(
+        filewatch, "ALLSKY_DISCOVERY_PATHS", [tmp_path / "nothing-here.jpg"]
+    )
+    assert filewatch.detect_allsky() == []
+
+
 # ---------------------------------------------------------------------------
 # Probing must never take the report down
 # ---------------------------------------------------------------------------

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

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