RemoteRF 2.1.0.dev7__py3-none-any.whl → 2.1.2__py3-none-any.whl

remoteRF/common/grpc/v2_codec.py

@@ -48,7 +48,7 @@ def _json_safe(value):
     if hasattr(value, "as_payload"):
         return _json_safe(value.as_payload())
     if isinstance(value, np.generic):
-        return value.item()
+        return _json_safe(value.item())
     if isinstance(value, complex):
         return {
             _JSON_TYPE_KEY: "complex",

remoteRF/core/app.py

@@ -581,7 +581,8 @@ def _federated_reserve():
         )
         return
     _pick_slot_and_reserve(dev["device_id"], dev["display_name"], dev["block_min"], _federated_reservations_for_range, _federated_reserve_slot,
-                           device_label=f"{dev['display_name']} @{dev['deployment_name']}")
+                           device_label=f"{dev['display_name']} @{dev['deployment_name']}",
+                           max_days=-(-int(dev.get("max_horizon_sec") or 0) // 86400) or None)
 
 
 def reservations():
@@ -985,7 +986,7 @@ def perms():
         printf("Accessible Devices: ", (Sty.BOLD, Sty.BLUE), f"{devices}", Sty.MAGENTA)
 
         # Build per-device caps and group identical limits together
-        buckets: dict[tuple[int, int], list[int]] = {}  # (max_r, max_t_sec) -> [dev_ids]
+        buckets: dict[tuple[int, int, int], list[int]] = {}  # (max_r, max_t_sec, horizon_sec) -> [dev_ids]
         for d in devices:
             try:
                 did = int(d)
@@ -994,7 +995,8 @@ def perms():
             c = _cap_for(did)
             max_t = int(c.get("max_reservation_time_sec", 0) or 0)
             max_r = int(c.get("max_reservations", 0) or 0)
-            buckets.setdefault((max_r, max_t), []).append(did)
+            max_h = int(c.get("max_horizon_sec", 0) or 0)
+            buckets.setdefault((max_r, max_t, max_h), []).append(did)
 
         if not buckets:
             print("Limits per device: (none)")
@@ -1003,16 +1005,17 @@ def perms():
 
         # If everything shares the same limits, print once
         if len(buckets) == 1:
-            (max_r, max_t), _devs = next(iter(buckets.items()))
+            (max_r, max_t, max_h), _devs = next(iter(buckets.items()))
             printf("Permissions:", (Sty.BOLD, Sty.BLUE))
             printf("  Max Reservations: ", Sty.GRAY, f"{max_r}", Sty.CYAN)
             printf("  Reservation Duration (min): ", Sty.GRAY, f"{max_t // 60}", Sty.CYAN)
+            printf("  Days Ahead: ", Sty.GRAY, f"{max_h / 86400:g}" if max_h else "no limit", Sty.CYAN)
             render_remote_permissions()
             return
 
         # Otherwise print grouped limits
         printf("Permissions per device (grouped):", (Sty.BOLD, Sty.BLUE))
-        for (max_r, max_t), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[1])):
+        for (max_r, max_t, max_h), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[0][2], kv[1])):
             devs = sorted(devs)
 
             # compress ranges like 0-3,5,7-9
@@ -1031,7 +1034,7 @@ def perms():
                 ranges.append(f"{start}-{prev}" if start != prev else f"{start}")
 
             dev_str = ",".join(ranges)
-            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}", Sty.CYAN)
+            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}, days_ahead={f'{max_h / 86400:g}' if max_h else 'no limit'}", Sty.CYAN)
 
         render_remote_permissions()
 
@@ -1306,16 +1309,18 @@ def _auto_block_minutes(max_t_sec: int) -> int:
             break
     return best
 
-def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None):
+def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None, max_days=None):
     """Shared `resdev` slot picker: days -> free slots -> pick -> confirm -> reserve.
     Native and federated homes differ only in how reservations are fetched and
-    how the reservation is made (token vs. HOME handle)."""
+    how the reservation is made (token vs. HOME handle). `max_days` is the
+    group's reservation horizon; the server refuses starts beyond it anyway."""
     device_label = chosen_device_id if device_label is None else device_label
-    num_days_s = session.prompt(stylize("Enter the number of days to check for available reservations (starting today): ", (Sty.BOLD, Sty.GREEN))).strip()
+    limit = f" (up to {max_days})" if max_days else ""
+    num_days_s = session.prompt(stylize(f"Enter the number of days to check for available reservations (starting today){limit}: ", (Sty.BOLD, Sty.GREEN))).strip()
     try:
         num_days = int(num_days_s)
-        if num_days <= 0:
-            print("Invalid number of days.")
+        if num_days <= 0 or (max_days and num_days > max_days):
+            print("Invalid number of days." if num_days <= 0 else f"Your group may reserve at most {max_days} days ahead.")
             return
     except ValueError:
         print("Invalid input. Please enter a number.")
@@ -1501,6 +1506,7 @@ def interactive_reserve_next_days_auto():
         printf("Devices:", Sty.BOLD)
         block_by_dev: dict[str, int] = {}
         max_by_dev: dict[str, int] = {}
+        days_by_dev: dict[str, int] = {}
 
         for idx, dev_id in enumerate(sorted_device_ids):
             dev_name = unmap_arg(dev_resp.results[dev_id])
@@ -1510,6 +1516,7 @@ def interactive_reserve_next_days_auto():
                 c = _cap_for(int(dev_id))
                 try:
                     max_t_sec = int(c.get("max_reservation_time_sec", 0) or 0)
+                    days_by_dev[str(dev_id)] = -(-int(c.get("max_horizon_sec", 0) or 0) // 86400)
                 except Exception:
                     max_t_sec = 0
             elif perm_level == "Power User" and power_user_max_t_sec is not None:
@@ -1562,7 +1569,8 @@ def interactive_reserve_next_days_auto():
             )
             return
 
-        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot)
+        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot,
+                               max_days=days_by_dev.get(chosen_device_id) or None)
 
     except Exception as e:
         print(f"Error: {e}")

remoteRF/core/direct_path.py

@@ -32,7 +32,8 @@ path; everything else still takes the home's.
 When the answer names a *fixed port* (a Server with a reachable address
 listening for QUIC on one admitted UDP port), the path dials it like any QUIC
 server -- no punch, so it works behind any NAT -- and claims the session with
