remotivelabs-cli 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

cli/cloud/__init__.py

@@ -0,0 +1,17 @@
+from cli.cloud import auth, brokers, configs, organisations, projects, recordings, sample_recordings, service_accounts, storage
+from cli.cloud.licenses.cmd import licenses
+from cli.typer import typer_utils
+
+app = typer_utils.create_typer()
+
+app.command(name="licenses", help="List licenses for an organization")(licenses)
+
+app.add_typer(organisations.app, name="organizations", help="Manage organizations")
+app.add_typer(projects.app, name="projects", help="Manage projects")
+app.add_typer(auth.app, name="auth")
+app.add_typer(brokers.app, name="brokers", help="Manage cloud broker lifecycle")
+app.add_typer(recordings.app, name="recordings", help="Manage recordings")
+app.add_typer(configs.app, name="signal-databases", help="Manage signal databases")
+app.add_typer(storage.app, name="storage")
+app.add_typer(service_accounts.app, name="service-accounts", help="Manage project service account keys")
+app.add_typer(sample_recordings.app, name="samples", help="Manage sample recordings")

cli/cloud/auth/cmd.py

@@ -1,22 +1,25 @@
 from __future__ import annotations
 
-import sys
+import os
 
 import typer
+from rich.console import Console
+from rich.table import Table
 
 from cli.cloud.auth.login import login as do_login
 from cli.errors import ErrorPrinter
-from cli.settings import TokenNotFoundError, settings
+from cli.settings import settings
 from cli.typer import typer_utils
 from cli.utils.rest_helper import RestHelper as Rest
 
 from .. import auth_tokens
 
+console = Console(stderr=False)
+
 HELP = """
 Manage how you authenticate with our cloud platform
 """
 app = typer_utils.create_typer(help=HELP)
-# app.add_typer(auth_tokens.app, name="credentials", help="Manage account credentials")
 
 
 @app.command(name="login")
@@ -36,11 +39,7 @@ def whoami() -> None:
     """
     Validates authentication and fetches your account information
     """
-    try:
-        Rest.handle_get("/api/whoami")
-    except TokenNotFoundError as e:
-        ErrorPrinter.print_hint(str(e))
-        sys.exit(1)
+    Rest.handle_get("/api/whoami")
 
 
 @app.command()
