RemoteRF 2.5.1__tar.gz → 2.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.1
+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
@@ -52,6 +52,8 @@ source venv/bin/activate    # Activate virtual environment
 pip install remoterf        # Install remoterf
 ```
 
+The package was named `remoteRF` before 2.2.0. Old code that does `import remoteRF` or `from remoteRF.drivers... import ...` still runs, with a one-time warning; change it to `remoterf`.
+
 ## NI USRP-2901, Ettus B205-mini, B200-family, and USRP N210
 
 The packaged client natively includes the shared USRP schema for the qualified
@@ -145,6 +147,12 @@ not close the physical radio. `read_samples` and `read_bytes` are bounded to a
 4 MiB response. Call them repeatedly for longer captures. Native asynchronous
 callbacks are not transported remotely.
 
+Through the RemoteRF Global relay one reply is capped at 768 KiB. A lab on a
+current Server keeps a larger reply (up to 4 MiB) and the client fetches it in
+pages; an older lab refuses it with `response_too_large`, so keep reads there
+to about 98k complex64 samples (`read_samples(65536)` is safe). LAN and direct
+paths are not capped.
+
 When a Tailscale address differs from the IP or DNS identity in the server
 certificate, keep TLS verification enabled and set the expected identity:
 
@@ -346,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.1 → remoterf-2.6.0}/README.md

@@ -27,6 +27,8 @@ source venv/bin/activate    # Activate virtual environment
 pip install remoterf        # Install remoterf
 ```
 
+The package was named `remoteRF` before 2.2.0. Old code that does `import remoteRF` or `from remoteRF.drivers... import ...` still runs, with a one-time warning; change it to `remoterf`.
+
 ## NI USRP-2901, Ettus B205-mini, B200-family, and USRP N210
 
 The packaged client natively includes the shared USRP schema for the qualified
@@ -120,6 +122,12 @@ not close the physical radio. `read_samples` and `read_bytes` are bounded to a
 4 MiB response. Call them repeatedly for longer captures. Native asynchronous
 callbacks are not transported remotely.
 
+Through the RemoteRF Global relay one reply is capped at 768 KiB. A lab on a
+current Server keeps a larger reply (up to 4 MiB) and the client fetches it in
+pages; an older lab refuses it with `response_too_large`, so keep reads there
+to about 98k complex64 samples (`read_samples(65536)` is safe). LAN and direct
+paths are not capped.
+
 When a Tailscale address differs from the IP or DNS identity in the server
 certificate, keep TLS verification enabled and set the expected identity:
 
@@ -321,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.1 → remoterf-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.5.1"
+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"
@@ -36,7 +36,8 @@ remoterf = "remoterf.remoterf_cli:main"
 [tool.setuptools]
 package-dir = { "" = "src" }
 # src/remoterf.py: see its docstring (upgrades from 2.0.14-2.1.x).
-py-modules = ["remoterf"]
+# src/_remoterf_alias.py: `import remoteRF` (setup.py adds its .pth).
+py-modules = ["remoterf", "_remoterf_alias"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

remoterf-2.6.0/setup.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py
+
+
+class BuildPy(build_py):
+    """The wheel also ships _remoterf_alias.pth, so `import remoteRF` works
+    (see src/_remoterf_alias.py)."""
+
+    def run(self):
+        super().run()
+        Path(self.build_lib, "_remoterf_alias.pth").write_text("import _remoterf_alias\n")
+
+
+setup(cmdclass={"build_py": BuildPy})

remoterf-2.6.0/src/_remoterf_alias.py

@@ -0,0 +1,60 @@
+# 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/>.
+
+"""``import remoteRF``, the package's name before 2.2.0, still works.
+
+_remoterf_alias.pth imports this module at startup. It maps ``remoteRF`` and
+every ``remoteRF.*`` to the same module objects as ``remoterf``, warning once.
+Until something imports ``remoteRF``, it imports nothing (no remoterf, grpc, numpy).
+A ``remoteRF.py`` file cannot do this: on a case-insensitive disk it would
+collide with the ``remoterf.py`` rescue module.
+"""
+
+import importlib
+import importlib.machinery
+import sys
+import warnings
+
+_OLD, _NEW = "remoteRF", "remoterf"
+
+
+class _Alias:  # a meta path finder and its loader
+    warned = False
+
+    def find_spec(self, name, path=None, target=None):
+        if name == _OLD or name.startswith(_OLD + "."):
+            return importlib.machinery.ModuleSpec(name, self)
+        return None
+
+    def create_module(self, spec):
+        if not _Alias.warned:
+            _Alias.warned = True
+            # FutureWarning: shown by default (a DeprecationWarning is hidden outside __main__).
+            # stacklevel skips the import machinery, so it points at the importing line.
+            warnings.warn(
+                "'remoteRF' was renamed 'remoterf' in 2.2.0; import remoterf instead",
+                FutureWarning, stacklevel=2,
+            )
+        module = importlib.import_module(_NEW + spec.name[len(_OLD):])
+        spec.loader_state = module.__spec__
+        return module
+
+    def exec_module(self, module):
+        module.__spec__ = module.__spec__.loader_state  # loading set it to the alias's spec
+
+
+# First: on an upgraded machine a surviving remoteRF folder would load a second copy.
+if not any(isinstance(finder, _Alias) for finder in sys.meta_path):
+    sys.meta_path.insert(0, _Alias())

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.1 → remoterf-2.6.0}/src/remoterf/core/direct_path.py