-the secret the answer carried. ICE is the fallback.
+the secret the answer carried. The dial and the punch run at once; the first
+to connect wins.
 """
 
 from __future__ import annotations
@@ -112,7 +113,10 @@ def quiet_aioice_errors(loop) -> None:
 
     The retry fires from a TimerHandle named for aioice's Transaction and
     dies inside asyncio's own transport code once the socket is gone (an
-    AttributeError on the closed transport or its dropped loop)."""
+    AttributeError on the closed transport or its dropped loop).
+
+    Likewise aioquic's shielded connect waiter: a handshake that ran out of
+    time leaves it to fail with a ConnectionError nobody reads."""
     default = loop.default_exception_handler
 
     def handler(loop, context):
@@ -120,6 +124,8 @@ def quiet_aioice_errors(loop) -> None:
         where = repr(context.get("handle", "")) + str(context.get("message", ""))
         if isinstance(exc, (AttributeError, OSError)) and "Transaction.__retry" in where:
             return
+        if isinstance(exc, ConnectionError) and "exception was never retrieved" in where:
+            return
         default(context)
 
     loop.set_exception_handler(handler)
@@ -189,6 +195,10 @@ class PathError(Exception):
     """The direct path could not carry this call and is down now."""
 
 
+def _why(exc: BaseException) -> str:
+    return "timed out" if isinstance(exc, asyncio.TimeoutError) else f"{type(exc).__name__}: {exc}"
+
+
 class _IceTransport:
     """The sendto() surface aioquic's protocol needs, on a nominated ICE pair."""
 
@@ -354,10 +364,7 @@ class DirectPath:
                 try:
                     await asyncio.wait_for(self._establish(), SETTLE_SECONDS)
                 except Exception as exc:  # noqa: BLE001 - a failed punch is expected on some networks
-                    self.reason = (
-                        "timed out" if isinstance(exc, asyncio.TimeoutError)
-                        else f"{type(exc).__name__}: {exc}"
-                    )
+                    self.reason = str(exc) if isinstance(exc, PathError) else _why(exc)
                     self.state = "down"
                     if "No matching server function" in self.reason:
                         self.state = "unavailable"
@@ -397,6 +404,10 @@ class DirectPath:
             "ufrag": ice.local_username,
             "pwd": ice.local_password,
             "candidates": [candidate.to_sdp() for candidate in ice.local_candidates],
+            # This client punches at once (no fixed-port head start), so the
+            # Server may send its first check sooner; a Server that predates
+            # the flag ignores it.
+            "race": True,
         }
         answer = await loop.run_in_executor(None, self._offer, offer)
 
@@ -409,35 +420,68 @@ class DirectPath:
         )
         configuration.load_verify_locations(cadata=ca_pem)
 
+        # Both at once. The Server starts its checks the moment it answers,
+        # and a NAT admits them only once this side has sent its own: a punch
+        # held back for the fixed dial (filtered from off campus) misses that
+        # window. On campus the fixed port still wins in milliseconds.
+        racers: dict[str, asyncio.Task] = {}
         if answer.get("udp") and answer.get("session"):
-            try:
-                await self._dial_fixed(answer, configuration)
-            except Exception as exc:  # noqa: BLE001 - filtered or wrong: the punch is next
-                self.reason = f"fixed port: {type(exc).__name__}: {exc}"
-            else:
-                await close_ice(ice)
-                self._ice = None
-                return
-        ice.remote_username = str(answer["ufrag"])
-        ice.remote_password = str(answer["pwd"])
-        for sdp in answer["candidates"]:
-            await ice.add_remote_candidate(Candidate.from_sdp(str(sdp)))
-        await ice.add_remote_candidate(None)
-        await asyncio.wait_for(ice.connect(), ICE_SECONDS)
-        peer = peer_address(ice)
-        protocol = _Protocol(QuicConnection(configuration=configuration))
-        self._transport = _IceTransport(ice)
-        protocol.connection_made(self._transport)
-        self._tasks = [
-            asyncio.ensure_future(self._pump(ice, protocol, peer)),
-            asyncio.ensure_future(self._watch(protocol)),
-            asyncio.ensure_future(self._watch_sleep()),
-        ]
-        protocol.connect(peer)
+            racers["fixed port"] = asyncio.ensure_future(self._dial_fixed(answer, configuration))
+        racers["punch"] = asyncio.ensure_future(self._punch(ice, answer, configuration))
+        failures: dict[asyncio.Task, Exception] = {}
+        pending = set(racers.values())
         try:
-            await asyncio.wait_for(protocol.wait_connected(), QUIC_SECONDS)
-        except ConnectionError:
-            raise ConnectionError(f"QUIC handshake refused: {protocol.terminated}") from None
+            while pending:
+                done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+                for task in done:
+                    try:
+                        task.result()
+                    except Exception as exc:  # noqa: BLE001 - filtered or refused: the other may still win
+                        failures[task] = exc
+                    else:
+                        return
+        finally:
+            await cancel_tasks(pending)
+        if len(failures) == 1:
+            raise next(iter(failures.values()))
+        raise PathError("; ".join(f"{name}: {_why(failures[task])}" for name, task in racers.items()))
+
+    async def _punch(self, ice: Connection, answer: dict, configuration: QuicConfiguration) -> None:
+        """QUIC over the pair ICE nominates; the ICE goes with it when this loses."""
+        tasks: list[asyncio.Task] = []
+        transport = None
+        try:
+            ice.remote_username = str(answer["ufrag"])
+            ice.remote_password = str(answer["pwd"])
+            for sdp in answer["candidates"]:
+                await ice.add_remote_candidate(Candidate.from_sdp(str(sdp)))
+            await ice.add_remote_candidate(None)
+            await asyncio.wait_for(ice.connect(), ICE_SECONDS)
+            peer = peer_address(ice)
+            protocol = _Protocol(QuicConnection(configuration=configuration))
+            transport = _IceTransport(ice)
+            protocol.connection_made(transport)
+            tasks = [
+                asyncio.ensure_future(self._pump(ice, protocol, peer)),
+                asyncio.ensure_future(self._watch(protocol)),
+                asyncio.ensure_future(self._watch_sleep()),
+            ]
+            protocol.connect(peer)
+            try:
+                await asyncio.wait_for(protocol.wait_connected(), QUIC_SECONDS)
+            except ConnectionError:
+                raise ConnectionError(f"QUIC handshake refused: {protocol.terminated}") from None
+            if self._protocol is not None:
+                raise PathError("the fixed port connected first")
+        except BaseException:
+            await cancel_tasks(tasks)  # before the close, or _watch reports it as a death
+            if transport is not None:
+                protocol.close()
+                transport.close()
+            await close_ice(ice)
+            self._ice = None
+            raise
+        self._transport, self._tasks = transport, tasks
         self._protocol, self.remote = protocol, peer
 
     async def _dial_fixed(self, answer: dict, configuration: QuicConfiguration) -> None:
@@ -457,6 +501,8 @@ class DirectPath:
             reply = json.loads(await asyncio.wait_for(read_frame(reader), FIXED_SECONDS))
             if not reply.get("ok"):
                 raise PathError(str(reply.get("a", "session refused")))
+            if self._protocol is not None:
+                raise PathError("the punch connected first")
         except BaseException:
             protocol.close()
             transport.close()
@@ -595,21 +641,30 @@ def _stored_login() -> Optional[dict]:
     return homes.recall_login(profile.home) if profile.home else None
 
 
