RemoteRF 2.5.1__tar.gz → 2.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.1
+Version: 2.5.2
 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:
 

{remoterf-2.5.1 → remoterf-2.5.2}/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:
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.5.1"
+version = "2.5.2"
 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.5.2/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.5.2/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.5.1 → remoterf-2.5.2}/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.5.2}/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.5.2}/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.5.2}/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(

{remoterf-2.5.1 → remoterf-2.5.2}/src/remoterf/drivers/rtl_sdr/rtl_sdr_remote.py

@@ -14,21 +14,35 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # Auto-generated from IDL schema — do not edit by hand.
-# device_type: rtl_sdr  driver_version: 0.1.1  schema_hash: sha256:1c84effc2c21be734398a87d24bb9da52ab5b7ea0def955c503da484b8d818c0
+# device_type: rtl_sdr  driver_version: 0.1.1  schema_hash: sha256:6603ec8e642c87073c35202980de9a3d9e4bb6eb88967686d3810c389fb4fb97
 
 _PREFIX = "Rtl_sdr"
-_SCHEMA_HASH = "sha256:1c84effc2c21be734398a87d24bb9da52ab5b7ea0def955c503da484b8d818c0"
+_SCHEMA_HASH = "sha256:6603ec8e642c87073c35202980de9a3d9e4bb6eb88967686d3810c389fb4fb97"
 _CLIENT_MODULES = {}
 _CLIENT_OBJECTS = {}
 
+import os
+
 from importlib import import_module as _import_module
 
-from ...core.grpc_client import rpc_client
 from ...common.utils import map_arg, unmap_arg
+from .._virtual import (
+    is_virtual_token,
+    make_virtual_token,
+    virtual_call,
+    virtual_get,
+    virtual_set,
+)
 
 _NO_ARG = object()
 
 
+def _rpc_client(*, function_name, args):
+    from ...core.grpc_client import rpc_client
+
+    return rpc_client(function_name=function_name, args=args)
+
+
 for _alias, _module_path in _CLIENT_MODULES.items():
     globals()[_alias] = _import_module(_module_path)
 
@@ -71,27 +85,34 @@ def _wrap_client_return(spec, self_obj, result):
 
 
 def _try_get(prop, token):
-    return unmap_arg(rpc_client(
+    if is_virtual_token(token):
+        return virtual_get(token, prop)
+    return unmap_arg(_rpc_client(
         function_name=f"{_PREFIX}:{prop}:GET",
         args={'a': map_arg(token)},
     ).results[prop])
 
 
 def _try_set(prop, value, token):
-    rpc_client(
+    if is_virtual_token(token):
+        virtual_set(token, prop, value)
+        return None
+    _rpc_client(
         function_name=f"{_PREFIX}:{prop}:SET",
         args={prop: map_arg(value), 'a': map_arg(token)},
     )
 
 
 def _try_call(prop, token, arg=_NO_ARG):
+    if is_virtual_token(token):
+        return virtual_call(token, prop, arg, has_arg=arg is not _NO_ARG)
     if arg is _NO_ARG:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL0",
             args={'a': map_arg(token)},
         )
     else:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL1",
             args={'a': map_arg(token), 'arg1': map_arg(arg)},
         )
@@ -100,12 +121,15 @@ def _try_call(prop, token, arg=_NO_ARG):
 
 
 def _try_calln(prop, token, kwargs):
+    if is_virtual_token(token):
+        filtered = {key: value for key, value in dict(kwargs).items() if value is not _NO_ARG}
+        return virtual_call(token, prop, filtered, has_arg=True)
     payload = {'a': map_arg(token)}
     for key, value in dict(kwargs).items():
         if value is _NO_ARG:
             continue
         payload[str(key)] = map_arg(value)
-    resp = rpc_client(
+    resp = _rpc_client(
         function_name=f"{_PREFIX}:{prop}:CALLN",
         args=payload,
     )
@@ -114,7 +138,15 @@ def _try_calln(prop, token, kwargs):
 
 class RtlSdr:
 
-    def __init__(self, token: str):
+    def __init__(self, token: str = None, *, virtual: bool = False):
+        self.virtual = bool(virtual)
+        if self.virtual:
+            self.token = make_virtual_token(token, device_type="rtl_sdr")
+            return
+        if token is None:
+            token = os.getenv("REMOTERF_TOKEN")
+        if not token:
+            raise ValueError("A reservation token is required; pass token= or set REMOTERF_TOKEN")
         self.token = token
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)

{remoterf-2.5.1 → remoterf-2.5.2}/src/remoterf/drivers/ti_mmwave/ti_mmwave_remote.py

@@ -21,14 +21,28 @@ _SCHEMA_HASH = "sha256:320a89d95075a472d7899ff2f98b9fdee05c0be96fa5651bf5c4f0e5d
 _CLIENT_MODULES = {'ti_mmwave': 'remoterf.drivers.support.ti_mmwave'}
 _CLIENT_OBJECTS = {}
 
+import os
+
 from importlib import import_module as _import_module
 
-from ...core.grpc_client import rpc_client
 from ...common.utils import map_arg, unmap_arg
+from .._virtual import (
+    is_virtual_token,
+    make_virtual_token,
+    virtual_call,
+    virtual_get,
+    virtual_set,
+)
 
 _NO_ARG = object()
 
 
+def _rpc_client(*, function_name, args):
+    from ...core.grpc_client import rpc_client
+
+    return rpc_client(function_name=function_name, args=args)
+
+
 for _alias, _module_path in _CLIENT_MODULES.items():
     globals()[_alias] = _import_module(_module_path)
 
@@ -71,27 +85,34 @@ def _wrap_client_return(spec, self_obj, result):
 
 
 def _try_get(prop, token):
-    return unmap_arg(rpc_client(
+    if is_virtual_token(token):
+        return virtual_get(token, prop)
+    return unmap_arg(_rpc_client(
         function_name=f"{_PREFIX}:{prop}:GET",
         args={'a': map_arg(token)},
     ).results[prop])
 
 
 def _try_set(prop, value, token):
-    rpc_client(
+    if is_virtual_token(token):
+        virtual_set(token, prop, value)
+        return None
+    _rpc_client(
         function_name=f"{_PREFIX}:{prop}:SET",
         args={prop: map_arg(value), 'a': map_arg(token)},
     )
 
 
 def _try_call(prop, token, arg=_NO_ARG):
+    if is_virtual_token(token):
+        return virtual_call(token, prop, arg, has_arg=arg is not _NO_ARG)
     if arg is _NO_ARG:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL0",
             args={'a': map_arg(token)},
         )
     else:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL1",
             args={'a': map_arg(token), 'arg1': map_arg(arg)},
         )
@@ -100,12 +121,15 @@ def _try_call(prop, token, arg=_NO_ARG):
 
 
 def _try_calln(prop, token, kwargs):
+    if is_virtual_token(token):
+        filtered = {key: value for key, value in dict(kwargs).items() if value is not _NO_ARG}
+        return virtual_call(token, prop, filtered, has_arg=True)
     payload = {'a': map_arg(token)}
     for key, value in dict(kwargs).items():
         if value is _NO_ARG:
             continue
         payload[str(key)] = map_arg(value)
-    resp = rpc_client(
+    resp = _rpc_client(
         function_name=f"{_PREFIX}:{prop}:CALLN",
         args=payload,
     )
@@ -114,7 +138,15 @@ def _try_calln(prop, token, kwargs):
 
 class TiMmWave:
 
-    def __init__(self, token: str):
+    def __init__(self, token: str = None, *, virtual: bool = False):
+        self.virtual = bool(virtual)
+        if self.virtual:
+            self.token = make_virtual_token(token, device_type="ti_mmwave")
+            return
+        if token is None:
+            token = os.getenv("REMOTERF_TOKEN")
+        if not token:
+            raise ValueError("A reservation token is required; pass token= or set REMOTERF_TOKEN")
         self.token = token
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.1
+Version: 2.5.2
 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:
 

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

@@ -1,6 +1,8 @@
 LICENSE
 README.md
 pyproject.toml
+setup.py
+src/_remoterf_alias.py
 src/remoterf.py
 src/remoterf/__init__.py
 src/remoterf/remoterf_cli.py
@@ -70,6 +72,7 @@ src/remoterf/drivers/usrp/usrp_remote.py
 src/remoterf/drivers/usrp/usrp_remote.pyi
 tests/test_banner.py
 tests/test_batch.py
+tests/test_bundled_drivers.py
 tests/test_cli_login_fresh.py
 tests/test_config_address.py
 tests/test_deployment_accounts.py
@@ -88,9 +91,11 @@ tests/test_grpc_client_target.py
 tests/test_homes.py
 tests/test_native_account_credentials.py
 tests/test_native_devices.py
+tests/test_old_import_name.py
 tests/test_partner_dynamic_v2.py
 tests/test_pluto_virtual.py
 tests/test_process_arg.py
+tests/test_relay_paging.py
 tests/test_remoterf_cli.py
 tests/test_rx_readahead.py
 tests/test_ti_mmwave.py

remoterf-2.5.2/src/remoterf.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_remoterf_alias
+remoterf

remoterf-2.5.2/tests/test_bundled_drivers.py

@@ -0,0 +1,57 @@
+"""Each bundled driver is what the client would generate from the Server's
+schema, so a first device call does not rewrite site-packages."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from remoterf.drivers import dynamic_device
+
+SERVER_SRC = Path(
+    os.environ.get("REMOTERF_SERVER_SRC", Path(__file__).resolve().parents[2] / "RemoteRF-Server" / "src")
+)
+SCHEMAS = {
+    "adalm_pluto": "remoteRF_server.drivers.adalm_pluto.pluto_schema:PlutoSchema",
+    "hackrf": "remoteRF_server.drivers.hackrf.hackrf_schema:HackRFSchema",
+    "rtl_sdr": "remoteRF_server.drivers.rtl_sdr.rtl_sdr_schema:RtlSdrSchema",
+    "ti_mmwave": "remoteRF_server.drivers.ti_mmwave.ti_mmwave_schema:TiMmWaveSchema",
+}
+# A subprocess: the Server package stays out of this process's imports.
+DUMP = """
+import importlib, json, sys, types
+try:
+    import adi
+except ImportError:
+    sys.modules["adi"] = types.ModuleType("adi")  # the Pluto schema imports pyadi at load
+out = {}
+for device_type, spec in json.loads(sys.argv[1]).items():
+    module, cls = spec.split(":")
+    out[device_type] = getattr(importlib.import_module(module), cls)().get_idl()
+print(json.dumps(out))
+"""
+
+
+@pytest.fixture(scope="module")
+def server_schemas():
+    if not (SERVER_SRC / "remoteRF_server").is_dir():
+        pytest.skip(f"no Server source at {SERVER_SRC} (set REMOTERF_SERVER_SRC)")
+    result = subprocess.run(
+        [sys.executable, "-c", DUMP, json.dumps(SCHEMAS)],
+        env={**os.environ, "PYTHONPATH": str(SERVER_SRC)},
+        capture_output=True, text=True, check=True,
+    )
+    return json.loads(result.stdout.splitlines()[-1])
+
+
+@pytest.mark.parametrize("device_type", sorted(SCHEMAS))
+def test_bundled_driver_matches_the_server_schema(server_schemas, device_type):
+    schema = server_schemas[device_type]
+    path = dynamic_device._DRIVERS_DIR / device_type / f"{device_type}_remote.py"
+    assert dynamic_device._read_schema_hash(path) == schema["schema_hash"]
+    assert path.read_text(encoding="utf-8") == dynamic_device._codegen(schema)

{remoterf-2.5.1 → remoterf-2.5.2}/tests/test_direct_path_global.py

@@ -137,3 +137,15 @@ def test_the_login_backend_is_built_once_when_a_path_thread_asks_too(monkeypatch
     for thread in threads:
         thread.join(5)
     assert len(built) == 1 and got == built * 2
+
+
+def test_describe_reports_a_global_path(fresh, monkeypatch):
+    monkeypatch.setattr(direct_path, "_from_stored_login", lambda: None)
+    monkeypatch.setattr(grpc_client, "_current_profile", lambda: None)
+    monkeypatch.setattr(direct_path, "_active_route", lambda profile: None)
+    path = direct_path.global_path(REF)
+    path.describe = lambda: "direct 192.0.2.7:4433 (48 calls)"
+    assert direct_path.describe() == "Global: direct 192.0.2.7:4433 (48 calls)"
+    path.state = "down"
+    path.describe = lambda: "relay (direct path down: timed out; retrying)"
+    assert direct_path.describe() == "Global: relay (direct path down: timed out; retrying)"

{remoterf-2.5.1 → remoterf-2.5.2}/tests/test_fetch_idl_fallback.py

@@ -96,3 +96,22 @@ def test_a_v1_hash_that_differs_still_lets_v2_decide_and_reinstall(monkeypatch,
     # A stale v1 driver: reinstalled from what v2 says, exactly as before.
     assert dynamic_device.install_driver_if_stale(token="tok5", current_hash="sha256:old") is True
     assert written == [v2]
+
+
+def test_a_read_only_install_keeps_its_driver(monkeypatch, capsys):
+    import remoterf.drivers.dynamic_v2 as dynamic_v2
+
+    def v1_only(token):
+        raise v2_errors.RemoteRFProtocolError("partner devices use the v1 device plane")
+
+    monkeypatch.setattr(dynamic_v2, "fetch_schema_v2", v1_only)
+    calls = _schema_rpc(monkeypatch, "sha256:new")
+
+    def read_only(schema):
+        raise PermissionError(13, "Permission denied")
+
+    monkeypatch.setattr(dynamic_device, "_write_driver_files", read_only)
+    assert dynamic_device.install_driver_if_stale(token="tok5", current_hash="sha256:old") is False
+    assert "could not be updated" in capsys.readouterr().out
+    dynamic_device.install_driver_if_stale(token="tok5", current_hash="sha256:old")
+    assert len(calls) == 2  # fetched once (v1, then the v2 probe's fallback), not per device

remoterf-2.5.2/tests/test_old_import_name.py

@@ -0,0 +1,31 @@
+"""Code written before 2.2.0 imports remoteRF: it gets the remoterf modules
+themselves, with one FutureWarning pointing at that code."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parents[1] / "src"
+PROBE = """
+import site, sys, warnings
+sys.path.insert(0, sys.argv[1])
+site.addsitedir(sys.argv[2])  # runs the .pth, as site-packages does at startup
+assert not {"remoterf", "grpc", "numpy"} & set(sys.modules)  # the hook alone stays light
+with warnings.catch_warnings(record=True) as caught:
+    warnings.simplefilter("always")
+    import remoteRF
+    from remoteRF.drivers.adalm_pluto import Pluto
+    import remoteRF.drivers.adalm_pluto as old
+import remoterf
+import remoterf.drivers.adalm_pluto as new
+assert remoteRF is remoterf and old is new and Pluto is new.Pluto
+assert remoterf.__spec__.name == "remoterf" and new.__spec__.name == "remoterf.drivers.adalm_pluto"
+assert [(w.category, w.filename) for w in caught if "remoteRF" in str(w.message)] == [(FutureWarning, "<string>")], caught
+print("ok")
+"""
+
+
+def test_import_remoteRF_aliases_remoterf_with_one_warning(tmp_path):
+    (tmp_path / "_remoterf_alias.pth").write_text("import _remoterf_alias\n")  # what setup.py ships
+    result = subprocess.run([sys.executable, "-c", PROBE, str(SRC), str(tmp_path)], capture_output=True, text=True)
+    assert result.stdout.strip() == "ok", result.stderr

remoterf-2.5.2/tests/test_relay_paging.py

@@ -0,0 +1,63 @@
+import pytest
+
+from remoterf.common.grpc import grpc_pb2
+from remoterf.common.utils import map_arg, unmap_arg
+from remoterf.core import direct_path, dynamic_v2_transport, grpc_client
+from remoterf.core.v2_errors import RemoteRFPolicyError
+from remoterf.deployment.http import AccountBackendError
+
+REF = "00000000-0000-4000-8000-000000000001:7"
+WHOLE = grpc_pb2.GenericRPCResponse(results={"rx": map_arg(bytes(range(256)) * 4000)}).SerializeToString()
+
+
+class Lab:
+    def __init__(self, pages=True):
+        self.pages = pages
+        self.requests = []
+
+    def device_rpc(self, ref, raw):
+        request = grpc_pb2.GenericRPCRequest.FromString(raw)
+        self.requests.append(request)
+        if request.function_name != "Federation:page:CALL2":
+            raise AccountBackendError("response_too_large", provenance="destination")
+        if not self.pages:  # an older lab: not a device function
+            raise AccountBackendError("device_unavailable", provenance="destination")
+        offset = unmap_arg(request.args["arg1"])
+        return grpc_pb2.GenericRPCResponse(results={
+            "page": map_arg(WHOLE[offset:offset + 600_000]),
+            "size": map_arg(len(WHOLE)),
+            "nonce": map_arg("n1"),
+        }).SerializeToString()
+
+
+@pytest.fixture
+def lab(monkeypatch):
+    lab = Lab()
+    monkeypatch.setattr(direct_path, "wants", lambda function_name: False)
+    monkeypatch.setattr(grpc_client, "federated_backend", lambda: lab)
+    return lab
+
+
+def test_an_oversized_reply_is_fetched_in_pages(lab):
+    response = grpc_client._federated_call(REF, "Rtl_sdr:read_samples:CALL1", {"a": map_arg(REF)})
+    assert response.SerializeToString() == WHOLE
+    pages = lab.requests[1:]
+    assert [unmap_arg(r.args["arg1"]) for r in pages] == [0, 600_000]
+    assert [unmap_arg(r.args["arg2"]) for r in pages] == ["", "n1"]
+
+
+def test_an_older_lab_gets_a_clear_error(lab):
+    lab.pages = False
+    with pytest.raises(RuntimeError, match=r"response_too_large \[destination\].*768 KiB"):
+        grpc_client._federated_call(REF, "Rtl_sdr:read_samples:CALL1", {"a": map_arg(REF)})
+    assert len(lab.requests) == 2
+
+
+def test_dynamic_v2_reports_it_as_a_policy_error(monkeypatch):
+    def refused(**_):
+        raise RuntimeError("response_too_large [destination]: over the relay limit")
+
+    monkeypatch.setattr(grpc_client, "rpc_client", refused)
+    stub = dynamic_v2_transport._DevicePlaneStub("token")
+    with pytest.raises(RemoteRFPolicyError, match="response_too_large"):
+        stub.Invoke(grpc_pb2.InvokeRequest())

remoterf-2.5.1/src/remoterf.egg-info/top_level.txt

@@ -1 +0,0 @@
-remoterf