RemoteRF 2.5.2__tar.gz → 2.6.0__tar.gz

{remoterf-2.5.2/src/remoterf.egg-info → remoterf-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.2
+Version: 2.6.0
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -354,6 +354,25 @@ If converting a existing `non-remoterf` compatible script:
 
 Nothing else needs changing! 
 
+#### List devices and availability
+
+With a saved login (lab or Global), list the devices you can use, each with the handle to paste into `token=`, and whether it is free right now:
+
+```python
+import remoterf
+
+rows = remoterf.devices()   # prints a table and returns it as a list of dicts
+```
+
+```
+DEVICE (token=)  TYPE   ONLINE   NOW                 NEXT
+Pluto_01@lab     pluto  online   free                14:30
+Pluto_02@lab     pluto  online   in use until 13:45  -
+Pluto_03@lab     pluto  offline  yours until 15:00   -
+```
+
+Each account may ask once every 10 seconds; a repeat call within that reprints the last table with the remaining wait.
+
 ## Closing
 
 This is fundamentally a experimental platform, and there will be many unknown bugs and issues. Some devices do not have universal support for all its functions at the moment, I am working on that aspect. 

{remoterf-2.5.2 → remoterf-2.6.0}/README.md

@@ -329,6 +329,25 @@ If converting a existing `non-remoterf` compatible script:
 
 Nothing else needs changing! 
 
+#### List devices and availability
+
+With a saved login (lab or Global), list the devices you can use, each with the handle to paste into `token=`, and whether it is free right now:
+
+```python
+import remoterf
+
+rows = remoterf.devices()   # prints a table and returns it as a list of dicts
+```
+
+```
+DEVICE (token=)  TYPE   ONLINE   NOW                 NEXT
+Pluto_01@lab     pluto  online   free                14:30
+Pluto_02@lab     pluto  online   in use until 13:45  -
+Pluto_03@lab     pluto  offline  yours until 15:00   -
+```
+
+Each account may ask once every 10 seconds; a repeat call within that reprints the last table with the remaining wait.
+
 ## Closing
 
 This is fundamentally a experimental platform, and there will be many unknown bugs and issues. Some devices do not have universal support for all its functions at the moment, I am working on that aspect. 

{remoterf-2.5.2 → remoterf-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.5.2"
+version = "2.6.0"
 description = "A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts."
 readme = "README.md"
 license = "GPL-3.0-or-later"

remoterf-2.6.0/src/remoterf/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+def devices():
+    """Print the devices your saved login can use (handles to paste into
+    ``Pluto(token=...)``) with who-has-it-now availability; returns the rows."""
+    from .core.availability import devices as _devices
+
+    return _devices()

remoterf-2.6.0/src/remoterf/core/availability.py

@@ -0,0 +1,185 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""remoterf.devices(): the devices the saved login can use, with handles and
+what is free right now. Homes allow one call per account per interval; within
+it this process reprints its last answer instead of asking again."""
+
+import json
+import time
+from datetime import datetime
+
+from ..common.utils import map_arg, unmap_arg
+
+_cache = None  # (key, monotonic at fetch, rows or None after a refusal, interval)
+NOT_LOGGED_IN = "Not logged in: run `remoterf` and log in (keep the login saved)."
+STALE_LOGIN = "Saved login is no longer valid: run `remoterf` and log in again."
+
+
+class _Refused(Exception):
+    def __init__(self, wait):
+        self.wait = wait
+
+
+def _when(ts):
+    try:
+        return datetime.fromtimestamp(ts) if ts else None
+    except (OverflowError, ValueError, OSError, TypeError):
+        return None
+
+
+def _hhmm(dt):
+    return dt.strftime("%H:%M") if dt.date() == datetime.now().date() else dt.strftime("%b %d %H:%M")
+
+
+def _row(handle, name, dtype, lab, online, state, until, nxt):
+    return {"handle": handle, "name": name, "type": dtype, "lab": lab, "online": bool(online),
+            "state": state if state in ("free", "busy", "mine") else "unknown",
+            "until": _when(until), "next": _when(nxt)}
+
+
+def _global(backend):
+    from .app import _global_slug
+    from ..deployment.http import AccountBackendError
+
+    note = None
+    try:
+        data = backend.availability()
+    except AccountBackendError as exc:
+        if exc.retry_after:
+            raise _Refused(exc.retry_after) from None
+        if exc.code != "not_found":
+            raise
+        data, note = backend.devices(), "This Global home does not report availability yet; showing devices only."
+    if data.get("incomplete") or any(d.get("status") == "unavailable" for d in data["destinations"]):
+        note = "\n".join(filter(None, [note, "Some labs did not answer; the list may be incomplete."]))
+    slugs, rows = {}, []
+    for d in data["devices"]:
+        key = (d.get("deployment_id"), d.get("deployment_name"))
+        if key not in slugs:
+            slugs[key] = _global_slug(d.get("device_id", ""), d.get("deployment_name"))
+        slug = slugs[key]
+        handle = f"{d['handle']}@{slug}" if d.get("handle") and slug else None
+        rows.append(_row(handle, d.get("display_name"), d.get("device_type"), d.get("deployment_name"),
+                         d.get("online"), d.get("state"), d.get("until"), d.get("next")))
+    return rows, data.get("interval"), note
+
+
+def _lab(home, creds):
+    from .grpc_client import rpc_client
+
+    args = {"un": map_arg(creds[0]), "pw": map_arg(creds[1])}
+    res = rpc_client(function_name="ACC:availability", args=args).results
+    if "UC" in res:
+        data = json.loads(unmap_arg(res["UC"]))
+        rows = [_row(f"{d['handle']}@{home}" if d.get("handle") and home else None, d.get("display_name"),
+                     d.get("device_type"), home, d.get("online"), d.get("state"), d.get("until"), d.get("next"))
+                for d in data["devices"]]
+        return rows, data.get("interval"), None
+    if "retry_after" in res:
+        raise _Refused(int(unmap_arg(res["retry_after"])))
+    error = str(unmap_arg(res.get("ace", map_arg("Unexpected reply from the lab."))))
+    if error == "Invalid login credentials.":
+        raise RuntimeError(STALE_LOGIN)
+    if "No matching server function" not in error:
+        raise RuntimeError(error)
+    # A lab older than ACC:availability: its device list, no availability.
+    from .app import _LOCAL_LABEL, _PARTNER_LABEL, _name_and_handle
+
+    res = rpc_client(function_name="ACC:get_dev", args=args).results
+    if "ace" in res:
+        raise RuntimeError(str(unmap_arg(res["ace"])))
+    rows = []
+    for key in sorted(res, key=lambda k: int(k) if str(k).isdigit() else 0):
+        label = str(unmap_arg(res[key]))
+        local = _LOCAL_LABEL.match(label)
+        if _PARTNER_LABEL.match(label) or not local:
+            continue  # partner devices have no handles yet
+        name, handle = _name_and_handle(local["name"])
+        rows.append(_row(f"{handle}@{home}" if handle and home else None, name, None, home,
+                         local["state"].startswith("online"), "unknown", None, None))
+    return rows, None, "This lab does not report availability yet; showing devices only."
+
+
+def _print(rows, footer=None):
+    def now(r):
+        if r["state"] == "free":
+            return "free"
+        if r["state"] in ("busy", "mine") and r["until"]:
+            return f"{'yours' if r['state'] == 'mine' else 'in use'} until {_hhmm(r['until'])}"
+        return "?"
+
+    table = [("DEVICE (token=)", "TYPE", "ONLINE", "NOW", "NEXT")] + [
+        (r["handle"] or f"{r['name']}{' @' + r['lab'] if r['lab'] else ''} (no handle)", r["type"] or "-", "online" if r["online"] else "offline",
+         now(r), _hhmm(r["next"]) if r["next"] else "-") for r in rows]
+    widths = [max(len(str(line[i])) for line in table) for i in range(5)]
+    for line in table:
+        print("  ".join(str(c).ljust(w) for c, w in zip(line, widths)).rstrip())
+    if not rows:
+        print("(no devices)")
+    if footer:
+        print(footer)
+
+
+def devices():
+    global _cache
+    from ..deployment.state import load_target
+
+    target = load_target()
+    try:
+        if target and target["transport"] == "https-json":
+            from .grpc_client import federated_backend
+
+            try:
+                backend = federated_backend()
+            except RuntimeError as exc:
+                print(exc)
+                return []
+            key, fetch = ("global", target["origin"]), lambda: _global(backend)
+        else:
+            from . import direct_path
+            from .grpc_client import _active_home_name
+
+            home, creds = _active_home_name(), direct_path._credentials()
+            if not creds:
+                print(NOT_LOGGED_IN)
+                return []
+            key, fetch = ("lab", home, creds[0]), lambda: _lab(home, creds)
+
+        if _cache and _cache[0] == key:
+            left = _cache[3] - (time.monotonic() - _cache[1])
+            if left > 0:
+                if _cache[2] is None:
+                    print(f"Asked too recently; try again in {max(1, round(left))} s.")
+                    return []
+                _print(_cache[2], f"(cached; refresh in {max(1, round(left))} s)")
+                return _cache[2]
+        try:
+            rows, interval, note = fetch()
+        except _Refused as exc:
+            # Remember the refusal so calls inside the wait stay local.
+            old = _cache[2] if _cache and _cache[0] == key else None
+            _cache = (key, time.monotonic(), old, float(exc.wait))
+            if old is not None:
+                _print(old, f"(cached; refresh in {exc.wait} s)")
+                return old
+            print(f"Asked too recently; try again in {exc.wait} s.")
+            return []
+    except RuntimeError as exc:
+        print(exc)
+        return []
+    _cache = (key, time.monotonic(), rows, float(interval or 10))
+    _print(rows, note)
+    return rows

{remoterf-2.5.2 → remoterf-2.6.0}/src/remoterf/deployment/backend.py

@@ -325,6 +325,19 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
             raise AccountBackendError("Invalid home device response")
         return value
 
+    def availability(self):
+        """Devices plus now/until/next state (Global >= the availability
+        route; an older one answers code not_found)."""
+        self._operation("ACC:get_dev")
+        value = self.transport.request(
+            "GET", self.base + "/availability", access=self._access(),
+            overall_timeout=DEVICE_AGGREGATION_TIMEOUT_SECONDS + 3,
+            max_response_bytes=MAX_DEVICE_LIST_HTTP_RESPONSE_BYTES,
+        )
+        if type(value.get("devices")) is not list or type(value.get("destinations")) is not list:
+            raise AccountBackendError("Invalid home device response")
+        return value
+
     def reservations(self):
         self._operation("ACC:get_res")
         value = self.transport.request(

{remoterf-2.5.2 → remoterf-2.6.0}/src/remoterf/deployment/http.py

@@ -21,9 +21,10 @@ FRAMED_CONTENT_TYPE = "application/x-remoterf-framed"
 
 
 class AccountBackendError(RuntimeError):
-    def __init__(self, code, *, provenance=None):
+    def __init__(self, code, *, provenance=None, retry_after=None):
         self.code = code
         self.provenance = provenance
+        self.retry_after = retry_after
         super().__init__(code)
 
 
@@ -120,7 +121,10 @@ class JsonTransport:
                     )
                     if provenance not in {None, "home", "transport", "destination"}:
                         provenance = None
-                    raise AccountBackendError(code, provenance=provenance)
+                    wait = error.get("retry_after") if isinstance(error, dict) else None
+                    if type(wait) is not int or not 1 <= wait <= 3600:
+                        wait = None
+                    raise AccountBackendError(code, provenance=provenance, retry_after=wait)
                 if type(value) is not dict:
                     raise AccountBackendError("Invalid account response")
                 return value

{remoterf-2.5.2 → remoterf-2.6.0}/src/remoterf/drivers/adalm_pluto/adalm_pluto_remote.py

@@ -14,10 +14,10 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # Auto-generated from IDL schema — do not edit by hand.
-# device_type: adalm_pluto  driver_version: 0.0.3  schema_hash: sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4
+# device_type: adalm_pluto  driver_version: 0.0.4  schema_hash: sha256:9cbbbbc0cd76fc7897dd702adc0c4a0aa9b5042484c6cb38d0057ca217cb92ce
 
 _PREFIX = "Adalm_pluto"
-_SCHEMA_HASH = "sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4"
+_SCHEMA_HASH = "sha256:9cbbbbc0cd76fc7897dd702adc0c4a0aa9b5042484c6cb38d0057ca217cb92ce"
 _CLIENT_MODULES = {}
 _CLIENT_OBJECTS = {}
 

{remoterf-2.5.2 → remoterf-2.6.0/src/remoterf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.2
+Version: 2.6.0
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -354,6 +354,25 @@ If converting a existing `non-remoterf` compatible script:
 
 Nothing else needs changing! 
 
+#### List devices and availability
+
+With a saved login (lab or Global), list the devices you can use, each with the handle to paste into `token=`, and whether it is free right now:
+
+```python
+import remoterf
+
+rows = remoterf.devices()   # prints a table and returns it as a list of dicts
+```
+
+```
+DEVICE (token=)  TYPE   ONLINE   NOW                 NEXT
+Pluto_01@lab     pluto  online   free                14:30
+Pluto_02@lab     pluto  online   in use until 13:45  -
+Pluto_03@lab     pluto  offline  yours until 15:00   -
+```
+
+Each account may ask once every 10 seconds; a repeat call within that reprints the last table with the remaining wait.
+
 ## Closing
 
 This is fundamentally a experimental platform, and there will be many unknown bugs and issues. Some devices do not have universal support for all its functions at the moment, I am working on that aspect. 

{remoterf-2.5.2 → remoterf-2.6.0}/src/remoterf.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ src/remoterf/config/config.py
 src/remoterf/core/__init__.py
 src/remoterf/core/acc_login.py
 src/remoterf/core/app.py
+src/remoterf/core/availability.py
 src/remoterf/core/banner_note.txt
 src/remoterf/core/direct_path.py
 src/remoterf/core/dynamic_v2_transport.py
@@ -77,6 +78,7 @@ tests/test_cli_login_fresh.py
 tests/test_config_address.py
 tests/test_deployment_accounts.py
 tests/test_device_routes.py
+tests/test_devices_api.py
 tests/test_direct_path_fixed.py
 tests/test_direct_path_global.py
 tests/test_direct_path_partner.py

remoterf-2.6.0/tests/test_devices_api.py

@@ -0,0 +1,228 @@
+"""remoterf.devices(): handles + availability from the saved login's home."""
+
+import json
+import time
+from types import SimpleNamespace
+
+import pytest
+
+import remoterf
+from remoterf.common.utils import map_arg
+from remoterf.core import app, availability, direct_path, grpc_client
+from remoterf.deployment import state
+from remoterf.deployment.http import AccountBackendError
+
+NOW = int(time.time())
+
+
+@pytest.fixture(autouse=True)
+def fresh(monkeypatch):
+    monkeypatch.setattr(availability, "_cache", None)
+
+
+def _lab(monkeypatch, replies, creds=("jdoe", "s3cret")):
+    calls = []
+    monkeypatch.setattr(state, "load_target", lambda: {"origin": None, "transport": "grpc", "deployment_id": None})
+    monkeypatch.setattr(grpc_client, "_active_home_name", lambda: "ucla")
+    monkeypatch.setattr(direct_path, "_credentials", lambda: creds)
+
+    def rpc(*, function_name, args):
+        calls.append(function_name)
+        return SimpleNamespace(results=replies[function_name])
+
+    monkeypatch.setattr(grpc_client, "rpc_client", rpc)
+    return calls
+
+
+def _ok(devices, interval=10):
+    return {"UC": map_arg(json.dumps({"now": NOW, "interval": interval, "window": 21600, "devices": devices}))}
+
+
+LAB_DEVICES = [
+    {"local_device_id": "1", "display_name": "Pluto 01", "device_type": "pluto", "online": True,
+     "handle": "Pluto_01", "state": "free", "until": None, "next": NOW + 3600},
+    {"local_device_id": "2", "display_name": "Pluto 02", "device_type": "pluto", "online": True,
+     "handle": "Pluto_02", "state": "busy", "until": NOW + 600, "next": None},
+    {"local_device_id": "3", "display_name": "bench", "device_type": None, "online": False,
+     "state": "mine", "until": NOW + 900, "next": None},
+]
+
+
+def test_lab_table_and_rows(monkeypatch, capsys):
+    calls = _lab(monkeypatch, {"ACC:availability": _ok(LAB_DEVICES)})
+    rows = remoterf.devices()
+    assert calls == ["ACC:availability"]
+    assert [(r["handle"], r["state"], r["online"]) for r in rows] == [
+        ("Pluto_01@ucla", "free", True), ("Pluto_02@ucla", "busy", True), (None, "mine", False)]
+    assert rows[1]["until"].timestamp() == NOW + 600
+    out = capsys.readouterr().out
+    assert "DEVICE (token=)" in out and "Pluto_01@ucla" in out
+    assert "in use until" in out and "yours until" in out and "bench @ucla (no handle)" in out
+    assert availability._hhmm(rows[0]["next"]) in out
+
+
+def test_hhmm_and_bad_epochs():
+    from datetime import datetime, timedelta
+
+    noon = datetime.now().replace(hour=12, minute=5)
+    assert availability._hhmm(noon) == "12:05"
+    assert availability._hhmm(noon + timedelta(days=1)) == (noon + timedelta(days=1)).strftime("%b %d 12:05")
+    assert availability._when(1_760_000_000_000) is None and availability._when(2**62) is None
+
+
+def test_refusal_is_remembered_locally(monkeypatch, capsys):
+    calls = _lab(monkeypatch, {"ACC:availability": {"ace": map_arg("Too many availability requests; try again in 8 s."),
+                                                    "retry_after": map_arg(8)}})
+    assert remoterf.devices() == [] and remoterf.devices() == []
+    assert calls == ["ACC:availability"]
+    out = capsys.readouterr().out
+    assert out.count("try again in") == 2
+
+
+def test_stale_saved_login(monkeypatch, capsys):
+    _lab(monkeypatch, {"ACC:availability": {"ace": map_arg("Invalid login credentials.")}})
+    assert remoterf.devices() == []
+    assert "no longer valid" in capsys.readouterr().out
+
+
+def test_cached_within_interval_and_server_retry_after(monkeypatch, capsys):
+    calls = _lab(monkeypatch, {"ACC:availability": _ok(LAB_DEVICES)})
+    first = remoterf.devices()
+    assert remoterf.devices() is first
+    assert calls == ["ACC:availability"]
+    assert "(cached; refresh in" in capsys.readouterr().out
+
+    # Cache expired locally but the server still refuses: show the cache and its wait.
+    availability._cache = (*availability._cache[:3], 0.0)
+    _lab(monkeypatch, {"ACC:availability": {"ace": map_arg("Too many availability requests; try again in 4 s."),
+                                            "retry_after": map_arg(4)}})
+    assert remoterf.devices() is first
+    assert "(cached; refresh in 4 s)" in capsys.readouterr().out
+
+    availability._cache = None
+    assert remoterf.devices() == []
+    assert "try again in 4 s" in capsys.readouterr().out
+
+
+def test_old_lab_falls_back_to_get_dev(monkeypatch, capsys):
+    calls = _lab(monkeypatch, {
+        "ACC:availability": {"ace": map_arg("No matching server function to call: availability")},
+        "ACC:get_dev": {"3": map_arg("Pluto 01 (online)"), "4": map_arg("Remote @mit (online)")},
+    })
+    rows = remoterf.devices()
+    assert calls == ["ACC:availability", "ACC:get_dev"]
+    assert [(r["handle"], r["state"]) for r in rows] == [("Pluto_01@ucla", "unknown")]
+    assert "does not report availability" in capsys.readouterr().out
+
+
+def test_lab_not_logged_in(monkeypatch, capsys):
+    calls = _lab(monkeypatch, {}, creds=None)
+    assert remoterf.devices() == []
+    assert calls == []
+    assert "Not logged in" in capsys.readouterr().out
+
+
+class FakeBackend:
+    def __init__(self, error=None):
+        self.error = error
+
+    def availability(self):
+        if self.error:
+            raise self.error
+        return {"devices": [
+            {"device_id": "u1:1", "deployment_id": "u1", "deployment_name": "ucla", "local_device_id": "1",
+             "display_name": "Pluto 01", "device_type": "pluto", "online": True, "handle": "Pluto_01",
+             "state": "mine", "until": NOW + 60, "next": None},
+            {"device_id": "u2:5", "deployment_id": "u2", "deployment_name": "Some Lab", "local_device_id": "5",
+             "display_name": "Pluto 05", "device_type": "pluto", "online": True, "handle": "Pluto_05",
+             "state": "unknown", "until": None, "next": None},
+        ], "destinations": [], "interval": 10}
+
+    def devices(self):
+        return {"devices": [{"device_id": "u1:1", "deployment_id": "u1", "deployment_name": "ucla",
+                             "local_device_id": "1", "display_name": "Pluto 01", "device_type": "pluto",
+                             "online": False, "handle": "Pluto_01"}], "destinations": []}
+
+
+def _global(monkeypatch, backend):
+    monkeypatch.setattr(state, "load_target", lambda: {"origin": "https://global.example.org",
+                                                       "transport": "https-json", "deployment_id": "x"})
+    if isinstance(backend, Exception):
+        def fail():
+            raise backend
+        monkeypatch.setattr(grpc_client, "federated_backend", fail)
+    else:
+        monkeypatch.setattr(grpc_client, "federated_backend", lambda: backend)
+    monkeypatch.setattr(app, "_global_slug", lambda device_id, name: name if name == "ucla" else None)
+
+
+def test_global_rows(monkeypatch, capsys):
+    _global(monkeypatch, FakeBackend())
+    rows = remoterf.devices()
+    assert [(r["handle"], r["state"], r["lab"]) for r in rows] == [
+        ("Pluto_01@ucla", "mine", "ucla"), (None, "unknown", "Some Lab")]
+    out = capsys.readouterr().out
+    assert "yours until" in out and "Pluto 05 @Some Lab (no handle)" in out and "incomplete" not in out
+
+
+def test_old_global_falls_back_to_devices(monkeypatch, capsys):
+    _global(monkeypatch, FakeBackend(AccountBackendError("not_found")))
+    rows = remoterf.devices()
+    assert [(r["handle"], r["state"], r["online"]) for r in rows] == [("Pluto_01@ucla", "unknown", False)]
+    assert "does not report availability" in capsys.readouterr().out
+
+
+def test_old_global_over_http_falls_back(monkeypatch, capsys):
+    import httpx
+    from remoterf_federation_core import local_capabilities
+
+    from remoterf.deployment.backend import HttpsJsonAccountBackend
+    from remoterf.deployment.http import JsonTransport
+
+    caps = local_capabilities(deployment_id="550e8400-e29b-41d4-a716-446655440000")
+    caps.update(account_transport="https-json", account_api_base="/v2/deployment")
+    listing = FakeBackend().devices()
+    listing["destinations"] = [{"status": "unavailable", "display_name": "Some Lab"}]
+    seen = []
+
+    def handle(request):
+        seen.append(request.url.path)
+        if request.url.path == "/.well-known/remoterf-deployment":
+            return httpx.Response(200, json=caps)
+        if request.url.path == "/v2/deployment/devices":
+            return httpx.Response(200, json=listing)
+        return httpx.Response(404, json={"detail": "Not Found"})  # FastAPI, no such route
+
+    transport = JsonTransport("https://global.example.org", client=httpx.Client(transport=httpx.MockTransport(handle)))
+    backend = HttpsJsonAccountBackend(transport.origin, transport=transport, store=object())
+    backend.credentials = {"access_token": "t", "access_expires_at": 2**31}
+    _global(monkeypatch, backend)
+    rows = remoterf.devices()
+    assert seen[1:] == ["/v2/deployment/availability", "/v2/deployment/devices"]
+    assert [(r["handle"], r["state"]) for r in rows] == [("Pluto_01@ucla", "unknown")]
+    out = capsys.readouterr().out
+    assert "does not report availability" in out and "may be incomplete" in out
+
+
+def test_global_rate_limited_without_cache(monkeypatch, capsys):
+    _global(monkeypatch, FakeBackend(AccountBackendError("rate_limited", retry_after=7)))
+    assert remoterf.devices() == []
+    assert "try again in 7 s" in capsys.readouterr().out
+
+
+def test_global_not_logged_in(monkeypatch, capsys):
+    _global(monkeypatch, RuntimeError("Log in to the account home first (run `remoterf`, then `login`)"))
+    assert remoterf.devices() == []
+    assert "Log in to the account home first" in capsys.readouterr().out
+
+
+def test_http_error_carries_retry_after():
+    import httpx
+
+    from remoterf.deployment.http import JsonTransport
+
+    body = {"error": {"code": "rate_limited", "retry_after": 9}}
+    client = httpx.Client(transport=httpx.MockTransport(lambda request: httpx.Response(429, json=body)))
+    with pytest.raises(AccountBackendError) as raised:
+        JsonTransport("https://global.example.org", client=client).request("GET", "/v2/deployment/availability")
+    assert (raised.value.code, raised.value.retry_after) == ("rate_limited", 9)

remoterf-2.5.2/src/remoterf/drivers/support/__init__.py

@@ -1,14 +0,0 @@
-# Copyright (C) 2026 RemoteRF
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.