RemoteRF 2.1.0__tar.gz → 2.1.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.0
+Version: 2.1.9
 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.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.1.0"
+version = "2.1.9"
 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.9}/src/remoteRF/core/app.py

@@ -230,8 +230,8 @@ def _account_command(command):
             # out of quota); there is no token coming. Straight on to login.
             return False
         printf("Verify your email", (Sty.BOLD, Sty.BLUE))
-        printf("  Paste the token from the verification email.", Sty.GRAY)
-        account.backend.verify(_ask('Verification token', hidden=True))
+        printf("  Enter the 6-digit code from the verification email.", Sty.GRAY)
+        account.backend.verify(account.username or account.email, _ask('Verification code').strip())
         printf('Email verified. You can now log in.', (Sty.BOLD, Sty.GREEN))
         return False
     if command in ('forgot-password', 'reset-password'):
@@ -349,7 +349,8 @@ def commands():
     printf("'cancelres' ", Sty.MAGENTA, "     : ", Sty.GRAY, "Cancel a reservation", Sty.DEFAULT)
     printf("'getres' ", Sty.MAGENTA, "        : ", Sty.GRAY, "View all reservations", Sty.DEFAULT)
     printf("'myres' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View my reservations", Sty.DEFAULT)
-    printf("'perms' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View permissions", Sty.DEFAULT)
+    if not account.is_https_home:
+        printf("'perms' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View permissions", Sty.DEFAULT)
     printf("'enroll' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Enroll with an enrollment code", Sty.DEFAULT)
     printf("'logout' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Log out and forget the stored login", Sty.DEFAULT)
     printf("'status' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Connection and the path device calls use", Sty.DEFAULT)
@@ -538,6 +539,8 @@ def _federated_reserve_slot(device_id, chosen_day, chosen_slot, slot_start_str,
     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)
+    account.install_reserved_driver(handle, device_id)
 
 
 def _federated_reserve():
@@ -581,7 +584,8 @@ def _federated_reserve():
         )
         return
     _pick_slot_and_reserve(dev["device_id"], dev["display_name"], dev["block_min"], _federated_reservations_for_range, _federated_reserve_slot,
-                           device_label=f"{dev['display_name']} @{dev['deployment_name']}")
+                           device_label=f"{dev['display_name']} @{dev['deployment_name']}",
+                           max_days=-(-int(dev.get("max_horizon_sec") or 0) // 86400) or None)
 
 
 def reservations():
@@ -841,6 +845,7 @@ def reserve():
         if token != '':
             printf(f"Reservation successful. Your Token -> ", Sty.BOLD, f"{token}", Sty.BG_GREEN)
             printf(f"Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one. ", Sty.DEFAULT)
+            account.install_reserved_driver(token, rows[int(pick) - 1]["id"])
     except Exception as e:
         printf(f"Error: {e}", Sty.BRIGHT_RED)
 
@@ -985,7 +990,7 @@ def perms():
         printf("Accessible Devices: ", (Sty.BOLD, Sty.BLUE), f"{devices}", Sty.MAGENTA)
 
         # Build per-device caps and group identical limits together
-        buckets: dict[tuple[int, int], list[int]] = {}  # (max_r, max_t_sec) -> [dev_ids]
+        buckets: dict[tuple[int, int, int], list[int]] = {}  # (max_r, max_t_sec, horizon_sec) -> [dev_ids]
         for d in devices:
             try:
                 did = int(d)
@@ -994,7 +999,8 @@ def perms():
             c = _cap_for(did)
             max_t = int(c.get("max_reservation_time_sec", 0) or 0)
             max_r = int(c.get("max_reservations", 0) or 0)
-            buckets.setdefault((max_r, max_t), []).append(did)
+            max_h = int(c.get("max_horizon_sec", 0) or 0)
+            buckets.setdefault((max_r, max_t, max_h), []).append(did)
 
         if not buckets:
             print("Limits per device: (none)")
@@ -1003,16 +1009,17 @@ def perms():
 
         # If everything shares the same limits, print once
         if len(buckets) == 1:
-            (max_r, max_t), _devs = next(iter(buckets.items()))
+            (max_r, max_t, max_h), _devs = next(iter(buckets.items()))
             printf("Permissions:", (Sty.BOLD, Sty.BLUE))
             printf("  Max Reservations: ", Sty.GRAY, f"{max_r}", Sty.CYAN)
             printf("  Reservation Duration (min): ", Sty.GRAY, f"{max_t // 60}", Sty.CYAN)
+            printf("  Days Ahead: ", Sty.GRAY, f"{max_h / 86400:g}" if max_h else "no limit", Sty.CYAN)
             render_remote_permissions()
             return
 
         # Otherwise print grouped limits
         printf("Permissions per device (grouped):", (Sty.BOLD, Sty.BLUE))
-        for (max_r, max_t), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[1])):
+        for (max_r, max_t, max_h), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[0][2], kv[1])):
             devs = sorted(devs)
 
             # compress ranges like 0-3,5,7-9
