RemoteRF 2.1.0.dev7__py3-none-any.whl → 2.1.1__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/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.1.dist-info}/METADATA

@@ -1,39 +1,27 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0.dev7
+Version: 2.1.1
 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.1.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
@@ -24,11 +25,11 @@ remoteRF/core/__init__.py,sha256=1E9ARnxVICp4uCpGNQT3Fb-jD9TvUYbJmctuUqPy8hU,120
 remoteRF/core/acc_login.py,sha256=Qct7vEsc0OIdVwmikOv2mVv9-ehH4CMVw7QWHe2yOsg,1010
 remoteRF/core/app.py,sha256=uh4UtLpN9Qx88EfeKMP4J9XU9mKS4HD942xh3zD1PJg,71823
 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,11 +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/pluto_remote.py,sha256=6HRc94yZlM9FDt0_XcPIo_kVcG6ELgRahW0T25BIfb0,9134
+remoteRF/drivers/adalm_pluto/adalm_pluto_remote.py,sha256=yIf_VkgMsDPsz5W54MK0emRJz22UujydMpWGFV41jtU,12186
 remoteRF/drivers/hackrf/__init__.py,sha256=BlpF0ZyAu8IcfpxyQlPXbI4PATdisFT1lR0cM8Gk6O0,821
 remoteRF/drivers/hackrf/hackrf_remote.py,sha256=UMwBsKGTUjq6lp0s3axwbdel9YtUUMoik0VtpsjGN-Y,8956
 remoteRF/drivers/rtl_sdr/__init__.py,sha256=sJ0oAIS4hwE3PdZtnfNHTWKiYuLUHpWM_WspiTEKMTI,823
@@ -53,15 +53,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.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+remoterf-2.1.1.dist-info/METADATA,sha256=EuGx38QDsfkF6s6GkXWfj-m6l1Qrr3O46l6G2LWZbIY,12778
+remoterf-2.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+remoterf-2.1.1.dist-info/entry_points.txt,sha256=La_TjAqCfqdcVTVjB2WrsJNn5rfgcuIYroe2v-CMwRQ,56
+remoterf-2.1.1.dist-info/top_level.txt,sha256=XQJoVTmAOsHV9qtPSP_QSh0ma4jKxsDkxn4IjM_ZuZk,9
+remoterf-2.1.1.dist-info/RECORD,,

remoteRF/drivers/adalm_pluto/pluto_remote.py

