RemoteRF 2.2.3__tar.gz → 2.2.5__tar.gz

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

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

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

@@ -116,7 +116,7 @@ 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.
+# A username already given (`name@lab` at `-l`): 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
@@ -209,6 +209,9 @@ def _account_command(command):
             account.email = _ask('Email') if policy['email_required'] else ''
             if not account.create_user():
                 raise AccountBackendError('Registration failed')
+            if account.is_https_home:
+                from ..deployment import homes
+                printf(f"Log in from anywhere as {account.username}@{homes.GLOBAL_ACCOUNTS}", Sty.GRAY)
         except BaseException:
             # The code was fine; only the details failed. Keep it for the retry.
             pending_enrollment_code = account.enrollment_code or None
@@ -252,8 +255,13 @@ def _account_command(command):
     if command in ('l', 'login'):
         printf(f"Login to {_home_name()}", (Sty.BOLD, Sty.BLUE))
         global pending_username
-        account.username = pending_username or _ask('Username or Email' if account.is_https_home else 'Username')
+        from ..deployment import homes
+        typed = pending_username or _ask('Username or Email' if account.is_https_home else 'Username')
         pending_username = None
+        # `alice@ucla` typed at ucla is `alice` there.
+        name, where = homes.split_account(typed)
+        here = homes.GLOBAL_ACCOUNTS if account.is_https_home else home_name
+        account.username = name if where == here else typed
         account.password = _ask('Password (Hidden)', hidden=True)
         ok = bool(account.login_user(remember=not account.is_https_home))
         if ok:
@@ -1620,9 +1628,12 @@ def run(backend=None, *, register=False, enrollment_code=None, server_label=None
         # Continue below the banner rather than wiping the screen: with a
         # stored login the wipe came a split second after everything appeared.
         session_line()
+        from ..deployment import homes
+        # The prompt is the account's full name: alice@ucla, alice@global.
+        where = homes.GLOBAL_ACCOUNTS if account.is_https_home else (home_name or 'remoterf')
         while True:
             try:
-                inpu = session.prompt(stylize(f'{account.username}@remoterf: ', Sty.BOLD))
+                inpu = session.prompt(stylize(f'{account.username}@{where}: ', Sty.BOLD))
                 if inpu in ('register', 'verify', 'login', 'forgot-password', 'reset-password'):
                     authenticated = _account_command(inpu)
                     if inpu == 'reset-password' and not welcome(show_banner=False):

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

@@ -268,25 +268,18 @@ 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()
+# An account is `name@<deployment>`; Global's own accounts are `name@global`.
+GLOBAL_ACCOUNTS = "global"
+
+
+def split_account(text: str) -> tuple[str, str | None]:
+    """`alice@ucla` -> ("alice", "ucla"). A bare name, or an email (a dot
+    after the @; deployment names never have one), names no deployment."""
+    text = text.strip()
+    name, at, where = text.rpartition("@")
+    if not at or not name or not where or "." in where:
+        return text, None
+    return name, where.lower()
 
 
 def register_home(host: str) -> tuple[str, dict, dict]:

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

@@ -150,7 +150,7 @@ def print_help() -> None:
     printf("  remoterf -h | --help", Sty.CYAN, "              Show this help", Sty.DEFAULT)
     print()
     printf("Commands:", (Sty.BOLD, Sty.MAGENTA))
-    printf("  remoterf -l | --login [target]", Sty.CYAN, "    Login: last used, 'global', or a home name", Sty.DEFAULT)
+    printf("  remoterf -l | --login [target]", Sty.CYAN, "    Login: last used, 'global', a home name, or an account (username@lab)", Sty.DEFAULT)
     printf("  remoterf -r | --register [global]", Sty.CYAN, " Register with an enrollment code (or a RemoteRF Global account)", Sty.DEFAULT)
     printf("  remoterf homes", Sty.CYAN, "                    List saved deployment homes", Sty.DEFAULT)
     printf("  remoterf -v | --version", Sty.CYAN, "           Print version", Sty.DEFAULT)
@@ -171,6 +171,7 @@ def print_help() -> None:
     printf("  remoterf --login", Sty.GREEN)
     printf("  remoterf --login ucla", Sty.GREEN)
     printf("  remoterf --login global", Sty.GREEN)
+    printf("  remoterf --login jdoe@ucla", Sty.GREEN)
     printf("  remoterf homes", Sty.GREEN)
     printf("  remoterf --version", Sty.GREEN)
     printf("  remoterf --config --addr 203.0.113.10:12321", Sty.GREEN)
@@ -295,7 +296,8 @@ def _reason(exc: BaseException) -> str:
     return str(exc)
 
 
-def _use_home(name: str, *, register: bool, enrollment_code: str | None = None) -> int:
+def _use_home(name: str, *, register: bool, enrollment_code: str | None = None,
+              username: str | None = None) -> int:
     from remoterf.deployment import homes
 
     try:
@@ -311,6 +313,7 @@ def _use_home(name: str, *, register: bool, enrollment_code: str | None = None)
         server_label=f'{name} ({_route_label(route)})',
         home=name,
         route={**route, 'home': home},
+        username=username,
     )
 
 