-def _from_stored_login() -> Optional[DirectPath]:
-    """A path for a process that never logged in (a script using a driver)."""
+def _active_route(profile) -> Optional[dict]:
+    """The active home's route this process is connected over, if it has one."""
     from ..deployment import homes
-    from .grpc_client import _current_profile
 
-    profile = _current_profile()
     if not profile.home:
         return None
-    route = next(
+    return next(
         (r for r in homes.load_home(profile.home)["routes"]
          if f"{r['host']}:{r['port']}" == profile.grpc_endpoint),
         None,
     )
+
+
+def _from_stored_login() -> Optional[DirectPath]:
+    """A path for a process that never logged in (a script using a driver)."""
+    from ..deployment import homes
+    from .grpc_client import _current_profile
+
+    profile = _current_profile()
+    route = _active_route(profile)
+    if route is None or route["kind"] != "relay":
+        return None
     login = homes.recall_login(profile.home)
-    if route is None or route["kind"] != "relay" or login is None:
+    if login is None:
         return None
     return DirectPath(
         offer=_offer_rpc(login["username"], login["secret"]), server_name=route["host"],
@@ -690,7 +745,17 @@ def describe() -> str:
     if not enabled():
         return "relay (direct path disabled: REMOTERF_DIRECT=0)"
     path = _path
-    return path.describe() if path is not None else "relay (direct path off)"
+    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"])
 
 
 def stop() -> None:

remoteRF/core/dynamic_v2_transport.py

@@ -28,6 +28,7 @@ from ..common.grpc.v2_codec import decode_value, encode_value
 from .v2_errors import (
     RemoteRFError,
     RemoteRFProtocolError,
+    RemoteRFReservationError,
     RemoteRFTransportError,
     raise_for_envelope,
 )
@@ -75,6 +76,55 @@ def _payload(value):
     return value
 
 
+class _DevicePlaneStub:
+    """DynamicControlV2 and SampleDataV1 for a partner lab's device: each
+    request is one ``DynamicV2:<Operation>:WIRE`` device RPC, routed like any
+    call on that token (the direct path to the owner when it is up, else the
+    HOME, which relays it). The owner runs it through its own servicers."""
+
+    def __init__(self, token: str):
+        self._token = str(token)
+
+    def _rpc(self, operation, request, response_type):
+        from ..common.utils import map_arg, unmap_arg
+        from .grpc_client import rpc_client
+
+        try:
+            response = rpc_client(
+                function_name=f"DynamicV2:{operation}:WIRE",
+                args={"a": map_arg(self._token), "wire": map_arg(request.SerializeToString())},
+            )
+        except RuntimeError as 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"partner device: {exc}") from exc
+        wire = unmap_arg(response.results["wire"]) if "wire" in response.results else None
+        if not isinstance(wire, bytes):
+            raise RemoteRFProtocolError("partner device plane returned no Dynamic v2 reply")
+        return response_type.FromString(wire)
+
+    def Negotiate(self, request, timeout=None):
+        return self._rpc("Negotiate", request, grpc_pb2.NegotiateResponse)
+
+    def GetSchema(self, request, timeout=None):
+        return self._rpc("GetSchema", request, grpc_pb2.GetSchemaResponse)
+
+    def OpenSession(self, request, timeout=None):
+        return self._rpc("OpenSession", request, grpc_pb2.OpenSessionResponse)
+
+    def Invoke(self, request, timeout=None):
+        return self._rpc("Invoke", request, grpc_pb2.InvokeResponse)
+
+    def CloseHandle(self, request, timeout=None):
+        return self._rpc("CloseHandle", request, grpc_pb2.CloseResponse)
+
+    def CloseSession(self, request, timeout=None):
+        return self._rpc("CloseSession", request, grpc_pb2.CloseResponse)
+
+    def SampleStream(self, frames, timeout=None):
+        return [self._rpc("SampleFrame", frame, grpc_pb2.SampleFrame) for frame in frames]
+
+
 class DynamicV2Transport:
     def __init__(
         self,
@@ -82,15 +132,21 @@ class DynamicV2Transport:
         control_stub=None,
         sample_stub=None,
         control_timeout_sec: float = 30.0,
+        open_timeout_sec: float = 120.0,
         stream_timeout_margin_sec: float = 5.0,
     ):
         self.control_timeout_sec = float(control_timeout_sec)
+        # A cold USRP open loads firmware/FPGA (B2xx re-enumerates on USB),
+        # which can outlast the normal control deadline.
+        self.open_timeout_sec = float(open_timeout_sec)
         self.stream_timeout_margin_sec = float(stream_timeout_margin_sec)
         if (
             not math.isfinite(self.control_timeout_sec)
             or self.control_timeout_sec <= 0
         ):
             raise ValueError("control_timeout_sec must be finite and positive")
+        if not math.isfinite(self.open_timeout_sec) or self.open_timeout_sec <= 0:
+            raise ValueError("open_timeout_sec must be finite and positive")
         if (
             not math.isfinite(self.stream_timeout_margin_sec)
             or self.stream_timeout_margin_sec <= 0
@@ -107,9 +163,35 @@ class DynamicV2Transport:
         self.control = control_stub
         self.samples = sample_stub
 
-    def _call(self, fn, request):
+    def _to_owner(self, token: str, owner: str | None = None) -> bool:
+        """Carry this transport over the device plane when ``token`` drives a
+        partner lab's device (named by the HOME's refusal, or already known)."""
+        from . import direct_path
+
+        if isinstance(self.control, _DevicePlaneStub):
+            return False
+        owner = owner or direct_path.partner_of(str(token))
+        if not owner:
+            return False
+        # Marked, the token's device calls take the direct path to the owner.
+        direct_path.mark_partner(str(token), str(owner))
+        self.control = self.samples = _DevicePlaneStub(token)
+        return True
+
+    def _checked(self, response, token: str) -> bool:
+        """raise_for_envelope, except for the refusal of a partner's token:
+        True when the call should be repeated over the device plane."""
+        try:
+            raise_for_envelope(response.error)
+        except RemoteRFProtocolError as exc:
+            if self._to_owner(token, exc.details.get("federated")):
+                return True
+            raise
+        return False
+
+    def _call(self, fn, request, *, timeout: float | None = None):
         try:
-            return fn(request, timeout=self.control_timeout_sec)
+            return fn(request, timeout=timeout or self.control_timeout_sec)
         except grpc.RpcError as exc:
             raise RemoteRFTransportError(
                 f"Dynamic v2 RPC failed: {exc.code().name}: {exc.details()}",
@@ -141,6 +223,7 @@ class DynamicV2Transport:
         return response
 
     def get_schema(self, token: str) -> dict:
+        self._to_owner(token)
         self.negotiate()
         response = self._call(
             self.control.GetSchema,
@@ -149,7 +232,8 @@ class DynamicV2Transport:
                 schema_versions=[SCHEMA_VERSION],
             ),
         )
-        raise_for_envelope(response.error)
+        if self._checked(response, token):
+            return self.get_schema(token)
         try:
             schema = json.loads(response.schema_json)
         except (TypeError, json.JSONDecodeError) as exc:
@@ -165,6 +249,7 @@ class DynamicV2Transport:
         return schema
 
     def open_session(self, token: str, schema_hash: str):
+        self._to_owner(token)
         response = self._call(
             self.control.OpenSession,
             grpc_pb2.OpenSessionRequest(
@@ -173,8 +258,10 @@ class DynamicV2Transport:
                 control_protocol_version=CONTROL_PROTOCOL_VERSION,
                 streaming_protocol_version=STREAMING_PROTOCOL_VERSION,
             ),
+            timeout=self.open_timeout_sec,
         )
-        raise_for_envelope(response.error)
+        if self._checked(response, token):
+            return self.open_session(token, schema_hash)
         try:
             schema = json.loads(response.schema_json)
             capabilities = json.loads(response.capabilities_json or "{}")

remoteRF/core/grpc_acc.py

@@ -110,7 +110,7 @@ class RemoteRFAccount:
             token = unmap_arg(response.results["Token"])
             try:
                 from ..drivers.dynamic_device import install_driver
-                install_driver(device_id=device_id)
+                install_driver(token=token, device_id=device_id)
             except Exception as e:
                 print(f"Warning: could not install driver for device {device_id}: {e}")
             return token

remoteRF/core/grpc_client.py

@@ -14,7 +14,6 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import os
-import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -31,7 +30,7 @@ _CONFIG_HELP = (
     "Run:\n"
     "  remoterf --config --addr <host:port>\n"
     "Example:\n"
-    "  remoterf --config --addr 123.45.654.321:12321"
+    "  remoterf --config --addr 203.0.113.10:12321"
 )
 
 
@@ -229,10 +228,11 @@ def rpc_client(*, function_name, args, connection=None):
     ref = _federated_ref(function_name, args) if connection is None else None
     if ref is not None:
         return _finish(_federated_call(ref, function_name, args))
-    wire = os.getenv("REMOTERF_RX_WIRE", "").strip().lower()
+    wire = os.getenv("REMOTERF_RX_WIRE", "i16").strip().lower()
     if wire and function_name.endswith(":rx:CALL0"):
-        # Gate I slice 3, opt-in: c64 halves the samples on the wire, i16 quarters
-        # them when they are integer IQ; the driver still sees a complex array.
+        # Gate I slice 3: c64 halves the samples on the wire, i16 (the default)
+        # quarters them when they are integer IQ; the driver still sees a complex
+        # array. REMOTERF_RX_WIRE="" or "c128" opts out (servers ignore unknown).
         args = {**args, "wire": map_arg(wire)}
     if connection is None and direct_path.wants(function_name):
         path = direct_path.current(token=_device_token(function_name, args))
@@ -265,9 +265,7 @@ def _finish(response):
         
     if 'UE' in response.results:
         print(f"UserError: {unmap_arg(response.results['UE'])}")
-        if sys.stdin.isatty():  # a script has nobody to hit enter
-            input("Hit enter to continue...")
-        
+
     if 'Message' in response.results:
         print(f"{unmap_arg(response.results['Message'])}")
             

remoteRF/core/secure_channel.py

@@ -36,6 +36,15 @@ import grpc
 DEFAULT_OPTIONS: Tuple[Tuple[str, int], ...] = (
     ("grpc.max_send_message_length", 100 * 1024 * 1024),
     ("grpc.max_receive_message_length", 100 * 1024 * 1024),
+    # A call in flight when the network changes under it (a laptop roaming to
+    # another access point) fails within ~30 s instead of waiting out TCP's
+    # own retransmission timeout, ~9 minutes on macOS. Pings go out only while
+    # a call is open, at most two per quiet stretch (gRPC's default), which
+    # even a Server that never raised its ping allowance accepts.
+    ("grpc.keepalive_time_ms", 20_000),
+    ("grpc.keepalive_timeout_ms", 10_000),
+    # The ack deadline a keepalive ping actually waits on (default 60 s).
+    ("grpc.http2.ping_timeout_ms", 10_000),
 )
 
 

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.2  schema_hash: sha256:fa4603755fdfde9ff8286c95b2f30996df0d6253fdec608976b1aaae9f48354e
+# device_type: adalm_pluto  driver_version: 0.0.3  schema_hash: sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4
 
 _PREFIX = "Adalm_pluto"
-_SCHEMA_HASH = "sha256:fa4603755fdfde9ff8286c95b2f30996df0d6253fdec608976b1aaae9f48354e"
+_SCHEMA_HASH = "sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4"
 _CLIENT_MODULES = {}
 _CLIENT_OBJECTS = {}
 
@@ -375,6 +375,18 @@ class Pluto:
         'Return a connection identifier for this device (ping / verify).'
         return _try_call("ip", self.token)
 
+    def power_cycle(self):
+        'PoE Plutos: power off, then on, and wait for boot. No-op on other Plutos.'
+        return _try_call("power_cycle", self.token)
+
+    def power_down(self):
+        'PoE Plutos: cut power; the next command powers it back up. No-op on other Plutos.'
+        return _try_call("power_down", self.token)
+
+    def power_up(self):
+        'PoE Plutos: power on and wait for boot (any command does this when needed). No-op on other Plutos.'
+        return _try_call("power_up", self.token)
+
     def rx(self):
         return _try_call("rx", self.token)
 

remoteRF/drivers/dynamic_device.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 
 import json
 import keyword
+import sys
 from pathlib import Path
 
 from ..common.utils import map_arg, unmap_arg
@@ -94,7 +95,7 @@ def fetch_idl(
     # A HOME-minted device reference has no direct v2 control channel; the
     # schema is fetched through the same relayed IDL RPC every driver uses.
     federated = is_global_ref(token) or is_global_ref(device_id)
-    if token is not None and prefer_v2 and not federated:
+    if token is not None and device_id is None and prefer_v2 and not federated:
         from .dynamic_v2 import fetch_schema_v2
         from ..core.v2_errors import RemoteRFProtocolError, RemoteRFReservationError, RemoteRFTransportError
 
@@ -111,14 +112,19 @@ def fetch_idl(
                 raise
 
     args: dict = {}
-    if token is not None:
-        args['token'] = map_arg(str(token))
-    elif device_id is not None:
+    if device_id is not None:
         args['device_id'] = map_arg(device_id if is_global_ref(device_id) else int(device_id))
+    elif token is not None:
+        args['token'] = map_arg(str(token))
     elif device_name is not None:
         args['device_name'] = map_arg(str(device_name))
     else:
         raise ValueError("fetch_idl requires token, device_id, or device_name")
+    if prefer_v2 and 'token' not in args and not federated:
+        # Servers that know v2 answer with it when the device publishes one
+        # (by device_id, which needs no active reservation); v1-only devices
+        # and older servers answer v1.
+        args['schema_versions'] = map_arg(["2.0"])
 
     from ..core.grpc_client import rpc_client
 
@@ -126,13 +132,18 @@ def fetch_idl(
 
     if 'error' in resp.results:
         raise RuntimeError(f"IDL fetch failed: {unmap_arg(resp.results['error'])}")
-    if token is not None and 'federated' in resp.results:
-        # A partner lab answered: device calls with this token can punch to it.
-        from ..core import direct_path
-
-        direct_path.mark_partner(str(token), str(unmap_arg(resp.results['federated'])))
+    schema = json.loads(unmap_arg(resp.results['schema']))
+    if 'federated' in resp.results:
+        if token is not None:
+            # A partner lab answered: device calls with this token can punch to it.
+            from ..core import direct_path
 
-    return json.loads(unmap_arg(resp.results['schema']))
+            direct_path.mark_partner(str(token), str(unmap_arg(resp.results['federated'])))
+        if str(schema.get("schema_version")) != "2.0":
+            # A partner's v1 answer may replace an installed v2 driver (see
+            # _write_v1_driver_files); a v2 schema is hashed, so left as is.
+            schema["federated"] = True
+    return schema
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1393,8 +1404,14 @@ _DRIVERS_DIR = Path(__file__).parent
 
 
 def _write_driver_files(schema: dict) -> Path:
-    if str(schema.get("schema_version")) == "2.0":
-        return _write_v2_driver_files(schema)
+    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 + ".")]:
+        del sys.modules[name]
+    return pkg_dir
+
+
+def _write_v1_driver_files(schema: dict) -> Path:
 
     (
         device_type,
@@ -1409,8 +1426,14 @@ def _write_driver_files(schema: dict) -> Path:
         _call_map,
     ) = _schema_maps(schema)
     pkg_dir = _DRIVERS_DIR / device_type
+    remote_path = pkg_dir / f"{device_type}_remote.py"
+    if remote_path.exists() and _is_v2_driver(remote_path) and not schema.get("federated"):
+        # The server answered v1 (older server, or a device that no longer
+        # publishes v2); don't trade an installed Dynamic v2 driver for it.
+        # A partner's device has only the v1 plane, so its answer does.
+        return pkg_dir
     pkg_dir.mkdir(exist_ok=True)
-    (pkg_dir / f"{device_type}_remote.py").write_text(_codegen(schema), encoding="utf-8")
+    remote_path.write_text(_codegen(schema), encoding="utf-8")
     init_lines = [
         *_GPL_NOTICE_LINES,
         "from importlib import import_module as _import_module",
@@ -1562,11 +1585,7 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
         device_name=device_name,
         prefer_v2=True,
     )
-    device_type = (
-        _require_package_name(schema.get("device_type"), field="device_type")
-        if str(schema.get("schema_version")) == "2.0"
-        else _schema_maps(schema)[0]
-    )
+    device_type = _schema_device_type(schema)
     remote_path = _DRIVERS_DIR / device_type / f"{device_type}_remote.py"
     init_path = remote_path.with_name("__init__.py")
 
@@ -1586,6 +1605,8 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
     current_hash = _read_schema_hash(remote_path)
     if current_hash != schema.get("schema_hash"):
         _write_driver_files(schema)
+        if _read_schema_hash(remote_path) == current_hash:
+            return
         print(
             f"Driver for '{device_type}' updated "
             f"(was {(current_hash or '?')[:16]}…, "
@@ -1594,6 +1615,19 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
         )
 
 
+def _schema_device_type(schema: dict) -> str:
+    if str(schema.get("schema_version")) == "2.0":
+        return _require_package_name(schema.get("device_type"), field="device_type")
+    return _schema_maps(schema)[0]
+
+
+def _is_v2_driver(path: Path) -> bool:
+    try:
+        return "build_uhd_bindings" in path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+
+
 def _read_schema_hash(path: Path) -> str | None:
     """Extract _SCHEMA_HASH value from a generated driver file without importing it."""
     try:
@@ -1621,12 +1655,14 @@ def install_driver_if_stale(*, token: str, current_hash: str) -> bool:
 
         from remoteRF.drivers.pluto import *
     """
-    schema = fetch_idl(token=token, prefer_v2=False)
+    schema = fetch_idl(token=token, prefer_v2=True)
     if schema.get("schema_hash") == current_hash:
         return False
 
-    device_type = _schema_maps(schema)[0]
-    _write_driver_files(schema)
+    device_type = _schema_device_type(schema)
+    pkg_dir = _write_driver_files(schema)
+    if _read_schema_hash(pkg_dir / f"{device_type}_remote.py") == current_hash:
+        return False
     print(
         f"Driver for '{device_type}' updated "
         f"(was {current_hash[:16]}…, now {schema.get('schema_hash','?')[:16]}…).\n"

remoteRF/drivers/dynamic_v2.py

@@ -21,7 +21,6 @@ import hashlib
 import json
 import keyword
 import numbers
-import re
 import types
 import weakref
 
@@ -83,24 +82,6 @@ _PARAMETER_KINDS = {
 _PARAMETER_DIRECTIONS = {"in", "out", "inout"}
 
 
-def _canonical_native_version(value) -> str:
-    """Strip distro/build metadata while retaining the pinned upstream API."""
-    text = str(value or "").strip()
-    if text.lower().startswith("uhd "):
-        text = text[4:].strip()
-    match = re.match(
-        r"^(\d+)\.(\d+)\.(\d+)(?:\.(\d+|main|head))?",
-        text,
-        flags=re.IGNORECASE,
-    )
-    if match is None:
-        return text.partition("-")[0].strip()
-    major, minor, patch, build = match.groups()
-    if build is None or build.lower() in {"main", "head"}:
-        build = "0"
-    return ".".join((major, minor, patch, build))
-
-
 def validate_schema_v2(schema: dict) -> dict:
     if not isinstance(schema, dict) or schema.get("schema_version") != "2.0":
         raise RemoteRFProtocolError("Dynamic schema_version must be '2.0'")
@@ -223,9 +204,13 @@ def _matches_type(value, wire_type: str) -> bool:
             return True
         if choice == "bytes" and isinstance(value, (bytes, bytearray, memoryview)):
             return True
-        if choice == "complex" and isinstance(value, (complex, np.complexfloating)):
+        if (
+            choice == "complex"
+            and isinstance(value, (numbers.Complex, np.number))
+            and not isinstance(value, bool)
+        ):
             return True
-        if choice.startswith("list") and isinstance(value, (list, tuple)):
+        if choice.startswith("list") and isinstance(value, (list, tuple, np.ndarray)):
             if "[" not in choice:
                 return True
             item_type = choice.partition("[")[2].rpartition("]")[0]
@@ -295,7 +280,11 @@ class OverloadBinder:
             else:
                 raise TypeError(f"missing required argument {name!r}")
 
-            if supplied and not _matches_type(value, spec.get("type", "any")):
+            if (
+                supplied
+                and not (value is None and not spec.get("required", True))
+                and not _matches_type(value, spec.get("type", "any"))
+            ):
                 raise TypeError(
                     f"argument {name!r} must match {spec.get('type')}, "
                     f"not {type(value).__name__}"
@@ -678,23 +667,21 @@ def build_uhd_bindings(schema: dict, *, transport_factory=DynamicV2Transport):
             self.token = str(token)
             self._transport = transport_factory()
             self._transport.negotiate()
-            opened = self._transport.open_session(self.token, schema["schema_hash"])
-            required_uhd = str(
-                schema.get("native_api", {}).get("version") or ""
-            )
-            actual_uhd = str(opened.get("uhd_version") or "")
-            if (
-                required_uhd
-                and _canonical_native_version(actual_uhd)
-                != _canonical_native_version(required_uhd)
-            ):
-                try:
-                    self._transport.close_session(opened["session_id"])
-                finally:
+            try:
+                opened = self._transport.open_session(self.token, schema["schema_hash"])
+            except RemoteRFProtocolError as exc:
+                if not exc.details.get("current"):
+                    raise
+                from .dynamic_device import install_driver_if_stale
+
+                device_type = schema.get("device_type", "usrp")
+                if install_driver_if_stale(token=self.token, current_hash=schema["schema_hash"]):
                     raise RemoteRFProtocolError(
-                        f"client requires UHD {required_uhd}; "
-                        f"server reports {actual_uhd or 'unknown'}"
-                    )
+                        f"the server's {device_type} driver changed and the local copy "
+                        f"was updated; reimport remoteRF.drivers.{device_type} and retry",
+                        details=dict(exc.details),
+                    ) from exc
+                raise
             self._session_id = opened["session_id"]
             self._handle = opened["device_handle"]
             self._generation = 0
@@ -833,6 +820,7 @@ def build_uhd_bindings(schema: dict, *, transport_factory=DynamicV2Transport):
         Range=uhd_v2.Range,
         MetaRange=uhd_v2.MetaRange,
         TuneRequest=uhd_v2.TuneRequest,
+        TuneRequestPolicy=uhd_v2.TuneRequestPolicy,
         TuneResult=uhd_v2.TuneResult,
         StreamCMD=uhd_v2.StreamCMD,
         StreamMode=uhd_v2.StreamMode,
@@ -864,6 +852,7 @@ def build_uhd_bindings(schema: dict, *, transport_factory=DynamicV2Transport):
             time_spec=uhd_v2.TimeSpec,
             device_addr=uhd_v2.DeviceAddr,
             tune_request=uhd_v2.TuneRequest,
+            tune_request_policy=uhd_v2.TuneRequestPolicy,
             tune_result=uhd_v2.TuneResult,
         )
     )

remoteRF/drivers/support/uhd_v2.py

@@ -230,6 +230,10 @@ class TuneRequestPolicy(str, Enum):
     NONE = "NONE"
     AUTO = "AUTO"
     MANUAL = "MANUAL"
+    # UHD's own spellings: uhd.types.TuneRequestPolicy.manual
+    none = "NONE"
+    auto = "AUTO"
+    manual = "MANUAL"
 
 
 class TuneRequest(_ValueObject):
@@ -246,6 +250,11 @@ class TuneRequest(_ValueObject):
         self.dsp_freq = 0.0
         self.rf_freq_policy = TuneRequestPolicy.AUTO
         self.dsp_freq_policy = TuneRequestPolicy.AUTO
+        if self.lo_offset is not None:
+            # As UHD's tune_request_t(target, lo_off): the RF LO sits manually
+            # at target + offset and the DSP takes up the difference.
+            self.rf_freq_policy = TuneRequestPolicy.MANUAL
+            self.rf_freq = self.target_freq + self.lo_offset
         self.args = DeviceAddr()
 
     def as_payload(self):

remoteRF/remoterf_cli.py

@@ -114,7 +114,7 @@ def _ensure_config_present() -> tuple[bool, str]:
             "Run:\n"
             "  remoterf --config --addr <host:port>\n"
             "Example:\n"
-            "  remoterf --config --addr 123.45.654.321:12321\n",
+            "  remoterf --config --addr 203.0.113.10:12321\n",
         )
 
     kv = _read_dotenv_kv(env_file)
@@ -158,6 +158,7 @@ def print_help() -> None:
     printf("Config:", (Sty.BOLD, Sty.MAGENTA))
     printf("  remoterf -c | --config [options]", Sty.CYAN)
     printf("    -a, --addr, -addr <host:port>", Sty.CYAN, "   Set target server", Sty.DEFAULT)
+    printf("    --cert-port <port>", Sty.CYAN, "              Cert server port (default: grpc port + 1)", Sty.DEFAULT)
     printf("    -w, --wipe, -wipe", Sty.CYAN, "               Delete all local config", Sty.DEFAULT)
     printf("    -y, --yes, -yes", Sty.CYAN, "                 Skip wipe confirmation", Sty.DEFAULT)
     printf("    -r, --register", Sty.CYAN, "                  Register right after configuring", Sty.DEFAULT)
@@ -172,7 +173,7 @@ def print_help() -> None:
     printf("  remoterf --login global", Sty.GREEN)
     printf("  remoterf homes", Sty.GREEN)
     printf("  remoterf --version", Sty.GREEN)
-    printf("  remoterf --config --addr 123.45.654.321:12321", Sty.GREEN)
+    printf("  remoterf --config --addr 203.0.113.10:12321", Sty.GREEN)
     printf("  remoterf --config --addr global.remoterf.net --register", Sty.GREEN)
     printf("  remoterf --config --wipe", Sty.GREEN)
     printf("  remoterf --config --wipe --yes", Sty.GREEN)
@@ -460,6 +461,7 @@ def main() -> int:
         yes = False
         register = False
         account_transport = None
+        cert_port_arg = None
 
         i = 1
         while i < len(argv):
@@ -481,6 +483,18 @@ def main() -> int:
                 i += 2
                 continue
 
+            if tok in ("--cert-port", "-cert-port"):
+                if i + 1 >= len(argv):
+                    print("ERROR: missing required argument after --cert-port")
+                    return 2
+                try:
+                    cert_port_arg = int(argv[i + 1].strip())
+                except Exception:
+                    print("ERROR: --cert-port must be an integer")
+                    return 2
+                i += 2
+                continue
+
             if tok in ("--wipe", "-w", "-wipe"):
                 wipe = True
                 i += 1
@@ -549,7 +563,7 @@ def main() -> int:
                 return 2
 
             # configure returns the proper exit code
-            cert_port = port + 1
+            cert_port = cert_port_arg if cert_port_arg is not None else port + 1
             result = configure(host, port, cert_port)
             if result not in (None, 0):
                 return int(result)

remoteRF.py

@@ -0,0 +1,39 @@
+# 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/>.
+
+"""Rescue for an upgrade from remoterf 2.0.7-2.0.13 on Windows and macOS.
+
+Those releases installed the package in a lowercase ``remoterf`` folder. When
+that folder survives an upgrade (it holds the generated drivers pip does not
+know about), the new files land inside it, and on a case-insensitive disk
+``import remoteRF`` no longer finds the package. Python only reaches this
+module then: a correctly named ``remoteRF`` folder always takes precedence.
+"""
+
+import importlib.util
+import os
+import sys
+
+_FOLDER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "remoterf")
+_SPEC = importlib.util.spec_from_file_location(
+    __name__, os.path.join(_FOLDER, "__init__.py"), submodule_search_locations=[_FOLDER]
+)
+if _SPEC is None or not os.path.isfile(os.path.join(_FOLDER, "__init__.py")):
+    raise ImportError("the remoteRF package folder is missing; reinstall with: pip install --force-reinstall remoterf")
+_MODULE = importlib.util.module_from_spec(_SPEC)
+# The import system returns whatever this name maps to once this module has
+# run: the package itself, so ``remoteRF.<submodule>`` resolves inside it.
+sys.modules[__name__] = _MODULE
+_SPEC.loader.exec_module(_MODULE)

{remoterf-2.1.0.dev7.dist-info → remoterf-2.1.2.dist-info}/METADATA

@@ -1,39 +1,27 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0.dev7
+Version: 2.1.2
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
-Author: Ethan Ge
-Author-email: ethoGalaxy@gmail.com
-License: GPL-3.0-or-later
+Author-email: Ethan Ge <ethoGalaxy@gmail.com>
+License-Expression: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: remoterf-federation-core==0.13.0
+Requires-Dist: remoterf-federation-core==0.16.0
 Requires-Dist: grpcio<2.0.0,>=1.78.1
 Requires-Dist: protobuf<7.0.0,>=6.31.1
 Requires-Dist: numpy
 Requires-Dist: prompt_toolkit
 Requires-Dist: python-dotenv
-Requires-Dist: prompt-toolkit
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: certifi
 Requires-Dist: pydantic<3.0,>=2.6
 Requires-Dist: keyring<26,>=24
 Requires-Dist: aioice<0.11,>=0.10
 Requires-Dist: aioquic<2.0,>=1.2
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Remote RF
 

{remoterf-2.1.0.dev7.dist-info → remoterf-2.1.2.dist-info}/RECORD

@@ -1,5 +1,6 @@
+remoteRF.py,sha256=ANpEl1Hg7HpGji6UZP6SzHORqE1v4S7SzsZzWFiG6Es,1853
 remoteRF/__init__.py,sha256=-1h_xQjiE66oiWRO-vnLGJ4smpgUNhFuV-ZreW9_tD4,667
-remoteRF/remoterf_cli.py,sha256=ShiYgQfrjYxoegQD432XVJ9MrZrTn7iq9yLGVW-uPbE,20749
+remoteRF/remoterf_cli.py,sha256=c09oAUXQp5N65d0riN35eUfkX6Lg-TlP2N2MZZ6Iywk,21403
 remoteRF/version.py,sha256=NWzcPOAdd567IvC8ei1yyPdeS7w0kt99oKwL6oWAQSc,850
 remoteRF/common/__init__.py,sha256=ey1IjkAaXFL1sZBnBwuWVlHhA_n0bu_uxgkDV_KOxYg,708
 remoteRF/common/tos_notice.txt,sha256=fUHXV6U9uhZDvVs8BcRi4kWbU1PeU9mkxML0n5DDQp8,334
@@ -10,7 +11,7 @@ remoteRF/common/grpc/deployment_capabilities_pb2_grpc.py,sha256=Vy_7zGsMNy_UwbGR
 remoteRF/common/grpc/grpc.proto,sha256=X85kGh3DgypPsb_sDjtARCkdb91XXNOr6GiTr2axEcY,5853
 remoteRF/common/grpc/grpc_pb2.py,sha256=8aVMR9vsLGWtdpvK1iAMspgGQN1_Jn7EdHzdz_YcJ3M,12736
 remoteRF/common/grpc/grpc_pb2_grpc.py,sha256=1vbqOxzDXt0bi8mjTJLAS742CsSUQcaZTw0N4cxRVyE,17731
-remoteRF/common/grpc/v2_codec.py,sha256=a9_xpxAnJAvAssfkElbGaDitkUpd1ntoK6a9h-xx7Og,5179
+remoteRF/common/grpc/v2_codec.py,sha256=kgj_WXBOKw--J7ZgE7TBfrUbF5AmjMg_VNMx9tDNHTQ,5191
 remoteRF/common/utils/__init__.py,sha256=mRw79YhvGlA5m1wsejx6n4uNcGwusUizDquSkoU1nFY,1128
 remoteRF/common/utils/ansi_codes.py,sha256=jzSri_BqezN5yMBBLT9cjU2LoJZiQ4qBxhk5Y0KQPSI,5275
 remoteRF/common/utils/api_token.py,sha256=G0kratdJk1PUs4svF6qjRC0do8osV9mntj7UgqzRySI,1928
@@ -22,13 +23,13 @@ remoteRF/config/cert_fetcher.py,sha256=_m4CiYxJPTckDrdynwUjwnehD_gd6yZoly5etfT83
 remoteRF/config/config.py,sha256=jItSEI557nTor1BW2iOgebmMfl24TfIY7juRTjjICrc,9353
 remoteRF/core/__init__.py,sha256=1E9ARnxVICp4uCpGNQT3Fb-jD9TvUYbJmctuUqPy8hU,1206
 remoteRF/core/acc_login.py,sha256=Qct7vEsc0OIdVwmikOv2mVv9-ehH4CMVw7QWHe2yOsg,1010
-remoteRF/core/app.py,sha256=uh4UtLpN9Qx88EfeKMP4J9XU9mKS4HD942xh3zD1PJg,71823
+remoteRF/core/app.py,sha256=kLDTUMChZfriuUuZOGo-uCzwwjtBNiRuuzZlR-iQ6pQ,72701
 remoteRF/core/banner_note.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-remoteRF/core/direct_path.py,sha256=O-DsMt198ywRuiszBxjINA_2sP3XHmj-ow9s6dSl9E0,28813
-remoteRF/core/dynamic_v2_transport.py,sha256=MLTi920dFeYeAxeOTuNZtw4mY-zZIq_ZYLDW992To3c,18029
-remoteRF/core/grpc_acc.py,sha256=-4eFiYcE8R1A6LN4KuqJG6QYlpEMoLcH6WmNH_VPwKI,7623
-remoteRF/core/grpc_client.py,sha256=34bNG5s65eatP91h0EYsLXrtRDCqykXDdRQbSI3Uw2M,18023
-remoteRF/core/secure_channel.py,sha256=ffPpc5o-3YAh7jMIT4izRbC-Iq9D-biSwpXwGBVlvUU,2283
+remoteRF/core/direct_path.py,sha256=5-75osvC2vgEyfk4zopX-wYy8XJpFvE1EcYTVKjDygM,31789
+remoteRF/core/dynamic_v2_transport.py,sha256=sOXrgvo020u_Mu8lGp1v0SI-MvMY3A43ezTbJRzY5aY,21998
+remoteRF/core/grpc_acc.py,sha256=XzE4uTSQ6ZX_4jcgK9pbS96_9_7oDqWEqDTTi07Z6P0,7636
+remoteRF/core/grpc_client.py,sha256=SAKdDQUm92zAYyzgG1N0gE9Lq53Z9CulRjv_49XILw8,17973
+remoteRF/core/secure_channel.py,sha256=_avJBcvtLv0_9MgT6dpM-6bNH8DGph2Gls6DJZMkIXo,2859
 remoteRF/core/v2_errors.py,sha256=Xmuta24cfQEy4FGG7HZk7B9hD5g4pGT5Hz8Eguy42lU,2956
 remoteRF/deployment/__init__.py,sha256=aEl9z32KMUBfRRm6Ho0-fM-VUtiKIRq4bQBU2_u29-c,69
 remoteRF/deployment/backend.py,sha256=ULrHn31w-v8tN5BU4HktuPKG4vEGIteqPYo0hUWVjfI,16135
@@ -38,10 +39,10 @@ remoteRF/deployment/http.py,sha256=8Ar1-GOIyCJrPWURZyOl969e7FZqjdQuOkA5Km2IMGw,4
 remoteRF/deployment/state.py,sha256=rXHEMf-kJP1sYCJn-VD84ZNalkYUaNAiYaoaVu4uo3U,6541
 remoteRF/drivers/__init__.py,sha256=DXjon8E0R1X27fDQDy6IrwzqTFwrT6-suC5VSDXUP8Y,1250
 remoteRF/drivers/_virtual.py,sha256=J6uy0G1VCpr3AeTKWiPUZienNTlO9eBC3TVb2uBdcvc,4402
-remoteRF/drivers/dynamic_device.py,sha256=mGbRLh92QuWcktHNm_ZMej7AFWUvHM9ttJtsGDOGm9I,60504
-remoteRF/drivers/dynamic_v2.py,sha256=vF45cgH4rpKo8Gf67yJ4Hw6lKY1JhP-LGdyd68Fz-PI,33919
+remoteRF/drivers/dynamic_device.py,sha256=lSdDgGl6022G2rUyo2WD0zMImwi9Q-uIzqX-T60MYeY,62180
+remoteRF/drivers/dynamic_v2.py,sha256=CIJ6SW0jptT0Kp93Rly7WlYbeDoTdZVoP2CfHCaSiAo,33666
 remoteRF/drivers/adalm_pluto/__init__.py,sha256=QmFIGRC9MG9GMOc277Hkwd2CG-3wI59UmuV0k2XsvY8,829
-remoteRF/drivers/adalm_pluto/adalm_pluto_remote.py,sha256=uvaJmmd8IK7THqjKn6xjLwnXKIXNO_MNGoQz1KJCZf8,11669
+remoteRF/drivers/adalm_pluto/adalm_pluto_remote.py,sha256=yIf_VkgMsDPsz5W54MK0emRJz22UujydMpWGFV41jtU,12186
 remoteRF/drivers/adalm_pluto/pluto_remote.py,sha256=6HRc94yZlM9FDt0_XcPIo_kVcG6ELgRahW0T25BIfb0,9134
 remoteRF/drivers/hackrf/__init__.py,sha256=BlpF0ZyAu8IcfpxyQlPXbI4PATdisFT1lR0cM8Gk6O0,821
 remoteRF/drivers/hackrf/hackrf_remote.py,sha256=UMwBsKGTUjq6lp0s3axwbdel9YtUUMoik0VtpsjGN-Y,8956
@@ -53,15 +54,15 @@ remoteRF/drivers/support/__init__.py,sha256=-1h_xQjiE66oiWRO-vnLGJ4smpgUNhFuV-Zr
 remoteRF/drivers/support/ti_mmwave.py,sha256=a7ThvnYjdGzoqJjoG1l7KOdOGAbhVWXBYFjW3UE2MDI,10085
 remoteRF/drivers/support/uhd.py,sha256=t0X2wG_xHSSVYedGhKSN-GIuvmkmd346bM7hx1KHm6s,11722
 remoteRF/drivers/support/uhd_dsp.py,sha256=s1_PsBYao16wv8Gq2mHBo8tTBfHzc_cyd1DmRATNhAg,3223
-remoteRF/drivers/support/uhd_v2.py,sha256=5Ho-ryyC86y-vitBsbFPouvzrVylNI0pdNzwXMANfXg,22600
+remoteRF/drivers/support/uhd_v2.py,sha256=A66MK7FqfyT8AeNqS4pnCIwBxTTszMmT02YoZF2kqGk,23028
 remoteRF/drivers/ti_mmwave/__init__.py,sha256=-ZhvekQi9UCgtZUhezu17s-wUoxc_FZO1-5ATLRzBAI,1189
 remoteRF/drivers/ti_mmwave/ti_mmwave_remote.py,sha256=sQiRCstSoi73T7TkE2WXp1YYp3GhCIeJavq50qKsllU,5696
 remoteRF/drivers/usrp/__init__.py,sha256=y79nl50_4dV9-AI3cfDptOAWeR58fAaihHObqJI9HJM,780
 remoteRF/drivers/usrp/usrp_remote.py,sha256=hBh_CmGOAoEkkdQQ8uPFAsBA6LVeZsPSlpPGgo1c7sM,115018
 remoteRF/drivers/usrp/usrp_remote.pyi,sha256=MG7rMJdjyT0hLLoJmnS1emDQjgepWz695GbFED3v-T4,11810
-remoterf-2.1.0.dev7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-remoterf-2.1.0.dev7.dist-info/METADATA,sha256=p6qsKMi09w4yItYpIHhlSSylztT45QLMAzbFvKxV92c,13090
-remoterf-2.1.0.dev7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-remoterf-2.1.0.dev7.dist-info/entry_points.txt,sha256=La_TjAqCfqdcVTVjB2WrsJNn5rfgcuIYroe2v-CMwRQ,56
-remoterf-2.1.0.dev7.dist-info/top_level.txt,sha256=XQJoVTmAOsHV9qtPSP_QSh0ma4jKxsDkxn4IjM_ZuZk,9
-remoterf-2.1.0.dev7.dist-info/RECORD,,
+remoterf-2.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+remoterf-2.1.2.dist-info/METADATA,sha256=xQLoKP0HEbmSxVt2I52TGq6bCcpxb9vmlj_Tmt436r0,12778
+remoterf-2.1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+remoterf-2.1.2.dist-info/entry_points.txt,sha256=La_TjAqCfqdcVTVjB2WrsJNn5rfgcuIYroe2v-CMwRQ,56
+remoterf-2.1.2.dist-info/top_level.txt,sha256=XQJoVTmAOsHV9qtPSP_QSh0ma4jKxsDkxn4IjM_ZuZk,9
+remoterf-2.1.2.dist-info/RECORD,,