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

cli/settings/core.py

@@ -3,20 +3,18 @@ from __future__ import annotations
 import os
 import stat
 import sys
-from json import JSONDecodeError
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 
-from pydantic import ValidationError
 from rich.console import Console
 
-from cli.errors import ErrorPrinter
 from cli.settings import config_file as cf
 from cli.settings import state_file as sf
 from cli.settings import token_file as tf
-from cli.settings.config_file import ConfigFile
+from cli.settings.config_file import Account, ConfigFile
 from cli.settings.state_file import StateFile
 from cli.settings.token_file import TokenFile
+from cli.utils.console import print_hint
 
 err_console = Console(stderr=True)
 
@@ -24,27 +22,17 @@ CONFIG_DIR_PATH = Path.home() / ".config" / "remotive"
 CLI_CONFIG_FILE_NAME = "config.json"
 CLI_INTERNAL_STATE_FILE_NAME = "app-state.json"
 
-TokenFileMetadata = Tuple[TokenFile, Path]
-
 
 class InvalidSettingsFilePathError(Exception):
     """Raised when trying to access an invalid settings file or file path"""
 
 
-class TokenNotFoundError(Exception):
-    """Raised when a token cannot be found in settings"""
-
-
 class Settings:
     """
     Settings handles tokens and other config for the remotive CLI
 
-    TODO: return None instead of raising errors when no active account is found
-    TODO: be consisten in how we update (and write) state to the different files
     TODO: migrate away from singleton instance
-    TODO: what about manually downloaded tokens when removing a token?
-    TODO: what about active token when removing a token?
-    TODO: list tokens should use better listing logic
+    TODO: How do we handle REMOTIVE_CLOUD_ACCESS_TOKEN in combination with active account? What takes precedence?
     """
 
     config_dir: Path
@@ -60,57 +48,78 @@ class Settings:
         if not self.state_file_path.exists():
             self._write_state_file(StateFile())
 
-    def get_cli_config(self) -> ConfigFile:
+    def _get_cli_config(self) -> ConfigFile:
         return self._read_config_file()
 
-    def get_state_file(self) -> StateFile:
+    def _get_state_file(self) -> StateFile:
         return self._read_state_file()
 
+    def should_perform_update_check(self) -> bool:
+        """
+        Check if we should perform an update check.
+        """
+        return self._get_state_file().should_perform_update_check()
+
     def set_default_organisation(self, organisation: str) -> None:
         """
         Set the default organization for the active account
+
+        TODO: Raise error, dont sys.exit
         """
-        config = self.get_cli_config()
+        config = self._get_cli_config()
         active_account = config.get_active_account()
         if not active_account:
-            ErrorPrinter.print_hint("You must have an account activated in order to set default organization")
+            print_hint("You must have an account activated in order to set default organization")
             sys.exit(1)
         active_account.default_organization = organisation
         self._write_config_file(config)
 
-    def get_active_token(self) -> str:
+    def get_active_account(self) -> Account | None:
         """
-        Get the current active token secret
+        Get the current active account
+
+        TODO: Add email field to Account
         """
-        token_file = self.get_active_token_file()
-        return token_file.token
+        return self._get_cli_config().get_active_account()
 
-    def get_active_token_file(self) -> TokenFile:
+    def get_active_token_file(self) -> TokenFile | None:
         """
-        Get the current active token file
+        Get the token file for the current active account
         """
-        active_account = self.get_cli_config().get_active_account()
-        if not active_account:
-            raise TokenNotFoundError("No active account found")
+        active_account = self.get_active_account()
+        return self._read_token_file(active_account.credentials_file) if active_account else None
 
-        token_file_name = active_account.credentials_file
-        return self._read_token_file(self.config_dir / token_file_name)
+    def get_active_token(self) -> str | None:
+        """
+        Get the token secret for the current active account
+        """
+        token_file = self.get_active_token_file()
+        return token_file.token if token_file else None
 
-    def activate_token(self, token_file: TokenFile) -> None:
+    def activate_token(self, token_file: TokenFile) -> TokenFile:
         """
         Activate a token by name or path
 
         The token secret will be set as the current active secret.
+
+        Returns the activated token file
         """
