RemoteRF 2.2.1__tar.gz → 2.2.3__tar.gz

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

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

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

@@ -14,7 +14,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 def main(*, register=False, enrollment_code=None, server_label=None, show_banner=True,
-         home=None, route=None):
+         home=None, route=None, username=None):
     from .app import run
     return run(
         register=register,
@@ -23,4 +23,5 @@ def main(*, register=False, enrollment_code=None, server_label=None, show_banner
         show_banner=show_banner,
         home=home,
         route=route,
+        username=username,
     )

{remoterf-2.2.1 → remoterf-2.2.3}/src/remoterf/core/app.py

@@ -116,6 +116,8 @@ def _password_confirmation(*, enforce_policy=False):
 
 # The code typed at `remoterf -r`, used once for this registration.
 pending_enrollment_code = None
+# A username already given (found on Global): the login asks only the password.
+pending_username = None
 # The saved home this shell is attached to (None on a bare direct profile).
 home_name = None
 # The route it was reached over (None on a bare direct profile or an HTTPS home).
@@ -249,7 +251,9 @@ def _account_command(command):
         return False
     if command in ('l', 'login'):
         printf(f"Login to {_home_name()}", (Sty.BOLD, Sty.BLUE))
-        account.username = _ask('Username or Email' if account.is_https_home else 'Username')
+        global pending_username
+        account.username = pending_username or _ask('Username or Email' if account.is_https_home else 'Username')
+        pending_username = None
         account.password = _ask('Password (Hidden)', hidden=True)
         ok = bool(account.login_user(remember=not account.is_https_home))
         if ok:
@@ -1585,8 +1589,9 @@ def interactive_reserve_next_days_auto():
 
 
 def run(backend=None, *, register=False, enrollment_code=None, server_label=None,
-        show_banner=True, home=None, route=None):
-    global account, session, server_addr, pending_enrollment_code, home_name, current_route
+        show_banner=True, home=None, route=None, username=None):
+    global account, session, server_addr, pending_enrollment_code, home_name, current_route, pending_username
+    pending_username = username
     home_name = home
     current_route = route
     from ..deployment.backend import selected_backend

{remoterf-2.2.1 → remoterf-2.2.3}/src/remoterf/deployment/homes.py

@@ -268,6 +268,27 @@ def connect(name: str) -> dict:
     return route
 
 
+# Global's own account home, by its name on Global's broker.
+GLOBAL_HOME = "home"
+
+
+def lookup_username(global_origin: str, username: str) -> str | None:
+    """The deployment that holds this username on Global, or None."""
+    from .http import AccountBackendError, JsonTransport
+
+    transport = JsonTransport(global_origin)
+    try:
+        return transport.request(
+            "POST", "/v2/broker/usernames/lookup", data={"username": username}
+        )["deployment"]
+    except AccountBackendError as exc:
+        if exc.code == "not_found":
+            return None
+        raise
+    finally:
+        transport.close()
+
+
 def register_home(host: str) -> tuple[str, dict, dict]:
     """Learn a deployment from its code, save it, and connect to it."""
     document = discover(host)

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

@@ -180,7 +180,8 @@ def print_help() -> None:
 
 def _account_shell(*, register: bool, enrollment_code: str | None = None,
                    server_label: str | None = None, show_banner: bool = True,
-                   home: str | None = None, route: dict | None = None) -> int:
+                   home: str | None = None, route: dict | None = None,
+                   username: str | None = None) -> int:
     ok, _ = _ensure_config_present()
     if not ok:
         _print_server_unavailable()
@@ -198,6 +199,7 @@ def _account_shell(*, register: bool, enrollment_code: str | None = None,
                 show_banner=show_banner,
                 home=home,
                 route=route,
+                username=username,
             )
             or 0
         )
@@ -212,7 +214,7 @@ def _global_origin() -> str:
     return os.getenv('REMOTERF_GLOBAL_ORIGIN', 'https://global.remoterf.net')
 
 