@@ -904,10 +904,12 @@ def describe() -> str:
         return f"relay (direct path unavailable: {_BROKEN}; fix: pip install --force-reinstall remoterf)"
     if not enabled():
         return "relay (direct path disabled: REMOTERF_DIRECT=0)"
+    # A Global ref's path has no owner; its calls fall back to Global's relay.
     partners = "; ".join(
         f"partner {_partner_owners[key]}: "
         + (path.describe() if path.ready else path.describe().replace("relay", "via HOME", 1))
-        for key, path in list(_partners.items()) if key in _partner_owners
+        if key in _partner_owners else f"Global: {path.describe()}"
+        for key, path in list(_partners.items())
     )
     path = _path
     if path is not None:

{remoterf-2.5.1 → remoterf-2.6.0}/src/remoterf/core/dynamic_v2_transport.py

@@ -27,6 +27,7 @@ from ..common.grpc import grpc_pb2, grpc_pb2_grpc
 from ..common.grpc.v2_codec import decode_value, encode_value
 from .v2_errors import (
     RemoteRFError,
+    RemoteRFPolicyError,
     RemoteRFProtocolError,
     RemoteRFReservationError,
     RemoteRFTransportError,
@@ -96,6 +97,8 @@ class _DevicePlaneStub:
                 args={"a": map_arg(self._token), "wire": map_arg(request.SerializeToString())},
             )
         except RuntimeError as exc:
+            if "response_too_large" in str(exc):
+                raise RemoteRFPolicyError(f"{self._label}{exc}") from exc
             # A refusal the HOME or the owner carried in "a": no live
             # reservation, a revoked agreement, a device no longer visible.
             raise RemoteRFReservationError(f"{self._label}{exc}") from exc

{remoterf-2.5.1 → remoterf-2.6.0}/src/remoterf/core/grpc_client.py

@@ -228,21 +228,32 @@ def _federated_call(route, function_name, args):
                 refused = "a" in response.results and unmap_arg(response.results["a"]) == "the reservation has ended"
                 if not refused:
                     return response
+    def send(request):
+        if ref.startswith("rfg_"):
+            return _token_backend().device_token_rpc(
+                ref, getattr(route, "deployment_id", None), request.SerializeToString()
+            )
+        return federated_backend().device_rpc(ref, request.SerializeToString())
+
     request = grpc_pb2.GenericRPCRequest(function_name=function_name, args=args)
     for retry in (function_name.endswith(":GET"), False):
         try:
-            if ref.startswith("rfg_"):
-                raw = _token_backend().device_token_rpc(
-                    ref, getattr(route, "deployment_id", None), request.SerializeToString()
-                )
-            else:
-                raw = federated_backend().device_rpc(ref, request.SerializeToString())
+            raw = send(request)
             break
         except AccountBackendError as exc:
             if retry and exc.code == "internal_error" and exc.provenance == "transport":
                 # An older lab drops ~0.1% of relayed results when a clock second
                 # ticks mid-call; a GET changes nothing, so it is sent once more.
                 continue
