RemoteRF 2.4.0__tar.gz → 2.5.1__tar.gz

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.4.0"
+version = "2.5.1"
 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.4.0 → remoterf-2.5.1}/src/remoterf/common/utils/process_arg.py

@@ -98,7 +98,7 @@ def _json_safe(value: Any):
         return _json_safe(value.as_payload())
     if isinstance(value, np.ndarray):
         if value.dtype == object:
-            raise ValueError(f"Cannot JSON-map object-dtype array: {value!r}")
+            return _json_safe(value.tolist())
         array = np.asarray(value)
         if np.iscomplexobj(array):
             data = [[float(num.real), float(num.imag)] for num in array.ravel()]
@@ -206,13 +206,15 @@ def map_arg(value: Any) -> grpc_pb2.Argument:
             try:
                 array = np.stack(value)
             except Exception:
-                arg.json_value = json.dumps(_json_safe(value), separators=(",", ":"))
-                return arg
+                pass
+        if array.dtype == object:
+            arg.json_value = json.dumps(_json_safe(value), separators=(",", ":"))
+            return arg
         return map_arg(array)
     elif isinstance(value, np.ndarray):
-        if value.dtype == object:
-            raise ValueError(f"Cannot map object-dtype array: {value!r}")
-        if value.dtype.kind not in _SUPPORTED_NDARRAY_KINDS:
+        # Object arrays (a list of dicts, say) and non-numeric dtypes go as
+        # JSON, which the client decodes back to lists.
+        if value.dtype == object or value.dtype.kind not in _SUPPORTED_NDARRAY_KINDS:
             arg.json_value = json.dumps(
                 _json_safe(value.tolist()), separators=(",", ":")
             )

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/core/app.py

@@ -177,11 +177,31 @@ def _print_reserved(where, when, token, handle, logged_in_to, install, no_handle
         printf("  Works anywhere, no login needed. Keep it safe: it can't be shown again.", Sty.DEFAULT)
         printf(f"  ({no_handle}. Lost the token? Cancel and reserve again.)", Sty.DEFAULT)
     printf("", Sty.DEFAULT)
-    call = DRIVER_CALLS.get(install())
+    device_type = install()
+    call = DRIVER_CALLS.get(device_type)
     if call:
         printf("Use either one as the token:" if handle else "Use it as the token:", Sty.DEFAULT)
         for text in (token, handle) if handle else (token,):
             printf(f'  sdr = {call}(token="{text}")', Sty.CYAN)
+    elif device_type and (cls := _client_class(device_type)):
+        # A lab's own driver (bluetooth, gps, ...): its class, from its IDL.
+        printf("Use either one as the token:" if handle else "Use it as the token:", Sty.DEFAULT)
+        printf("  from remoterf.drivers import ensure_driver", Sty.CYAN)
+        printf(f'  ensure_driver(token="{token}")  # installs it on any other machine', Sty.CYAN)
+        printf(f"  from remoterf.drivers.{device_type} import {cls}", Sty.CYAN)
+        for text in (token, handle) if handle else (token,):
+            printf(f'  dev = {cls}(token="{text}")', Sty.CYAN)
+
+
+def _client_class(device_type):
+    """The client class a generated driver package exports (beside its `adi` alias)."""
+    from importlib import import_module
+
+    try:
+        names = import_module(f"remoterf.drivers.{device_type}").__all__
+    except Exception:  # noqa: BLE001 - no usage lines is all a bad package costs
+        return None
+    return next((n for n in names if n != "adi"), None)
 
 
 def _print_native_reserved(device_id, label, when, token):

{remoterf-2.4.0 → remoterf-2.5.1}/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,27 @@ 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)"
+    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
+    )
     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.4.0 → remoterf-2.5.1}/src/remoterf/core/grpc_client.py

@@ -17,6 +17,9 @@ import os
 import re
 import sys
 import threading
+import time
+from collections import deque
+from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -226,20 +229,26 @@ def _federated_call(route, function_name, args):
                 if not refused:
                     return response
     request = grpc_pb2.GenericRPCRequest(function_name=function_name, args=args)