-        config = self.get_cli_config()
+        config = self._get_cli_config()
         config.activate_account(token_file.account.email)
         self._write_config_file(config)
+        return token_file
+
+    def is_active_account(self, email: str) -> bool:
+        """
+        Returns True if the given email is the active account
+        """
+        return self._get_cli_config().active == email
 
-    def clear_active_token(self) -> None:
+    def clear_active_account(self) -> None:
         """
         Clear the current active token
         """
-        config = self.get_cli_config()
+        config = self._get_cli_config()
         config.active = None
         self._write_config_file(config)
 
@@ -120,78 +129,56 @@ class Settings:
 
         If multiple tokens are found, the first one is returned.
         """
-        tokens = [t for t in self.list_personal_tokens() if t.account is not None and t.account.email == email]
-        if len(tokens) > 0:
-            return tokens[0]
-        tokens = [t for t in self.list_service_account_tokens() if t.account is not None and t.account.email == email]
-        if len(tokens) > 0:
-            return tokens[0]
-        return None
+        accounts = self._get_cli_config().accounts.get(email)
+        return self._read_token_file(accounts.credentials_file) if accounts else None
 
-    def get_token_file(self, name: str) -> TokenFile:
+    def get_token_file(self, name: str) -> TokenFile | None:
         """
         Get a token file by name or path
         """
         # 1. Try relative path
         if (self.config_dir / name).exists():
-            return self._read_token_file(self.config_dir / name)
+            return self._read_token_file(name)
 
-        # 2. Try absolute path
-        if Path(name).exists():
-            return self._read_token_file(Path(name))
-
-        # 3. Try name
-        return self._get_token_by_name(name)[0]
+        # 2. Try name
+        return self._get_token_by_name(name)
 
     def remove_token_file(self, name: str) -> None:
         """
         Remove a token file by name or path
-
-        TODO: what about manually downloaded tokens?
         """
-        if Path(name).exists():
-            if self.config_dir not in Path(name).parents:
-                raise InvalidSettingsFilePathError(f"cannot remove a token file not located in settings dir {self.config_dir}")
-            return Path(name).unlink()
+        token_file = self.get_token_file(name)
+        if not token_file:
+            return
+
+        # If the token is active, clear it first
+        email = token_file.account.email
+        if self.is_active_account(email):
+            self.clear_active_account()
 
-        # TODO: what about the active token?
-        path = self._get_token_by_name(name)[1]
-        return path.unlink()
+        # Remove the token file
+        path = self.config_dir / self._get_cli_config().accounts[email].credentials_file
+        path.unlink()
+
+        # Remove the account from the config file
+        config = self._get_cli_config()
+        config.remove_account(email)
+        self._write_config_file(config)
 
     def add_personal_token(self, token: str, activate: bool = False, overwrite_if_exists: bool = False) -> TokenFile:
         """
         Add a personal token
         """
-        file = tf.loads(token)
-        if file.type != "authorized_user":
+        token_file = tf.loads(token)
+        if token_file.type != "authorized_user":
             raise ValueError("Token type MUST be authorized_user")
 
-        file_name = file.get_token_file_name()
-        path = self.config_dir / file_name
-        if path.exists() and not overwrite_if_exists:
-            raise FileExistsError(f"Token file already exists: {path}")
-
-        self._write_token_file(path, file)
-        cli_config = self.get_cli_config()
-        cli_config.init_account(email=file.account.email, token_file=file)
-        self._write_config_file(cli_config)
+        token_file = self.add_token_as_account(token_file, overwrite_if_exists)
 
         if activate:
-            self.activate_token(file)
+            self.activate_token(token_file)
 
-        return file
-
-    def list_personal_tokens(self) -> list[TokenFile]:
-        """
-        List all personal tokens
-        """
-        return [f[0] for f in self._list_personal_tokens()]
-
-    def list_personal_token_files(self) -> list[Path]:
-        """
-        List paths to all personal token files
-        """
-        return [f[1] for f in self._list_personal_tokens()]
+        return token_file
 
     def add_service_account_token(self, token: str, overwrite_if_exists: bool = False) -> TokenFile:
         """