-def _use_global(*, register: bool, show_banner: bool = True) -> int:
+def _use_global(*, register: bool, show_banner: bool = True, username: str | None = None) -> int:
     """Register or log in with the RemoteRF Global identity itself.
 
     A Global-native account is complete on its own: it needs no deployment
@@ -238,7 +240,7 @@ def _use_global(*, register: bool, show_banner: bool = True) -> int:
     except (RuntimeError, ValueError) as exc:
         print(f'Could not reach RemoteRF Global: {exc}')
         return 2
-    return _account_shell(register=register, show_banner=show_banner)
+    return _account_shell(register=register, show_banner=show_banner, username=username)
 
 
 @contextmanager
@@ -397,13 +399,11 @@ def _login(target: str | None) -> int:
             # Nothing saved. A legacy address in .env still logs in there;
             # a fresh install has nothing to log in to, so `-l` is `-r`.
             if not _ensure_config_present()[0]:
-                return _register()
+                return _login_by_username()
             return _account_shell(register=False)
     if target == 'global':
-        if not homes.has_global_account():
-            printf('No RemoteRF Global account is configured here.', Sty.WARNING)
-            printf('Run: ', Sty.GRAY, 'remoterf --register', Sty.CYAN)
-            return 2
+        # Global's address is built in, so a fresh install can log in to an
+        # existing Global account without registering again.
         return _use_global(register=False)
     if target not in homes.homes():
         printf(f'No saved home named {target!r}.', Sty.WARNING)
@@ -411,6 +411,43 @@ def _login(target: str | None) -> int:
     return _use_home(target, register=False)
 
 
+def _login_by_username() -> int:
+    """A fresh install: Global knows which lab holds a username, so the
+    account is found by name. Enter registers, as `-l` here always did."""
+    from remoterf.deployment import homes
+
+    try:
+        name = input('Username (Enter to register): ').strip()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return 1
+    if not name:
+        return _register()
+    try:
+        with _working("Looking up your account…"):
+            deployment = homes.lookup_username(_global_origin(), name)
+    except (RuntimeError, ValueError) as exc:
+        printf(f'Could not reach RemoteRF Global: {_reason(exc)}', Sty.WARNING)
+        return 2
+    if deployment is None:
+        printf(f'No RemoteRF account named {name!r} was found.', Sty.WARNING)
+        printf('Run: ', Sty.GRAY, 'remoterf --register', Sty.CYAN)
+        return 2
+    if deployment == homes.GLOBAL_HOME:
+        return _use_global(register=False, username=name)
+    host = f'{deployment}.{homes.GLOBAL_DOMAIN}'
+    try:
+        with _working(f"Looking up {host}…"):
+            lab, home, route = homes.register_home(host)
+    except (RuntimeError, ValueError) as exc:
+        printf(f'Could not reach {host}: {_reason(exc)}', Sty.WARNING)
+        return 2
+    return _account_shell(
+        register=False, server_label=f'{lab} ({_route_label(route)})',
+        home=lab, route={**route, 'home': home}, username=name,
+    )
+
+
 def _print_pick_a_target() -> int:
     _print_homes()
     printf('Choose one: ', Sty.GRAY, 'remoterf --login <name>', Sty.CYAN)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.2.1
+Version: 2.2.3
 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.3/tests/test_cli_login_fresh.py

@@ -0,0 +1,162 @@
+"""`remoterf -l` on a fresh install is `remoterf -r`; a configured client logs in."""
+
+import os
+import tempfile
+from unittest import mock
+
+
+def _fresh_home():
+    tmp = tempfile.TemporaryDirectory()
+    env = {k: v for k, v in os.environ.items() if not k.startswith("REMOTERF_")}
+    env["HOME"] = tmp.name
+    return tmp, mock.patch.dict(os.environ, env, clear=True)
+
+
+def test_login_on_a_fresh_install_registers_on_enter():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch("builtins.input", return_value=""), \
+            mock.patch("remoterf.deployment.homes.lookup_username") as lookup, \
+            mock.patch.object(remoterf_cli, "_register", return_value=0) as register, \
+            mock.patch.object(remoterf_cli, "_account_shell") as shell:
+        assert remoterf_cli._login(None) == 0
+    register.assert_called_once_with()
+    shell.assert_not_called()
+    lookup.assert_not_called()
+
+
+def test_login_on_a_fresh_install_finds_the_account_by_username():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    route = {"kind": "relay", "host": "ucla.global.remoterf.net", "port": 12321}
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch("builtins.input", return_value="ian"), \
+            mock.patch("remoterf.deployment.homes.lookup_username", return_value="ucla") as lookup, \
+            mock.patch("remoterf.deployment.homes.register_home",
+                       return_value=("ucla", {"display_name": "UCLA"}, route)) as register_home, \
+            mock.patch.object(remoterf_cli, "_account_shell", return_value=0) as shell:
+        assert remoterf_cli._login(None) == 0
+    assert lookup.call_args.args[1] == "ian"
+    register_home.assert_called_once_with("ucla.global.remoterf.net")
+    assert shell.call_args.kwargs["register"] is False
+    assert shell.call_args.kwargs["home"] == "ucla"
+    assert shell.call_args.kwargs["username"] == "ian"
+
+
+def test_login_on_a_fresh_install_finds_a_global_account():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch("builtins.input", return_value="ian"), \
+            mock.patch("remoterf.deployment.homes.lookup_username", return_value="home"), \
+            mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global:
+        assert remoterf_cli._login(None) == 0
+    use_global.assert_called_once_with(register=False, username="ian")
+
+
+def test_login_on_a_fresh_install_with_an_unknown_username():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch("builtins.input", return_value="nobody"), \
+            mock.patch("remoterf.deployment.homes.lookup_username", return_value=None), \
+            mock.patch.object(remoterf_cli, "_register") as register, \
+            mock.patch.object(remoterf_cli, "_account_shell") as shell:
+        assert remoterf_cli._login(None) == 2
+    register.assert_not_called()
+    shell.assert_not_called()
+
+
+def test_login_global_on_a_fresh_install_logs_in_to_global():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global:
+        assert remoterf_cli._login("global") == 0
+    use_global.assert_called_once_with(register=False)
+
+
+def test_login_with_a_legacy_address_still_logs_in_there():
+    from remoterf import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
+            mock.patch.object(remoterf_cli, "_ensure_config_present", return_value=(True, "")), \
+            mock.patch.object(remoterf_cli, "_register") as register, \
+            mock.patch.object(remoterf_cli, "_account_shell", return_value=0) as shell:
+        assert remoterf_cli._login(None) == 0
+    shell.assert_called_once_with(register=False)
+    register.assert_not_called()
+
+
+def test_register_without_a_code_makes_a_global_account(monkeypatch):
+    from remoterf import remoterf_cli
+
+    monkeypatch.setattr("builtins.input", lambda prompt="": "")
+    with mock.patch("remoterf.config.config._confirm_tos", return_value=True), \
+            mock.patch("remoterf.config.config.forget_tos_agreement"), \
+            mock.patch("remoterf.config.config.remember_tos_agreement"), \
+            mock.patch.object(remoterf_cli, "print_client_banner"), \
+            mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global, \
+            mock.patch.object(remoterf_cli, "_account_shell") as shell:
+        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()
+
+
+def test_a_found_username_is_not_asked_again():
+    from remoterf.core import app
+
+    account = mock.Mock(is_https_home=False, backend=None)
+    account.login_user.return_value = True
+    with mock.patch.object(app, "account", account), \
+            mock.patch.object(app, "pending_username", "ian"), \
+            mock.patch.object(app, "local_capabilities",
+                              return_value={"registration_policy": {}}), \
+            mock.patch.object(app, "_home_name", return_value="ucla"), \
+            mock.patch.object(app, "_remember_login"), \
+            mock.patch.object(app, "_ask", return_value="secret") as ask:
+        assert app._account_command("login") is True
+        assert app.pending_username is None
+    assert account.username == "ian"
+    ask.assert_called_once_with("Password (Hidden)", hidden=True)

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

@@ -366,13 +366,8 @@ def test_login_names_a_home_explicitly(monkeypatch, reachable):
     assert run_cli(["-l", "nope"], monkeypatch, _account_shell=shell) == 2
 
 
-def test_login_global_requires_a_global_account(monkeypatch):
+def test_login_global_works_without_a_saved_global_account(monkeypatch):
     homes.save_home("ucla", document())
-    assert run_cli(["-l", "global"], monkeypatch, _account_shell=mock.Mock()) == 2
-
-    homes.remember_global_account(
-        "https://global.remoterf.net", "897541e5-b61f-45f7-a814-8ffeaad2ae69"
-    )
     used_global = mock.Mock(return_value=0)
     assert run_cli(["-l", "global"], monkeypatch, _use_global=used_global) == 0
     used_global.assert_called_once_with(register=False)

remoterf-2.2.1/tests/test_cli_login_fresh.py

@@ -1,82 +0,0 @@
-"""`remoterf -l` on a fresh install is `remoterf -r`; a configured client logs in."""
-
-import os
-import tempfile
-from unittest import mock
-
-
-def _fresh_home():
-    tmp = tempfile.TemporaryDirectory()
-    env = {k: v for k, v in os.environ.items() if not k.startswith("REMOTERF_")}
-    env["HOME"] = tmp.name
-    return tmp, mock.patch.dict(os.environ, env, clear=True)
-
-
-def test_login_on_a_fresh_install_registers():
-    from remoterf import remoterf_cli
-
-    tmp, env = _fresh_home()
-    with tmp, env, \
-            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
-            mock.patch.object(remoterf_cli, "_register", return_value=0) as register, \
-            mock.patch.object(remoterf_cli, "_account_shell") as shell:
-        assert remoterf_cli._login(None) == 0
-    register.assert_called_once_with()
-    shell.assert_not_called()
-
-
-def test_login_with_a_legacy_address_still_logs_in_there():
-    from remoterf import remoterf_cli
-
-    tmp, env = _fresh_home()
-    with tmp, env, \
-            mock.patch("remoterf.config.config.require_tos_for_login", return_value=True), \
-            mock.patch.object(remoterf_cli, "_ensure_config_present", return_value=(True, "")), \
-            mock.patch.object(remoterf_cli, "_register") as register, \
-            mock.patch.object(remoterf_cli, "_account_shell", return_value=0) as shell:
-        assert remoterf_cli._login(None) == 0
-    shell.assert_called_once_with(register=False)
-    register.assert_not_called()
-
-
-def test_register_without_a_code_makes_a_global_account(monkeypatch):
-    from remoterf import remoterf_cli
-
-    monkeypatch.setattr("builtins.input", lambda prompt="": "")
-    with mock.patch("remoterf.config.config._confirm_tos", return_value=True), \
-            mock.patch("remoterf.config.config.forget_tos_agreement"), \
-            mock.patch("remoterf.config.config.remember_tos_agreement"), \
-            mock.patch.object(remoterf_cli, "print_client_banner"), \
-            mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global, \
-            mock.patch.object(remoterf_cli, "_account_shell") as shell:
-        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()