@@ -1,291 +0,0 @@
-# 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/>.
-
-from ...common.utils import *
-from .._virtual import (
-    is_virtual_token,
-    make_virtual_token,
-    retag_virtual_token,
-    virtual_call,
-    virtual_get,
-    virtual_set,
-)
-
-
-def _rpc_client(*, function_name, args):
-    # Keep transport/configuration initialization out of the virtual path.
-    from ...core.grpc_client import rpc_client
-
-    return rpc_client(function_name=function_name, args=args)
-
-def try_get(function_name, token):
-    if is_virtual_token(token):
-        return virtual_get(token, function_name)
-    try:
-        return unmap_arg(_rpc_client(function_name=f"Pluto:{function_name}:GET", args={'a':map_arg(token)}).results[function_name])
-    except Exception as e:
-        input(f"Error: {e}\nHit enter to continue...")
-    return None
-
-def try_set(function_name, value, token):
-    if is_virtual_token(token):
-        virtual_set(token, function_name, value)
-        return None
-    try:
-        _rpc_client(function_name=f"Pluto:{function_name}:SET", args={function_name: map_arg(value), 'a':map_arg(token)})
-    except Exception as e:
-        input(f"Error: {e}\nHit enter to continue...")
-        
-def try_call_0_arg(function_name, token):   # 0 argument call
-    if is_virtual_token(token):
-        return virtual_call(token, function_name)
-    try:
-        response = _rpc_client(
-            function_name=f"Pluto:{function_name}:CALL0", 
-            args={
-                'a': map_arg(token)
-            }
-        )
-        return unmap_arg(response.results[function_name])
-    except Exception as e:
-        input(f"RPC_0_call Error: {e}\nHit enter to continue...")
-    return None
-        
-def try_call_1_arg(function_name, arg, token):  # 1 argument call
-    if is_virtual_token(token):
-        return virtual_call(token, function_name, arg, has_arg=True)
-    try:
-        response = _rpc_client(
-            function_name=f"Pluto:{function_name}:CALL1", 
-            args={
-                'a': map_arg(token),
-                'arg1': map_arg(arg)
-            }
-        )
-        # The server should return something like {function_name: <something>}
-        return unmap_arg(response.results[function_name])
-    except Exception as e:
-        input(f"RPC_1_call Error: {e}\nHit enter to continue...")
-    return None
-
-class rx_def:
-    pass
-
-class tx_def:
-    pass
-
-class rx_tx_def(rx_def, tx_def):
-    pass
-
-class ad9364(rx_tx_def):
-    pass
-
-class Pluto: # client
-    
-    def __init__(self, token: str | None = None, debug=False, *, virtual=False):
-        self.virtual = bool(virtual)
-        if self.virtual:
-            self.token = make_virtual_token(token, device_type="adalm_pluto")
-            return
-        if token is None:
-            raise ValueError("A reservation token is required unless virtual=True")
-        self.token = token
-        try_call_0_arg(function_name="ip", token=token)
-        
-        
-    def api_token(self, token:str) -> None:
-        if self.virtual:
-            self.token = retag_virtual_token(self.token, token)
-            return
-        self.token = token
-        try_call_0_arg(function_name="ip", token=token)
-    
-    # PlutoSDR
-    
-    _device_name = "PlutoSDR"
-    _uri_auto = "ip:pluto.local"
-
-    def __repr__(self): # ! UNTESTED !
-        return try_get("__repr__", self.token)
-    
-    #region ad9364
-    """AD9364 Transceiver"""
-
-    @property
-    def filter(self):
-        return try_get("filter", self.token)
-
-    @filter.setter
-    def filter(self, value):
-        try_set("filter", value, self.token)
-
-    @property
-    def loopback(self):
-        """loopback: Set loopback mode. Options are:
-        0 (Disable), 1 (Digital), 2 (RF)"""
-        return try_get("loopback", self.token)
-
-    @loopback.setter
-    def loopback(self, value):
-        try_set("loopback", value, self.token)
-
-    @property
-    def gain_control_mode_chan0(self):
-        """gain_control_mode_chan0: Mode of receive path AGC. Options are:
-        slow_attack, fast_attack, manual"""
-        return try_get("gain_control_mode_chan0", self.token)
-
-    @gain_control_mode_chan0.setter
-    def gain_control_mode_chan0(self, value):
-        try_set("gain_control_mode_chan0", value, self.token)
-
-    @property
-    def rx_hardwaregain_chan0(self):
-        """rx_hardwaregain_chan0: Gain applied to RX path. Only applicable when
-        gain_control_mode is set to 'manual'"""
-        return try_get("rx_hardwaregain_chan0", self.token)
-
-    @rx_hardwaregain_chan0.setter
-    def rx_hardwaregain_chan0(self, value):
-        try_set("rx_hardwaregain_chan0", value, self.token)
-
-    @property
-    def tx_hardwaregain_chan0(self):
-        """tx_hardwaregain_chan0: Attenuation applied to TX path"""
-        return try_get("tx_hardwaregain_chan0", self.token)
-
-    @tx_hardwaregain_chan0.setter
-    def tx_hardwaregain_chan0(self, value):
-        try_set("tx_hardwaregain_chan0", value, self.token)
-
-    @property
-    def rx_rf_bandwidth(self):
-        """rx_rf_bandwidth: Bandwidth of front-end analog filter of RX path"""
-        return try_get("rx_rf_bandwidth", self.token)
-
-    @rx_rf_bandwidth.setter
-    def rx_rf_bandwidth(self, value):
-        try_set("rx_rf_bandwidth", value, self.token)
-
-    @property
-    def tx_rf_bandwidth(self):
-        """tx_rf_bandwidth: Bandwidth of front-end analog filter of TX path"""
-        return try_get("tx_rf_bandwidth", self.token)
-
-    @tx_rf_bandwidth.setter
-    def tx_rf_bandwidth(self, value):
-        try_set("tx_rf_bandwidth", value, self.token)
-
-    @property
-    def sample_rate(self):                # ! UNTESTED !
-        """sample_rate: Sample rate RX and TX paths in samples per second"""
-        return try_get("sample_rate", self.token)
-
-    @sample_rate.setter
-    def sample_rate(self, rate):          # ! UNTESTED !
-        try_set("sample_rate", rate, self.token)
-
-    @property
-    def rx_lo(self):
-        """rx_lo: Carrier frequency of RX path"""
-        return try_get("rx_lo", self.token)
-
-    @rx_lo.setter
-    def rx_lo(self, value):
-        try_set("rx_lo", value, self.token)
-
-    @property
-    def tx_lo(self):
-        """tx_lo: Carrier frequency of TX path"""
-        return try_get("tx_lo", self.token)
-
-    @tx_lo.setter
-    def tx_lo(self, value):
-        try_set("tx_lo", value, self.token)
-        
-    @property
-    def tx_cyclic_buffer(self):
-        """tx_cyclic_buffer: Size of cyclic buffer"""
-        return try_get("tx_cyclic_buffer", self.token)
-    
-    @tx_cyclic_buffer.setter
-    def tx_cyclic_buffer(self, value):
-        try_set("tx_cyclic_buffer", value, self.token)
-        
-    def tx_destroy_buffer(self):
-        try_call_0_arg("tx_destroy_buffer", self.token)
-
-    def rx_destroy_buffer(self):
-        try_call_0_arg("rx_destroy_buffer", self.token)
-
-    #endregion
-    #region rx_def
-    
-    def rx(self):
-        return try_get("rx", self.token)
-    
-    @property
-    def rx_buffer_size(self):
-        return try_get("rx_buffer_size", self.token)
-    
-    @rx_buffer_size.setter
-    def rx_buffer_size(self, value):
-        try_set("rx_buffer_size", value, self.token)
-    
-    #endregion
-    #region tx_def
-    
-    def tx(self, value):
-        return try_call_1_arg("tx", value, self.token)
-    
-    # @tx.setter
-    # def tx(self, value):
-    #     try_set("tx", value, self.token)
-    
-    #endregion
-    
-    #region tx
-    
-    #endregion
-    
-    #region _dec_int_fpga_filter
-    
-    """Decimator and interpolator fpga filter controls"""
-
-    def _get_rates(self, dev, output):           # ! UNTESTED !
-        """Get the decimation and interpolation rates"""
-        return try_get("rates", self.token)
-
-    @property
-    def rx_dec8_filter_en(self) -> bool:         # ! UNTESTED !
-        """rx_dec8_filter_en: Enable decimate by 8 filter in FPGA"""
-        return try_get("rx_dec8_filter_en", self.token)
-
-    @rx_dec8_filter_en.setter
-    def rx_dec8_filter_en(self, value: bool):    # ! UNTESTED !
-        """rx_dec8_filter_en: Enable decimate by 8 filter in FPGA"""
-        return try_set("rx_dec8_filter_en", value, self.token)
-
-    @property
-    def tx_int8_filter_en(self) -> bool:         # ! UNTESTED !
-        """tx_int8_filter_en: Enable interpolate by 8 filter in FPGA"""
-        return try_get("tx_int8_filter_en", self.token)
-
-    @tx_int8_filter_en.setter
-    def tx_int8_filter_en(self, value: bool):    # ! UNTESTED !
-        """tx_int8_filter_en: Enable interpolate by 8 filter in FPGA"""
-        return try_set("tx_int8_filter_en", value, self.token)
-
-    #endregion