remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/settings/migration/migrate_token_file.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from remotivelabs.cli.settings.token_file import TokenFile, TokenFileAccount
+from remotivelabs.cli.utils.rest_helper import RestHelper
+
+
+class InvalidTokenError(Exception):
+    """Raised when a token is invalid."""
+
+
+class UnsupportedTokenVersionError(Exception):
+    """Raised when a token version is not supported."""
+
+
+def migrate_legacy_token(token: TokenFile) -> TokenFile:
+    """
+    Migrate a token from a legacy format to the latest format.
+
+    Args:
+        token: The token to migrate.
+
+    Returns:
+        TokenFile: The migrated token.
+
+    Raises:
+        InvalidTokenError: If the token is invalid.
+        UnsupportedTokenVersionError: If the token version is not supported.
+    """
+    # use a naive approach to compare versions for now
+    version = float(token.version)
+
+    # already migrated
+    if version >= 1.1:
+        return token
+
+    if version == 1.0:
+        res = RestHelper.handle_get("/api/whoami", return_response=True, allow_status_codes=[401, 400, 403], access_token=token.token)
+        if res.status_code != 200:
+            raise InvalidTokenError(f"Token {token.name} is invalid")
+
+        email = res.json()["email"]
+        return TokenFile(
+            version="1.1",
+            type=token.type,
+            name=token.name,
+            token=token.token,
+            created=token.created,
+            expires=token.expires,
+            account=TokenFileAccount(email=email),
+        )
+
+    raise UnsupportedTokenVersionError(f"Unsupported token version: {token.version}")

remotivelabs/cli/settings/migration/migration_tools.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from itertools import chain
+from pathlib import Path
+
+from remotivelabs.cli.settings.token_file import TokenFile
+from remotivelabs.cli.utils.console import print_generic_message
+
+
+def list_token_files(config_dir: Path) -> list[TokenFile]:
+    """
+    List all token files in the config directory
+
+    Note! Dont use settings, as that will couple settings to the old config and token formats we want to migrate away from.
+    """
+    token_files = []
+    patterns = ["personal-token-*.json", "service-account-token-*.json"]
+    files = list(chain.from_iterable(config_dir.glob(pattern) for pattern in patterns))
+    for file in files:
+        try:
+            token_file = TokenFile.from_json_str(file.read_text())
+            token_files.append(token_file)
+        except Exception:
+            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 | None:
+    """
+    Get the token file for a given credentials name.
+
+    Note! Dont use settings, as that will couple settings to the old config and token formats we want to migrate away from.
+    """
+    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:
+        return None
+    return matches[0]

remotivelabs/cli/settings/state_file.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os
+from datetime import datetime, timedelta
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from remotivelabs.cli.utils.time import parse_datetime
+
+
+class StateFile(BaseModel):
+    """
+    Contains CLI state and other application specific data.
+    """
+
+    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.
+
+        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()

