RemoteRF 2.2.0__tar.gz → 2.2.1__tar.gz

{remoterf-2.2.0/src/remoterf.egg-info → remoterf-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.2.0
+Version: 2.2.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.2.0 → remoterf-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.2.0"
+version = "2.2.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.2.0 → remoterf-2.2.1}/src/remoterf/core/app.py

@@ -536,10 +536,9 @@ def _federated_reservations_for_range(start_day, end_day):
 
 def _federated_reserve_slot(device_id, chosen_day, chosen_slot, slot_start_str, slot_end_str):
     handle = account.reserve_device(device_id, chosen_slot[0], chosen_slot[1])
-    printf("Reservation successful for ", (Sty.BOLD, Sty.GREEN), f"{chosen_day.strftime('%Y-%m-%d')} {slot_start_str}-{slot_end_str}.", Sty.CYAN)
-    printf("Your device handle -> ", Sty.BOLD, f"{handle}", (Sty.BOLD, Sty.GREEN))
-    printf("Use it where a token goes, e.g. adi.Pluto(\"" + handle + "\"); it works while you are logged in to this home.", Sty.DEFAULT)
-    printf("The first call can take ~20 s while the radio powers on.", Sty.GRAY)
+    # Worded as a lab account's reservation; the handle goes where a token goes.
+    printf("Reservation successful on device ", (Sty.BOLD, Sty.GREEN), f"{str(device_id).rsplit(':', 1)[-1]}", Sty.MAGENTA, " for ", Sty.DEFAULT, f"{chosen_day.strftime('%Y-%m-%d')} {slot_start_str}-{slot_end_str}.", Sty.CYAN)
+    printf("Your Token -> ", Sty.BOLD, f"{handle}", (Sty.BOLD, Sty.GREEN))
     account.install_reserved_driver(handle, device_id)
 
 

{remoterf-2.2.0 → remoterf-2.2.1}/src/remoterf/core/direct_path.py

@@ -50,11 +50,18 @@ import threading
 import time
 from typing import Callable, Optional
 
-from aioice import Candidate, Connection
-from aioquic.asyncio.protocol import QuicConnectionProtocol
-from aioquic.quic import events
-from aioquic.quic.configuration import QuicConfiguration
-from aioquic.quic.connection import QuicConnection
+try:
+    from aioice import Candidate, Connection
+    from aioquic.asyncio.protocol import QuicConnectionProtocol
+    from aioquic.quic import events
+    from aioquic.quic.configuration import QuicConfiguration
+    from aioquic.quic.connection import QuicConnection
+
+    _BROKEN = None
+except Exception as _exc:  # noqa: BLE001 - e.g. conda swapped in a cryptography pip's pyOpenSSL cannot use
+    Candidate = Connection = QuicConnectionProtocol = QuicConfiguration = QuicConnection = object
+    events = None
+    _BROKEN = f"{type(_exc).__name__}: {_exc}"
 
 from ..common.grpc import grpc_pb2
 from ..common.utils import map_arg, unmap_arg
@@ -136,7 +143,7 @@ STUN_SECONDS = 1.5  # a STUN server answers in milliseconds or not at all
 
 
 def enabled() -> bool:
-    return os.getenv("REMOTERF_DIRECT", "1").strip().lower() not in {"0", "off", "no", "false"}
+    return _BROKEN is None and os.getenv("REMOTERF_DIRECT", "1").strip().lower() not in {"0", "off", "no", "false"}
 
 
 def wants(function_name: str) -> bool:
@@ -742,6 +749,8 @@ def current(token: Optional[str] = None) -> Optional[DirectPath]:
 
 def describe() -> str:
     """What device calls use right now, for the shell."""
+    if _BROKEN is not None:
+        return f"relay (direct path unavailable: {_BROKEN}; fix: pip install --force-reinstall remoterf)"
     if not enabled():
         return "relay (direct path disabled: REMOTERF_DIRECT=0)"
     path = _path

{remoterf-2.2.0 → remoterf-2.2.1}/src/remoterf/core/grpc_client.py

@@ -225,15 +225,16 @@ def _device_token(function_name, args):
 def rpc_client(*, function_name, args, connection=None):
     global tcp_calls
     tcp_calls += 1
-    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", "i16").strip().lower()
     if wire and function_name.endswith(":rx:CALL0"):
         # 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).
+        # Also through a HOME, whose relay caps each response at ~768 KiB.
         args = {**args, "wire": map_arg(wire)}
+    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))
     if connection is None and direct_path.wants(function_name):
         path = direct_path.current(token=_device_token(function_name, args))
         if path is not None:

