RemoteRF 2.1.0__py3-none-any.whl → 2.1.0.dev7__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 _json_safe(value.item())
+        return value.item()
     if isinstance(value, complex):
         return {
             _JSON_TYPE_KEY: "complex",

remoteRF/core/dynamic_v2_transport.py

@@ -28,7 +28,6 @@ from ..common.grpc.v2_codec import decode_value, encode_value
 from .v2_errors import (
     RemoteRFError,
     RemoteRFProtocolError,
-    RemoteRFReservationError,
     RemoteRFTransportError,
     raise_for_envelope,
 )
@@ -76,55 +75,6 @@ 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,
@@ -132,21 +82,15 @@ 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
@@ -163,35 +107,9 @@ class DynamicV2Transport:
         self.control = control_stub
         self.samples = sample_stub
 
-    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):
+    def _call(self, fn, request):
         try:
-            return fn(request, timeout=timeout or self.control_timeout_sec)
+            return fn(request, timeout=self.control_timeout_sec)
         except grpc.RpcError as exc:
             raise RemoteRFTransportError(
                 f"Dynamic v2 RPC failed: {exc.code().name}: {exc.details()}",
@@ -223,7 +141,6 @@ class DynamicV2Transport:
         return response
 
     def get_schema(self, token: str) -> dict:
-        self._to_owner(token)
         self.negotiate()
         response = self._call(
             self.control.GetSchema,
@@ -232,8 +149,7 @@ class DynamicV2Transport:
                 schema_versions=[SCHEMA_VERSION],
             ),
         )
-        if self._checked(response, token):
-            return self.get_schema(token)
+        raise_for_envelope(response.error)
         try:
             schema = json.loads(response.schema_json)
         except (TypeError, json.JSONDecodeError) as exc:
@@ -249,7 +165,6 @@ 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(
@@ -258,10 +173,8 @@ class DynamicV2Transport:
                 control_protocol_version=CONTROL_PROTOCOL_VERSION,
                 streaming_protocol_version=STREAMING_PROTOCOL_VERSION,
             ),
-            timeout=self.open_timeout_sec,
         )
-        if self._checked(response, token):
-            return self.open_session(token, schema_hash)
+        raise_for_envelope(response.error)
         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(token=token, device_id=device_id)
+                install_driver(device_id=device_id)
             except Exception as e:
                 print(f"Warning: could not install driver for device {device_id}: {e}")
             return token

remoteRF/core/secure_channel.py

@@ -36,15 +36,6 @@ 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.3  schema_hash: sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4
+# device_type: adalm_pluto  driver_version: 0.0.2  schema_hash: sha256:fa4603755fdfde9ff8286c95b2f30996df0d6253fdec608976b1aaae9f48354e
 
 _PREFIX = "Adalm_pluto"
-_SCHEMA_HASH = "sha256:35b66a1e4383a344046be27ff80d40aff3ebd147e7aa5dd0513303fd3c0cfab4"
+_SCHEMA_HASH = "sha256:fa4603755fdfde9ff8286c95b2f30996df0d6253fdec608976b1aaae9f48354e"
 _CLIENT_MODULES = {}
 _CLIENT_OBJECTS = {}
 
@@ -375,18 +375,6 @@ 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,7 +36,6 @@ from __future__ import annotations
 
 import json
 import keyword
-import sys
 from pathlib import Path
 
 from ..common.utils import map_arg, unmap_arg
@@ -95,7 +94,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 device_id is None and prefer_v2 and not federated:
+    if token is not None and prefer_v2 and not federated:
         from .dynamic_v2 import fetch_schema_v2
         from ..core.v2_errors import RemoteRFProtocolError, RemoteRFReservationError, RemoteRFTransportError
 
