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

cli/cloud/service_account_tokens.py

@@ -56,6 +56,6 @@ def revoke(
         Rest.handle_patch(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}/revoke", quiet=True)
     if delete:
         Rest.handle_delete(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}", quiet=True)
-        token_with_name = [token for token in settings.list_service_account_tokens() if token.name == name]
+        token_with_name = [token for token in settings.list_service_account_token_files() if token.name == name]
         if len(token_with_name) > 0:
             settings.remove_token_file(name)

cli/connect/protopie/protopie.py

@@ -11,12 +11,12 @@ from typing import Any, Dict, List, Tuple, Union
 
 import grpc
 import socketio
-from remotivelabs.broker.sync import BrokerException, Client, SignalIdentifier, SignalsInFrame
 from rich import print as pretty_print
 from rich.console import Console
 from socketio.exceptions import ConnectionError as SocketIoConnectionError
 
 from cli.broker.lib.broker import SubscribableSignal
+from cli.broker.lib.client import BrokerException, Client, SignalIdentifier, SignalsInFrame
 from cli.errors import ErrorPrinter
 from cli.settings import settings
 

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
@@ -10,17 +9,16 @@ from trogon import Trogon
 from typer.main import get_group
 
 from cli.broker.brokers import app as broker_app
-from cli.cloud.cloud_cli import app as cloud_app
+from cli.cloud import app as cloud_app
 from cli.connect.connect import app as connect_app
-from cli.settings import settings
-from cli.settings.core import Settings
+from cli.settings import Settings, settings
 from cli.settings.migration.migrate_all_token_files import migrate_any_legacy_tokens
 from cli.settings.migration.migrate_config_file import migrate_config_file
 from cli.settings.migration.migrate_legacy_dirs import migrate_legacy_settings_dirs
 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 +43,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 +53,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 +81,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_active_account()
+        if active_account and active_account.default_organization:
+            os.environ["REMOTIVE_CLOUD_ORGANIZATION"] = active_account.default_organization
 
 
 @app.callback()
@@ -115,21 +112,15 @@ def tui(ctx: typer.Context) -> None:
 
 
 app.add_typer(broker_app, name="broker", help="Manage a single broker - local or cloud")
-app.add_typer(
-    cloud_app,
-    name="cloud",
-    help="Manage resources in RemotiveCloud",
-)
+app.add_typer(cloud_app, name="cloud", help="Manage resources in RemotiveCloud")
 app.add_typer(connect_app, name="connect", help="Integrations with other systems")
 app.add_typer(tools_app, name="tools")
+app.add_typer(
+    topology_app,
+    name="topology",
+    help="""
+Interact and manage RemotiveTopology resources
 
-if is_featue_flag_enabled("REMOTIVE_TOPOLOGY_ENABLED"):
-    app.add_typer(
-        topology_app,
-        name="topology",
-        help="""
-    RemotiveTopology actions
-
-    Read more at https://docs.remotivelabs.com/docs/remotive-topology
-    """,
-    )
+Read more at https://docs.remotivelabs.com/docs/remotive-topology
+""",
+)

cli/settings/__init__.py

@@ -1,14 +1,13 @@
 from cli.settings.config_file import Account, ConfigFile
 from cli.settings.config_file import dumps as dumps_config_file
 from cli.settings.config_file import loads as loads_config_file
-from cli.settings.core import InvalidSettingsFilePathError, Settings, TokenNotFoundError, settings
+from cli.settings.core import InvalidSettingsFilePathError, Settings, settings
 from cli.settings.token_file import TokenFile
 from cli.settings.token_file import dumps as dumps_token_file
 from cli.settings.token_file import loads as loads_token_file
 
 __all__ = [
     "settings",
-    "TokenNotFoundError",
     "InvalidSettingsFilePathError",
     "Settings",
     "TokenFile",

cli/settings/config_file.py

@@ -1,42 +1,48 @@
 from __future__ import annotations
 
-import dataclasses
-import json
-from dataclasses import dataclass
 from typing import Any, Optional
 
-from dacite import from_dict
+from pydantic import BaseModel, Field, model_validator
 
 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)
+class Account(BaseModel):
+    """
+    Account represents an account in the configuration file.
 
+    TODO: Add email field to Account
+    """
 
-@dataclass
-class Account:
     credentials_file: str
     default_organization: Optional[str] = None
-    # Add project as well
 
 
-@dataclass
-class ConfigFile:
+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] = dataclasses.field(default_factory=dict)
+    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
 
-    def get_active_default_organisation(self) -> Optional[str]:
-        active_account = self.get_active()
-        return active_account.default_organization if active_account else None
+        # 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"]
 
-    def get_active(self) -> Optional[Account]:
+        return json_data
+
+    def get_active_account(self) -> Optional[Account]:
         if not self.active:
             return None
         account = self.get_account(self.active)
@@ -44,50 +50,64 @@ class ConfigFile:
             raise KeyError(f"Activated account {self.active} is not a valid account")
         return account
 
-    def activate(self, email: str) -> None:
+    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]:
-        if not self.accounts:
-            return None
-        return self.accounts.get(email, None)
+        return self.accounts.get(email)
 
     def remove_account(self, email: str) -> None:
-        if self.accounts:
-            self.accounts.pop(email, None)
+        self.accounts.pop(email, None)
 
-    def init_account(self, email: str, token_file: TokenFile) -> None:
-        if self.accounts is None:
-            self.accounts = {}
+    @classmethod
+    def from_json_str(cls, data: str) -> ConfigFile:
+        return cls.model_validate_json(data)
 
-        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
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ConfigFile:
+        return cls.model_validate(data)
 
-    def set_account_field(self, email: str, default_organization: Optional[str] = None) -> ConfigFile:
-        if self.accounts is None:
-            self.accounts = {}
+    def to_json_str(self) -> str:
+        return self.model_dump_json()
 
-        account = self.get_account(email)
-        if not account:
-            raise KeyError(f"Account with email {email} has not been initialized with token")
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump()
 
-        # Update only fields explicitly passed
-        if default_organization is not None:
-            account.default_organization = default_organization
 
-        return self
+def loads(data: str) -> ConfigFile:
+    """
+    Creates a ConfigFile from a JSON string.
+    """
+    return ConfigFile.from_json_str(data)
 
-    @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)
+def dumps(config: ConfigFile) -> str:
+    """
+    Returns the JSON string representation of the ConfigFile.
+    """
+    return config.to_json_str()