@@ -201,29 +188,74 @@ class Settings:
         if token_file.type != "service_account":
             raise ValueError("Token type MUST be service_account")
 
-        file = token_file.get_token_file_name()
-        path = self.config_dir / file
+        return self.add_token_as_account(token_file, overwrite_if_exists)
+
+    def add_token_as_account(self, token_file: TokenFile, overwrite_if_exists: bool = False) -> TokenFile:
+        """
+        Add an account to the config file
+        """
+        file_name = token_file.get_token_file_name()
+        path = self.config_dir / file_name
         if path.exists() and not overwrite_if_exists:
             raise FileExistsError(f"Token file already exists: {path}")
 
         self._write_token_file(path, token_file)
-        cli_config = self.get_cli_config()
+        cli_config = self._get_cli_config()
         cli_config.init_account(email=token_file.account.email, token_file=token_file)
         self._write_config_file(cli_config)
 
         return token_file
 
-    def list_service_account_tokens(self) -> list[TokenFile]:
+    def list_accounts(self) -> dict[str, Account]:
+        """
+        List all accounts
+        """
+        return self._get_cli_config().accounts
+
+    def list_personal_accounts(self) -> dict[str, Account]:
+        """
+        List all personal accounts
+
+        TODO: add account type to Account
         """
-        List all service account tokens
+        accounts = self.list_accounts()
+        return {
+            email: account
+            for email, account in accounts.items()
+            if self._read_token_file(account.credentials_file).type == "authorized_user"
+        }
+
+    def list_service_accounts(self) -> dict[str, Account]:
+        """
+        List all personal accounts
+
+        TODO: add account type to Account
+        """
+        accounts = self.list_accounts()
+        return {
+            email: account
+            for email, account in accounts.items()
+            if self._read_token_file(account.credentials_file).type == "service_account"
+        }
+
+    def list_token_files(self) -> list[TokenFile]:
+        """
+        List all token files
         """
-        return [f[0] for f in self._list_service_account_tokens()]
+        accounts = self._get_cli_config().accounts.values()
+        return [self._read_token_file(account.credentials_file) for account in accounts]
 
-    def list_service_account_token_files(self) -> list[Path]:
+    def list_personal_token_files(self) -> list[TokenFile]:
         """
-        List paths to all service account token files
+        List all personal token files
         """
-        return [f[1] for f in self._list_service_account_tokens()]
+        return [token_file for token_file in self.list_token_files() if token_file.type == "authorized_user"]
+
+    def list_service_account_token_files(self) -> list[TokenFile]:
+        """
+        List all service account token files
+        """
+        return [token_file for token_file in self.list_token_files() if token_file.type == "service_account"]
 
     def set_last_update_check_time(self, timestamp: str) -> None:
         """
@@ -233,78 +265,46 @@ class Settings:
         state.last_update_check_time = timestamp
         self._write_state_file(state)
 
-    def _list_personal_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=tf.PERSONAL_TOKEN_FILE_PREFIX)
-
-    def _list_service_account_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=tf.SERVICE_ACCOUNT_TOKEN_FILE_PREFIX)
-
-    def _get_token_by_name(self, name: str) -> TokenFileMetadata:
-        token_files = self._list_token_files()
-        matches = [token_file for token_file in token_files if token_file[0].name == name]
-        if len(matches) != 1:
-            raise TokenNotFoundError(f"Ambiguous token file name {name}, found {len(matches)} files")
-        return matches[0]
-
-    def _list_token_files(self, prefix: str = "") -> list[TokenFileMetadata]:
+    def _get_token_by_name(self, name: str) -> TokenFile | None:
         """