@@ -384,6 +387,8 @@ def _login(target: str | None) -> int:
     if not require_tos_for_login():
         return 1
     homes.migrate_legacy_target()
+    if target is not None and '@' in target:
+        return _login_as(target)
     if target is None:
         last = homes.last_target()
         saved = sorted(homes.homes())
@@ -412,30 +417,28 @@ def _login(target: str | None) -> int:
 
 
 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
-
+    """A fresh install: an account says where it lives (`alice@ucla`), so
+    asking for it is enough. Enter registers, as `-l` here always did."""
     try:
-        name = input('Username (Enter to register): ').strip()
+        name = input('Account (username@lab, 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 _login_as(name)
+
+
+def _login_as(account: str) -> int:
+    """Log in to `name@lab` at that lab; a bare name or an email is Global."""
+    from remoterf.deployment import homes
+
+    name, lab = homes.split_account(account)
+    if lab is None or lab == homes.GLOBAL_ACCOUNTS:
         return _use_global(register=False, username=name)
-    host = f'{deployment}.{homes.GLOBAL_DOMAIN}'
+    if lab in homes.homes():
+        return _use_home(lab, register=False, username=name)
+    host = f'{lab}.{homes.GLOBAL_DOMAIN}'
     try:
         with _working(f"Looking up {host}…"):
             lab, home, route = homes.register_home(host)

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

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

@@ -19,63 +19,88 @@ def test_login_on_a_fresh_install_registers_on_enter():
     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():
+def test_an_account_name_says_where_it_lives():
+    from remoterf.deployment.homes import split_account
+
+    assert split_account(" jdoe@ucla ") == ("jdoe", "ucla")
+    assert split_account("JDoe@UCLA") == ("JDoe", "ucla")
+    assert split_account("jdoe@global") == ("jdoe", "global")
+    assert split_account("jdoe") == ("jdoe", None)
+    assert split_account("jdoe@ucla.edu") == ("jdoe@ucla.edu", None)  # an email
+    assert split_account("a@b@ucla") == ("a@b", "ucla")
+    assert split_account("@ucla") == ("@ucla", None)
+    assert split_account("jdoe@") == ("jdoe@", None)
+
+
+def test_login_on_a_fresh_install_goes_to_the_lab_in_the_account_name():
     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("builtins.input", return_value="jdoe@ucla"), \
             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"
+    assert shell.call_args.kwargs["username"] == "jdoe"
 
 
-def test_login_on_a_fresh_install_finds_a_global_account():
+def test_login_on_a_fresh_install_global_bare_names_and_emails_go_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("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")
+    for typed, username in (("jdoe@global", "jdoe"), ("jdoe", "jdoe"), ("jdoe@ucla.edu", "jdoe@ucla.edu")):
+        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=typed), \
+                mock.patch("remoterf.deployment.homes.register_home") as register_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=username)
+        register_home.assert_not_called()
 
 
-def test_login_on_a_fresh_install_with_an_unknown_username():
+def test_login_to_a_lab_that_does_not_answer():
     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("builtins.input", return_value="jdoe@nolab"), \
+            mock.patch("remoterf.deployment.homes.register_home",
+                       side_effect=RuntimeError("no such deployment")) as register_home, \
             mock.patch.object(remoterf_cli, "_account_shell") as shell:
         assert remoterf_cli._login(None) == 2
-    register.assert_not_called()
+    register_home.assert_called_once_with("nolab.global.remoterf.net")
     shell.assert_not_called()
 
 
