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

cli/settings/core.py

@@ -3,17 +3,16 @@ 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, token_file
+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
 
@@ -23,20 +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: migrate away from singleton instance
+    TODO: How do we handle REMOTIVE_CLOUD_ACCESS_TOKEN in combination with active account? What takes precedence?
     """
 
     config_dir: Path
@@ -50,57 +46,78 @@ class Settings:
         self.state_dir = self.config_dir / "state"
         self.state_file_path = self.state_dir / CLI_INTERNAL_STATE_FILE_NAME
         if not self.state_file_path.exists():
-            self.write_state_file(StateFile())
+            self._write_state_file(StateFile())
+
+    def _get_cli_config(self) -> ConfigFile:
+        return self._read_config_file()
+
+    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:
-        cli_config = self.get_cli_config()
-        try:
-            token = settings.get_active_token_file()
-            cli_config.set_account_field(token.account.email, organisation)
-            self._write_config_file(cli_config)
-        except TokenNotFoundError:
+        """
+        Set the default organization for the active account
+        """
+        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")
             sys.exit(1)
+        active_account.default_organization = organisation
+        self._write_config_file(config)
 
-    def get_cli_config(self) -> ConfigFile:
-        try:
-            return self._read_config_file()
-        except TokenNotFoundError:
-            return ConfigFile()
-
-    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()
-        if active_account is not None:
-            token_file_name = active_account.credentials_file
-            return self._read_token_file(self.config_dir / token_file_name)
+        active_account = self.get_active_account()
+        return self._read_token_file(active_account.credentials_file) if active_account else None
 
-        raise TokenNotFoundError
+    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
         """
-        cli_config = self.get_cli_config()
-        cli_config.activate(token_file.account.email)
-        self._write_config_file(cli_config)
+        config = self._get_cli_config()
+        config.activate_account(token_file.account.email)
+        self._write_config_file(config)
+        return token_file
 
-    def clear_active_token(self) -> None:
+    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_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)
 
@@ -110,87 +127,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()
-
-        # TODO: what about the active token?
-        path = self._get_token_by_name(name)[1]
-        return path.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()
+
+        # 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)
-
-        return file
+            self.activate_token(token_file)
 
-    def read_state_file(self) -> StateFile:
-        try:
-            return StateFile.loads(self.state_file_path.read_text(encoding="utf-8"))
-        except Exception:
-            return StateFile()
-
-    def write_state_file(self, state_file: StateFile) -> None:
-        self._write_file(self.state_file_path, state_file.dumps())
-
-    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:
         """
@@ -200,110 +186,129 @@ 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 service account tokens
+        List all accounts
         """
-        return [f[0] for f in self._list_service_account_tokens()]
+        return self._get_cli_config().accounts
 
-    def list_service_account_token_files(self) -> list[Path]:
-        """
-        List paths to all service account token files
+    def list_personal_accounts(self) -> dict[str, Account]:
         """
-        return [f[1] for f in self._list_service_account_tokens()]
-
-    def _list_personal_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=token_file.PERSONAL_TOKEN_FILE_PREFIX)
+        List all personal accounts
 
-    def _list_service_account_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=token_file.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]
+        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 == "authorized_user"
+        }
+
+    def list_service_accounts(self) -> dict[str, Account]:
+        """
+        List all personal accounts
 
-    def _list_token_files(self, prefix: str = "") -> list[TokenFileMetadata]:
+        TODO: add account type to Account
         """
