remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/topology/all.py

@@ -0,0 +1,322 @@
+# ruff: noqa
+from __future__ import annotations
+
+import typer
+
+from remotivelabs.cli.topology.cmd import app as topology
+from remotivelabs.cli.topology.cli import run_topology_cli
+from remotivelabs.cli.typer import typer_utils
+
+app = topology
+
+topology_show = typer_utils.create_typer_sorted(
+    rich_markup_mode="rich",
+    help="""
+Show information from database file
+""",
+)
+
+topology.add_typer(topology_show, name="show")
+
+
+@topology_show.command("signals")
+def topology_show_signals(
+    ctx: typer.Context,
+    path: str = typer.Argument(
+        ..., help="Path to the Database file, supported extensions: extensions: '.arxml', '.dbc', '.xml', '.ldf', '.signaldb.yaml'"
+    ),
+    out_path: str | None = typer.Argument(None, help="Write content to provided file path"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+    jsonl: bool = typer.Option(False, "--jsonl", help="Output results in JSONL format"),
+    broker_format: bool = typer.Option(False, "--bf", help="Output results in broker format"),
+) -> None:
+    """
+    [EXPERIMENTAL] Show signals in the provided database file
+    """
+    cmd = ["show", "signals"]
+    cmd.append(path)
+    if out_path is not None:
+        cmd.append(out_path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    if jsonl:
+        cmd.append("--jsonl")
+    if broker_format:
+        cmd.append("--bf")
+    run_topology_cli(ctx, cmd)
+
+
+@topology_show.command("constants")
+def topology_show_constants(
+    ctx: typer.Context,
+    path: str = typer.Argument(..., help="Path to the Database file, supported extensions: extensions: '.arxml'"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+) -> None:
+    """
+    [EXPERIMENTAL] Extract constants from database file
+    """
+    cmd = ["show", "constants"]
+    cmd.append(path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    run_topology_cli(ctx, cmd)
+
+
+@topology_show.command("topology")
+def topology_show_topology(
+    ctx: typer.Context,
+    path: str = typer.Argument(
+        ...,
+        help="Path to the Database file, supported extensions: extensions: '.arxml', '.xml', '.instance.yaml', '.platform.yaml', '.dbc', '.ldf', '.signaldb.yaml'",
+    ),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+    resolve: bool = typer.Option(False, "--resolve", help="Show the resolved topology"),
+    check: bool = typer.Option(False, "--check", help="Check topology, requires --resolve"),
+    verbose: bool = typer.Option(False, "--verbose", help="Show verbose output"),
+    out_path: str | None = typer.Option(None, "-o", "--out-path", help="Write content to provided file path"),
+) -> None:
+    """
+    Shows the topology from database or instance file
+    """
+    cmd = ["show", "topology"]
+    cmd.append(path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    if resolve:
+        cmd.append("--resolve")
+    if check:
+        cmd.append("--check")
+    if verbose:
+        cmd.append("--verbose")
+    if out_path is not None:
+        cmd.extend(["--out-path", out_path])
+    run_topology_cli(ctx, cmd)
+
+
+@topology_show.command("ethernet")
+def topology_show_ethernet(
+    ctx: typer.Context,
+    path: str = typer.Argument(..., help="Path to the Database file, supported extensions: extensions: '.arxml'"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+) -> None:
+    """
+    [EXPERIMENTAL] Shows Ethernet configuration from database file
+    """
+    cmd = ["show", "ethernet"]
+    cmd.append(path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    run_topology_cli(ctx, cmd)
+
+
+@topology_show.command("services")
+def topology_show_services(
+    ctx: typer.Context,
+    path: str = typer.Argument(..., help="Path to the Database file, supported extensions: extensions: '.arxml'"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+    services: list[str] = typer.Option([], "-s", "--services", help="List of SOME/IP services to process"),
+) -> None:
+    """
+    [EXPERIMENTAL] Show SOME/IP services from database file
+    """
+    cmd = ["show", "services"]
+    cmd.append(path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    for item in services:
+        cmd.extend(["--services", item])
+    run_topology_cli(ctx, cmd)
+
+
+@topology.command("generate")
+def topology_generate(
+    ctx: typer.Context,
+    topology_output_path: str = typer.Argument(..., help="Path to where generated files should be written"),
+    name: str | None = typer.Option(None, "-n", "--name", help="Name of the generated topology"),
+    topology_files: list[str] = typer.Option(
+        [], "-f", "--file", help="RemotiveTopology .instance.yaml file(s), applied in the order they are provided"
+    ),
+) -> None:
+    """
+    Generate topology environment based on instance descriptions
+    """
+    cmd = ["generate"]
+    cmd.append(topology_output_path)
+    if name is not None:
+        cmd.extend(["--name", name])
+    for item in topology_files:
+        cmd.extend(["--file", item])
+    run_topology_cli(ctx, cmd)
+
+
+topology_recording_session = typer_utils.create_typer_sorted(
+    rich_markup_mode="rich",
+    help="""
+Work with recording sessions
+""",
+)
+
+topology.add_typer(topology_recording_session, name="recording-session")
+
+
+@topology_recording_session.command("create")
+def topology_recording_session_create(
+    ctx: typer.Context,
+    out_path: str | None = typer.Argument(None, help="Write content to provided file path"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+    recording_files: list[str] = typer.Option(
+        [], "-f", "--file", help="Recording file(s), applied in the order they are provided, e.g. candump.log, .csv"
+    ),
+) -> None:
+    """
+    Create a new recording session from recording files
+    """
+    cmd = ["recording_session", "create"]
+    if out_path is not None:
+        cmd.append(out_path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    for item in recording_files:
+        cmd.extend(["--file", item])
+    run_topology_cli(ctx, cmd)
+
+
+@topology_recording_session.command("instantiate")
+def topology_recording_session_instantiate(
+    ctx: typer.Context,
+    recording_session: str = typer.Argument(..., help="Path to the recording session file"),
+    out_path: str | None = typer.Argument(None, help="Write content to provided file path"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+) -> None:
+    """
+    Create a topology instance ready to play a recording session
+    """
+    cmd = ["recording_session", "instantiate"]
+    cmd.append(recording_session)
+    if out_path is not None:
+        cmd.append(out_path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    run_topology_cli(ctx, cmd)
+
+
+@topology_recording_session.command("recalculate")
+def topology_recording_session_recalculate(
+    ctx: typer.Context,
+    recording_session: str = typer.Argument(..., help="Path to the recording session file"),
+    out_path: str | None = typer.Argument(None, help="Write content to provided file path"),
+    json: bool = typer.Option(False, "--json", help="Output results in JSON format"),
+    yaml: bool = typer.Option(False, "--yaml", help="Output results in YAML format (default)"),
+) -> None:
+    """
+    Recalculate the recording session start and end time based on the files and their offsets
+    """
+    cmd = ["recording_session", "recalculate"]
+    cmd.append(recording_session)
+    if out_path is not None:
+        cmd.append(out_path)
+    if json:
+        cmd.append("--json")
+    if yaml:
+        cmd.append("--yaml")
+    run_topology_cli(ctx, cmd)
+
+
+@topology.command("split")
+def topology_split(
+    ctx: typer.Context,
+    topology_output_path: str = typer.Argument(..., help="Path to a folder where generated signal databases should be written"),
+    topology_description_files: list[str] = typer.Option(
+        [], "-f", "--file", help="RemotiveTopology platform file(s), applied in the order they are provided"
+    ),
+) -> None:
+    """
+    [DEPRECATED] Extract individual signal databases for each channel in a RemotiveTopology platform.
+    """
+    cmd = ["split"]
+    cmd.append(topology_output_path)
+    for item in topology_description_files:
+        cmd.extend(["--file", item])
+    run_topology_cli(ctx, cmd)
+
+
+@topology.command("convert")
+def topology_convert(
+    ctx: typer.Context,
+    topology_description_files: str = typer.Option(..., "-f", "--file", help="RemotiveTopology platform file"),
+    output_file: str | None = typer.Option(
+        None,
+        "-o",
+        "--output",
+        help="Optional path to a file where generated signal database should be written. If not provided, the result will be printed to stdout.",
+    ),
+    format: str | None = typer.Option(None, "--format", help="Format to convert to. Currently only 'remotive' is supported."),
+    channel_names: list[str] = typer.Option(
+        [], "-c", "--channel", help="Optional channel(s) to convert. If not provided, all CAN channels will be converted."
+    ),
+) -> None:
+    """
+    [EXPERIMENTAL] Convert signal database to different format. Currently only CAN frames is supported.
+    """
+    cmd = ["convert"]
+    cmd.extend(["--file", topology_description_files])
+    if output_file is not None:
+        cmd.extend(["--output", output_file])
+    if format is not None:
+        cmd.extend(["--format", format])
+    for item in channel_names:
+        cmd.extend(["--channel", item])
+    run_topology_cli(ctx, cmd)
+
+
+@topology.command("validate")
+def topology_validate(
+    ctx: typer.Context, path: str = typer.Argument(..., help="Path to the Database file, supported extensions: extensions: '.arxml'")
+) -> None:
+    """
+    [EXPERIMENTAL] Validate file
+    """
+    cmd = ["validate"]
+    cmd.append(path)
+    run_topology_cli(ctx, cmd)
+
+
+@topology.command("gateway-mapping")
+def topology_gateway_mapping(
+    ctx: typer.Context,
+    out_path: str = typer.Argument(..., help="Path to file where extracted gateway mapping should be written"),
+    only_fully_resolved: bool = typer.Option(False, "-o", "--only-fully-resolved", help="Only show fully resolved mapping"),
+    gateway_ecu: str = typer.Option(..., "-g", "--gateway-ecu", help="Gateway ECU name"),
+    platform: str = typer.Option(..., "-p", "--platform", help="Topology platform"),
+) -> None:
+    """
+    [EXPERIMENTAL] List gateway mapping for ECU
+    """
+    cmd = ["gateway_mapping"]
+    cmd.append(out_path)
+    if only_fully_resolved:
+        cmd.append("--only-fully-resolved")
+    cmd.extend(["--gateway-ecu", gateway_ecu])
+    cmd.extend(["--platform", platform])
+    run_topology_cli(ctx, cmd)

remotivelabs/cli/topology/cli/__init__.py

@@ -0,0 +1,3 @@
+from remotivelabs.cli.topology.cli.topology_cli import run_topology_cli
+
+__all__ = ["run_topology_cli"]

remotivelabs/cli/topology/cli/run_in_docker.py

@@ -0,0 +1,58 @@
+"""
+Delegate all arguments to the remotive-topology CLI inside Docker.
+Example:
+  remotive topology status --help
+"""
+
+import os
+import shutil
+import subprocess
+
+import typer
+
+
+def check_docker_installed() -> None:
+    """Check if Docker is installed and accessible."""
+    if shutil.which("docker") is None:
+        typer.echo("❌ Docker is not installed or not in PATH.", err=True)
+        typer.echo("👉 Please install Docker: https://docs.docker.com/get-docker/", err=True)
+        raise typer.Exit(code=1)
+
+
+def run_topology_cli_in_docker(ctx: typer.Context, args: list[str]) -> None:
+    check_docker_installed()
+
+    topology_image = ctx.obj.get("topology_image") or "remotivelabs/remotive-topology:0.14.1"
+    container_engine = ctx.obj.get("container_engine")
+    # Build base docker command equivalent to your alias
+    docker_cmd = [
+        container_engine,
+        "run",
+    ]
+    # -u flag only works on Unix (os.getuid/getgid not available on Windows)
+    if hasattr(os, "getuid") and hasattr(os, "getgid"):
+        docker_cmd += ["-u", f"{os.getuid()}:{os.getgid()}"]  # type: ignore[unused-ignore, attr-defined]  # needed on Windows
+    docker_cmd += [
+        "--rm",
+        "-v",
+        f"{os.path.expanduser('~')}/.config/remotive/:/.config/remotive",
+        "-v",
+        f"{os.getcwd()}:{os.getcwd()}",
+        "-w",
+        os.getcwd(),
+        "-e",
+        f"REMOTIVE_CLOUD_ORGANIZATION={os.environ.get('REMOTIVE_CLOUD_ORGANIZATION', '')}",
+        "-e",
+        f"REMOTIVE_CLOUD_AUTH_TOKEN={os.environ.get('REMOTIVE_CLOUD_AUTH_TOKEN', '')}",
+        "-e",
+        "REMOTIVE_CONFIG_DIR=/.config/remotive",
+    ]
+    docker_cmd += [topology_image] + args
+
+    try:
+        subprocess.run(docker_cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        raise typer.Exit(code=e.returncode)
+    except FileNotFoundError:
+        typer.echo(f"❌ {container_engine} not found. Make sure {container_engine} is installed and in PATH.", err=True)
+        raise typer.Exit(code=1)

remotivelabs/cli/topology/cli/topology_cli.py

@@ -0,0 +1,16 @@
+import subprocess
+
+import typer
+
+from remotivelabs.cli.topology.cli.run_in_docker import run_topology_cli_in_docker
+
+
+def run_topology_cli(ctx: typer.Context, args: list[str]) -> None:
+    if ctx.obj["topology_cmd"] is None:
+        run_topology_cli_in_docker(ctx, args)
+    else:
+        cmd = [ctx.obj["topology_cmd"]] + args
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            raise typer.Exit(code=e.returncode)

remotivelabs/cli/topology/cmd.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import typer
+
+from remotivelabs.cli.topology.cli.topology_cli import run_topology_cli
+from remotivelabs.cli.topology.start_trial import (
+    MissingOrganizationError,
+    NoActiveAccountError,
+    NoOrganizationOrPermissionError,
+    NotAuthorizedError,
+    NotAuthorizedToStartTrialError,
+    NotSignedInError,
+    SubscriptionExpiredError,
+    get_organization_and_account,
+    start_trial,
+)
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_error, print_generic_message, print_hint
+
+HELP = """
+Manage RemotiveTopology resources
+"""
+
+app = typer_utils.create_typer_sorted(rich_markup_mode="rich", help=HELP)
+
+
+@app.command("start-trial")
+def start_trial_cmd(  # noqa: C901
+    organization: str = typer.Option(None, help="Organization to start trial for", envvar="REMOTIVE_CLOUD_ORGANIZATION"),
+) -> None:
+    """
+    Allows you ta start a 30 day trial subscription for running RemotiveTopology.
+
+    You can read more at https://docs.remotivelabs.com/docs/remotive-topology.
+    """
+
+    try:
+        (valid_organization, _) = get_organization_and_account(organization_uid=organization)
+        ok_to_start_trial = typer.confirm(
+            f"You are about to start trial of RemotiveTopology for {valid_organization.display_name}"
+            f" (uid={valid_organization.uid}), continue?",
+            default=True,
+        )
+        if not ok_to_start_trial:
+            return
+
+        (subscription, created) = start_trial(organization)
+
+        def print_start_trial_result() -> None:
+            assert subscription.type in ("trial", "paid"), f"Unexpected subscription type: {subscription.type}"
+            kind = None
+            status = None
+            if subscription.type == "trial":
+                status = "started now" if created else "is already active"
+                kind = "trial subscription"
+            elif subscription.type == "paid":
+                status = "started now" if created else "is already started"
+                kind = "subscription"
+
+            end_text = subscription.end_date or "Never"
+            print_generic_message(f"RemotiveTopology {kind} for {valid_organization.display_name} {status}, expires {end_text}")
+
+        print_start_trial_result()
+
+    except NotSignedInError:
+        print_generic_error(
+            "You must first sign in to RemotiveCloud, please use [bold]remotive cloud auth login[/bold] to sign-in"
+            "This requires a RemotiveCloud account, if you do not have an account you can sign-up at https://cloud.remotivelabs.com"
+        )
+        raise typer.Exit(2)
+
+    except NoActiveAccountError:
+        print_hint(
+            "You have not activated your account, please run [bold]remotive cloud auth activate[/bold] to choose an account"
+            "or [bold]remotive cloud auth login[/bold] to sign-in"
+        )
+        raise typer.Exit(3)
+
+    except NotAuthorizedError:
+        print_hint(
+            "Your current active credentials are not valid, please run [bold]remotive cloud auth login[/bold] to sign-in again."
+            "This requires a RemotiveCloud account, if you do not have an account you can sign-up at https://cloud.remotivelabs.com"
+        )
+        raise typer.Exit(4)
+
+    except MissingOrganizationError:
+        print_hint("You have not specified any organization and no default organization is set")
+        raise typer.Exit(5)
+
+    except NotAuthorizedToStartTrialError as e:
+        print_generic_error(f"You are not allowed to start-trial topology in organization {e.organization.display_name}.")
+        raise typer.Exit(6)
+
+    except SubscriptionExpiredError as e:
+        if e.subscription.type == "trial":
+            print_generic_error(
+                f"RemotiveTopology trial in {e.organization.display_name} expired"
+                f" {e.subscription.end_date}, please contact support@remotivelabs.com"
+            )
+            raise typer.Exit(7)
+
+        print_generic_error(
+            f"RemotiveTopology subscription in {e.organization.display_name} has expired"
+            f" {e.subscription.end_date}, please contact support@remotivelabs.com"
+        )
+        raise typer.Exit(7)
+
+    except NoOrganizationOrPermissionError as e:
+        print_generic_error(f"Organization id {e.organization} does not exist or you do not have permission to access it.")
+        raise typer.Exit(7)
+
+    except Exception as e:
+        print_generic_error(f"Unexpected error: {e}")
+        raise typer.Exit(1)
+
+
+@app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
+def cli(args: list[str] = typer.Argument(None), ctx: typer.Context = typer.Option(None)) -> None:
+    """
+    Run any RemotiveTopology CLI command.
+    """
+    run_topology_cli(ctx, args or ["--help"])
+
+
+@app.command("version")
+def version(ctx: typer.Context = typer.Option(None)) -> None:
+    """
+    Show RemotiveTopology CLI version.
+    """
+    run_topology_cli(ctx, ["--version"])

remotivelabs/cli/topology/start_trial.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass
+from datetime import date
+from typing import Any
+
+from remotivelabs.cli.settings import settings
+from remotivelabs.cli.settings.config_file import Account
+from remotivelabs.cli.utils.rest_helper import RestHelper
+from remotivelabs.cli.utils.time import parse_date
+
+
+class NoActiveAccountError(Exception):
+    """Raised when the user has no active account, but there are available accounts to activate"""
+
+
+class NotSignedInError(Exception):
+    """Raised when the user has no active account, and no available accounts to activate"""
+
+
+class NotAuthorizedError(Exception):
+    """Raised when the user is not authorized"""
+
+    def __init__(self, account: Account):
+        self.account = account
+
+
+class NoOrganizationOrPermissionError(Exception):
+    """Raised when the user is trying to access an organization that it does not have access to or it does not exist"""
+
+    def __init__(self, account: Account, organization_uid: str):
+        self.account = account
+        self.organization = organization_uid
+
+
+class MissingOrganizationError(Exception):
+    """Raised when the user has not specified an organization and no default organization is set"""
+
+
+class NotAuthorizedToStartTrialError(Exception):
+    """Raised when the user is not authorized to start a topology trial"""
+
+    def __init__(self, account: Account, organization: Organization):
+        self.account = account
+        self.organization = organization
+
+
+class SubscriptionExpiredError(Exception):
+    """Raised when the subscription has expired"""
+
+    def __init__(self, subscription: Subscription, organization: Organization):
+        self.subscription = subscription
+        self.organization = organization
+
+
+@dataclass
+class Organization:
+    uid: str
+    display_name: str
+
+
+@dataclass
+class Subscription:
+    type: str
+    display_name: str
+    feature: str
+    start_date: date
+    end_date: date
+
+    @staticmethod
+    def from_dict(data: Any) -> Subscription:
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid subscription data {data}")
+
+        return Subscription(
+            type=data["subscriptionType"],
+            display_name=data["displayName"],
+            feature=data["feature"],
+            start_date=parse_date(data["startDate"]),
+            end_date=parse_date(data["endDate"]),
+        )
+
+
+def get_organization_and_account(organization_uid: str | None = None) -> tuple[Organization, Account]:
+    active_account = settings.get_active_account()
+    active_token_file = settings.get_active_token_file()
+
+    if not active_account or not active_token_file:
+        if len(settings.list_accounts()) == 0:
+            raise NotSignedInError()
+        raise NoActiveAccountError()
+
+    if not RestHelper.has_access("/api/whoami"):
+        raise NotAuthorizedError(account=active_account)
+
+    org_uid = organization_uid or active_account.default_organization
+    if not org_uid:
+        raise MissingOrganizationError()
+
+    response = RestHelper.handle_get(f"/api/bu/{organization_uid}", return_response=True, allow_status_codes=[403, 404])
+    if response.status_code in (403, 404):
+        raise NoOrganizationOrPermissionError(account=active_account, organization_uid=org_uid)
+
+    display_name = response.json()["displayName"]
+
+    return Organization(uid=org_uid, display_name=display_name), active_account
+
+
+def start_trial(organization_uid: str | None = None) -> tuple[Subscription, bool]:
+    """
+    Start a 30 day trial subscription for running RemotiveTopology,
+    If a trial is already started in this organization, returns the existing trial instead.
+    Returns (subscription, created_now).
+    """
+
+    (organization, active_account) = get_organization_and_account(organization_uid)
+
+    res = RestHelper.handle_get(f"/api/bu/{organization.uid}/features/topology", return_response=True, allow_status_codes=[403, 404])
+    if res.status_code == 403:
+        raise NotAuthorizedToStartTrialError(account=active_account, organization=organization)
+
+    created_now = False
+    if res.status_code == 404:
+        created = RestHelper.handle_post(f"/api/bu/{organization.uid}/features/topology", return_response=True)
+        subscription = Subscription.from_dict(created.json())
+        created_now = True
+    else:
+        subscription = Subscription.from_dict(res.json())
+
+    if subscription.end_date < datetime.datetime.now().date():
+        raise SubscriptionExpiredError(subscription=subscription, organization=organization)
+
+    return subscription, created_now