+def test_login_with_an_account_uses_the_saved_home():
+    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("remoterf.deployment.homes.homes", return_value={"ucla": {}}), \
+            mock.patch("remoterf.deployment.homes.register_home") as register_home, \
+            mock.patch.object(remoterf_cli, "_use_home", return_value=0) as use_home:
+        assert remoterf_cli._login("jdoe@ucla") == 0
+    use_home.assert_called_once_with("ucla", register=False, username="jdoe")
+    register_home.assert_not_called()
+
+
 def test_login_global_on_a_fresh_install_logs_in_to_global():
     from remoterf import remoterf_cli
 
@@ -144,19 +169,35 @@ def test_register_global_asks_for_the_tos_like_register(monkeypatch):
     use_global.assert_not_called()
 
 
-def test_a_found_username_is_not_asked_again():
+def _login_at(home, typed, *, https=False, pending=None):
     from remoterf.core import app
 
-    account = mock.Mock(is_https_home=False, backend=None)
+    account = mock.Mock(is_https_home=https, 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, "home_name", home), \
+            mock.patch.object(app, "pending_username", pending), \
             mock.patch.object(app, "local_capabilities",
                               return_value={"registration_policy": {}}), \
-            mock.patch.object(app, "_home_name", return_value="ucla"), \
+            mock.patch.object(app, "_home_name", return_value=home), \
             mock.patch.object(app, "_remember_login"), \
-            mock.patch.object(app, "_ask", return_value="secret") as ask:
+            mock.patch.object(app, "_ask", side_effect=[typed, "secret"] if typed else ["secret"]) as ask:
+        if https:
+            account.backend = mock.Mock(capabilities={"registration_policy": {}})
         assert app._account_command("login") is True
         assert app.pending_username is None
-    assert account.username == "ian"
+    return account.username, ask
+
+
+def test_a_found_username_is_not_asked_again():
+    username, ask = _login_at("ucla", None, pending="jdoe")
+    assert username == "jdoe"
     ask.assert_called_once_with("Password (Hidden)", hidden=True)
+
+
+def test_the_full_account_name_works_at_its_own_home_only():
+    assert _login_at("ucla", "jdoe@ucla")[0] == "jdoe"
+    assert _login_at("ucla", "jdoe")[0] == "jdoe"
+    assert _login_at("otheruni", "jdoe@ucla")[0] == "jdoe@ucla"  # not this lab's: no such name here
+    assert _login_at(None, "jdoe@global", https=True)[0] == "jdoe"
+    assert _login_at(None, "jdoe@ucla.edu", https=True)[0] == "jdoe@ucla.edu"  # an email

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

@@ -444,7 +444,7 @@ def test_every_command_after_login_goes_native_to_the_home(reachable, monkeypatc
         return response
 
     monkeypatch.setattr(grpc_acc, "rpc_client", rpc_client)
-    account = grpc_acc.RemoteRFAccount("ethan", "secret")
+    account = grpc_acc.RemoteRFAccount("jdoe", "secret")
     # A deployment-native account is not an HTTPS home: no Global in the path.
     assert not account.is_https_home
 
@@ -466,7 +466,7 @@ def test_every_command_after_login_goes_native_to_the_home(reachable, monkeypatc
     assert token == "reservation-token"
     # Credentials go to the HOME itself, never through any broker.
     for _, args in sent:
-        assert args["un"].string_value == "ethan"
+        assert args["un"].string_value == "jdoe"
 
     # And the transport those calls ride is this HOME's own direct channel.
     monkeypatch.setattr("grpc.secure_channel", lambda *a, **k: mock.Mock())
@@ -626,7 +626,7 @@ def test_reserve_shows_the_token_even_when_the_driver_fetch_fails(monkeypatch, c
 
     monkeypatch.setattr(grpc_acc, "rpc_client", rpc_client)
     monkeypatch.setattr("remoterf.drivers.dynamic_device.install_driver", install_driver)
-    account = grpc_acc.RemoteRFAccount("ethan", "secret")
+    account = grpc_acc.RemoteRFAccount("jdoe", "secret")
     now = datetime.datetime.now()
 
     assert account.reserve_device(0, now, now + datetime.timedelta(hours=1)) == "reservation-token"