RemoteRF 2.1.0__tar.gz → 2.1.1__tar.gz

{remoterf-2.1.0 → remoterf-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0
+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-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.1.0 → remoterf-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.1.0"
+version = "2.1.1"
 description = "A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{remoterf-2.1.0 → remoterf-2.1.1}/src/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-2.1.0 → remoterf-2.1.1}/src/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-2.1.0 → remoterf-2.1.1}/src/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)
@@ -173,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)

{remoterf-2.1.0 → remoterf-2.1.1}/src/remoterf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0
+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-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.1.0 → remoterf-2.1.1}/src/remoterf.egg-info/SOURCES.txt

@@ -46,7 +46,6 @@ src/remoteRF/drivers/dynamic_device.py
 src/remoteRF/drivers/dynamic_v2.py
 src/remoteRF/drivers/adalm_pluto/__init__.py
 src/remoteRF/drivers/adalm_pluto/adalm_pluto_remote.py
-src/remoteRF/drivers/adalm_pluto/pluto_remote.py
 src/remoteRF/drivers/hackrf/__init__.py
 src/remoteRF/drivers/hackrf/hackrf_remote.py
 src/remoteRF/drivers/rtl_sdr/__init__.py
@@ -74,6 +73,7 @@ tests/test_config_address.py
 tests/test_deployment_accounts.py
 tests/test_direct_path_fixed.py
 tests/test_direct_path_partner.py
+tests/test_direct_path_race.py
 tests/test_dynamic_device_codegen.py
 tests/test_dynamic_v2.py
 tests/test_federated_devices.py

remoterf-2.1.1/tests/test_direct_path_race.py

