remotivelabs-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: remotivelabs-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com
@@ -12,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: click (<8.2.0)
-Requires-Dist: dacite (>=1.9.2,<2.0.0)
 Requires-Dist: email-validator (>=2.2.0,<3.0.0)
 Requires-Dist: grpc-stubs (>=1.53.0.5)
 Requires-Dist: mypy-protobuf (>=3.0.0)

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/cloud/auth_tokens.py

@@ -10,7 +10,6 @@ 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.token_file import TokenFile
 from cli.typer import typer_utils
 from cli.utils.rest_helper import RestHelper as Rest
@@ -52,20 +51,11 @@ 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)
+            return settings.get_active_token_file()
         except TokenNotFoundError:
-            pass
-        return None
+            return None
 
     active_token = get_active_token_or_none()
     active_token_index = None
@@ -163,7 +153,8 @@ def activate(
 
 
 def prompt_to_set_org() -> None:
-    if settings.get_cli_config().get_active_default_organisation() is None:
+    active_account = settings.get_cli_config().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,

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/cloud/organisations.py

@@ -74,18 +74,17 @@ 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_cli_config().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 active_account:
+            token = settings.get_token_file(active_account.credentials_file)
             if token.type != "authorized_user":
                 ErrorPrinter.print_hint(
                     "You must supply the organization name as argument when using a service-account since the "

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/remotive.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-from importlib.metadata import version
 
 import typer
 from rich import print as rich_print
@@ -20,7 +19,7 @@ from cli.settings.migration.migrate_legacy_dirs import migrate_legacy_settings_d
 from cli.tools.tools import app as tools_app
 from cli.topology.cmd import app as topology_app
 from cli.typer import typer_utils
-from cli.utils.version_check import check_for_update
+from cli.utils import versions
 
 err_console = Console(stderr=True)
 
@@ -45,8 +44,7 @@ For documentation - https://docs.remotivelabs.com
 
 def version_callback(value: bool) -> None:
     if value:
-        my_version = version("remotivelabs-cli")
-        typer.echo(my_version)
+        typer.echo(f"remotivelabs-cli {versions.cli_version()} ({versions.platform_info()})")
 
 
 def test_callback(value: int) -> None:
@@ -56,7 +54,7 @@ def test_callback(value: int) -> None:
 
 
 def check_for_newer_version(settings: Settings) -> None:
-    check_for_update("remotivelabs-cli", version("remotivelabs-cli"), settings)
+    versions.check_for_update(settings)
 
 
 def run_migrations(settings: Settings) -> None:
@@ -84,9 +82,9 @@ def set_default_org_as_env(settings: Settings) -> None:
     This has to be done early before it is read
     """
     if "REMOTIVE_CLOUD_ORGANIZATION" not in os.environ:
-        org = settings.get_cli_config().get_active_default_organisation()
-        if org is not None:
-            os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = org
+        active_account = settings.get_cli_config().get_active_account()
+        if active_account and active_account.default_organization:
+            os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = active_account.default_organization
 
 
 @app.callback()

remotivelabs_cli-0.2.3/cli/settings/config_file.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from cli.settings.token_file import TokenFile
+
+
+class Account(BaseModel):
+    """
+    Account represents an account in the configuration file.
+    """
+
+    credentials_file: str
+    default_organization: Optional[str] = None
+
+
+class ConfigFile(BaseModel):
+    """
+    ConfigFile represents the configuration file for the CLI.
+
+    TODO: Should all setters return a new instance of the ConfigFile?
+    """
+
+    version: str = "1.0"
+    active: Optional[str] = None
+    accounts: dict[str, Account] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _validate_json_data(cls, json_data: Any) -> Any:
+        """Try to migrate old formats and missing fields as best we can."""
+        if not isinstance(json_data, dict):
+            return json_data
+
+        # If the active account is not in accounts, remove it
+        if "active" in json_data and json_data["active"] not in json_data["accounts"]:
+            del json_data["active"]
+
+        return json_data
+
+    def get_active_account(self) -> Optional[Account]:
+        if not self.active:
+            return None
+        account = self.get_account(self.active)
+        if not account:
+            raise KeyError(f"Activated account {self.active} is not a valid account")
+        return account
+
+    def activate_account(self, email: str) -> None:
+        account = self.get_account(email)
+        if not account:
+            raise KeyError(f"Account {email} does not exists")
+        self.active = email
+
+    def _update_account(self, email: str, **updates: Any) -> None:
+        """TODO: Consider using model_copy and always return a new instance of ConfigFile"""
+        existing_account = self.get_account(email)
+        if existing_account:
+            updated_account = existing_account.model_copy(update=updates)
+        else:
+            updated_account = Account(**updates)
+
+        new_accounts = {**self.accounts, email: updated_account}
+        self.accounts = new_accounts
+
+    def init_account(self, email: str, token_file: TokenFile) -> None:
+        """
+        Create a new account with the given email and token file.
+        """
+        self._update_account(email, credentials_file=token_file.get_token_file_name())
+
+    def set_default_organization_for_account(self, email: str, default_organization: Optional[str] = None) -> None:
+        if not self.get_account(email):
+            raise KeyError(f"Account with email {email} has not been initialized with token")
+        self._update_account(email, default_organization=default_organization)
+
+    def get_account(self, email: str) -> Optional[Account]:
+        return self.accounts.get(email)
+
+    def remove_account(self, email: str) -> None:
+        self.accounts.pop(email, None)
+
+    @classmethod
+    def from_json_str(cls, data: str) -> ConfigFile:
+        return cls.model_validate_json(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ConfigFile:
+        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) -> ConfigFile:
+    """
+    Creates a ConfigFile from a JSON string.
+    """
+    return ConfigFile.from_json_str(data)
+
+
+def dumps(config: ConfigFile) -> str:
+    """
+    Returns the JSON string representation of the ConfigFile.
+    """
+    return config.to_json_str()

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/settings/core.py

@@ -11,7 +11,8 @@ 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.state_file import StateFile
@@ -37,6 +38,13 @@ class TokenNotFoundError(Exception):
 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
     """
 
     config_dir: Path
@@ -50,23 +58,25 @@ 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 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)
-
-    def get_cli_config(self) -> ConfigFile:
-        try:
-            return self._read_config_file()
-        except TokenNotFoundError:
-            return ConfigFile()
+        active_account.default_organization = organisation
+        self._write_config_file(config)
 
     def get_active_token(self) -> str:
         """
@@ -79,12 +89,12 @@ class Settings:
         """
         Get the current active token file
         """
-        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_cli_config().get_active_account()
+        if not active_account:
+            raise TokenNotFoundError("No active account found")
 
-        raise TokenNotFoundError
+        token_file_name = active_account.credentials_file
+        return self._read_token_file(self.config_dir / token_file_name)
 
     def activate_token(self, token_file: TokenFile) -> None:
         """
@@ -92,9 +102,9 @@ class Settings:
 
         The token secret will be set as the current active secret.
         """
-        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)
 
     def clear_active_token(self) -> None:
         """
@@ -171,15 +181,6 @@ class Settings:
 
         return 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
@@ -224,11 +225,19 @@ class Settings:
         """
         return [f[1] for f in self._list_service_account_tokens()]
 
+    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)
+
     def _list_personal_tokens(self) -> list[TokenFileMetadata]:
-        return self._list_token_files(prefix=token_file.PERSONAL_TOKEN_FILE_PREFIX)
+        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=token_file.SERVICE_ACCOUNT_TOKEN_FILE_PREFIX)
+        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()
@@ -272,38 +281,36 @@ class Settings:
         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)
+        data = self._read_file(self.config_file_path)
+        return cf.loads(data)
+
+    def _read_state_file(self) -> StateFile:
+        data = self._read_file(self.state_file_path)
+        return sf.loads(data)
 
     def _read_file(self, path: Path) -> str:
         if not path.exists():
-            raise TokenNotFoundError(f"File could not be found: {path}")
+            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)
-        path = self._write_file(path, data)
-        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
-        return path
-
-    # Temporary function while considering how to solve this
-    def write_config_file(self, config: ConfigFile) -> Path:
-        return self._write_config_file(config)
+        return self._write_file(path, 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 _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}")
         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
 
 

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/settings/migration/migrate_config_file.py

@@ -5,8 +5,6 @@ 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.migration.migration_tools import get_token_file
@@ -54,6 +52,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

remotivelabs_cli-0.2.3/cli/settings/state_file.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+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?
+    """
+
+    version: str = "1.0"
+    last_update_check_time: Optional[str] = None
+
+    def should_perform_update_check(self) -> bool:
+        """
+        Check if we should perform an update check.
+
+        Returns True if the last update check time is older than 2 hours.
+        """
+        if not self.last_update_check_time:
+            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()

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/settings/token_file.py

@@ -29,10 +29,20 @@ def _parse_token_type(token: str) -> TokenType:
 
 
 class TokenFileAccount(BaseModel):
+    """
+    TokenFileAccount represents the account information for a token file.
+    """
+
     email: EmailStr = DEFAULT_EMAIL
 
 
 class TokenFile(BaseModel):
+    """
+    TokenFile represents a token file for the CLI.
+
+    TODO: Should all setters return a new instance of the TokenFile?
+    """
+
     version: str = "1.0"
     type: TokenType
     name: str
@@ -43,14 +53,14 @@ class TokenFile(BaseModel):
 
     @field_validator("created", "expires", mode="before")
     @classmethod
-    def validate_parse_date(cls, value: str | date) -> date:
+    def _validate_parse_date(cls, value: str | date) -> date:
         if isinstance(value, date):
             return value
         return parse_date(value)
 
     @model_validator(mode="before")
     @classmethod
-    def init_with_defaults(cls, json_data: Any) -> Any:
+    def _validate_json_data(cls, json_data: Any) -> Any:
         """
         Try to migrate old formats and missing fields as best we can.
 
@@ -76,7 +86,7 @@ class TokenFile(BaseModel):
 
     def get_token_file_name(self) -> str:
         """
-        Returns the name of the token file using the proper file name format.
+        Returns the name of the token_file following a predictable naming format.
         """
         email = _email_to_safe_filename(self.account.email) if self.account is not None else "unknown"
         if self.type == "authorized_user":
@@ -84,41 +94,23 @@ class TokenFile(BaseModel):
         return f"{SERVICE_ACCOUNT_TOKEN_FILE_PREFIX}{self.name}-{email}.json"
 
     def is_expired(self) -> bool:
-        """
-        Returns True if the token is expired, False otherwise.
-        """
         return datetime.today().date() > self.expires
 
     def expires_in_days(self) -> int:
-        """
-        Returns the number of days until the token expires.
-        """
         return (self.expires - datetime.today().date()).days
 
     @classmethod
     def from_json_str(cls, data: str) -> TokenFile:
-        """
-        Creates a TokenFile from a JSON string.
-        """
         return cls.model_validate_json(data)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> TokenFile:
-        """
-        Creates a TokenFile from a dictionary.
-        """
         return cls.model_validate(data)
 
     def to_json_str(self) -> str:
-        """
-        Returns the JSON string representation of the TokenFile.
-        """
         return self.model_dump_json()
 
     def to_dict(self) -> dict[str, Any]:
-        """
-        Returns the dictionary representation of the TokenFile.
-        """
         return self.model_dump()
 
 

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/topology/cmd.py

@@ -84,7 +84,8 @@ def start_trial(
         ErrorPrinter.print_generic_message("Your current active credentials are not valid")
         raise typer.Exit(1)
 
-    if organization is None and settings.get_cli_config().get_active_default_organisation() is None:
+    active_account = settings.get_cli_config().get_active_account()
+    if active_account and not organization and not active_account.default_organization:
         ErrorPrinter.print_hint("You have not specified any organization and no default organization is set")
         raise typer.Exit(1)
 

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/cli/utils/rest_helper.py

@@ -17,6 +17,7 @@ from rich.progress import Progress, SpinnerColumn, TextColumn, wrap_file
 
 from cli.errors import ErrorPrinter
 from cli.settings import TokenNotFoundError, settings
+from cli.utils import versions
 
 err_console = Console(stderr=True)
 
@@ -45,14 +46,7 @@ class RestHelper:
     if "cloud-dev" in __base_url:
         __license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
 
-    # if 'REMOTIVE_CLOUD_AUTH_TOKEN' not in os.environ:
-    #    print('export REMOTIVE_CLOUD_AUTH_TOKEN=auth must be set')
-    #    exit(0)
-
-    # token = os.environ["REMOTIVE_CLOUD_AUTH_TOKEN"]
-    # headers = {"Authorization": "Bearer " + token}
-
-    __headers: Dict[str, str] = {"User-Agent": f"remotivelabs-cli/{version('remotivelabs-cli')}"}
+    __headers: Dict[str, str] = {"User-Agent": f"remotivelabs-cli/{versions.cli_version()} ({versions.platform_info()})"}
     __org: str = ""
 
     __token: str = ""
@@ -90,10 +84,13 @@ class RestHelper:
 
     @staticmethod
     def ensure_auth_token(quiet: bool = False, access_token: Optional[str] = None) -> None:
+        # TODO: remove this? We already set the default organization as env in remotive.py
         if "REMOTIVE_CLOUD_ORGANIZATION" not in os.environ:
-            org = settings.get_cli_config().get_active_default_organisation()
-            if org is not None:
-                os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = org
+            active_account = settings.get_cli_config().get_active_account()
+            if active_account:
+                org = active_account.default_organization
+                if org:
+                    os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = org
 
         token = None
 

remotivelabs_cli-0.2.2/cli/utils/version_check.py → remotivelabs_cli-0.2.3/cli/utils/versions.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import datetime
 import json
 import os
+import platform
 import urllib.request
 from datetime import timedelta
 from importlib import metadata as importlib_metadata
+from importlib.metadata import version as python_project_version
 
 from packaging.version import InvalidVersion, Version
 
@@ -13,6 +15,26 @@ from cli.errors import ErrorPrinter
 from cli.settings import Settings
 
 
+def cli_version() -> str:
+    return python_project_version("remotivelabs-cli")
+
+
+def python_version() -> str:
+    return platform.python_version()
+
+
+def host_os() -> str:
+    return platform.system().lower()  # 'linux', 'darwin', 'windows'
+
+
+def host_env() -> str:
+    return "docker" if os.environ.get("RUNS_IN_DOCKER") else "native"
+
+
+def platform_info() -> str:
+    return f"python {python_version()}; {host_os()}; {host_env()}"
+
+
 def _pypi_latest(
     project: str, *, include_prereleases: bool, timeout: float = 2.5, user_agent: str | None = None
 ) -> tuple[str | None, str | None]:
@@ -59,32 +81,31 @@ def _installed_version(distribution_name: str, fallback: str | None = None) -> s
         return fallback
 
 
-def check_for_update(project: str, current_version: str, settings: Settings) -> None:
+def check_for_update(settings: Settings) -> None:
     # Make it possible to disable update check, i.e in CI
     if os.environ.get("PYTHON_DISABLE_UPDATE_CHECK"):
         return
+    project = "remotivelabs-cli"
 
     # Determine current version
-    cur = current_version or _installed_version(project)
+    cur = cli_version() or _installed_version(project)
     if not cur:
         return  # unknown version → skip silently
 
-    state = settings.read_state_file()
-
+    state = settings.get_state_file()
     if not state.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
-            state.last_update_check_time = (datetime.datetime.now() - timedelta(hours=10)).isoformat()
-            settings.write_state_file(state)
+            last_update_check_time = (datetime.datetime.now() - timedelta(hours=10)).isoformat()
+            settings.set_last_update_check_time(last_update_check_time)
             return
 
     elif not state.should_perform_update_check():
         return
 
     # We end up here if last_update_check_time is None or should_perform_update_check is true
-
     include_prereleases = Version(cur).is_prerelease or Version(cur).is_devrelease
 
     latest, proj_url = _pypi_latest(
@@ -96,8 +117,7 @@ def check_for_update(project: str, current_version: str, settings: Settings) ->
                 cur,
                 latest,
             )
-    state.last_update_check_time = datetime.datetime.now().isoformat()
-    settings.write_state_file(state)
+    settings.set_last_update_check_time(datetime.datetime.now().isoformat())
 
 
 def _print_update_info(cur: str, latest: str) -> None:

{remotivelabs_cli-0.2.2 → remotivelabs_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "remotivelabs-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "CLI for operating RemotiveCloud and RemotiveBroker"
 authors = ["Johan Rask <johan.rask@remotivelabs.com>"]
 readme = "README.md"
@@ -26,7 +26,6 @@ python-can = ">=4.3.1"
 grpc-stubs = ">=1.53.0.5"
 mypy-protobuf = ">=3.0.0"
 types-requests = "^2.32.0.20240622"
-dacite = "^1.9.2"
 pydantic = "^2.11.7"
 email-validator = "^2.2.0"
 

remotivelabs_cli-0.2.2/cli/settings/config_file.py

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import json
-from dataclasses import dataclass
-from typing import Any, Optional
-
-from dacite import from_dict
-
-from cli.settings.token_file import TokenFile
-
-
-def loads(data: str) -> ConfigFile:
-    d = json.loads(data)
-    return from_dict(ConfigFile, d)
-
-
-def dumps(config: ConfigFile) -> str:
-    return json.dumps(dataclasses.asdict(config), default=str)
-
-
-@dataclass
-class Account:
-    credentials_file: str
-    default_organization: Optional[str] = None
-    # Add project as well
-
-
-@dataclass
-class ConfigFile:
-    version: str = "1.0"
-    active: Optional[str] = None
-    accounts: dict[str, Account] = dataclasses.field(default_factory=dict)
-
-    def get_active_default_organisation(self) -> Optional[str]:
-        active_account = self.get_active()
-        return active_account.default_organization if active_account else None
-
-    def get_active(self) -> Optional[Account]:
-        if not self.active:
-            return None
-        account = self.get_account(self.active)
-        if not account:
-            raise KeyError(f"Activated account {self.active} is not a valid account")
-        return account
-
-    def activate(self, email: str) -> None:
-        account = self.get_account(email)
-        if not account:
-            raise KeyError(f"Account {email} does not exists")
-        self.active = email
-
-    def get_account(self, email: str) -> Optional[Account]:
-        if not self.accounts:
-            return None
-        return self.accounts.get(email, None)
-
-    def remove_account(self, email: str) -> None:
-        if self.accounts:
-            self.accounts.pop(email, None)
-
-    def init_account(self, email: str, token_file: TokenFile) -> None:
-        if self.accounts is None:
-            self.accounts = {}
-
-        account = self.get_account(email)
-        if not account:
-            account = Account(credentials_file=token_file.get_token_file_name())
-        else:
-            account.credentials_file = token_file.get_token_file_name()
-        self.accounts[email] = account
-
-    def set_account_field(self, email: str, default_organization: Optional[str] = None) -> ConfigFile:
-        if self.accounts is None:
-            self.accounts = {}
-
-        account = self.get_account(email)
-        if not account:
-            raise KeyError(f"Account with email {email} has not been initialized with token")
-
-        # Update only fields explicitly passed
-        if default_organization is not None:
-            account.default_organization = default_organization
-
-        return self
-
-    @staticmethod
-    def from_json_str(data: str) -> ConfigFile:
-        return loads(data)
-
-    @staticmethod
-    def from_dict(data: dict[str, Any]) -> ConfigFile:
-        return from_dict(ConfigFile, data)

remotivelabs_cli-0.2.2/cli/settings/state_file.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import json
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional
-
-from dacite import from_dict
-
-from cli.utils.time import parse_datetime
-
-
-@dataclass
-class StateFile:
-    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)