@@ -112,19 +111,14 @@ def fetch_idl(
                 raise
 
     args: dict = {}
-    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:
+    if token is not None:
         args['token'] = map_arg(str(token))
+    elif device_id is not None:
+        args['device_id'] = map_arg(device_id if is_global_ref(device_id) else int(device_id))
     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
 
@@ -132,18 +126,13 @@ def fetch_idl(
 
     if 'error' in resp.results:
         raise RuntimeError(f"IDL fetch failed: {unmap_arg(resp.results['error'])}")
-    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
+    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'])))
 
-            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
+    return json.loads(unmap_arg(resp.results['schema']))
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1404,14 +1393,8 @@ _DRIVERS_DIR = Path(__file__).parent
 
 
 def _write_driver_files(schema: dict) -> Path:
-    pkg_dir = _write_v2_driver_files(schema) if str(schema.get("schema_version")) == "2.0" else _write_v1_driver_files(schema)
-    stale = f"remoteRF.drivers.{pkg_dir.name}"
-    for name in [m for m in sys.modules if m == stale or m.startswith(stale + ".")]:
-        del sys.modules[name]
-    return pkg_dir
-
-
-def _write_v1_driver_files(schema: dict) -> Path:
+    if str(schema.get("schema_version")) == "2.0":
+        return _write_v2_driver_files(schema)
 
     (
         device_type,
@@ -1426,14 +1409,8 @@ def _write_v1_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)
-    remote_path.write_text(_codegen(schema), encoding="utf-8")
+    (pkg_dir / f"{device_type}_remote.py").write_text(_codegen(schema), encoding="utf-8")
     init_lines = [
         *_GPL_NOTICE_LINES,
         "from importlib import import_module as _import_module",
@@ -1585,7 +1562,11 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
         device_name=device_name,
         prefer_v2=True,
     )
-    device_type = _schema_device_type(schema)
+    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]
+    )
     remote_path = _DRIVERS_DIR / device_type / f"{device_type}_remote.py"
     init_path = remote_path.with_name("__init__.py")
 