remotivelabs/cli/settings/token_file.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import re
+from datetime import date, datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, EmailStr, Field, field_validator, model_validator
+
+from remotivelabs.cli.utils.time import parse_date
+
+DEFAULT_EMAIL = "unknown@remotivecloud.com"
+PERSONAL_TOKEN_FILE_PREFIX = "personal-token-"
+SERVICE_ACCOUNT_TOKEN_FILE_PREFIX = "service-account-token-"
+
+TokenType = Literal["authorized_user", "service_account"]
+
+
+def _email_to_safe_filename(email: str) -> str:
+    """Replace any invalid character with an underscore"""
+    return re.sub(r'[<>:"/\\|?*]', "_", email)
+
+
+def _parse_token_type(token: str) -> TokenType:
+    if token.startswith("pa"):
+        return "authorized_user"
+    if token.startswith("sa"):
+        return "service_account"
+    raise ValueError(f"Unknown token type for token: {token}")
+
+
+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
+    token: str
+    created: date
+    expires: date
+    account: TokenFileAccount = Field(default_factory=TokenFileAccount)
+
+    @field_validator("created", "expires", mode="before")
+    @classmethod
+    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 _validate_json_data(cls, json_data: Any) -> Any:
+        """
+        Try to migrate old formats and missing fields as best we can.
+
+        NOTE: If we ever need to add a new version (like 2.0), we should add explicit classes for each version (e.g. TokenFileV1,
+        TokenFileV2, etc.), each with their own fields. This will allow us to migrate to new versions without breaking
+        backwards compatibility.
+        """
+        if not isinstance(json_data, dict):
+            return json_data
+
+        if "version" not in json_data:
+            json_data["version"] = "1.0"
+
+        if "type" not in json_data and "token" in json_data:
+            json_data["type"] = _parse_token_type(json_data["token"])
+
+        if "account" not in json_data:
+            json_data["account"] = {"email": DEFAULT_EMAIL}
+        elif isinstance(json_data["account"], str):
+            json_data["account"] = {"email": json_data["account"]}
+
+        return json_data
+
+    def get_token_file_name(self) -> str:
+        """
+        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":
+            return f"{PERSONAL_TOKEN_FILE_PREFIX}{self.name}-{email}.json"
+        return f"{SERVICE_ACCOUNT_TOKEN_FILE_PREFIX}{self.name}-{email}.json"
+
+    def is_expired(self) -> bool:
+        return datetime.today().date() > self.expires
+
+    def expires_in_days(self) -> int:
+        return (self.expires - datetime.today().date()).days
+
+    @classmethod
+    def from_json_str(cls, data: str) -> TokenFile:
+        return cls.model_validate_json(data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TokenFile:
+        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) -> TokenFile:
+    """
+    Creates a TokenFile from a JSON string.
+    """
+    return TokenFile.from_json_str(data)
+
+
+def dumps(token_file: TokenFile) -> str:
+    """
+    Returns the JSON string representation of the TokenFile.
+    """
+    return token_file.to_json_str()

remotivelabs/cli/tools/can/can.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+
+import can
+import typer
+
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_error, print_success
+
+HELP = """
+CAN related tools
+"""
+
+app = typer_utils.create_typer(help=HELP)
+
+
+@app.command("convert")
+def convert(
+    in_file: Path = typer.Argument(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="File to convert from (.blf .asc .log)",
+    ),
+    out_file: Path = typer.Argument(
+        exists=False,
+        file_okay=True,
+        dir_okay=False,
+        writable=True,
+        readable=True,
+        resolve_path=True,
+        help="File to convert to (.blf .asc .log)",
+    ),
+) -> None:
+    r"""
+    Converts between ASC, BLF and LOG files. Files must end with .asc, .blf or .log.
+
+    remotive tools can convert \[my_file.blf|.log|.asc] \[my_file.blf|.log|.asc]
+    """
+
+    with can.LogReader(in_file, relative_timestamp=False) as reader:
+        try:
+            with can.Logger(out_file) as writer:
+                for msg in reader:
+                    writer.on_message_received(msg)
+        except Exception as e:
+            print_generic_error(f"Failed to convert file: {e}")
+
+
+@app.command("validate")
+def validate(
+    in_file: Path = typer.Argument(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="File to validate (.blf .asc .log)",
+    ),
+    print_to_terminal: bool = typer.Option(False, help="Print file contents to terminal"),
+) -> None:
+    r"""
+    Validates that the input file is an ASC, BLF and LOG file
+
+    remotive tools can validate \[my_file.blf|.log|.asc]
+    """
+    with can.LogReader(in_file, relative_timestamp=False) as reader:
+        try:
+            with can.Printer() as writer:
+                for msg in reader:
+                    if print_to_terminal:
+                        writer.on_message_received(msg)
+            print_success(f"{in_file} verified")
+        except Exception as e:
+            print_generic_error(f"Failed to convert file: {e}")

remotivelabs/cli/tools/tools.py

@@ -0,0 +1,9 @@
+from remotivelabs.cli.tools.can.can import app as can_app
+from remotivelabs.cli.typer import typer_utils
+
+HELP_TEXT = """
+CLI tools unrelated to cloud or broker
+"""
+
+app = typer_utils.create_typer(help=HELP_TEXT)
+app.add_typer(can_app, name="can", help="CAN tools")

remotivelabs/cli/topology/__init__.py

@@ -0,0 +1,28 @@
+from enum import Enum
+
+import typer
+
+from remotivelabs.cli.topology.all import app
+
+
+class ContainerEngine(str, Enum):
+    docker = "docker"
+    podman = "podman"
+
+
+@app.callback()
+def service_callback(
+    ctx: typer.Context,
+    topology_cmd: str = typer.Option(
+        None, envvar="REMOTIVE_TOPOLOGY_COMMAND", hidden=True, help="Optional path to RemotiveTopology command"
+    ),
+    topology_image: str = typer.Option(None, envvar="REMOTIVE_TOPOLOGY_IMAGE", help="Optional docker image for RemotiveTopology "),
+    container_engine: ContainerEngine = typer.Option(ContainerEngine.docker, envvar="CONTAINER_ENGINE", help="Specify container engine"),
+) -> None:
+    ctx.obj = ctx.obj or {}
+    ctx.obj["topology_cmd"] = topology_cmd
+    ctx.obj["topology_image"] = topology_image
+    ctx.obj["container_engine"] = container_engine.name
+
+
+__all__ = ["app"]