-        list all tokens with the correct prefix in the config dir, but omit files that are not token files
-
-        TODO: improve is_valid_json and is_valid_token_file using token_file parsing instead
+        Token name is only available as a property of TokenFile, so we must iterate over all tokens to find the right one
         """
+        token_files = self.list_token_files()
+        matches = [token_file for token_file in token_files if token_file.name == name]
+        if len(matches) != 1:
+            return None
+        return matches[0]
 
-        def is_valid_json(path: Path) -> bool:
-            try:
-                self._read_token_file(path)
-                return True
-            except (JSONDecodeError, ValidationError):
-                # TODO - this should be printed but printing it here causes it to be displayed to many times
-                # err_console.print(f"File is not valid json, skipping. {path}")
-                return False
-
-        def is_valid_token_file(path: Path) -> bool:
-            is_token_file = path.name.startswith(tf.SERVICE_ACCOUNT_TOKEN_FILE_PREFIX) or path.name.startswith(
-                tf.PERSONAL_TOKEN_FILE_PREFIX
-            )
-            has_correct_prefix = path.is_file() and path.name.startswith(prefix)
-            is_cli_config = path == self.config_file_path
-            is_present_in_cli_config_accounts = any(
-                path.name == account.credentials_file for account in self.get_cli_config().accounts.values()
-            )
-            return is_token_file and is_valid_json(path) and has_correct_prefix and not is_cli_config and is_present_in_cli_config_accounts
-
-        paths = [path for path in self.config_dir.iterdir() if is_valid_token_file(path)]
-        return [(self._read_token_file(token_file), token_file) for token_file in paths]
-
-    def _read_token_file(self, path: Path) -> TokenFile:
+    def _read_token_file(self, file_name: str) -> TokenFile:
+        path = self.config_dir / file_name
         data = self._read_file(path)
         return tf.loads(data)
 
+    def _write_token_file(self, path: Path, token: TokenFile) -> Path:
+        data = tf.dumps(token)
+        return self._write_file(path, data)
+
     def _read_config_file(self) -> ConfigFile:
         data = self._read_file(self.config_file_path)
         return cf.loads(data)
 
+    def _write_config_file(self, config: ConfigFile) -> Path:
+        data = cf.dumps(config)
+        return self._write_file(self.config_file_path, data)
+
     def _read_state_file(self) -> StateFile:
         data = self._read_file(self.state_file_path)
         return sf.loads(data)
 
+    def _write_state_file(self, state: StateFile) -> Path:
+        data = sf.dumps(state)
+        return self._write_file(self.state_file_path, data)
+
     def _read_file(self, path: Path) -> str:
         if not path.exists():
             raise FileNotFoundError(f"File could not be found: {path}")
         return path.read_text(encoding="utf-8")
 
-    def _write_token_file(self, path: Path, token: TokenFile) -> Path:
-        data = tf.dumps(token)
-        return self._write_file(path, data)
-
-    def _write_config_file(self, config: ConfigFile) -> Path:
-        data = cf.dumps(config)
-        return self._write_file(self.config_file_path, data)
-
-    def _write_state_file(self, state: StateFile) -> Path:
-        data = sf.dumps(state)
-        return self._write_file(self.state_file_path, data)
-
     def _write_file(self, path: Path, data: str) -> Path:
         if self.config_dir not in path.parents:
             raise InvalidSettingsFilePathError(f"file {path} not in settings dir {self.config_dir}")

cli/settings/migration/migrate_config_file.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Any, Optional
 
 from cli.settings.config_file import ConfigFile, loads
-from cli.settings.core import Settings, TokenNotFoundError
+from cli.settings.core import Settings
 from cli.settings.migration.migration_tools import get_token_file
 
 
@@ -21,13 +21,20 @@ def migrate_account_data(config: dict[str, Any], settings: Settings) -> Optional
         cred_name = account_info.pop("credentials_name", None)
         if not cred_name:
             continue
+
+        # found legacy account, try to migrate it, or drop it...
         found_old = True
-        try:
-            cred_file = get_token_file(cred_name, settings.config_dir).get_token_file_name()
-        except TokenNotFoundError:
-            # schedule this account for removal
+
+        token_file = get_token_file(cred_name, settings.config_dir)
+        if not token_file:
+            sys.stderr.write(f"Dropping account {account_email!r}: credentials file for {cred_name} not found")
+            to_delete.append(account_email)
+            continue
+
+        cred_file = token_file.get_token_file_name()
+        if not cred_file:
+            sys.stderr.write(f"Dropping account {account_email!r}: credentials file for {cred_name} not found")
             to_delete.append(account_email)
-            sys.stderr.write(f"Dropping account {account_email!r}: token file for {cred_name} not found")
             continue
 
         account_info["credentials_file"] = cred_file

cli/settings/migration/migration_tools.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 from itertools import chain
 from pathlib import Path
 
-from cli.settings.core import TokenNotFoundError
 from cli.settings.token_file import TokenFile
+from cli.utils.console import print_generic_message
 
 
 def list_token_files(config_dir: Path) -> list[TokenFile]:
@@ -19,11 +21,11 @@ def list_token_files(config_dir: Path) -> list[TokenFile]:
             token_file = TokenFile.from_json_str(file.read_text())
             token_files.append(token_file)
         except Exception:
-            print(f"warning: invalid token file {file}. Consider removing it.")
+            print_generic_message(f"warning: invalid token file {file}. Consider removing it.")
     return token_files
 
 
-def get_token_file(cred_name: str, config_dir: Path) -> TokenFile:
+def get_token_file(cred_name: str, config_dir: Path) -> TokenFile | None:
     """
     Get the token file for a given credentials name.
 