-    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())
-    except AccountBackendError as exc:
-        if ref.startswith("rfg_") and str(exc) == "not_found":
-            raise RuntimeError(
-                "this RemoteRF Global does not accept device tokens yet; use the device reference"
-            ) from None
-        label = f" [{exc.provenance}]" if exc.provenance else ""
-        raise RuntimeError(f"{exc}{label}") from None
+    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())
+            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 ref.startswith("rfg_") and str(exc) == "not_found":
+                raise RuntimeError(
+                    "this RemoteRF Global does not accept device tokens yet; use the device reference"
+                ) from None
+            label = f" [{exc.provenance}]" if exc.provenance else ""
+            raise RuntimeError(f"{exc}{label}") from None
     response = grpc_pb2.GenericRPCResponse()
     response.ParseFromString(raw)
     return response
@@ -476,12 +485,181 @@ def rpc_client(*, function_name, args, connection=None):
     token = _device_token(function_name, args)
     if function_name.endswith(":tx:CALL1") and "arg1" in args and token in _ci16_tokens:
         args = {**args, "arg1": _tx_wire(args["arg1"])}
-    response = _dispatch(function_name, args, connection)
+    response = _driver_hooks(function_name, args, token) if connection is None else None
+    if response is None:
+        response = _dispatch(function_name, args, connection)
     if token is not None and function_name.endswith(":rx:CALL0") and _is_ci16(response.results.get(function_name.split(":")[1])):
         _ci16_tokens.add(token)
+    if token is not None and function_name.endswith(":rx:CALL0") and _readahead_k():
+        _rx_sizes[token] = response.ByteSize()
+    return response
+
+
+def _driver_hooks(function_name, args, token):
+    """Batching and RX read-ahead for driver calls; None: send it as usual."""
+    parts = function_name.split(":")
+    driver_call = token is not None and len(parts) == 3
+    if driver_call and parts[2] != "GET" and parts[1:] != ["rx", "CALL0"]:
+        _rx_queues.clear()
+    pending = _batch_local.pending
+    same = driver_call and pending is not None and pending[:2] == (token, parts[0])
+    if same and parts[2] != "SET":
+        return _flush((function_name, args))
+    if pending is not None and not same:
+        _flush()
+    if driver_call and parts[2] == "SET" and parts[0] != "DynamicV2" and token in _batch_local.depth:
+        if _batch_local.pending is None:
+            _batch_local.pending = (token, parts[0], [])
+        _batch_local.pending[2].append((function_name, args))
+        if len(_batch_local.pending[2]) >= _BATCH_MAX_OPS:
+            _flush()
+        return grpc_pb2.GenericRPCResponse()  # setters' results are never read
+    if driver_call and parts[1:] == ["rx", "CALL0"] and _readahead_k():
+        return _rx_readahead(parts[0], args, token)
+    return None
+
+
+# ── config batching: with sdr.batch(): ───────────────────────────────
+#
+# A driver's property SETs queue up and go out as one <Prefix>:batch:CALLN
+# RPC, which the lab runs in order under the device lock. The queue is sent
+# when the block ends or at any other call; a call on the batching driver
+# rides along as the last op and gets its own results back. A failed SET
+# raises there, naming it; the SETs before it ran, the ones after did not.
+
+_BATCH_MAX_OPS = 64
+_batch_support: Dict[str, bool] = {}  # token -> the lab runs batches (unknown until the first)
+
+
+class _BatchState(threading.local):
+    pending = None  # (token, prefix, [(function_name, args), ...])
+
+    def __init__(self):
+        self.depth = {}  # token -> nesting of its open `with batch(token)`
+
+
+_batch_local = _BatchState()
+
+
+@contextmanager
+def batch(token):
+    """Queue this token's property SETs until the block ends (re-entrant)."""
+    from ..drivers._virtual import is_virtual_token
+
+    if is_virtual_token(token):
+        yield
+        return
+    depth = _batch_local.depth
+    depth[token] = depth.get(token, 0) + 1
+    try:
+        yield
+    finally:
+        depth[token] -= 1
+        if not depth[token]:
+            del depth[token]
+            pending = _batch_local.pending
+            if pending is not None and pending[0] == token:
+                _flush()
+
+
+def _flush(last=None):
+    token, prefix, ops = _batch_local.pending
+    _batch_local.pending = None
+    if last is not None:
+        ops.append(last)
+    if len(ops) == 1 or _batch_support.get(token) is False:
+        return _replay(ops)
+    args = {"a": ops[0][1]["a"]}
+    for i, (name, op_args) in enumerate(ops):
+        op = grpc_pb2.GenericRPCRequest(function_name=name, args={k: v for k, v in op_args.items() if k != "a"})
+        args[f"op{i}"] = grpc_pb2.Argument(bytes_value=op.SerializeToString())
+    try:
+        response = _dispatch(f"{prefix}:batch:CALLN", args, None)
+    except RuntimeError as exc:
+        # An older lab or Host refuses it before running anything: as before, one by one.
+        if not any(s in str(exc) for s in ("call_batch", "device_unavailable")):
+            raise
+        response = None
+    if response is None or "batch_done" not in response.results:
+        _batch_support[token] = False
+        return _replay(ops)
+    _batch_support[token] = True
+    if "batch_failed" in response.results:
+        failed = unmap_arg(response.results["batch_failed"])
+        name = ops[failed][0] if isinstance(failed, int) and 0 <= failed < len(ops) else f"{prefix}:batch:CALLN"
+        raise RuntimeError(f"{name}: {unmap_arg(response.results['batch_error'])}")
+    del response.results["batch_done"]
     return response
 
 