{remoterf-2.2.0 → remoterf-2.2.1}/src/remoterf/remoterf_cli.py

@@ -312,25 +312,39 @@ def _use_home(name: str, *, register: bool, enrollment_code: str | None = None)
     )
 
 
+def _agree_to_tos() -> bool:
+    """Every registration is a fresh agreement, whoever is at the keyboard --
+    and starting one forgets the old agreement, so backing out here means
+    the next login asks too."""
+    from remoterf.config.config import _confirm_tos, forget_tos_agreement, remember_tos_agreement
+
+    forget_tos_agreement()
+    if not _confirm_tos("Do you agree to the RemoteRF Terms of Service? [y/N]: ",
+                        "Registration cancelled."):
+        return False
+    remember_tos_agreement()
+    return True
+
+
+def _register_global() -> int:
+    """`remoterf -r global`: straight to a Global account, same agreement as -r."""
+    print_client_banner(_installed_version(), server="")
+    if not _agree_to_tos():
+        return 1
+    return _use_global(register=True, show_banner=False)
+
+
 def _register() -> int:
     """`remoterf -r`: a deployment enrollment code, or a Global account."""
     from remoterf_federation_core import ValidationError
 
     from remoterf.deployment import homes
 
-    from remoterf.config.config import _confirm_tos, forget_tos_agreement, remember_tos_agreement
-
     # The banner opens the session; the target is not known yet, so the shell
     # below must not print it a second time.
     print_client_banner(_installed_version(), server="")
-    # Every registration is a fresh agreement, whoever is at the keyboard --
-    # and starting one forgets the old agreement, so backing out here means
-    # the next login asks too.
-    forget_tos_agreement()
-    if not _confirm_tos("Do you agree to the RemoteRF Terms of Service? [y/N]: ",
-                        "Registration cancelled."):
+    if not _agree_to_tos():
         return 1
-    remember_tos_agreement()
     try:
         entered = input('Enrollment code (Enter for a RemoteRF Global account): ').strip()
     except (EOFError, KeyboardInterrupt):
@@ -434,8 +448,8 @@ def main() -> int:
         return 0
 
     if argv[0] in ("--register", "-register", "-r"):
-        if len(argv) == 2 and argv[1] == "global":
-            return _use_global(register=True)
+        if len(argv) == 2 and argv[1].lstrip("-") == "global":
+            return _register_global()
         if len(argv) > 1:
             print("ERROR: --register takes no arguments (or 'global')")
             return 2

{remoterf-2.2.0 → remoterf-2.2.1/src/remoterf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.2.0
+Version: 2.2.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.2.0 → remoterf-2.2.1}/tests/test_cli_login_fresh.py

@@ -52,3 +52,31 @@ def test_register_without_a_code_makes_a_global_account(monkeypatch):
         assert remoterf_cli._register() == 0
     use_global.assert_called_once_with(register=True, show_banner=False)
     shell.assert_not_called()
+
+
+def test_register_global_asks_for_the_tos_like_register(monkeypatch):
+    from remoterf import remoterf_cli
+
+    for arg in ("global", "-global"):
+        monkeypatch.setattr("sys.argv", ["remoterf", "-r", arg])
+        with mock.patch("remoterf.config.config._confirm_tos", return_value=True) as confirm, \
+                mock.patch("remoterf.config.config.forget_tos_agreement") as forget, \
+                mock.patch("remoterf.config.config.remember_tos_agreement") as remember, \
+                mock.patch.object(remoterf_cli, "print_client_banner"), \
+                mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global:
+            assert remoterf_cli.main() == 0
+        forget.assert_called_once_with()
+        confirm.assert_called_once()
+        remember.assert_called_once_with()
+        use_global.assert_called_once_with(register=True, show_banner=False)
+
+    # Declining stops before any account is made.
+    monkeypatch.setattr("sys.argv", ["remoterf", "-r", "global"])
+    with mock.patch("remoterf.config.config._confirm_tos", return_value=False), \
+            mock.patch("remoterf.config.config.forget_tos_agreement"), \
+            mock.patch("remoterf.config.config.remember_tos_agreement") as remember, \
+            mock.patch.object(remoterf_cli, "print_client_banner"), \
+            mock.patch.object(remoterf_cli, "_use_global") as use_global:
+        assert remoterf_cli.main() == 1
+    remember.assert_not_called()
+    use_global.assert_not_called()