-        list all tokens with the correct prefix in the config dir, but omit files that are not token files
+        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
+        """
+        accounts = self._get_cli_config().accounts.values()
+        return [self._read_token_file(account.credentials_file) for account in accounts]
 
-        TODO: improve is_valid_json and is_valid_token_file using token_file parsing instead
+    def list_personal_token_files(self) -> list[TokenFile]:
+        """
+        List all personal token files
         """
+        return [token_file for token_file in self.list_token_files() if token_file.type == "authorized_user"]
 
-        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 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 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
+    def set_last_update_check_time(self, timestamp: str) -> None:
+        """
+        Sets the timestamp of the last self update check
+        """
+        state = self._read_state_file()
+        state.last_update_check_time = timestamp
+        self._write_state_file(state)
 
-        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 _get_token_by_name(self, name: str) -> TokenFile | None:
+        """
+        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 _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 _read_config_file(self) -> ConfigFile:
-        data = self._read_file(self.config_dir / CLI_CONFIG_FILE_NAME)
-        return config_file.loads(data)
-
-    def _read_file(self, path: Path) -> str:
-        if not path.exists():
-            raise TokenNotFoundError(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)
-        path = self._write_file(path, data)
-        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
-        return path
+        return self._write_file(path, data)
 
-    # Temporary function while considering how to solve this
-    def write_config_file(self, config: ConfigFile) -> Path:
-        return self._write_config_file(config)
+    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:
-        """
-        TODO: add read cache to avoid parsing the config every time we read it
-        """
-        data = config_file.dumps(config)
-        path = self._write_file(self.config_file_path, data)
-        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
-        return 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_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}")
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(data, encoding="utf8")
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
         return path
 
 

cli/settings/migration/migrate_config_file.py

@@ -5,10 +5,8 @@ import sys
 from pathlib import Path
 from typing import Any, Optional
 
-from dacite import from_dict
-
 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
 
 
@@ -23,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
@@ -54,6 +59,6 @@ def migrate_config_file(path: Path, settings: Settings) -> ConfigFile:
         return loads(data)
 
     sys.stderr.write("Migrating old configuration format")
-    migrated_config: ConfigFile = from_dict(data_class=ConfigFile, data=migrated_data)
-    settings.write_config_file(migrated_config)
+    migrated_config: ConfigFile = ConfigFile.from_dict(migrated_data)
+    settings._write_config_file(migrated_config)
     return migrated_config

cli/settings/migration/migration_tools.py

@@ -1,7 +1,8 @@
+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
 
 
@@ -23,7 +24,7 @@ def list_token_files(config_dir: Path) -> list[TokenFile]:
     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 +33,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,32 +1,67 @@
 from __future__ import annotations
 
-import dataclasses
-import json
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional
+import os
+from datetime import datetime, timedelta
+from typing import Any, Optional
 
-from dacite import from_dict
+from pydantic import BaseModel
 
 from cli.utils.time import parse_datetime
 
 
-@dataclass
-class StateFile:
+class StateFile(BaseModel):
+    """
+    Contains CLI state and other application specific data.
+    """
+
     version: str = "1.0"
     last_update_check_time: Optional[str] = None
 
-    def dumps(self) -> str:
-        return json.dumps(dataclasses.asdict(self), default=str)
-
     def should_perform_update_check(self) -> bool:
-        if self.last_update_check_time:
-            seconds = (datetime.now() - parse_datetime(self.last_update_check_time)).seconds
-            return (seconds / 3600) > 2
-        # This will solve the issue
-        return True
-
-    @staticmethod
-    def loads(data: str) -> StateFile:
-        d = json.loads(data)
-        return from_dict(StateFile, d)
+        """
+        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
+        return (seconds / 3600) > 2
+
+    @classmethod
+    def from_json_str(cls, data: str) -> StateFile:
+        return cls.model_validate_json(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> StateFile:
+        return cls.model_validate(data)
+
+    def to_json_str(self) -> str:
+        return self.model_dump_json()
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump()
+
+
+def loads(data: str) -> StateFile:
+    """
+    Creates a StateFile from a JSON string.
+    """
+    return StateFile.from_json_str(data)
+
+
+def dumps(state: StateFile) -> str:
+    """
+    Returns the JSON string representation of the StateFile.
+    """
+    return state.to_json_str()