+def _replay(ops):
+    for name, op_args in ops:
+        response = _dispatch(name, op_args, None)
+    return response
+
+
+# ── RX read-ahead (opt-in): REMOTERF_RX_READAHEAD=<k> ────────────────
+#
+# One <Prefix>:rx_n:CALL1 RPC captures up to k buffers back to back; the
+# next rx() calls are served from them. They were captured when the first
+# rx() of the group ran, not when each later rx() is called, so use this only
+# for continuous-capture loops. They are dropped after 1 s and on any SET or
+# CALL (not GET) on any device of this process; changes made elsewhere
+# (another program, another user's TX, the RF environment) are not seen.
+
+# ponytail: fixed 1 s bound; make it configurable if a real loop needs another.
+_RX_READAHEAD_MAX_AGE = 1.0
+# The relay's response frame cap (core MAX_DEVICE_RPC_RESPONSE_FRAME_BYTES), less headroom.
+_RX_N_BYTES = 786432 - 4096
+_rx_queues: Dict[str, tuple] = {}  # token -> (captured at, deque of rx Arguments)
+_rx_sizes: Dict[str, int] = {}  # token -> size of its last rx response
+_rx_n_unsupported: set = set()
+
+
+def _readahead_k():
+    try:
+        k = int(os.getenv("REMOTERF_RX_READAHEAD") or 0)
+    except ValueError:
+        return 0
+    return min(k, 64) if k >= 2 else 0
+
+
+def _rx_readahead(prefix, args, token):
+    stamp, buffers = _rx_queues.get(token, (0.0, None))
+    if buffers and time.monotonic() - stamp <= _RX_READAHEAD_MAX_AGE:
+        try:
+            return grpc_pb2.GenericRPCResponse(results={"rx": buffers.popleft()})
+        except IndexError:
+            pass  # another thread took the last one
+    size = _rx_sizes.get(token)
+    k = min(_readahead_k(), _RX_N_BYTES // size) if size and token not in _rx_n_unsupported else 0
+    if k < 2:
+        return None
+    stamp = time.monotonic()
+    try:
+        response = _dispatch(f"{prefix}:rx_n:CALL1", {**args, "arg1": map_arg(k)}, None)
+    except RuntimeError as exc:
+        # An older lab or Host refused it unrun, or it outgrew the relay: plain rx from now on.
+        if not any(s in str(exc) for s in ("call_rx_n", "device_unavailable", "response_too_large")):
+            raise
+        response = None
+    arg = response.results.get("rx_n") if response is not None else None
+    nd = arg.ndarray_value if arg is not None and arg.WhichOneof("value") == "ndarray_value" else None
+    m = nd.shape[0] if nd is not None and nd.shape else 0
+    if m < 1 or len(nd.data) % m:
+        _rx_n_unsupported.add(token)
+        return None
+    step = len(nd.data) // m
+    buffers = deque(
+        grpc_pb2.Argument(ndarray_value=grpc_pb2.NDArrayValue(
+            dtype=nd.dtype, shape=nd.shape[1:], data=nd.data[i * step:(i + 1) * step]))
+        for i in range(m)
+    )
+    first = buffers.popleft()
+    _rx_queues[token] = (stamp, buffers)
+    return grpc_pb2.GenericRPCResponse(results={"rx": first})
+
+
 # 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.4.0 → remoterf-2.5.1}/src/remoterf/deployment/backend.py

@@ -102,6 +102,7 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
         # One refresh at a time: a direct-path thread shares this session, and
         # Global revokes a session whose refresh token is presented twice.
         self._refresh_lock = threading.RLock()
+        self._framed = False  # this deployment answered a device RPC with a raw frame
 
     def _operation(self, name):
         if name not in self.capabilities["supported_operations"]:
@@ -365,29 +366,40 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
         """Relay one serialized GenericRPCRequest; returns the response bytes."""
 
         self._operation("DEV:rpc")
-        value = self.transport.request(
-            "POST", self.base + "/devices/rpc", access=self._access(),
-            data={"device_id": self._ref(device_id, "device_id"),
-                  "request_b64": base64.b64encode(bytes(request_bytes)).decode("ascii")},
-            overall_timeout=DEVICE_RPC_CLIENT_TIMEOUT_SECONDS,
-            max_response_bytes=MAX_DEVICE_HTTP_RESPONSE_BYTES,
+        return self._device_call(
+            "/devices/rpc", {"device_id": self._ref(device_id, "device_id")}, request_bytes,
+            access=self._access(),
         )
-        return self._device_frame(value)
 
     def device_token_rpc(self, token, deployment_id, request_bytes):
         """Relay one frame on a Global device API token (``rfg_``): the token
         is the credential, so there is no login and no bearer."""
 
-        data = {"token": token,
-                "request_b64": base64.b64encode(bytes(request_bytes)).decode("ascii")}
+        data = {"token": token}
         if deployment_id is not None:
             data["deployment_id"] = deployment_id
-        value = self.transport.request(
-            "POST", self.base + "/devices/token-rpc", data=data,
-            overall_timeout=DEVICE_RPC_CLIENT_TIMEOUT_SECONDS,
-            max_response_bytes=MAX_DEVICE_HTTP_RESPONSE_BYTES,
-        )
-        return self._device_frame(value)
+        return self._device_call("/devices/token-rpc", data, request_bytes)
+
+    def _device_call(self, path, data, request_bytes, **auth):
+        """Raw frames once this deployment has answered with one; base64 JSON before."""
+        request_bytes = bytes(request_bytes)
+        framed = self._framed
+        while True:
+            try:
+                value = self.transport.request(
+                    "POST", self.base + path, **auth,
+                    data=data if framed else {**data, "request_b64": base64.b64encode(request_bytes).decode("ascii")},
+                    frame=request_bytes if framed else None, accept_framed=True,
+                    overall_timeout=DEVICE_RPC_CLIENT_TIMEOUT_SECONDS,
+                    max_response_bytes=MAX_DEVICE_HTTP_RESPONSE_BYTES,
+                )
+            except AccountBackendError as exc:
+                # A rolled-back deployment refuses the framed body before routing it.
+                if framed and exc.code == "invalid_request":
+                    self._framed = framed = False
+                    continue
+                raise
+            return self._device_frame(value)
 
     def device_direct(self, ref, deployment_id, ice):
         """Signal a direct path to the lab behind ``ref`` (a device ref under
@@ -408,8 +420,12 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
             raise AccountBackendError("Invalid home device response")
         return value["ice"]
 
-    @staticmethod
-    def _device_frame(value):
+    def _device_frame(self, value):
+        if "frame" in value:
+            if value.get("provenance") != "destination" or type(value["frame"]) is not bytes:
+                raise AccountBackendError("Invalid home device response")
+            self._framed = True
+            return value["frame"]
         encoded = value.get("response_b64")
         # An empty frame is a valid setter response (no results).
         if value.get("provenance") != "destination" or type(encoded) is not str:

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/deployment/http.py

@@ -1,5 +1,6 @@
 """Verified same-origin JSON transport with bounded responses and no retries."""
 
+import json
 import os
 import ssl
 import time
@@ -14,6 +15,10 @@ from remoterf_federation_core import (
 )
 from .state import origin
 
+# Device RPC bodies: u32be len(envelope) || JSON envelope || raw frame. The
+# core's FRAMED_CONTENT_TYPE, kept here while the client pins an older core.
+FRAMED_CONTENT_TYPE = "application/x-remoterf-framed"
+
 
 class AccountBackendError(RuntimeError):
     def __init__(self, code, *, provenance=None):
@@ -44,6 +49,8 @@ class JsonTransport:
         access=None,
         overall_timeout=None,
         max_response_bytes=65536,
+        frame=None,
+        accept_framed=False,
     ):
         if (
             not path.startswith("/")
@@ -51,7 +58,12 @@ class JsonTransport:
             or any(c in path for c in ("?", "#", "\\", "%"))
         ):
             raise ValidationError("Invalid same-origin account path")
-        headers = {"Accept": "application/json"}
+        headers = {"Accept": f"{FRAMED_CONTENT_TYPE}, application/json" if accept_framed else "application/json"}
+        content = None
+        if frame is not None:
+            envelope = json.dumps(data, separators=(",", ":")).encode()
+            content, data = len(envelope).to_bytes(4, "big") + envelope + bytes(frame), None
+            headers["Content-Type"] = FRAMED_CONTENT_TYPE
         if access:
             headers["Authorization"] = "Bearer " + access
         overall_timeout = (
@@ -71,6 +83,7 @@ class JsonTransport:
                 method,
                 self.origin + path,
                 json=data,
+                content=content,
                 headers=headers,
                 follow_redirects=False,
                 timeout=timeout,
@@ -86,6 +99,10 @@ class JsonTransport:
                         )
                 if 300 <= response.status_code < 400:
                     raise AccountBackendError("Account redirects are not allowed")
+                if accept_framed and response.status_code < 300 and (
+                    response.headers.get("content-type", "").split(";")[0].strip() == FRAMED_CONTENT_TYPE
+                ):
+                    return _unframe(bytes(raw), max_response_bytes)
                 value = strict_json(bytes(raw), max_bytes=max_response_bytes)
                 if response.status_code >= 400:
                     # Never print arbitrary server text (could contain secrets/terminal escapes).
@@ -123,3 +140,17 @@ class JsonTransport:
 
     def close(self):
         self.client.close()
+
+
+def _unframe(raw, max_bytes):
+    """A framed body -> {**envelope, "frame": frame}."""
+    size = int.from_bytes(raw[:4], "big")
+    if len(raw) < 4 or 4 + size > len(raw):
+        raise AccountBackendError("Invalid home device response")
+    try:
+        value = strict_json(raw[4:4 + size], max_bytes=max_bytes)
+    except ValidationError:
+        raise AccountBackendError("Invalid home device response") from None
+    if type(value) is not dict:
+        raise AccountBackendError("Invalid home device response")
+    return {**value, "frame": raw[4 + size:]}

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/drivers/adalm_pluto/adalm_pluto_remote.py

@@ -152,6 +152,10 @@ class Pluto:
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
         _try_call("ip", token)
 
+    def batch(self):
+        from ...core.grpc_client import batch
+        return batch(self.token)
+
     @property
     def dds_enabled(self):
         return _try_get("dds_enabled", self.token)

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/drivers/dynamic_device.py

@@ -1267,6 +1267,13 @@ def _codegen(schema: dict) -> str:
     if "ip" in call_map:
         lines.append('        _try_call("ip", token)')
     lines.append("")
+    if "batch" not in getter_map and "batch" not in setter_map and "batch" not in call_map:
+        lines += [
+            "    def batch(self):",
+            "        from ...core.grpc_client import batch",
+            "        return batch(self.token)",
+            "",
+        ]
 
     # ── Properties ────────────────────────────────────────────────────
     all_props = sorted(set(getter_map) | set(setter_map))

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/drivers/hackrf/hackrf_remote.py

@@ -151,6 +151,10 @@ class HackRF:
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
 
+    def batch(self):
+        from ...core.grpc_client import batch
+        return batch(self.token)
+
     @property
     def amplifier_on(self):
         'Whether the 14 dB RF front-end amplifier is enabled.'

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

@@ -119,6 +119,10 @@ class RtlSdr:
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
 
+    def batch(self):
+        from ...core.grpc_client import batch
+        return batch(self.token)
+
     @property
     def agc_mode(self):
         return _try_get("agc_mode", self.token)

{remoterf-2.4.0 → remoterf-2.5.1}/src/remoterf/drivers/sim_sdr/sim_sdr_remote.py

@@ -152,6 +152,10 @@ class SimSDR:
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
         _try_call("ip", token)
 
+    def batch(self):
+        from ...core.grpc_client import batch
+        return batch(self.token)
+
     @property
     def rx_buffer_size(self):
         return _try_get("rx_buffer_size", self.token)

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

@@ -119,6 +119,10 @@ class TiMmWave:
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
 
+    def batch(self):
+        from ...core.grpc_client import batch
+        return batch(self.token)
+
     @property
     def device_info(self):
         'USB/UART identity, firmware profile, and current stream state.'

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

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