@@ -32,5 +34,5 @@ def get_token_file(cred_name: str, config_dir: Path) -> TokenFile:
     token_files = list_token_files(config_dir)
     matches = [token_file for token_file in token_files if token_file.name == cred_name]
     if len(matches) != 1:
-        raise TokenNotFoundError(f"Token file for {cred_name} not found")
+        return None
     return matches[0]

cli/settings/state_file.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from datetime import datetime
+import os
+from datetime import datetime, timedelta
 from typing import Any, Optional
 
 from pydantic import BaseModel
@@ -10,9 +11,7 @@ from cli.utils.time import parse_datetime
 
 class StateFile(BaseModel):
     """
-    StateFile represents the state file for the CLI.
-
-    TODO: Should all setters return a new instance of the StateFile?
+    Contains CLI state and other application specific data.
     """
 
     version: str = "1.0"
@@ -23,8 +22,17 @@ class StateFile(BaseModel):
         Check if we should perform an update check.
 
         Returns True if the last update check time is older than 2 hours.
+
+        For Docker environments, returns False and sets a backdated timestamp
+        to prevent constant update checks due to ephemeral disks.
         """
         if not self.last_update_check_time:
+            if os.environ.get("RUNS_IN_DOCKER"):
+                # To prevent that we always check update in docker due to ephemeral disks we write an "old" check if the state
+                # is missing. If no disk is mounted we will never get the update check but if its mounted properly we will get
+                # it on the second attempt. This is good enough
+                self.last_update_check_time = (datetime.now() - timedelta(hours=10)).isoformat()
+                return False
             return True  # Returning True will trigger a check, which will properly set last_update_check_time
 
         seconds = (datetime.now() - parse_datetime(self.last_update_check_time)).seconds

cli/tools/can/can.py

@@ -2,12 +2,9 @@ from pathlib import Path
 
 import can
 import typer
-from rich.console import Console
 
 from cli.typer import typer_utils
-
-err_console = Console(stderr=True)
-console = Console()
+from cli.utils.console import print_generic_error, print_success
 
 HELP = """
 CAN related tools
@@ -49,7 +46,7 @@ def convert(
                 for msg in reader:
                     writer.on_message_received(msg)
         except Exception as e:
-            err_console.print(f":boom: [bold red]Failed to convert file[/bold red]: {e}")
+            print_generic_error(f"Failed to convert file: {e}")
 
 
 @app.command("validate")
@@ -76,6 +73,6 @@ def validate(
                 for msg in reader:
                     if print_to_terminal:
                         writer.on_message_received(msg)
-            console.print(f"Successfully verified {in_file}")
+            print_success(f"{in_file} verified")
         except Exception as e:
-            err_console.print(f":boom: [bold red]Failed to convert file[/bold red]: {e}")
+            print_generic_error(f"Failed to convert file: {e}")

cli/topology/__init__.py

@@ -0,0 +1,3 @@
+from cli.topology.cmd import app
+
+__all__ = ["app"]