RemoteRF 2.0.12__tar.gz → 2.0.14__tar.gz

{remoterf-2.0.12/src/remoterf.egg-info → remoterf-2.0.14}/PKG-INFO

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

{remoterf-2.0.12 → remoterf-2.0.14}/setup.py

@@ -21,7 +21,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="remoterf",
-    version="2.0.12",
+    version="2.0.14",
     author="Ethan Ge",
     author_email="ethoGalaxy@gmail.com",
     description="A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.",

remoterf-2.0.14/src/remoteRF/common/grpc/grpc.proto

@@ -0,0 +1,237 @@
+// 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/>.
+
+syntax = "proto3";
+
+option java_package = "com.example.demo";
+option java_outer_classname = "DemoProtos";
+
+package remote_rf;
+
+service GenericRPC {
+    rpc Call (GenericRPCRequest) returns (GenericRPCResponse);
+}
+
+// Dynamic protocol v2 is deliberately additive. GenericRPC remains the v1
+// compatibility surface for existing generated clients and device schemas.
+service DynamicControlV2 {
+    rpc Negotiate (NegotiateRequest) returns (NegotiateResponse);
+    rpc GetSchema (GetSchemaRequest) returns (GetSchemaResponse);
+    rpc OpenSession (OpenSessionRequest) returns (OpenSessionResponse);
+    rpc Invoke (InvokeRequest) returns (InvokeResponse);
+    rpc CloseHandle (CloseHandleRequest) returns (CloseResponse);
+    rpc CloseSession (CloseSessionRequest) returns (CloseResponse);
+}
+
+service SampleDataV1 {
+    rpc SampleStream (stream SampleFrame) returns (stream SampleFrame);
+}
+
+message GenericRPCRequest {
+    string function_name = 1;
+    map<string, Argument> args = 2;
+}
+
+message GenericRPCResponse {
+    map<string, Argument> results = 1;
+}
+
+message ArrayShape {
+    repeated int32 dim = 1;
+}
+
+message ComplexNumber {
+    float real = 1;
+    float imag = 2;
+}
+
+message ComplexNumpyArray {
+    ArrayShape shape = 1;
+    repeated ComplexNumber data = 2;
+}
+
+message RealNumpyArray {
+    ArrayShape shape = 1;
+    repeated float data = 2;
+}
+
+message Argument {
+    oneof value {
+        string string_value = 1;
+        int64 int64_value = 2;
+        float float_value = 3;
+        bool bool_value = 4;
+        ComplexNumpyArray complex_array = 5;
+        RealNumpyArray real_array = 6;
+        string json_value = 7;
+        bytes bytes_value = 8;
+        // Contiguous C-order numeric data; fields 5 and 6 remain decode-compatible.
+        NDArrayValue ndarray_value = 9;
+    }
+}
+
+message NDArrayValue {
+    string dtype = 1;
+    repeated int64 shape = 2;
+    bytes data = 3;
+}
+
+message DynamicValue {
+    oneof value {
+        bool null_value = 1;
+        bool bool_value = 2;
+        sint64 int64_value = 3;
+        double double_value = 4;
+        string string_value = 5;
+        bytes bytes_value = 6;
+        string json_value = 7;
+        NDArrayValue ndarray_value = 8;
+    }
+}
+
+message NamedValue {
+    string name = 1;
+    DynamicValue value = 2;
+}
+
+message Mutation {
+    string target = 1;
+    DynamicValue value = 2;
+}
+
+message ErrorEnvelope {
+    string code = 1;
+    string message = 2;
+    string details_json = 3;
+    string method = 4;
+    string native_exception = 5;
+    string uhd_version = 6;
+    bool retryable = 7;
+    bool fatal_to_session = 8;
+}
+
+message NegotiateRequest {
+    repeated string schema_versions = 1;
+    repeated string control_protocol_versions = 2;
+    repeated string streaming_protocol_versions = 3;
+}
+
+message NegotiateResponse {
+    string schema_version = 1;
+    string control_protocol_version = 2;
+    string streaming_protocol_version = 3;
+    ErrorEnvelope error = 4;
+}
+
+message GetSchemaRequest {
+    string token = 1;
+    repeated string schema_versions = 2;
+}
+
+message GetSchemaResponse {
+    string schema_version = 1;
+    string schema_json = 2;
+    string schema_hash = 3;
+    ErrorEnvelope error = 4;
+}
+
+message OpenSessionRequest {
+    string token = 1;
+    string requested_schema_hash = 2;
+    string control_protocol_version = 3;
+    string streaming_protocol_version = 4;
+}
+
+message OpenSessionResponse {
+    string session_id = 1;
+    string device_handle = 2;
+    string schema_json = 3;
+    string schema_hash = 4;
+    string capabilities_json = 5;
+    string uhd_version = 6;
+    string uhd_abi = 7;
+    string hardware_profile = 8;
+    ErrorEnvelope error = 9;
+}
+
+message InvokeRequest {
+    string session_id = 1;
+    string handle = 2;
+    string method = 3;
+    string overload_id = 4;
+    repeated NamedValue args = 5;
+}
+
+message InvokeResponse {
+    DynamicValue result = 1;
+    repeated Mutation mutations = 2;
+    ErrorEnvelope error = 3;
+}
+
+message CloseHandleRequest {
+    string session_id = 1;
+    string handle = 2;
+}
+
+message CloseSessionRequest {
+    string session_id = 1;
+}
+
+message CloseResponse {
+    bool closed = 1;
+    ErrorEnvelope error = 2;
+}
+
+enum SampleDirection {
+    SAMPLE_DIRECTION_UNSPECIFIED = 0;
+    SAMPLE_DIRECTION_RX = 1;
+    SAMPLE_DIRECTION_TX = 2;
+}
+
+enum SampleFrameKind {
+    SAMPLE_FRAME_UNSPECIFIED = 0;
+    SAMPLE_FRAME_OPEN = 1;
+    SAMPLE_FRAME_REQUEST = 2;
+    SAMPLE_FRAME_DATA = 3;
+    SAMPLE_FRAME_RESULT = 4;
+    SAMPLE_FRAME_CREDIT = 5;
+    SAMPLE_FRAME_CANCEL = 6;
+    SAMPLE_FRAME_CLOSE = 7;
+    SAMPLE_FRAME_ERROR = 8;
+}
+
+message SampleFrame {
+    string session_id = 1;
+    string handle = 2;
+    uint64 generation = 3;
+    string operation_id = 4;
+    uint64 sequence = 5;
+    SampleDirection direction = 6;
+    SampleFrameKind kind = 7;
+    string dtype = 8;
+    repeated int64 shape = 9;
+    repeated uint32 channels = 10;
+    uint64 sample_count = 11;
+    bytes payload = 12;
+    string metadata_json = 13;
+    double device_time_secs = 14;
+    uint32 credits = 15;
+    double timeout_sec = 16;
+    bool one_packet = 17;
+    bool end_of_stream = 18;
+    bool cancelled = 19;
+    ErrorEnvelope error = 20;
+    uint64 flags = 21;
+}