@@ -1031,7 +1038,7 @@ def perms():
                 ranges.append(f"{start}-{prev}" if start != prev else f"{start}")
 
             dev_str = ",".join(ranges)
-            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}", Sty.CYAN)
+            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}, days_ahead={f'{max_h / 86400:g}' if max_h else 'no limit'}", Sty.CYAN)
 
         render_remote_permissions()
 
@@ -1278,6 +1285,7 @@ def interactive_reserve_next_days(block_minutes=60):
             printf("Reservation successful on device ", (Sty.BOLD, Sty.GREEN), f"{chosen_device_id}", 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"{token}", (Sty.BOLD, Sty.GREEN))
             printf("Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one.", Sty.DEFAULT)
+            account.install_reserved_driver(token, int(chosen_device_id))
         
     except Exception as e:
         print(f"Error: {e}")
@@ -1306,16 +1314,18 @@ def _auto_block_minutes(max_t_sec: int) -> int:
             break
     return best
 
-def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None):
+def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None, max_days=None):
     """Shared `resdev` slot picker: days -> free slots -> pick -> confirm -> reserve.
     Native and federated homes differ only in how reservations are fetched and
-    how the reservation is made (token vs. HOME handle)."""
+    how the reservation is made (token vs. HOME handle). `max_days` is the
+    group's reservation horizon; the server refuses starts beyond it anyway."""
     device_label = chosen_device_id if device_label is None else device_label
-    num_days_s = session.prompt(stylize("Enter the number of days to check for available reservations (starting today): ", (Sty.BOLD, Sty.GREEN))).strip()
+    limit = f" (up to {max_days})" if max_days else ""
+    num_days_s = session.prompt(stylize(f"Enter the number of days to check for available reservations (starting today){limit}: ", (Sty.BOLD, Sty.GREEN))).strip()
     try:
         num_days = int(num_days_s)
-        if num_days <= 0:
-            print("Invalid number of days.")
+        if num_days <= 0 or (max_days and num_days > max_days):
+            print("Invalid number of days." if num_days <= 0 else f"Your group may reserve at most {max_days} days ahead.")
             return
     except ValueError:
         print("Invalid input. Please enter a number.")