{remoterf-2.2.0 → remoterf-2.2.1}/tests/test_gate_i_direct_path.py

@@ -248,6 +248,20 @@ class RoutingTests(unittest.TestCase):
         self.assertEqual(unmap_arg(seen[0][1]["wire"]), "c64")
         self.assertEqual(unmap_arg(seen[3][1]["wire"]), "i16")
 
+    def test_rx_through_a_home_asks_for_i16_too(self):
+        # A Global handle's rx goes through the HOME relay, which caps a response
+        # at ~768 KiB: complex128 samples overflow it four times sooner.
+        from remoterf.core import grpc_client
+
+        seen = []
+        with mock.patch.object(grpc_client, "_federated_ref", return_value="dep:103"), \
+                mock.patch.object(grpc_client, "_federated_call",
+                                  side_effect=lambda ref, name, args: seen.append(dict(args)) or grpc_pb2.GenericRPCResponse()), \
+                mock.patch.dict("os.environ"):
+            os.environ.pop("REMOTERF_RX_WIRE", None)
+            grpc_client.rpc_client(function_name="adalm_pluto:rx:CALL0", args={"a": map_arg("dep:103")})
+        self.assertEqual(unmap_arg(seen[0]["wire"]), "i16")
+
     def test_a_path_that_is_not_ready_is_skipped(self):
         from remoterf.core.grpc_client import rpc_client
 
@@ -482,3 +496,21 @@ class QuietHandlerTests(unittest.TestCase):
         finally:
             loop.close()
         self.assertEqual([type(c["exception"]) for c in seen], [ValueError])
+
+
+class BrokenQuicStackTests(unittest.TestCase):
+    def test_a_broken_pyopenssl_turns_the_direct_path_off_not_the_client(self):
+        # conda can swap in a cryptography the pip-installed pyOpenSSL (aioquic's) cannot use.
+        import subprocess
+        import sys
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / "OpenSSL").mkdir()
+            (Path(tmp) / "OpenSSL" / "__init__.py").write_text("raise AttributeError(\"module 'lib' has no attribute 'GEN_EMAIL'\")\n")
+            probe = ("from remoterf.core import direct_path, grpc_client; "
+                     "print(direct_path.enabled(), direct_path.current(), direct_path.describe())")
+            result = subprocess.run([sys.executable, "-c", probe], env={**os.environ, "PYTHONPATH": tmp, "HOME": tmp},
+                                    capture_output=True, text=True, timeout=120, stdin=subprocess.DEVNULL)
+        self.assertTrue(result.stdout.startswith("False None relay (direct path unavailable: AttributeError"), result.stderr[-2000:])
+

{remoterf-2.2.0 → remoterf-2.2.1}/tests/test_homes.py

@@ -315,14 +315,15 @@ def test_register_with_a_code_lands_in_the_home_shell(monkeypatch, reachable):
 
 
 def test_a_blank_code_registers_on_global_and_global_has_its_own_spelling(monkeypatch):
-    answers = iter(["y", ""])
+    answers = iter(["y", "", "y"])
     monkeypatch.setattr("builtins.input", lambda *_: next(answers, ""))
     used_global = mock.Mock(return_value=0)
     assert run_cli(["-r"], monkeypatch, _use_global=used_global) == 0
     used_global.assert_called_once_with(register=True, show_banner=False)  # no lab: the account lives on Global
     used_global.reset_mock()
+    # `-r global` asks for the Terms too, then skips the code prompt.
     assert run_cli(["-r", "global"], monkeypatch, _use_global=used_global) == 0
-    used_global.assert_called_once_with(register=True)
+    used_global.assert_called_once_with(register=True, show_banner=False)
 
 
 def test_declining_the_terms_stops_registration_before_any_code(monkeypatch):