remotivelabs-cli 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

cli/broker/license_flows.py

@@ -7,14 +7,12 @@ from typing import Union
 import grpc
 import requests
 import typer
-from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.broker.lib.broker import Broker, LicenseInfo
+from cli.utils.console import print_unformatted_to_stderr
 from cli.utils.rest_helper import RestHelper as Rest
 
-console = Console(stderr=True)
-
 
 class LicenseFlow:
     def describe_with_url(self, url: str) -> LicenseInfo:
@@ -35,7 +33,7 @@ class LicenseFlow:
         return b.get_license()
 
     def request_with_url_with_internet(self, url: str) -> None:
-        console.print("This requires internet connection from your computer during the entire licensing process")
+        print_unformatted_to_stderr("This requires internet connection from your computer during the entire licensing process")
 
         email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
 
@@ -52,7 +50,7 @@ class LicenseFlow:
             if not apply:
                 return
 
-        console.print(
+        print_unformatted_to_stderr(
             ":point_right: [bold yellow]This will request a new license or use an existing license if "
             "this hardware has already been licensed[/bold yellow]"
         )
@@ -66,7 +64,7 @@ class LicenseFlow:
         with use_progress("Applying license to broker..."):
             new_license = broker_to_license.apply_license(license_data_b64)
         if new_license.valid:
-            console.print(f":thumbsup: Successfully applied license, it remains valid until {new_license.expires}")
+            print_unformatted_to_stderr(f":thumbsup: Successfully applied license, it remains valid until {new_license.expires}")
 
     def request_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051") -> None:
         """
@@ -76,7 +74,7 @@ class LicenseFlow:
         if url is None:
             url = "http://192.168.4.1:50051"
 
-        console.print(
+        print_unformatted_to_stderr(
             "Licensing a broker over its wifi hotspot will require you to switch between internet connectivity "
             "and remotivelabs-xxx wifi hotspot"
         )
@@ -95,7 +93,7 @@ class LicenseFlow:
             if not apply:
                 return
 
-        console.print(
+        print_unformatted_to_stderr(
             ":point_right: [bold yellow]This will request a new license or use an existing license if "
             "this hardware has already been licensed[/bold yellow]"
         )
@@ -110,7 +108,7 @@ class LicenseFlow:
             progress_label="Applying license to broker...  Make sure to switch back to remotivelabs-xxx wifi hotspot",
         )
         new_license = broker_to_license.apply_license(license_data_b64)
-        console.print(f":thumbsup: Successfully applied license, expires {new_license.expires}")
+        print_unformatted_to_stderr(f":thumbsup: Successfully applied license, expires {new_license.expires}")
 
     @staticmethod
     def __try_connect_to_broker(url: str, progress_label: str, on_error_progress_label: Union[str, None] = None) -> Broker:
@@ -127,9 +125,9 @@ class LicenseFlow:
                         )
                     time.sleep(1)
         if on_error_progress_label is None:
-            console.print(f":white_check_mark: {progress_label}")
+            print_unformatted_to_stderr(f":white_check_mark: {progress_label}")
         else:
-            console.print(f":white_check_mark: {on_error_progress_label}")
+            print_unformatted_to_stderr(f":white_check_mark: {on_error_progress_label}")
         return broker_to_license
 
     @staticmethod
@@ -141,7 +139,7 @@ class LicenseFlow:
                     break
                 except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
                     time.sleep(1)
-        console.print(":white_check_mark: Fetching user info from cloud... Make sure you are connected to internet")
+        print_unformatted_to_stderr(":white_check_mark: Fetching user info from cloud... Make sure you are connected to internet")
         if r is None:
             return ""
         return str(r.json()["email"])
@@ -159,7 +157,7 @@ class LicenseFlow:
                     break
                 except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
                     time.sleep(1)
-        console.print(f":white_check_mark: {progress_label}")
+        print_unformatted_to_stderr(f":white_check_mark: {progress_label}")
         return bytes(license_data_b64)
 
 

cli/broker/playback.py

@@ -5,8 +5,8 @@ from typing import Dict, List
 import grpc
 import typer
 
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_success
 
 from .lib.broker import Broker
 
@@ -16,7 +16,7 @@ app = typer_utils.create_typer(help=help)
 def recording_and_namespace(recording: str) -> Dict[str, str]:
     splitted = recording.split("::")
     if len(splitted) != 2:
-        print("Invalid --recording option, expected file_name::namespace")
+        print_generic_error("Invalid --recording option, expected file_name::namespace")
         raise typer.Exit(1)
     return {"recording": splitted[0], "namespace": splitted[1]}
 
@@ -39,10 +39,10 @@ def play(
     try:
         broker = Broker(url, api_key)
         status = broker.play(rec)
-        print(status)
+        # TODO: use log instead of print for debug information?
+        print_generic_message(str(status))
     except grpc.RpcError as err:
-        ErrorPrinter.print_grpc_error(err)
-    # print(status)
+        print_grpc_error(err)
 
 
 @app.command()
@@ -64,9 +64,9 @@ def stop(
     try:
         broker = Broker(url, api_key)
         broker.stop_play(rec)
-        print("Successfully stopped recording")
+        print_success("Recording stopped")
     except grpc.RpcError as err:
-        ErrorPrinter.print_grpc_error(err)
+        print_grpc_error(err)
 
 
 @app.command()
@@ -87,9 +87,9 @@ def pause(
     try:
         broker = Broker(url, api_key)
         broker.pause_play(rec)
-        print("Successfully paused recording")
+        print_success("Recording paused")
     except grpc.RpcError as err:
-        ErrorPrinter.print_grpc_error(err)
+        print_grpc_error(err)
 
 
 @app.command()
@@ -115,4 +115,4 @@ def seek(
         broker = Broker(url, api_key)
         broker.seek(rec, int(seconds * 1000000))
     except grpc.RpcError as err:
-        ErrorPrinter.print_grpc_error(err)
+        print_grpc_error(err)

cli/broker/record.py

@@ -5,8 +5,8 @@ from typing import List
 import grpc
 import typer
 
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_grpc_error, print_success
 
 from .lib.broker import Broker
 
@@ -24,7 +24,7 @@ def start(
         broker = Broker(url, api_key)
         broker.record_multiple(namespace, filename)
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
 
 
 @app.command()
@@ -37,6 +37,6 @@ def stop(
     try:
         broker = Broker(url, api_key)
         broker.stop_multiple(namespace, filename)
-        print("Successfully stopped recording")
+        print_success("Recording stopped")
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)

cli/broker/scripting.py

@@ -5,10 +5,9 @@ from string import Template
 from typing import List
 
 import typer
-from rich import print as rich_print
 
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_generic_message, print_hint
 
 app = typer_utils.create_typer(
     rich_markup_mode="rich",
@@ -20,10 +19,9 @@ app = typer_utils.create_typer(
 
 def write(signal_name: str, script: str) -> None:
     path = f"{signal_name}.lua"
-    f = open(path, "w")
-    f.write(script)
-    f.close()
-    print(f"Secret token written to {path}")
+    with open(path, "w") as f:
+        f.write(script)
+    print_generic_message(f"Secret token written to {path}")
 
 
 @app.command("new-script")
@@ -35,7 +33,7 @@ def new_script(
     def to_subscribable_signal(sig: str) -> tuple[str, str]:
         arr = sig.split(":")
         if len(arr) != 2:
-            ErrorPrinter.print_hint(f"--input-signal must have format namespace:signal ({sig})")
+            print_hint(f"--input-signal must have format namespace:signal ({sig})")
             sys.exit(1)
         return arr[0], arr[1]
 
@@ -121,7 +119,6 @@ end
 
     script = template.substitute(
         local_signals=local_signals,
-        # signle_input_signal=signals_to_subscribe_to[0][1],  # Take one signal and use signal name in tuple
         subscribe_pattern=subscribe_pattern,
         output_signal=output_signal,
     )
@@ -129,4 +126,4 @@ end
     if save:
         write(output_signal, script)
     else:
-        rich_print(script)
+        print_generic_message(script)

cli/broker/signals.py

@@ -12,10 +12,9 @@ from typing import Any, Dict, Iterable, List, TypedDict, Union
 import grpc
 import plotext as plt  # type: ignore
 import typer
-from rich import print as rich_rprint
 
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_hint
 
 from .lib.broker import Broker, SubscribableSignal
 
@@ -23,8 +22,6 @@ app = typer_utils.create_typer(help=help)
 
 DEFAULT_GRPC_URL = "http://localhost:50051"
 
-# signal_values:list = list()
-
 
 class Signals(TypedDict):
     name: str
@@ -49,18 +46,18 @@ def list_signals(
     try:
         broker = Broker(url, api_key)
         available_signals = broker.list_signal_names(prefix=name_starts_with, suffix=name_ends_with)
-        print(json.dumps(available_signals))
+        print_generic_message(json.dumps(available_signals))
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
 
 
 def read_scripted_code_file(file_path: Path) -> bytes:
     try:
-        print(file_path)
+        print_generic_message(str(file_path))
         with open(file_path, "rb") as file:
             return file.read()
     except FileNotFoundError:
-        print("File not found. Please check your file path.")
+        print_generic_error("File not found. Please check your file path.")
         sys.exit(1)
 
 
@@ -100,12 +97,12 @@ def subscribe(  # noqa: C901, PLR0913, PLR0915
 
     if script is None:
         if len(signal) == 0:
-            ErrorPrinter.print_generic_error("You must use --signal or use --script when subscribing")
+            print_generic_error("You must use --signal or use --script when subscribing")
             sys.exit(1)
 
     if script is not None:
         if len(signal) > 0:
-            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            print_generic_error("You must must not specify --signal when using --script")
             sys.exit(1)
 
     plt.title("Signals")
@@ -153,7 +150,8 @@ def subscribe(  # noqa: C901, PLR0913, PLR0915
         plt.show()
 
     def on_frame_print(x: Iterable[Any]) -> None:
-        rich_rprint(json.dumps(list(x)))
+        # TODO: use log instead of print for debug information?
+        print_generic_message(json.dumps(list(x)))
 
     os_signal.signal(os_signal.SIGINT, exit_on_ctrlc)
 
@@ -172,7 +170,7 @@ def subscribe(  # noqa: C901, PLR0913, PLR0915
             def to_subscribable_signal(sig: str):
                 arr = sig.split(":")
                 if len(arr) != 2:
-                    ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")
+                    print_hint(f"--signal must have format namespace:signal ({sig})")
                     sys.exit(1)
                 return SubscribableSignal(namespace=arr[0], name=arr[1])
 
@@ -180,9 +178,9 @@ def subscribe(  # noqa: C901, PLR0913, PLR0915
 
             broker = Broker(url, api_key)
             broker.long_name_subscribe(signals_to_subscribe_to, on_frame_func, on_change_only)
-        print("Subscribing to signals, press Ctrl+C to exit")
+        print_generic_message("Subscribing to signals, press Ctrl+C to exit")
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
 
 
 @app.command(help="List namespaces on broker")
@@ -193,9 +191,9 @@ def namespaces(
     try:
         broker = Broker(url, api_key)
         namespaces_json = broker.list_namespaces()
-        print(json.dumps(namespaces_json))
+        print_generic_message(json.dumps(namespaces_json))
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
 
 
 @app.command()
@@ -214,11 +212,11 @@ def frame_distribution(
             timestamp: str = datetime.now().strftime("%H:%M:%S")
             distribution = data["countsByFrameId"]
             if len(distribution) == 0:
-                ErrorPrinter.print_hint(f"{timestamp} - No frames available")
+                print_hint(f"{timestamp} - No frames available")
             else:
                 for d in distribution:
-                    ErrorPrinter.print_generic_message(f"{timestamp}: {d}")
+                    print_generic_message(f"{timestamp}: {d}")
 
         broker.listen_on_frame_distribution(namespace, on_data)
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)

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,26 @@
 from __future__ import annotations
 
+import os
 import sys
 
 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.console import print_generic_error, print_generic_message, print_success, print_unformatted
 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 +40,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 +50,80 @@ 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:
-            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)
+    if not account:
+        active_token = settings.get_active_token() or os.getenv("REMOTIVE_CLOUD_ACCESS_TOKEN", None)
+        if not active_token:
+            print_generic_error("You have no active account")
+            sys.exit(1)
+
+        print_generic_message(active_token)
+        return
+
+    accounts = settings.list_accounts()
+    if account not in accounts:
+        print_generic_error(f"No account for {account} was found")
+        sys.exit(1)
+
+    token_file_name = accounts[account].credentials_file
+    token_file = settings.get_token_file(token_file_name)
+    if not token_file:
+        print_generic_error(f"Token file for {account} could not be found")
+        sys.exit(1)
+
+    print_generic_message(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))
+    active_token_file = settings.get_active_token_file()
+    if not active_token_file:
+        print_generic_error("You have no active account")
         sys.exit(1)
 
+    print_generic_message(str(active_token_file))
+
+
+@app.command(name="deactivate")
+def deactivate() -> None:
+    """
+    Clears active account
+    """
+    settings.clear_active_account()
+    print_success("Account no longer active")
+
+
+@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(help="Clears active credentials")
-def logout() -> None:
-    settings.clear_active_token()
-    print("Access token removed")
 
+@app.command(name="list")
+def list() -> None:
+    """
+    Lists available credential files on filesystem
 
-app.command("activate")(auth_tokens.select_personal_token)
-app.command("list")(auth_tokens.list_pats_files)
+    TODO: Support output format
+    """
+    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 "",
+        )
+    print_unformatted(table)