@@ -1419,6 +1429,7 @@ def _native_reserve_slot(chosen_device_id, chosen_day, chosen_slot, slot_start_s
         printf("Reservation successful on device ", (Sty.BOLD, Sty.GREEN), f"{chosen_device_id}", 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"{token}", (Sty.BOLD, Sty.GREEN))
         printf("Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one.", Sty.DEFAULT)
+        account.install_reserved_driver(token, int(chosen_device_id))
 
 
 def interactive_reserve_next_days_auto():
@@ -1492,7 +1503,10 @@ def interactive_reserve_next_days_auto():
         sorted_device_ids = sorted(dev_resp.results.keys(), key=int)  # strings
 
         if allowed_dev_ids is not None:
-            sorted_device_ids = [d for d in sorted_device_ids if int(d) in allowed_dev_ids]
+            # A partner lab's device is listed only when this account is enrolled
+            # there; it needs no local group (and has no local caps: 30 min blocks).
+            sorted_device_ids = [d for d in sorted_device_ids
+                                 if int(d) in allowed_dev_ids or _PARTNER_LABEL.match(str(unmap_arg(dev_resp.results[d])))]
 
         if not sorted_device_ids:
             printf("No devices available for your permission level.", Sty.WARNING)
@@ -1501,6 +1515,7 @@ def interactive_reserve_next_days_auto():
         printf("Devices:", Sty.BOLD)
         block_by_dev: dict[str, int] = {}
         max_by_dev: dict[str, int] = {}
+        days_by_dev: dict[str, int] = {}
 
         for idx, dev_id in enumerate(sorted_device_ids):
             dev_name = unmap_arg(dev_resp.results[dev_id])
@@ -1510,6 +1525,7 @@ def interactive_reserve_next_days_auto():
                 c = _cap_for(int(dev_id))
                 try:
                     max_t_sec = int(c.get("max_reservation_time_sec", 0) or 0)
+                    days_by_dev[str(dev_id)] = -(-int(c.get("max_horizon_sec", 0) or 0) // 86400)
                 except Exception:
                     max_t_sec = 0
             elif perm_level == "Power User" and power_user_max_t_sec is not None:
@@ -1562,7 +1578,8 @@ def interactive_reserve_next_days_auto():
             )
             return
 
-        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot)
+        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot,
+                               max_days=days_by_dev.get(chosen_device_id) or None)
 
     except Exception as e:
         print(f"Error: {e}")