@@ -50,39 +49,78 @@ def print_access_token(
     """
     Print current active access token or the token for the specified account
     """
-    if account is None:
-        try:
-            print(settings.get_active_token())
-        except TokenNotFoundError:
+    if not account:
+        active_token = settings.get_active_token() or os.getenv("REMOTIVE_CLOUD_ACCESS_TOKEN", None)
+        if not active_token:
             ErrorPrinter.print_generic_error("You have no active account", exit_code=1)
-    else:
-        config = settings.get_cli_config()
-        if account in config.accounts:
-            token_file_name = config.accounts[account].credentials_file
-            try:
-                print(settings.get_token_file(token_file_name).token)
-            except TokenNotFoundError:
-                ErrorPrinter.print_generic_error(f"Token file for {account} could not be found", exit_code=1)
-        else:
-            ErrorPrinter.print_generic_error(f"No account for {account} was found", exit_code=1)
+            return
+
+        print(active_token)
+        return
+
+    accounts = settings.list_accounts()
+    if account not in accounts:
+        ErrorPrinter.print_generic_error(f"No account for {account} was found", exit_code=1)
+        return
+
+    token_file_name = accounts[account].credentials_file
+    token_file = settings.get_token_file(token_file_name)
+    if not token_file:
+        ErrorPrinter.print_generic_error(f"Token file for {account} could not be found", exit_code=1)
+        return
+
+    print(token_file.token)
 
 
 def print_access_token_file() -> None:
     """
     Print current active token and its metadata
     """
-    try:
-        print(settings.get_active_token_file())
-    except TokenNotFoundError as e:
-        ErrorPrinter.print_hint(str(e))
-        sys.exit(1)
+    active_token_file = settings.get_active_token_file()
+    if not active_token_file:
+        ErrorPrinter.print_generic_error("You have no active account", exit_code=1)
+        return
+
+    print(active_token_file)
+
+
+@app.command(name="deactivate")
+def deactivate() -> None:
+    """
+    Clears active account
+    """
+    settings.clear_active_account()
+    print("Account no longer active")
 
 
-# @app.command(help="Clears active credentials")
-def logout() -> None:
-    settings.clear_active_token()
-    print("Access token removed")
+@app.command("activate")
+def activate(token_name: str = typer.Argument(None, help="Name, filename or path to a credentials file")) -> None:
+    """
+    Set the active account
+    """
+    auth_tokens.do_activate(token_name)
 
 
-app.command("activate")(auth_tokens.select_personal_token)
-app.command("list")(auth_tokens.list_pats_files)
+@app.command(name="list")
+def list() -> None:
+    """
+    Lists available credential files on filesystem
+    """
+    accounts = settings.list_accounts()
+
+    table = Table("#", "Active", "Type", "Token", "Account", "Organization", "Created", "Expires")
+    for idx, (email, account) in enumerate(accounts.items(), start=1):
+        token_file = settings.get_token_file_by_email(email)
+        is_active = settings.is_active_account(email)
+
+        table.add_row(
+            f"[yellow]{idx}",
+            ":white_check_mark:" if is_active else "",
+            "unknown" if not token_file else "user" if token_file.type == "authorized_user" else "sa",
+            token_file.name if token_file else "",
+            f"[bold]{email}[/bold]",
+            account.default_organization if account.default_organization else "",
+            str(token_file.created) if token_file else "",
+            str(token_file.expires) if token_file else "",
+        )
+    console.print(table)

cli/cloud/auth/login.py

@@ -18,7 +18,7 @@ from typing_extensions import override
 
 from cli.cloud.auth_tokens import do_activate, prompt_to_set_org
 from cli.errors import ErrorPrinter
-from cli.settings import TokenNotFoundError, settings
+from cli.settings import settings
 from cli.settings.token_file import TokenFile
 from cli.utils.rest_helper import RestHelper as Rest
 
@@ -174,14 +174,13 @@ def create_personal_token() -> None:
 
 
 def _do_prompt_to_use_existing_credentials() -> Optional[TokenFile]:
-    files = settings.list_personal_token_files()
-    if len(files) > 0:
+    token_files = settings.list_personal_token_files()
+    if len(token_files) > 0:
         should_select_token = typer.confirm(
             "You have credentials available already, would you like to choose one of these instead?", default=True
         )
         if should_select_token:
             token = do_activate(token_name=None)
-            # token = list_and_select_personal_token(skip_prompt=False, include_service_accounts=True)
             if token is not None:
                 return token
             # TODO - fix so this is not needed
@@ -189,7 +188,7 @@ def _do_prompt_to_use_existing_credentials() -> Optional[TokenFile]:
     return None
 
 
-def login(headless: bool = False) -> bool:  # noqa: C901, PLR0912, PLR0915
+def login(headless: bool = False) -> bool:  # noqa: C901, PLR0915
     """
     Initiate login
     """
@@ -197,31 +196,30 @@ def login(headless: bool = False) -> bool:  # noqa: C901, PLR0912, PLR0915
     #
     # Check login.md flowchart for better understanding
     #
-    # 1. Check for active token valid and working credentials
-    #
-    try:
-        activate_token = settings.get_active_token_file()
-
-        if not activate_token.is_expired():
-            if Rest.has_access("/api/whoami"):
-                token = _do_prompt_to_use_existing_credentials()
-                if token is not None:
-                    return True
-            else:
-                settings.clear_active_token()
-                raise TokenNotFoundError()
-        else:
-            # TODO - Cleanup token since expired
-            pass
-
-    except TokenNotFoundError:
-        #
-        # 2. If no token was found, let user choose an existing if exists
-        #
-        token = _do_prompt_to_use_existing_credentials()
-        if token is not None:
+
+    active_token_file = settings.get_active_token_file()
+    if active_token_file:
+        # check if the active token is valid, if not, prompt user to select a new token
+        if not Rest.has_access("/api/whoami") or active_token_file.is_expired():
+            settings.clear_active_account()
+            newly_activated_token_file = _do_prompt_to_use_existing_credentials()
+            if newly_activated_token_file:
+                return True
+
+            # intentional fall through to login since we have no token
+
+    else:
+        # no active token, prompt user to select a new token
+        newly_activated_token_file = _do_prompt_to_use_existing_credentials()
+        if newly_activated_token_file:
             return True
 
+        # intentional fall through to login since we have no token
+
+    #
+    # 2. Login in if no valid token found...
+    #
+
     prepare_local_webserver()
 
     def force_use_webserver_callback() -> bool:

cli/cloud/auth_tokens.py

@@ -1,34 +1,27 @@
 from __future__ import annotations
 
-from typing import List, Literal, Optional
+from typing import List, Optional
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
-from cli.api.cloud import tokens
 from cli.cloud.organisations import do_select_default_org
 from cli.errors import ErrorPrinter
-from cli.settings import TokenNotFoundError, settings
-from cli.settings.config_file import Account
+from cli.settings import settings
 from cli.settings.token_file import TokenFile
-from cli.typer import typer_utils
 from cli.utils.rest_helper import RestHelper as Rest
 
 console = Console(stderr=False)
 err_console = Console(stderr=True)
 
-app = typer_utils.create_typer()
 
-PromptType = Literal["activate", "login"]
-
-
-def _prompt_choice(  # noqa: C901, PLR0912
+def _prompt_choice(  # noqa: C901
     choices: List[TokenFile],
     skip_prompt: bool = False,
     info_message: Optional[str] = None,
 ) -> Optional[TokenFile]:
-    accounts = settings.get_cli_config().accounts
+    accounts = settings.list_accounts()
 
     table = Table("#", "Active", "Type", "Token", "Account", "Created", "Expires")
 
@@ -38,11 +31,10 @@ def _prompt_choice(  # noqa: C901, PLR0912
     for token in choices:
         account = accounts.get(token.account.email)
         if account and account.credentials_file:
-            try:
-                token_file = settings.get_token_file(account.credentials_file)
-                if token_file.name in (token.name or ""):
-                    included_tokens.append(token)
-            except TokenNotFoundError:
+            token_file = settings.get_token_file(account.credentials_file)
+            if token_file and token_file.name in (token.name or ""):
+                included_tokens.append(token)
+            else:
                 excluded_tokens.append(token)
         else:
             excluded_tokens.append(token)
@@ -52,22 +44,7 @@ def _prompt_choice(  # noqa: C901, PLR0912
 
     included_tokens.sort(key=lambda token: token.created, reverse=True)
 
-    def get_active_account_or_none() -> Optional[Account]:
-        try:
-            return settings.get_cli_config().get_active()
-        except TokenNotFoundError:
-            return None
-
-    def get_active_token_or_none() -> Optional[TokenFile]:
-        try:
-            active_account = get_active_account_or_none()
-            if active_account is not None:
-                return settings.get_token_file(active_account.credentials_file)
-        except TokenNotFoundError:
-            pass
-        return None
-
-    active_token = get_active_token_or_none()
+    active_token = settings.get_active_token_file()
     active_token_index = None
     for idx, choice in enumerate(included_tokens, start=1):
         is_active = active_token is not None and active_token.name == choice.name
@@ -108,62 +85,9 @@ def _prompt_choice(  # noqa: C901, PLR0912
         return _prompt_choice(included_tokens, skip_prompt, info_message)
 
 
-# @app.command(name="create")
-def create(
-    activate: bool = typer.Option(False, help="Activate the token for use after download"),
-) -> None:
-    """
-    Create a new personal access token in [bold]cloud[/bold] and download locally
-    """
-    response = tokens.create()
-    pat = settings.add_personal_token(response.text())
-    print(f"Personal access token added: {pat.name}")
-
-    if not activate:
-        print(f"Use 'remotive cloud auth tokens activate {pat.name}' to use this access token from cli")
-    else:
-        settings.activate_token(pat)
-        print("Token file activated and ready for use")
-    print("\033[93m This file contains secrets and must be kept safe")
-
-
-# @app.command(name="list", help="List personal credentials in [bold]cloud[/bold]")
-def list_tokens() -> None:
-    Rest.handle_get("/api/me/keys")
-
-
-# @app.command(name="revoke")
-def revoke(
-    name: str = typer.Argument(help="Access token name"),
-    delete: bool = typer.Option(True, help="Also delete token"),
-) -> None:
-    """
-    Revoke personal credentials in cloud and removes the file from filesystem
-
-    If cloud token is not found but token is found on file system it will delete it and
-    vice versa.
-    """
-    _revoke_and_delete_personal_token(name, delete)
-
-
-# @app.command(name="activate")
-def activate(
-    token_name: str = typer.Argument(..., help="Token path, filename or name to activate"),
-) -> None:
-    """
-    Activate a credential file to be used for authentication using filename, path or name.
-
-    This will be used as the current access token in all requests.
-    """
-    try:
-        token_file = settings.get_token_file(token_name)
-        settings.activate_token(token_file)
-    except TokenNotFoundError:
-        err_console.print(f":boom: [bold red] Error: [/bold red] Token with filename or name {token_name} could not be found")
-
-
 def prompt_to_set_org() -> None:
-    if settings.get_cli_config().get_active_default_organisation() is None:
+    active_account = settings.get_active_account()
+    if active_account and not active_account.default_organization:
         set_default_organisation = typer.confirm(
             "You have not set a default organization\nWould you like to choose one now?",
             abort=False,
@@ -173,45 +97,32 @@ def prompt_to_set_org() -> None:
             do_select_default_org(get=False)
 
 
-@app.command("activate")
-def select_personal_token(
-    token_name: str = typer.Argument(None, help="Name, filename or path to a credentials file"),
-) -> None:
-    """
-    Activates is setting the current active credentials to use by the CLI, this can be done by specifying a name
-    of the token or getting prompted and choosing from existing.
-    """
-    do_activate(token_name)
-
-
 def do_activate(token_name: Optional[str]) -> Optional[TokenFile]:
-    if token_name is not None:
-        try:
-            token_file = settings.get_token_file(token_name)
-            settings.activate_token(token_file)
-            return token_file
-        except TokenNotFoundError:
+    if token_name:
+        token_file = settings.get_token_file(token_name)
+        if not token_file:
             err_console.print(f":boom: [bold red] Error: [/bold red] Token with filename or name {token_name} could not be found")
             return None
-    else:
-        token_files = settings.list_personal_tokens()
-        token_files.extend(settings.list_service_account_tokens())
-        if len(token_files) > 0:
-            token_selected = list_and_select_personal_token(include_service_accounts=True)
-            if token_selected is not None:
-                is_logged_in = Rest.has_access("/api/whoami")
-                if not is_logged_in:
-                    ErrorPrinter.print_generic_error("Could not access RemotiveCloud with selected token")
-                else:
-                    console.print("[green]Success![/green] Access to RemotiveCloud granted")
-                    # Only select default if activate was done with selection and successful
-                    # and not SA since SA cannot list available organizations
-                    if token_selected.type == "authorized_user":
-                        prompt_to_set_org()
-            return token_selected
+        return settings.activate_token(token_file)
+
+    token_files = settings.list_personal_token_files()
+    token_files.extend(settings.list_service_account_token_files())
+    if len(token_files) > 0:
+        token_selected = list_and_select_personal_token(include_service_accounts=True)
+        if token_selected is not None:
+            is_logged_in = Rest.has_access("/api/whoami")
+            if not is_logged_in:
+                ErrorPrinter.print_generic_error("Could not access RemotiveCloud with selected token")
+            else:
+                console.print("[green]Success![/green] Access to RemotiveCloud granted")
+                # Only select default if activate was done with selection and successful
+                # and not SA since SA cannot list available organizations
+                if token_selected.type == "authorized_user":
+                    prompt_to_set_org()
+        return token_selected
 
-        ErrorPrinter.print_hint("No credentials available, login to activate credentials")
-        return None
+    ErrorPrinter.print_hint("No credentials available, login to activate credentials")
+    return None
 
 
 def list_and_select_personal_token(
@@ -219,10 +130,10 @@ def list_and_select_personal_token(
     include_service_accounts: bool = False,
     info_message: Optional[str] = None,
 ) -> Optional[TokenFile]:
-    personal_tokens = settings.list_personal_tokens()
+    personal_tokens = settings.list_personal_token_files()
 
     if include_service_accounts:
-        sa_tokens = settings.list_service_account_tokens()
+        sa_tokens = settings.list_service_account_token_files()
         personal_tokens.extend(sa_tokens)
 
     selected_token = _prompt_choice(personal_tokens, skip_prompt=skip_prompt, info_message=info_message)
@@ -230,126 +141,3 @@ def list_and_select_personal_token(
         settings.activate_token(selected_token)
 
     return selected_token
-
-
-# @app.command("select-revoke")
-def select_revoke_personal_token() -> None:
-    """
-    Prompts a user to select one of the credential files to revoke and delete
-    """
-    personal_tokens = settings.list_personal_tokens()
-    sa_tokens = settings.list_service_account_tokens()
-    personal_tokens.extend(sa_tokens)
-
-    is_logged_in = Rest.has_access("/api/whoami")
-    if not is_logged_in:
-        ErrorPrinter.print_hint("You must be logged in")
-        raise typer.Exit(0)
-
-    # merged = _merge_local_tokens_with_cloud(personal_tokens)
-
-    selected_token = _prompt_choice(personal_tokens)
-
-    if selected_token is not None:
-        _revoke_and_delete_personal_token(selected_token.name, True)
-        # Rest.handle_patch(f"/api/me/keys/{selected_token.name}/revoke", quiet=True, access_token=selected_token.token)
-        # Rest.handle_delete(f"/api/me/keys/{selected_token.name}", quiet=True, access_token=selected_token.token)
-        # settings.remove_token_file(selected_token.name)
-        # active_token = settings.get_active_token_file()
-        # if active_token.name == selected_token.name:
-        #    settings.clear_active_token()
-        # select_revoke_personal_token()
-
-
-# @app.command("test-all")
-def test_all_personal_tokens() -> None:
-    """
-    Tests each credential file to see if it is valid
-    """
-    personal_tokens = settings.list_personal_tokens()
-    personal_tokens.extend(settings.list_service_account_tokens())
-    if len(personal_tokens) == 0:
-        console.print("No personal tokens found on disk")
-        return
-
-    for token in personal_tokens:
-        r = Rest.handle_get(
-            "/api/whoami",
-            allow_status_codes=[401],
-            access_token=token.token,
-            use_progress_indicator=True,
-            return_response=True,
-        )
-        if r.status_code == 200:
-            if token.account is not None:
-                console.print(f"{token.account.email} ({token.name}) :white_check_mark:")
-            else:
-                console.print(f"{token.name} :white_check_mark:")
-        elif token.account is not None:
-            console.print(f"{token.account.email} ({token.name}) :x: Failed")
-        else:
-            console.print(f"{token.name} :x: Failed")
-
-
-# @app.command(name="list-service-account-tokens-files")
-def list_sats_files() -> None:
-    """
-    List service account access token files in remotivelabs config directory
-    """
-    service_account_files = settings.list_service_account_token_files()
-    for file in service_account_files:
-        print(file)
-
-
-@app.command(name="list")
-def list_pats_files(
-    accounts: bool = typer.Option(True, help="Lists all available accounts"),
-    files: bool = typer.Option(False, help="Shows all token files in config directory"),
-) -> None:
-    """
-    Lists available credential files on filesystem
-    """
-
-    if accounts:
-        list_and_select_personal_token(skip_prompt=True, include_service_accounts=True, info_message="hello")
-
-    if files:
-        personal_files = settings.list_personal_token_files()
-        service_account_files = settings.list_service_account_token_files()
-        personal_files.extend(service_account_files)
-        for file in personal_files:
-            print(file)
-
-
-def _revoke_and_delete_personal_token(name: str, delete: bool) -> None:
-    token_file = None
-
-    # First we try to find the file and make sure its not the currently active
-    try:
-        token_file = settings.get_token_file(name)
-        active_token = settings.get_active_token_file()
-        if token_file.name == active_token.name:
-            ErrorPrinter.print_hint("You cannot revoke the current active token")
-            return
-    except TokenNotFoundError:
-        pass
-
-    # The lets try to revoke from cloud
-    res_revoke = tokens.revoke(name)
-    if delete:
-        res_delete = tokens.delete(name)
-        if res_delete.is_success:
-            ErrorPrinter.print_generic_message("Token successfully revoked and deleted")
-        else:
-            ErrorPrinter.print_hint(f"Failed to revoke and delete token in cloud: {res_delete.status_code}")
-    elif res_revoke.is_success:
-        ErrorPrinter.print_generic_message("Token successfully revoked")
-    else:
-        ErrorPrinter.print_hint("Failed to revoke and delete token in cloud")
-
-    # Finally try to remove the file if exists
-    if token_file is not None:
-        settings.remove_token_file(token_file.name)
-        console.print("Successfully deleted token on filesystem")
-    else:
-        ErrorPrinter.print_hint("Token not found on filesystem")

cli/cloud/licenses/cmd.py

@@ -0,0 +1,14 @@
+import typer
+
+from cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper
+
+app = typer_utils.create_typer()
+
+
+@app.command(help="List licenses for an organization")
+def licenses(
+    organization: str = typer.Option(..., help="Organization ID", envvar="REMOTIVE_CLOUD_ORGANIZATION"),
+    filter_option: str = typer.Option("all", help="all, valid, expired"),
+) -> None:
+    RestHelper.handle_get(f"/api/bu/{organization}/licenses", {"filter": filter_option})

cli/cloud/organisations.py

@@ -26,10 +26,8 @@ class Organisation:
 def _prompt_choice(choices: List[Organisation]) -> Optional[Organisation]:
     table = Table("#", "Name", "Uid", "Default")
 
-    token = settings.get_active_token_file()
-    config = settings.get_cli_config()
-
-    current_default_org = config.accounts[token.account.email].default_organization if token is not None else None
+    account = settings.get_active_account()
+    current_default_org = account.default_organization if account else None
 
     for idx, choice in enumerate(choices, start=1):
         table.add_row(
@@ -74,19 +72,18 @@ def do_select_default_org(organisation_uid: Optional[str] = None, get: bool = Fa
     Note that service-accounts does Not have permission to list organizations and will get a 403 Forbidden response so you must
     select the organization uid as argument
     """
+    active_account = settings.get_active_account()
     if get:
-        default_organisation = settings.get_cli_config().get_active_default_organisation()
-        if default_organisation:
-            console.print(default_organisation)
+        if active_account and active_account.default_organization:
+            console.print(active_account.default_organization)
         else:
             console.print("No default organization set")
     elif organisation_uid is not None:
         settings.set_default_organisation(organisation_uid)
     else:
-        account = settings.get_cli_config().get_active()
-        if account:
-            token = settings.get_token_file(account.credentials_file)
-            if token.type != "authorized_user":
+        if active_account:
+            token = settings.get_token_file(active_account.credentials_file)
+            if token and token.type != "authorized_user":
                 ErrorPrinter.print_hint(
                     "You must supply the organization name as argument when using a service-account since the "
                     "service-account is not allowed to list"
@@ -100,7 +97,6 @@ def do_select_default_org(organisation_uid: Optional[str] = None, get: bool = Fa
         selected = _prompt_choice(orgs)
 
         if selected is not None:
-            settings.get_cli_config()
             typer.echo(f"Default organisation: {selected.display_name} (uid: {selected.uid})")
             settings.set_default_organisation(selected.uid)