{remoterf-2.0.12 → remoterf-2.0.14}/src/remoteRF/drivers/dynamic_device.py

@@ -1070,6 +1070,8 @@ def _emit_client_object_bindings(client_objects: dict, *, class_name: str) -> li
 # Regular string (not f-string) — {_PREFIX}/{prop}/{e} are literal text
 # that become f-strings inside the *generated* file.
 _HELPERS = '''\
+import os
+
 from importlib import import_module as _import_module
 
 from ...common.utils import map_arg, unmap_arg
@@ -1230,7 +1232,9 @@ def _codegen(schema: dict) -> str:
         f'            self.token = make_virtual_token(token, device_type="{device_type}")',
         "            return",
         '        if token is None:',
-        '            raise ValueError("A reservation token is required unless virtual=True")',
+        '            token = os.getenv("REMOTERF_TOKEN")',
+        '        if not token:',
+        '            raise ValueError("A reservation token is required; pass token= or set REMOTERF_TOKEN")',
         "        self.token = token",
         "        from ..dynamic_device import install_driver_if_stale",
         "        install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)",

{remoterf-2.0.12 → remoterf-2.0.14}/src/remoteRF/drivers/hackrf/hackrf_remote.py

@@ -14,21 +14,35 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # Auto-generated from IDL schema — do not edit by hand.
-# device_type: hackrf  driver_version: 0.1.1  schema_hash: sha256:1d6e935e2e33959e753b89d943a1a5696d814ec28aac52a7c39142b3fce89693
+# device_type: hackrf  driver_version: 0.1.1  schema_hash: sha256:6fb625ce99aaf7e190de013ad3e66276265020a5464d9d55d4c0e076dae28f3c
 
 _PREFIX = "Hackrf"
-_SCHEMA_HASH = "sha256:1d6e935e2e33959e753b89d943a1a5696d814ec28aac52a7c39142b3fce89693"
+_SCHEMA_HASH = "sha256:6fb625ce99aaf7e190de013ad3e66276265020a5464d9d55d4c0e076dae28f3c"
 _CLIENT_MODULES = {}
 _CLIENT_OBJECTS = {}
 
+import os
+
 from importlib import import_module as _import_module
 
-from ...core.grpc_client import rpc_client
 from ...common.utils import map_arg, unmap_arg
+from .._virtual import (
+    is_virtual_token,
+    make_virtual_token,
+    virtual_call,
+    virtual_get,
+    virtual_set,
+)
 
 _NO_ARG = object()
 
 
+def _rpc_client(*, function_name, args):
+    from ...core.grpc_client import rpc_client
+
+    return rpc_client(function_name=function_name, args=args)
+
+
 for _alias, _module_path in _CLIENT_MODULES.items():
     globals()[_alias] = _import_module(_module_path)
 
@@ -71,27 +85,34 @@ def _wrap_client_return(spec, self_obj, result):
 
 
 def _try_get(prop, token):
-    return unmap_arg(rpc_client(
+    if is_virtual_token(token):
+        return virtual_get(token, prop)
+    return unmap_arg(_rpc_client(
         function_name=f"{_PREFIX}:{prop}:GET",
         args={'a': map_arg(token)},
     ).results[prop])
 
 
 def _try_set(prop, value, token):
-    rpc_client(
+    if is_virtual_token(token):
+        virtual_set(token, prop, value)
+        return None
+    _rpc_client(
         function_name=f"{_PREFIX}:{prop}:SET",
         args={prop: map_arg(value), 'a': map_arg(token)},
     )
 
 
 def _try_call(prop, token, arg=_NO_ARG):
+    if is_virtual_token(token):
+        return virtual_call(token, prop, arg, has_arg=arg is not _NO_ARG)
     if arg is _NO_ARG:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL0",
             args={'a': map_arg(token)},
         )
     else:
-        resp = rpc_client(
+        resp = _rpc_client(
             function_name=f"{_PREFIX}:{prop}:CALL1",
             args={'a': map_arg(token), 'arg1': map_arg(arg)},
         )
@@ -100,12 +121,15 @@ def _try_call(prop, token, arg=_NO_ARG):
 
 
 def _try_calln(prop, token, kwargs):
+    if is_virtual_token(token):
+        filtered = {key: value for key, value in dict(kwargs).items() if value is not _NO_ARG}
+        return virtual_call(token, prop, filtered, has_arg=True)
     payload = {'a': map_arg(token)}
     for key, value in dict(kwargs).items():
         if value is _NO_ARG:
             continue
         payload[str(key)] = map_arg(value)
-    resp = rpc_client(
+    resp = _rpc_client(
         function_name=f"{_PREFIX}:{prop}:CALLN",
         args=payload,
     )
@@ -114,7 +138,15 @@ def _try_calln(prop, token, kwargs):
 
 class HackRF:
 
-    def __init__(self, token: str):
+    def __init__(self, token: str = None, *, virtual: bool = False):
+        self.virtual = bool(virtual)
+        if self.virtual:
+            self.token = make_virtual_token(token, device_type="hackrf")
+            return
+        if token is None:
+            token = os.getenv("REMOTERF_TOKEN")
+        if not token:
+            raise ValueError("A reservation token is required; pass token= or set REMOTERF_TOKEN")
         self.token = token
         from ..dynamic_device import install_driver_if_stale
         install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
@@ -204,6 +236,10 @@ class HackRF:
         'Clear any captured or queued IQ bytes while the radio is idle.'
         return _try_call("clear_buffer", self.token)
 
+    def close(self):
+        'Safely end this remote TX use without closing the server-owned radio.'
+        return _try_call("close", self.token)
+
     def enumerate(self):
         'Return attached serials as a JSON array for broad client compatibility.'
         return _try_call("enumerate", self.token)
@@ -213,7 +249,7 @@ class HackRF:
         return _try_call("get_serial_no", self.token)
 
     def load_tx_iq(self, samples):
-        'Convert normalized IQ samples and load the native transmit buffer.'
+        'Load normalized complex or native interleaved signed-int8 TX IQ.'
         return _try_call("load_tx_iq", self.token, samples)
 
     def read_samples(self, num_samples=_NO_ARG):
@@ -222,6 +258,18 @@ class HackRF:
             "num_samples": num_samples,
         })
 
+    def set_freq(self, value):
+        'Compatibility alias for setting the center frequency in Hz.'
+        return _try_call("set_freq", self.token, value)
+
+    def set_sample_rate(self, value):
+        'Compatibility alias for setting the complex sample rate in Hz.'
+        return _try_call("set_sample_rate", self.token, value)
+
+    def setup(self):
+        'Confirm the already-managed remote HackRF is ready for use.'
+        return _try_call("setup", self.token)
+
     def start_tx(self):
         'Start transmitting the IQ bytes previously loaded with load_tx_iq().'
         return _try_call("start_tx", self.token)

{remoterf-2.0.12 → remoterf-2.0.14}/src/remoteRF/remoterf_cli.py

@@ -134,6 +134,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)
     print()
@@ -182,6 +183,7 @@ def main() -> int:
         addr = None
         wipe = False
         yes = False
+        cert_port_arg = None
 
         i = 1
         while i < len(argv):
@@ -195,6 +197,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
@@ -235,7 +249,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
             configure(host, port, cert_port)
             return 0
 

{remoterf-2.0.12 → remoterf-2.0.14/src/remoterf.egg-info}/PKG-INFO

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

{remoterf-2.0.12 → remoterf-2.0.14}/src/remoterf.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/remoteRF/version.py
 src/remoteRF/common/__init__.py
 src/remoteRF/common/tos_notice.txt
 src/remoteRF/common/grpc/__init__.py
+src/remoteRF/common/grpc/grpc.proto
 src/remoteRF/common/grpc/grpc_pb2.py
 src/remoteRF/common/grpc/grpc_pb2_grpc.py
 src/remoteRF/common/grpc/v2_codec.py
@@ -48,49 +49,12 @@ src/remoteRF/drivers/ti_mmwave/ti_mmwave_remote.py
 src/remoteRF/drivers/usrp/__init__.py
 src/remoteRF/drivers/usrp/usrp_remote.py
 src/remoteRF/drivers/usrp/usrp_remote.pyi
-src/remoterf/__init__.py
-src/remoterf/remoterf_cli.py
-src/remoterf/version.py
 src/remoterf.egg-info/PKG-INFO
 src/remoterf.egg-info/SOURCES.txt
 src/remoterf.egg-info/dependency_links.txt
 src/remoterf.egg-info/entry_points.txt
 src/remoterf.egg-info/requires.txt
 src/remoterf.egg-info/top_level.txt
-src/remoterf/common/__init__.py
-src/remoterf/common/tos_notice.txt
-src/remoterf/common/grpc/__init__.py
-src/remoterf/common/grpc/grpc_pb2.py
-src/remoterf/common/grpc/grpc_pb2_grpc.py
-src/remoterf/common/grpc/v2_codec.py
-src/remoterf/common/utils/__init__.py
-src/remoterf/common/utils/ansi_codes.py
-src/remoterf/common/utils/api_token.py
-src/remoterf/common/utils/list_string.py
-src/remoterf/common/utils/process_arg.py
-src/remoterf/config/__init__.py
-src/remoterf/config/cert_fetcher.py
-src/remoterf/config/config.py
-src/remoterf/core/__init__.py
-src/remoterf/core/acc_login.py
-src/remoterf/core/app.py
-src/remoterf/core/banner_note.txt
-src/remoterf/core/dynamic_v2_transport.py
-src/remoterf/core/grpc_acc.py
-src/remoterf/core/grpc_client.py
-src/remoterf/core/v2_errors.py
-src/remoterf/drivers/__init__.py
-src/remoterf/drivers/dynamic_device.py
-src/remoterf/drivers/dynamic_v2.py
-src/remoterf/drivers/adalm_pluto/__init__.py
-src/remoterf/drivers/adalm_pluto/pluto_remote.py
-src/remoterf/drivers/support/__init__.py
-src/remoterf/drivers/support/uhd.py
-src/remoterf/drivers/support/uhd_dsp.py
-src/remoterf/drivers/support/uhd_v2.py
-src/remoterf/drivers/usrp/__init__.py
-src/remoterf/drivers/usrp/usrp_remote.py
-src/remoterf/drivers/usrp/usrp_remote.pyi
 tests/test_banner.py
 tests/test_dynamic_device_codegen.py
 tests/test_dynamic_v2.py

{remoterf-2.0.12 → remoterf-2.0.14}/tests/test_dynamic_device_codegen.py

@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+import os
 import unittest
 import sys
 import tempfile
@@ -413,6 +414,15 @@ class DynamicDeviceCodegenTests(unittest.TestCase):
             exec(code, module.__dict__)
 
             device = module.FakeDevice("token")
+            old_token = os.environ.get("REMOTERF_TOKEN")
+            os.environ["REMOTERF_TOKEN"] = "token-from-env"
+            try:
+                self.assertEqual(module.FakeDevice().token, "token-from-env")
+            finally:
+                if old_token is None:
+                    os.environ.pop("REMOTERF_TOKEN", None)
+                else:
+                    os.environ["REMOTERF_TOKEN"] = old_token
             self.assertEqual(device.status, {"raw": True})
             self.assertEqual(device.echo({"payload": 3}), {"payload": 3})
             self.assertEqual(device.configure(1.0), {"configured": True})
@@ -423,6 +433,7 @@ class DynamicDeviceCodegenTests(unittest.TestCase):
         self.assertEqual(
             [item[0] for item in seen],
             [
+                "Fake_device:ip:CALL0",
                 "Fake_device:ip:CALL0",
                 "Fake_device:status:GET",
                 "Fake_device:echo:CALL1",

{remoterf-2.0.12 → remoterf-2.0.14}/tests/test_remoterf_cli.py

@@ -48,6 +48,32 @@ class RemoteRFCliTests(unittest.TestCase):
         connected_server.assert_called_once_with()
         print_unavailable.assert_called_once_with()
 
+    @mock.patch("remoteRF.config.config.configure")
+    @mock.patch.object(
+        remoterf_cli.sys, "argv", ["remoterf", "--config", "--addr", "10.0.0.1:12321"]
+    )
+    def test_config_without_cert_port_defaults_to_grpc_port_plus_one(self, configure):
+        self.assertEqual(remoterf_cli.main(), 0)
+        configure.assert_called_once_with("10.0.0.1", 12321, 12322)
+
+    @mock.patch("remoteRF.config.config.configure")
+    @mock.patch.object(
+        remoterf_cli.sys,
+        "argv",
+        ["remoterf", "--config", "--addr", "10.0.0.1:12321", "--cert-port", "9999"],
+    )
+    def test_config_with_explicit_cert_port_overrides_default(self, configure):
+        self.assertEqual(remoterf_cli.main(), 0)
+        configure.assert_called_once_with("10.0.0.1", 12321, 9999)
+
+    @mock.patch("remoteRF.config.config.configure")
+    @mock.patch.object(
+        remoterf_cli.sys, "argv", ["remoterf", "-c", "-a", "10.0.0.1:12321"]
+    )
+    def test_existing_short_flag_usage_remains_compatible(self, configure):
+        self.assertEqual(remoterf_cli.main(), 0)
+        configure.assert_called_once_with("10.0.0.1", 12321, 12322)
+
 
 if __name__ == "__main__":
     unittest.main()