@@ -1635,7 +1652,7 @@ def run(backend=None, *, register=False, enrollment_code=None, server_label=None
                     devices()
                 elif inpu == "help" or inpu == "h":
                     commands()
-                elif inpu == "perms":
+                elif inpu == "perms" and not account.is_https_home:
                     perms()
                 elif inpu == "enroll":
                     enroll()
@@ -1666,7 +1683,7 @@ def run(backend=None, *, register=False, enrollment_code=None, server_label=None
                     reserve()
                 elif account.is_admin and inpu.strip().startswith("admin"):
                     handle_admin_command(inpu)
-                else:
+                elif inpu.strip():
                     print(f"Unknown command: {inpu}")
             except AccountBackendError as exc:
                 label = f" [{exc.provenance}]" if exc.provenance else ""

{remoterf-2.1.0 → remoterf-2.1.9}/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 or "shielded future" 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.9}/src/remoteRF/core/grpc_acc.py

@@ -20,6 +20,12 @@ from ..common.utils import *
 
 import datetime
 
+def _busy(label):
+    """A spinner while the home asks its labs: a slow lab is a wait, not a hang."""
+    from ..remoterf_cli import _working
+    return _working(label)
+
+
 class RemoteRFAccount:
     def __init__(self, username:str=None, password:str=None, email:str=None, *, backend=None):
         self.username = username
@@ -93,51 +99,58 @@ class RemoteRFAccount:
     
     def reserve_device(self, device_id, start_time:datetime, end_time:datetime):
         if self.is_https_home:
-            reservation = self.backend.reserve(device_id, int(start_time.timestamp()), int(end_time.timestamp()))
-            try:
-                from ..drivers.dynamic_device import install_driver
-                install_driver(device_id=reservation['device_id'])
-            except Exception as e:
-                print(f"Warning: could not install driver for device {reservation['device_id']}: {e}")
+            with _busy("Reserving…"):
+                reservation = self.backend.reserve(device_id, int(start_time.timestamp()), int(end_time.timestamp()))
             # The HOME reference is the driver handle: adi.Pluto("<deployment>:<id>")
             return reservation['device_id']
         username, credential_secret = self._rpc_credentials()
-        response = self._call(function_name="ACC:reserve_device", args={"un":map_arg(username), "pw":map_arg(credential_secret), "dd":map_arg(device_id), "st":map_arg(int(start_time.timestamp())), "et":map_arg(int(end_time.timestamp()))})
+        with _busy("Reserving…"):
+            response = self._call(function_name="ACC:reserve_device", args={"un":map_arg(username), "pw":map_arg(credential_secret), "dd":map_arg(device_id), "st":map_arg(int(start_time.timestamp())), "et":map_arg(int(end_time.timestamp()))})
 
         if 'ace' in response.results:
             raise Exception(f'{unmap_arg(response.results["ace"])}')
         elif 'Token' in response.results:
-            token = unmap_arg(response.results["Token"])
-            try:
-                from ..drivers.dynamic_device import install_driver
-                install_driver(token=token, device_id=device_id)
-            except Exception as e:
-                print(f"Warning: could not install driver for device {device_id}: {e}")
-            return token
+            return unmap_arg(response.results["Token"])
+
+    def install_reserved_driver(self, handle, device_id):
+        """Separate from reserve_device: the token is shown before this network
+        step runs, so a failed or stuck driver fetch cannot lose it."""
+        try:
+            from ..drivers.dynamic_device import install_driver
+            if self.is_https_home:
+                install_driver(device_id=handle)
+            else:
+                install_driver(token=handle, device_id=device_id)
+        except Exception as e:
+            print(f"Warning: could not install driver for device {device_id}: {e}")
             
     def get_reservations(self):
-        if self.is_https_home:
-            return self.backend.reservations()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_res', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for reservations…"):
+            if self.is_https_home:
+                return self.backend.reservations()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_res', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def get_devices(self):
-        if self.is_https_home:
-            return self.backend.devices()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_dev', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for devices…"):
+            if self.is_https_home:
+                return self.backend.devices()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_dev', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def cancel_reservation(self, res_id):
-        if self.is_https_home:
-            return self.backend.cancel(res_id)
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:cancel_res', args={"un":map_arg(username), "pw":map_arg(credential_secret), "res_id":map_arg(res_id)})
+        with _busy("Cancelling…"):
+            if self.is_https_home:
+                return self.backend.cancel(res_id)
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:cancel_res', args={"un":map_arg(username), "pw":map_arg(credential_secret), "res_id":map_arg(res_id)})
     
     def get_perms(self):
-        if self.is_https_home:
-            return self.backend.permissions()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_perms', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for permissions…"):
+            if self.is_https_home:
+                return self.backend.permissions()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_perms', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def logout(self):
         """Revoke the stored session on the deployment (best effort)."""

{remoterf-2.1.0 → remoterf-2.1.9}/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.9}/src/remoteRF/deployment/backend.py

@@ -111,10 +111,10 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
             data={"username": name, "email": email, "password": password},
         )
 
-    def verify(self, token):
+    def verify(self, login, code):
         self._operation("ACC:verify_email")
         return self.transport.request(
-            "POST", self.base + "/verify-email", data={"token": token}
+            "POST", self.base + "/verify-email", data={"login": login, "code": code}
         )
 
     def _validate_session(self, value, expected_subject=None):

{remoterf-2.1.0 → remoterf-2.1.9}/src/remoteRF/deployment/http.py

@@ -73,7 +73,7 @@ class JsonTransport:
                 timeout=timeout,
             ) as response:
                 raw = bytearray()
-                for chunk in response.iter_bytes(chunk_size=1):
+                for chunk in response.iter_bytes(chunk_size=65536):
                     if time.monotonic() >= deadline:
                         raise AccountBackendError("Account operation deadline exceeded")
                     raw.extend(chunk)