RemoteRF 2.5.0__tar.gz → 2.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.0
+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.0 → 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.0 → remoterf-2.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.5.0"
+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.0 → remoterf-2.5.2}/src/remoterf/core/direct_path.py

@@ -691,17 +691,25 @@ _partners: dict[str, DirectPath] = {}  # device token -> the path to the lab tha
 _partner_owners: dict[str, str] = {}  # device token -> owner deployment id
 
 
-def _offer_rpc(username: str, secret: str, token: Optional[str] = None) -> Callable[[dict], dict]:
-    """The offer RPC; with ``token`` the home has the partner lab answer instead."""
+def _offer_rpc(username: Optional[str], secret: Optional[str], token: Optional[str] = None) -> Callable[[dict], dict]:
+    """The offer RPC; with ``token`` the home has the partner lab answer instead.
+
+    Without a login (``username`` None) the partner token alone authorizes it."""
     def send(offer: dict) -> dict:
         from .grpc_client import rpc_client
 
-        args = {"un": map_arg(username), "pw": map_arg(secret), "ice": map_arg(json.dumps(offer))}
+        args = {"ice": map_arg(json.dumps(offer))}
+        if username is not None:
+            args.update(un=map_arg(username), pw=map_arg(secret))
         if token is not None:
             args["a"] = map_arg(token)
         response = rpc_client(function_name="ACC:direct_offer", args=args)
         if "ace" in response.results:
-            raise PathError(unmap_arg(response.results["ace"]))
+            reason = unmap_arg(response.results["ace"])
+            if username is None and reason.startswith("Internal server error"):
+                # A home Server that predates token offers fails on the missing login.
+                raise PathUnavailable("the home's Server needs a login for a direct path")
+            raise PathError(reason)
         answer = json.loads(unmap_arg(response.results["ice"]))
         for key in ("server_name", "ca_pem"):
             if key in response.results:
@@ -811,12 +819,18 @@ def _side_path(key: str, make: Callable[[], Optional[DirectPath]]) -> Optional[D
 def _partner(token: str) -> Optional[DirectPath]:
     """The path to the lab owning the device behind ``token``, punched on first use."""
     def make() -> Optional[DirectPath]:
+        owner = _partner_owners.get(token)
         credentials = _credentials()
         if credentials is None:
-            return None
+            # No login (a token-only script): the token is its own credential.
+            # Its own memo, so an old home refusing it cannot hold back a
+            # logged-in process's path to the same lab.
+            return DirectPath(
+                offer=_offer_rpc(None, None, token=token), server_name="", ca_pem=b"",
+                memo=owner and f"{owner}|token",
+            )
         return DirectPath(
-            offer=_offer_rpc(*credentials, token=token), server_name="", ca_pem=b"",
-            memo=_partner_owners.get(token),
+            offer=_offer_rpc(*credentials, token=token), server_name="", ca_pem=b"", memo=owner,
         )
 
     return _side_path(token, make)
@@ -890,18 +904,29 @@ 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))
+        if key in _partner_owners else f"Global: {path.describe()}"
+        for key, path in list(_partners.items())
+    )
     path = _path
     if path is not None:
-        return path.describe()
-    try:
-        from .grpc_client import _current_profile
-
-        route = _active_route(_current_profile())
-    except Exception:  # noqa: BLE001 - not configured, no home: nothing to add
-        route = None
-    if route is None or route["kind"] == "relay":
-        return "relay (direct path off)"
-    return "LAN (direct)" if route["kind"] == "lan" else str(route["kind"])
+        home = path.describe()
+    else:
+        try:
+            from .grpc_client import _current_profile
+
+            route = _active_route(_current_profile())
+        except Exception:  # noqa: BLE001 - not configured, no home: nothing to add
+            route = None
+        if route is None or route["kind"] == "relay":
+            if partners:  # the home path is not what these device calls take
+                return partners
+            return "relay (direct path off)"
+        home = "LAN (direct)" if route["kind"] == "lan" else str(route["kind"])
+    return f"{home}; {partners}" if partners else home
 
 
 def stop() -> None:

{remoterf-2.5.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → remoterf-2.5.2/src/remoterf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.5.0
+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.0 → 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