+            if exc.code == "response_too_large" and exc.provenance == "destination":
+                raw = _kept_reply(send, args)
+                if raw is not None:
+                    break
+                raise RuntimeError(
+                    "response_too_large [destination]: the reply is over the Global relay's "
+                    "768 KiB limit for one call and this lab does not page it; read fewer "
+                    "samples per call (about 98k complex64) or use a direct path"
+                ) from None
             if ref.startswith("rfg_") and str(exc) == "not_found":
                 raise RuntimeError(
                     "this RemoteRF Global does not accept device tokens yet; use the device reference"
@@ -660,6 +671,34 @@ def _rx_readahead(prefix, args, token):
     return grpc_pb2.GenericRPCResponse(results={"rx": first})
 
 
+# A newer lab keeps a reply too large for the relay (up to 4 MiB) for its
+# caller, who fetches it in pages; an older lab refuses the first page unrun.
+_PAGE_FUNCTION = "Federation:page:CALL2"
+_MAX_KEPT_REPLY = 4 * 1024 * 1024 + 65536
+
+
+def _kept_reply(send, args):
+    from ..deployment.http import AccountBackendError
+    data, nonce = b"", ""
+    while True:
+        page_args = {"arg1": map_arg(len(data)), "arg2": map_arg(nonce)}
+        if "a" in args:
+            page_args["a"] = args["a"]
+        try:
+            raw = send(grpc_pb2.GenericRPCRequest(function_name=_PAGE_FUNCTION, args=page_args))
+        except AccountBackendError:
+            return None
+        reply = grpc_pb2.GenericRPCResponse.FromString(raw)
+        if not {"page", "size", "nonce"} <= set(reply.results):
+            return None
+        page, size, nonce = (unmap_arg(reply.results[key]) for key in ("page", "size", "nonce"))
+        if not isinstance(page, bytes) or not page or type(size) is not int or size > _MAX_KEPT_REPLY:
+            return None
+        data += page
+        if len(data) >= size:
+            return data if len(data) == size else None
+
+
 # Device tokens whose Server answered an rx in ci16: it decodes ci16 too (the
 # same Gate I slice 3 change), so their tx may go out that way.
 _ci16_tokens: set = set()

{remoterf-2.5.1 → 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.1 → 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.1 → 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.1 → remoterf-2.6.0}/src/remoterf/drivers/dynamic_device.py

@@ -252,6 +252,9 @@ def _validate_client_modules(value) -> dict:
     out = {}
     for alias, module_path in value.items():
         alias = _require_identifier(alias, field="client_modules alias")
+        module_path = str(module_path or "").strip()
+        if module_path.startswith("remoteRF."):  # Servers still name the package as before 2.2.0
+            module_path = "remoterf." + module_path[len("remoteRF."):]
         module_path = _require_dotted_identifier(
             module_path,
             field=f"client_modules[{alias!r}]",
@@ -1415,7 +1418,8 @@ _DRIVERS_DIR = Path(__file__).parent
 def _write_driver_files(schema: dict) -> Path:
     pkg_dir = _write_v2_driver_files(schema) if str(schema.get("schema_version")) == "2.0" else _write_v1_driver_files(schema)
     stale = f"remoterf.drivers.{pkg_dir.name}"
-    for name in [m for m in sys.modules if m == stale or m.startswith(stale + ".")]:
+    old = "remoteRF" + stale[len("remoterf"):]  # the `import remoteRF` alias keys
+    for name in [m for m in sys.modules if m in (stale, old) or m.startswith((stale + ".", old + "."))]:
         del sys.modules[name]
     return pkg_dir
 
@@ -1685,7 +1689,13 @@ def install_driver_if_stale(*, token: str, current_hash: str) -> bool:
         return False
 
     device_type = _schema_device_type(schema)
-    pkg_dir = _write_driver_files(schema)
+    try:
+        pkg_dir = _write_driver_files(schema)
+    except OSError as exc:
+        # A read-only install (system site-packages): the installed driver keeps working.
+        _verified.add(key)
+        print(f"Driver for '{device_type}' is out of date and could not be updated ({exc}).")
+        return False
     if _read_schema_hash(pkg_dir / f"{device_type}_remote.py") == current_hash:
         return False
     print(