@@ -0,0 +1,129 @@
+"""The fixed dial and the punch run at once: whichever connects first is the
+path, the other is cancelled, and when both fail the reason names both."""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from remoteRF.core import direct_path
+
+from test_gate_i_direct_path import SERVER_NAME, FakeServer, write_certs
+
+
+class RaceTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.ca_pem = write_certs(Path(self._tmp.name))
+
+    def _path(self, offer):
+        path = direct_path.DirectPath(offer=offer, server_name=SERVER_NAME, ca_pem=self.ca_pem, stun=None)
+        self.addCleanup(path.stop)
+        path.start()
+        return path
+
+    def test_the_punch_wins_while_the_fixed_dial_still_hangs(self):
+        server = FakeServer(Path(self._tmp.name), lambda request: {})
+        self.addCleanup(server.close)
+        outcome = []
+
+        async def hang(self, answer, configuration):
+            try:
+                await asyncio.Event().wait()
+            except asyncio.CancelledError:
+                outcome.append("cancelled")
+                raise
+
+        with mock.patch.object(direct_path.DirectPath, "_dial_fixed", hang):
+            path = self._path(lambda offer: {**server.offer(offer), "udp": "127.0.0.1:9", "session": "s"})
+            self.assertTrue(path.wait(15), path.describe())
+        self.assertFalse(path.fixed)
+        self.assertTrue(path.describe().startswith("direct "), path.describe())
+        self.assertEqual(outcome, ["cancelled"])
+        self.assertEqual(len(path._tasks), 3)
+
+    def test_both_failing_names_both(self):
+        async def fixed(self, answer, configuration):
+            raise asyncio.TimeoutError
+
+        async def punch(self, ice, answer, configuration):
+            raise ConnectionError("ICE negotiation failed")
+
+        with mock.patch.object(direct_path.DirectPath, "_dial_fixed", fixed), \
+             mock.patch.object(direct_path.DirectPath, "_punch", punch):
+            path = self._path(lambda offer: {"ufrag": "a", "pwd": "b", "candidates": [], "udp": "h:1", "session": "s"})
+            self.assertFalse(path.wait(15))
+        self.assertEqual(path.state, "down")
+        self.assertEqual(path.reason, "fixed port: timed out; punch: ConnectionError: ICE negotiation failed")
+
+    def test_a_punch_alone_keeps_its_own_reason(self):
+        async def punch(self, ice, answer, configuration):
+            raise asyncio.TimeoutError
+
+        with mock.patch.object(direct_path.DirectPath, "_punch", punch):
+            path = self._path(lambda offer: {"ufrag": "a", "pwd": "b", "candidates": []})
+            self.assertFalse(path.wait(15))
+        self.assertEqual(path.reason, "timed out")
+
+    def test_the_offer_says_this_client_punches_at_once(self):
+        seen = []
+
+        def offer(request):
+            seen.append(request)
+            return {"ufrag": "a", "pwd": "b", "candidates": []}
+
+        path = self._path(offer)
+        path.wait(15)
+        self.assertEqual(len(seen), 1)
+        self.assertIs(seen[0]["race"], True)
+
+
+
+
+
+class DescribeTests(unittest.TestCase):
+    def setUp(self):
+        self.addCleanup(setattr, direct_path, "_path", None)
+        direct_path._path = None
+
+    def _describe(self, routes, endpoint="10.0.0.5:12321"):
+        profile = mock.Mock(home="lab", grpc_endpoint=endpoint)
+        with mock.patch("remoteRF.core.grpc_client._current_profile", return_value=profile), \
+             mock.patch("remoteRF.deployment.homes.load_home", return_value={"routes": routes}):
+            return direct_path.describe()
+
+    def test_a_lan_route_is_not_the_relay(self):
+        self.assertEqual(self._describe([{"kind": "lan", "host": "10.0.0.5", "port": 12321}]), "LAN (direct)")
+        self.assertEqual(self._describe([{"kind": "direct", "host": "10.0.0.5", "port": 12321}]), "direct")
+
+    def test_a_relay_route_and_a_failed_lookup_keep_the_old_wording(self):
+        self.assertEqual(self._describe([{"kind": "relay", "host": "10.0.0.5", "port": 12321}]), "relay (direct path off)")
+        with mock.patch("remoteRF.core.grpc_client._current_profile", side_effect=RuntimeError("not configured")):
+            self.assertEqual(direct_path.describe(), "relay (direct path off)")
+
+
+class QuietWaiterTests(unittest.TestCase):
+    def _run(self, exc):
+        loop = asyncio.new_event_loop()
+        seen = []
+        try:
+            loop.default_exception_handler = lambda context: seen.append(context)
+            direct_path.quiet_aioice_errors(loop)
+            loop.call_exception_handler({"message": "Future exception was never retrieved", "exception": exc})
+        finally:
+            loop.close()
+        return seen
+
+    def test_aioquic_orphaned_connect_waiter_is_silent(self):
+        self.assertEqual(self._run(ConnectionError()), [])
+
+    def test_other_unretrieved_exceptions_still_reach_the_default_handler(self):
+        self.assertEqual(len(self._run(ValueError("not ours"))), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{remoterf-2.1.0 → remoterf-2.1.1}/tests/test_finish_prompt.py

@@ -1,15 +1,20 @@
-"""A user-error reply never blocks a script on stdin."""
+"""A user-error reply never blocks on stdin, terminal or not."""
 
 import io
 
+import pytest
+
 from remoteRF.common.grpc import grpc_pb2
 from remoteRF.common.utils import map_arg
 from remoteRF.core import grpc_client
 
 
-def test_a_user_error_only_prompts_on_a_terminal(monkeypatch, capsys):
+@pytest.mark.parametrize("isatty", [False, True])
+def test_a_user_error_never_prompts(monkeypatch, capsys, isatty):
     response = grpc_pb2.GenericRPCResponse(results={"UE": map_arg("Username already exists.")})
-    monkeypatch.setattr("sys.stdin", io.StringIO(""))  # not a tty
+    stdin = io.StringIO("")
+    monkeypatch.setattr(stdin, "isatty", lambda: isatty)
+    monkeypatch.setattr("sys.stdin", stdin)
     monkeypatch.setattr("builtins.input", lambda *a: (_ for _ in ()).throw(AssertionError("prompted")))
     assert grpc_client._finish(response) is response
     assert "Username already exists" in capsys.readouterr().out

{remoterf-2.1.0 → remoterf-2.1.1}/tests/test_gate_i_direct_path.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import asyncio
 import datetime
+import os
 import threading
 import time
 import unittest
@@ -235,12 +236,17 @@ class RoutingTests(unittest.TestCase):
 
         seen = []
         self._path(lambda name, args: seen.append((name, dict(args))) or grpc_pb2.GenericRPCResponse())
-        with mock.patch.dict("os.environ", {"REMOTERF_RX_WIRE": "i16"}):
+        with mock.patch.dict("os.environ", {"REMOTERF_RX_WIRE": "c64"}):
             rpc_client(function_name="adalm_pluto:rx:CALL0", args={"a": map_arg("t")})
             rpc_client(function_name="adalm_pluto:rx_lo:GET", args={"a": map_arg("t")})
-        rpc_client(function_name="adalm_pluto:rx:CALL0", args={"a": map_arg("t")})
-        self.assertEqual([sorted(args) for _, args in seen], [["a", "wire"], ["a"], ["a"]])
-        self.assertEqual(unmap_arg(seen[0][1]["wire"]), "i16")
+        with mock.patch.dict("os.environ", {"REMOTERF_RX_WIRE": ""}):  # opt out
+            rpc_client(function_name="adalm_pluto:rx:CALL0", args={"a": map_arg("t")})
+        with mock.patch.dict("os.environ"):
+            os.environ.pop("REMOTERF_RX_WIRE", None)  # unset: i16 by default
+            rpc_client(function_name="adalm_pluto:rx:CALL0", args={"a": map_arg("t")})
+        self.assertEqual([sorted(args) for _, args in seen], [["a", "wire"], ["a"], ["a"], ["a", "wire"]])
+        self.assertEqual(unmap_arg(seen[0][1]["wire"]), "c64")
+        self.assertEqual(unmap_arg(seen[3][1]["wire"]), "i16")
 
     def test_a_path_that_is_not_ready_is_skipped(self):
         from remoteRF.core.grpc_client import rpc_client

remoterf-2.1.0/src/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