@@ -1605,8 +1586,6 @@ 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]}…, "
@@ -1615,19 +1594,6 @@ 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:
@@ -1655,14 +1621,12 @@ def install_driver_if_stale(*, token: str, current_hash: str) -> bool:
 
         from remoteRF.drivers.pluto import *
     """
-    schema = fetch_idl(token=token, prefer_v2=True)
+    schema = fetch_idl(token=token, prefer_v2=False)
     if schema.get("schema_hash") == current_hash:
         return False
 
-    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
+    device_type = _schema_maps(schema)[0]
+    _write_driver_files(schema)
     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,6 +21,7 @@ import hashlib
 import json
 import keyword
 import numbers
+import re
 import types
 import weakref
 
@@ -82,6 +83,24 @@ _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'")
@@ -204,13 +223,9 @@ 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, (numbers.Complex, np.number))
-            and not isinstance(value, bool)
-        ):
+        if choice == "complex" and isinstance(value, (complex, np.complexfloating)):
             return True
-        if choice.startswith("list") and isinstance(value, (list, tuple, np.ndarray)):
+        if choice.startswith("list") and isinstance(value, (list, tuple)):
             if "[" not in choice:
                 return True
             item_type = choice.partition("[")[2].rpartition("]")[0]
@@ -280,11 +295,7 @@ class OverloadBinder:
             else:
                 raise TypeError(f"missing required argument {name!r}")
 
-            if (
-                supplied
-                and not (value is None and not spec.get("required", True))
-                and not _matches_type(value, spec.get("type", "any"))
-            ):
+            if supplied 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__}"
@@ -667,21 +678,23 @@ def build_uhd_bindings(schema: dict, *, transport_factory=DynamicV2Transport):
             self.token = str(token)
             self._transport = transport_factory()
             self._transport.negotiate()
-            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"]):
+            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:
                     raise RemoteRFProtocolError(
-                        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
+                        f"client requires UHD {required_uhd}; "
+                        f"server reports {actual_uhd or 'unknown'}"
+                    )
             self._session_id = opened["session_id"]
             self._handle = opened["device_handle"]
             self._generation = 0
@@ -820,7 +833,6 @@ 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,
@@ -852,7 +864,6 @@ 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,10 +230,6 @@ 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):
@@ -250,11 +246,6 @@ 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

@@ -158,7 +158,6 @@ 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)
@@ -461,7 +460,6 @@ def main() -> int:
         yes = False
         register = False
         account_transport = None
-        cert_port_arg = None
 
         i = 1
         while i < len(argv):
@@ -483,18 +481,6 @@ 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
@@ -563,7 +549,7 @@ def main() -> int:
                 return 2
 
             # configure returns the proper exit code
-            cert_port = cert_port_arg if cert_port_arg is not None else port + 1
+            cert_port = port + 1
             result = configure(host, port, cert_port)
             if result not in (None, 0):
                 return int(result)

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

@@ -1,27 +1,39 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0
+Version: 2.1.0.dev7
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
-Author-email: Ethan Ge <ethoGalaxy@gmail.com>
-License-Expression: GPL-3.0-or-later
+Author: Ethan Ge
+Author-email: ethoGalaxy@gmail.com
+License: 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.16.0
+Requires-Dist: remoterf-federation-core==0.13.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.dist-info → remoterf-2.1.0.dev7.dist-info}/RECORD

@@ -1,6 +1,5 @@
-remoteRF.py,sha256=ANpEl1Hg7HpGji6UZP6SzHORqE1v4S7SzsZzWFiG6Es,1853
 remoteRF/__init__.py,sha256=-1h_xQjiE66oiWRO-vnLGJ4smpgUNhFuV-ZreW9_tD4,667
-remoteRF/remoterf_cli.py,sha256=fuLMH6ts-h5Ii_MlOB14-lgmkWis-WRP4wwWJy8jeIA,21407
+remoteRF/remoterf_cli.py,sha256=ShiYgQfrjYxoegQD432XVJ9MrZrTn7iq9yLGVW-uPbE,20749
 remoteRF/version.py,sha256=NWzcPOAdd567IvC8ei1yyPdeS7w0kt99oKwL6oWAQSc,850
 remoteRF/common/__init__.py,sha256=ey1IjkAaXFL1sZBnBwuWVlHhA_n0bu_uxgkDV_KOxYg,708
 remoteRF/common/tos_notice.txt,sha256=fUHXV6U9uhZDvVs8BcRi4kWbU1PeU9mkxML0n5DDQp8,334
@@ -11,7 +10,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=kgj_WXBOKw--J7ZgE7TBfrUbF5AmjMg_VNMx9tDNHTQ,5191
+remoteRF/common/grpc/v2_codec.py,sha256=a9_xpxAnJAvAssfkElbGaDitkUpd1ntoK6a9h-xx7Og,5179
 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
@@ -26,10 +25,10 @@ remoteRF/core/acc_login.py,sha256=Qct7vEsc0OIdVwmikOv2mVv9-ehH4CMVw7QWHe2yOsg,10
 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=sOXrgvo020u_Mu8lGp1v0SI-MvMY3A43ezTbJRzY5aY,21998
-remoteRF/core/grpc_acc.py,sha256=XzE4uTSQ6ZX_4jcgK9pbS96_9_7oDqWEqDTTi07Z6P0,7636
+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=_avJBcvtLv0_9MgT6dpM-6bNH8DGph2Gls6DJZMkIXo,2859
+remoteRF/core/secure_channel.py,sha256=ffPpc5o-3YAh7jMIT4izRbC-Iq9D-biSwpXwGBVlvUU,2283
 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
@@ -39,10 +38,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=lSdDgGl6022G2rUyo2WD0zMImwi9Q-uIzqX-T60MYeY,62180
-remoteRF/drivers/dynamic_v2.py,sha256=CIJ6SW0jptT0Kp93Rly7WlYbeDoTdZVoP2CfHCaSiAo,33666
+remoteRF/drivers/dynamic_device.py,sha256=mGbRLh92QuWcktHNm_ZMej7AFWUvHM9ttJtsGDOGm9I,60504
+remoteRF/drivers/dynamic_v2.py,sha256=vF45cgH4rpKo8Gf67yJ4Hw6lKY1JhP-LGdyd68Fz-PI,33919
 remoteRF/drivers/adalm_pluto/__init__.py,sha256=QmFIGRC9MG9GMOc277Hkwd2CG-3wI59UmuV0k2XsvY8,829
-remoteRF/drivers/adalm_pluto/adalm_pluto_remote.py,sha256=yIf_VkgMsDPsz5W54MK0emRJz22UujydMpWGFV41jtU,12186
+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/hackrf/__init__.py,sha256=BlpF0ZyAu8IcfpxyQlPXbI4PATdisFT1lR0cM8Gk6O0,821
 remoteRF/drivers/hackrf/hackrf_remote.py,sha256=UMwBsKGTUjq6lp0s3axwbdel9YtUUMoik0VtpsjGN-Y,8956
@@ -54,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=A66MK7FqfyT8AeNqS4pnCIwBxTTszMmT02YoZF2kqGk,23028
+remoteRF/drivers/support/uhd_v2.py,sha256=5Ho-ryyC86y-vitBsbFPouvzrVylNI0pdNzwXMANfXg,22600
 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.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-remoterf-2.1.0.dist-info/METADATA,sha256=bc71IrZ885tKY1vCyv-BfBONqq5aGmfyD5kJh9ZrId0,12778
-remoterf-2.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-remoterf-2.1.0.dist-info/entry_points.txt,sha256=La_TjAqCfqdcVTVjB2WrsJNn5rfgcuIYroe2v-CMwRQ,56
-remoterf-2.1.0.dist-info/top_level.txt,sha256=XQJoVTmAOsHV9qtPSP_QSh0ma4jKxsDkxn4IjM_ZuZk,9
-remoterf-2.1.0.dist-info/RECORD,,
+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.py

@@ -1,39 +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/>.
-
-"""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)