remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/cloud/storage/copy.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from remotivelabs.cli.cloud.resumable_upload import upload_signed_url
+from remotivelabs.cli.cloud.uri import URI
+from remotivelabs.cli.utils.console import print_success
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+_RCS_STORAGE_PATH = "/api/project/{project}/files/storage{path}"
+
+
+def copy(project: str, source: URI | Path, dest: URI | Path, overwrite: bool = False) -> None:
+    if isinstance(source, Path) and isinstance(dest, Path):
+        raise ValueError("Either source or destination must be an rcs:// uri")
+
+    if isinstance(source, URI) and isinstance(dest, URI):
+        raise ValueError("Either source or destination must be a local path")
+
+    if isinstance(source, URI) and isinstance(dest, Path):
+        _download(source=source, dest=dest, project=project, overwrite=overwrite)
+
+    elif isinstance(source, Path) and isinstance(dest, URI):
+        _upload(source=source, dest=dest, project=project, overwrite=overwrite)
+
+    else:
+        raise ValueError("invalid copy operation")
+
+
+def _upload(source: Path, dest: URI, project: str, overwrite: bool = False) -> None:
+    if not source.exists():
+        raise FileNotFoundError(f"Source file does not exist: {source}")
+
+    files_to_upload = _list_files_for_upload(source, dest)
+
+    for file_path, target_uri in files_to_upload:
+        _upload_single_file(file_path, target_uri, project, overwrite)
+
+
+def _list_files_for_upload(source: Path, dest: URI) -> list[tuple[Path, URI]]:
+    upload_pairs = []
+
+    if source.is_dir():
+        for file_path in source.rglob("*"):
+            if file_path.is_file():
+                relative_path = file_path.relative_to(source)
+                target_uri = dest / relative_path
+                upload_pairs.append((file_path, target_uri))
+    else:
+        target_uri = dest / source.name if dest.is_dir() else dest
+        upload_pairs.append((source, target_uri))
+
+    return upload_pairs
+
+
+def _upload_single_file(source: Path, target_uri: URI, project: str, overwrite: bool = False) -> None:
+    target = _RCS_STORAGE_PATH.format(project=project, path=target_uri.path)
+    upload_options = {"overwrite": "always" if overwrite else "never"}
+    res = Rest.handle_post(target, return_response=True, body=json.dumps(upload_options))
+
+    json_res = res.json()
+    url = json_res["url"]
+    headers = json_res["headers"]
+    upload_signed_url(url, source, headers)
+
+    print_success(f"Uploaded {source} to {target_uri.path}")
+
+
+def _download(source: URI, dest: Path, project: str, overwrite: bool = False) -> None:
+    if dest.is_dir():
+        if not dest.exists():
+            raise FileNotFoundError(f"Destination directory {dest} does not exist")
+        # create a target file name if destination is a dir
+        dest = dest / source.filename
+
+    elif not dest.parent.is_dir() or not dest.parent.exists():
+        raise FileNotFoundError(f"Destination directory {dest.parent} does not exist")
+
+    if dest.exists() and not overwrite:
+        raise FileExistsError(f"Destination file {dest} already exists")
+
+    target = _RCS_STORAGE_PATH.format(project=project, path=source.path) + "?download=true"
+    res = Rest.handle_get(target, return_response=True)
+
+    Rest.download_file(save_file_name=dest.absolute(), url=res.text)

remotivelabs/cli/cloud/storage/uri_or_path.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from remotivelabs.cli.cloud.uri import URI, InvalidURIError
+
+
+def uri(path: str) -> UriOrPath:
+    """
+    Parses a path and returns a UriOrPath object.
+
+    NOTE: The name of this function is important as it is used by Typer to determine the name/type of the argument
+    """
+    try:
+        p: Path | URI = URI(path)
+    except InvalidURIError:
+        p = Path(path)
+    return UriOrPath(p)
+
+
+class UriOrPath:
+    """
+    Union type for handling local and remote paths for Remotive Cloud Storage
+
+    Note: This custom type only exists because Typer currently does not support union types
+    TODO: Move to commands package when refactored
+    """
+
+    def __init__(self, value: Path | URI) -> None:
+        self._value = value
+
+    @property
+    def uri(self) -> URI | None:
+        return self._value if isinstance(self._value, URI) else None
+
+    @property
+    def path(self) -> Path | None:
+        return self._value if isinstance(self._value, Path) else None
+
+    @property
+    def value(self) -> Path | URI:
+        return self._value
+
+    def __str__(self) -> str:
+        return str(self._value)

remotivelabs/cli/cloud/uri.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from os import PathLike
+from pathlib import PurePosixPath
+from urllib.parse import urlparse
+
+
+class InvalidURIError(Exception):
+    """Raised when an invalid URI is encountered"""
+
+
+class JoinURIError(Exception):
+    """Raised when an error occurs while joining URIs"""
+
+
+class URI:
+    """
+    Custom type for rcs (Remotive Cloud Storage) URIs.
+
+    The URI format follows the pattern: rcs://bucket/path/to/resource
+    """
+
+    scheme: str
+    """The URI scheme (default: 'rcs')"""
+
+    path: str
+    """The full path component, including leading slash"""
+
+    filename: str
+    """The name of the file or last path segment"""
+
+    bucket: str
+    """The first path segment after the leading slash"""
+
+    parent: URI
+    """The parent URI. If at root, returns a copy of itself."""
+
+    def __init__(self, value: str, scheme: str = "rcs"):
+        """
+        Create a new URI.
+
+        Args:
+            value: The URI string in format "scheme://path/to/resource"
+            scheme: The URI scheme (default: 'rcs')
+
+        Raises:
+            InvalidURIError: If the URI format is invalid
+        """
+        self._raw = value
+        self.scheme = scheme
+
+        parsed = urlparse(value)
+        if parsed.scheme != self.scheme:
+            raise InvalidURIError(f"Invalid URI scheme. Expected '{self.scheme}://', got '{parsed.scheme}://'")
+        if parsed.netloc.startswith((".", "-", "#", " ", "/", "\\")):
+            raise InvalidURIError(f"Invalid URI. Path cannot start with invalid characters: '{value}'")
+        if not parsed.netloc and parsed.path == "/":
+            raise InvalidURIError(f"Invalid URI: '{value}'")
+
+        self.path = f"/{parsed.netloc}{parsed.path}" if parsed.netloc else f"/{parsed.path}"
+
+        self._posix_path = PurePosixPath(self.path)
+        self.filename = self._posix_path.name
+        self.bucket = self._posix_path.parts[1] if len(self._posix_path.parts) > 1 else ""
+
+        if self._posix_path == PurePosixPath("/"):
+            self.parent = self
+        else:
+            parent_path = self._posix_path.parent
+            new_uri = f"{self.scheme}://{str(parent_path)[1:]}"
+            self.parent = URI(new_uri, scheme=self.scheme)
+
+    def is_dir(self) -> bool:
+        """Check if the URI points to a directory."""
+        return self.path.endswith("/")
+
+    def __truediv__(self, other: PathLike[str] | str) -> URI:
+        """
+        Join this URI with another path component.
+
+        Args:
+            other: Path component to join
+
+        Returns:
+            A new URI with the joined path
+
+        Raises:
+            JoinURIError: If trying to join an absolute path
+            TypeError: If the path component is not a string or PathLike
+        """
+        if str(other).startswith("/"):
+            raise JoinURIError(f"Cannot join absolute path '{other}' to URI")
+
+        is_dir = str(other).endswith("/")
+        new_path = self._posix_path / other
+
+        for part in new_path.parts:
+            if part == "..":
+                new_path = new_path.parent
+            elif part != ".":
+                new_path = new_path / part
+
+        new_uri = f"{self.scheme}://{new_path.relative_to('/')}"  # we need to strip the starting '/'
+        new_uri = new_uri if not is_dir else f"{new_uri}/"  # and append slash if the added path was a dir
+        return URI(new_uri, scheme=self.scheme)
+
+    def __str__(self) -> str:
+        """Return the original URI string."""
+        return self._raw
+
+    def __repr__(self) -> str:
+        """Return the original URI string."""
+        return f"URI({self._raw})"

remotivelabs/cli/connect/connect.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+from typing_extensions import List
+
+from remotivelabs.cli.broker.lib.broker import SubscribableSignal
+from remotivelabs.cli.connect.protopie import protopie as ppie
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_hint
+
+app = typer_utils.create_typer()
+
+
+@app.command()
+def protopie(  # noqa: PLR0913
+    config: Path = typer.Option(
+        None,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="Configuration file with signal subscriptions and mapping if needed",
+    ),
+    signal: List[str] = typer.Option([], help="Signal names to subscribe to, mandatory when not using script"),
+    signal_name_expression: str = typer.Option(
+        None, help='[Experimental] Python expression to rename signal names, i.e \'lower().replace(".","_")\''
+    ),
+    changed_values_only: bool = typer.Option(
+        True, help="Only receive signal when its value is changed to minimize amount of data received"
+    ),
+    broker_url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option(None, help="Cloud Broker API-KEY", envvar="REMOTIVE_BROKER_API_KEY"),
+    pp_connect_host: str = typer.Option("http://localhost:9981", help="ProtoPie Connect URL"),
+) -> None:
+    """
+    ProtoPie Connect bridge-app to connect signals with RemotiveBroker
+
+    Subscribe to signals and send signal values to your Pie in a simple way. You can subscribe to signals from command line
+    using --signal or use --config to use a json configuration file.
+
+    ```
+    $ remotive connect protopie --signal vss:Vehicle.Chassis.SteeringWheel.Angle --signal vss:Vehicle.Speed
+    ```
+
+    You can use a configuration file for this if you have many signals, want to share the configuration or you want
+    custom mapping of the signal name.
+    ```
+    $ remotive connect protopie --config my-protopie-config.json
+    ```
+
+    Sample my-protopie-config.json
+    ```
+    {
+      "subscription": {
+        "Vehicle.CurrentLocation.Heading": {
+          "namespace": "vss"
+        },
+        "Vehicle.Speed": {
+          "namespace": "vss",
+           "mapTo": ["Speed", "VehicleSpeed"]
+        }
+      }
+    }
+    ```
+    For simple changes to signal names its possible to use a simple python expression that will be applied to all signal
+    names before its published to ProtoPie connect, i.e replacing chars or substring to match variables in Pie. This is
+    intended for simple use cases when you do not have a configuration file, otherwise we recommend using the mapTo
+    field in the configuration.
+
+    This will replace all occurrences of . (dot) with _ (underscore)
+        ```
+    $ remotive connect protopie --signal vss:Vehicle.Chassis.SteeringWheel.Angle --signal-name-expression 'replace(".", "_")'
+    ```
+    """
+
+    if len(signal) > 0 and config is not None:
+        print_hint("You must choose either --signal or --config, not both")
+        sys.exit(1)
+
+    if len(signal) == 0 and config is None:
+        print_hint("You must choose either --signal or --config")
+        sys.exit(1)
+
+    def to_subscribable_signal(sig: str) -> SubscribableSignal:
+        arr = sig.split(":")
+
+        if len(arr) != 2:
+            print_hint(f"--signal must have format namespace:signal ({sig})")
+            sys.exit(1)
+
+        return SubscribableSignal(namespace=arr[0], name=arr[1])
+
+    if len(signal) > 0:
+        signals_to_subscribe_to = list(map(to_subscribable_signal, signal))
+    else:
+        with open(config, "r", encoding="utf8") as f:
+            c = json.load(f)
+            s = c["subscription"]
+            ss = []
+            for entry in s.keys():
+                ss.append(SubscribableSignal(namespace=s[entry]["namespace"], name=entry))
+        signals_to_subscribe_to = ss
+
+    ppie.do_connect(  # type: ignore
+        address=pp_connect_host,
+        broker_url=broker_url,
+        api_key=api_key,
+        expression=signal_name_expression,
+        config=config,
+        signals=signals_to_subscribe_to,
+        on_change_only=changed_values_only,
+    )

remotivelabs/cli/connect/protopie/protopie.py

@@ -0,0 +1,185 @@
+# type: ignore
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
+
+import grpc
+import socketio
+from socketio.exceptions import ConnectionError as SocketIoConnectionError
+
+from remotivelabs.cli.broker.lib.broker import SubscribableSignal
+from remotivelabs.cli.broker.lib.client import BrokerException, Client, SignalIdentifier, SignalsInFrame
+from remotivelabs.cli.settings import settings
+from remotivelabs.cli.utils.console import print_generic_error, print_generic_message, print_success, print_unformatted_to_stderr
+
+PP_CONNECT_APP_NAME = "RemotiveBridge"
+
+io = socketio.Client()
+
+_has_received_signal = False
+is_connected = False
+config_path: Path
+x_api_key: str
+broker: Any
+
+
+@io.on("connect")
+def on_connect() -> None:
+    print_success("Connected to ProtoPie Connect")
+    io.emit("ppBridgeApp", {"name": PP_CONNECT_APP_NAME})
+    io.emit("PLUGIN_STARTED", {"name": PP_CONNECT_APP_NAME})
+
+    global is_connected  # noqa: PLW0603
+    is_connected = True
+
+
+# TODO - Receive message from ProtoPie connect
+
+
+def get_signals_and_namespaces(
+    config: Union[Path, None] = None, signals_to_subscribe_to: Union[List[SubscribableSignal], None] = None
+) -> Tuple[List[str], List[str], Union[Dict[str, str], None]]:
+    if config is not None:
+        with open(config) as f:
+            mapping = json.load(f)
+            sub = mapping["subscription"]
+            signals = list(sub.keys())
+            namespaces = list(map(lambda x: sub[x]["namespace"], signals))
+    else:
+        if signals_to_subscribe_to is None:
+            signals = []
+            namespaces = []
+        else:
+            signals = list(map(lambda s: s.name, signals_to_subscribe_to))
+            namespaces = list(map(lambda s: s.namespace, signals_to_subscribe_to))
+        sub = None
+    return signals, namespaces, sub
+
+
+def get_signal_name(expression: str, s_name: str) -> str:
+    if expression is not None:
+        try:
+            sig_name = eval(f"s_name.{expression}")
+            return str(sig_name)
+        except Exception as e:
+            print_generic_error(f"Failed to evaluate your python expression {expression}")
+            print_unformatted_to_stderr(e)
+            # This was the only way I could make this work, exiting on another thread than main
+            os._exit(1)
+    else:
+        return s_name
+
+
+def _connect_to_broker(
+    config: Union[Path, None] = None,
+    signals_to_subscribe_to: Union[List[SubscribableSignal], None] = None,
+    expression: str = "",
+    on_change_only: bool = False,
+) -> None:  # noqa: C901
+    signals, namespaces, sub = get_signals_and_namespaces(config, signals_to_subscribe_to)
+
+    def on_signals(frame: SignalsInFrame) -> None:
+        global _has_received_signal  # noqa: PLW0603
+        if not _has_received_signal:
+            print_generic_message("Bridge-app is properly receiving signals, you are good to go :thumbsup:")
+            _has_received_signal = True
+
+        for s in frame:
+            if config and sub is not None:
+                sig = sub[s.name()]
+                sig = s.name() if "mapTo" not in sig.keys() else sig["mapTo"]
+                if isinstance(sig, list):
+                    for ss in sig:
+                        io.emit("ppMessage", {"messageId": get_signal_name(expression, ss), "value": str(s.value())})
+                else:
+                    io.emit("ppMessage", {"messageId": get_signal_name(expression, sig), "value": str(s.value())})
+            else:
+                signal_name = get_signal_name(expression, s.name())
+                io.emit("ppMessage", {"messageId": signal_name, "value": str(s.value())})
+
+    grpc_connect(on_signals, signals_to_subscribe_to, on_change_only)
+
+
+def grpc_connect(
+    on_signals: Any, signals_to_subscribe_to: Union[List[SignalIdentifier], None] = None, on_change_only: bool = False
+) -> None:
+    try:
+        print_generic_message("Connecting and subscribing to broker...")
+        subscription = None
+        client = Client(client_id="cli")
+        client.connect(url=broker, api_key=x_api_key)
+        client.on_signals = on_signals
+
+        if signals_to_subscribe_to is None:
+            # TODO: use logs instead of print?
+            print_generic_error("No signals to subscribe to")
+            return
+        subscription = client.subscribe(signals_to_subscribe_to=signals_to_subscribe_to, changed_values_only=on_change_only)
+        print_generic_message("Subscription to broker completed")
+        print_generic_message("Waiting for signals...")
+
+        while True:
+            time.sleep(1)
+
+    except grpc.RpcError as e:
+        print_generic_error("Problems connecting or subscribing")
+        if isinstance(e, grpc.Call):
+            print_generic_error(f"{e.code()} - {e.details()}")
+        else:
+            print_generic_error(e)
+
+    except BrokerException as e:
+        print_generic_error(e)
+        if subscription is not None:
+            subscription.cancel()
+
+    except KeyboardInterrupt:
+        print_generic_message("Keyboard interrupt received. Closing subscription.")
+        if subscription is not None:
+            subscription.cancel()
+
+    except Exception as e:
+        print_generic_error(e)
+
+
+def do_connect(  # noqa: PLR0913
+    address: str,
+    broker_url: str,
+    api_key: Union[str, None],
+    config: Union[Path, None],
+    signals: List[SubscribableSignal],
+    expression: Union[str, None],
+    on_change_only: bool = False,
+) -> None:
+    global broker  # noqa: PLW0603
+    global x_api_key  # noqa: PLW0603
+    global config_path  # noqa: PLW0603
+    broker = broker_url
+
+    if broker_url.startswith("https"):
+        if api_key is None:
+            print_generic_message("No --api-key, reading token from file")
+            x_api_key = settings.get_active_token_secret()
+        else:
+            x_api_key = api_key
+    elif api_key is not None:
+        x_api_key = api_key
+    try:
+        io.connect(address)
+        config_path = config
+        while is_connected is None:
+            time.sleep(1)
+        _connect_to_broker(signals_to_subscribe_to=signals, config=config, expression=expression, on_change_only=on_change_only)
+    except SocketIoConnectionError as e:
+        print_generic_error("Failed to connect to ProtoPie Connect")
+        print_unformatted_to_stderr(e)
+        sys.exit(1)
+    except Exception as e:
+        print_generic_error("Unexpected error")
+        print_unformatted_to_stderr(e)
+        sys.exit(1)

remotivelabs/cli/remotive.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+
+import typer
+from trogon import Trogon
+from typer.main import get_group
+
+from remotivelabs.cli.broker import app as broker_app
+from remotivelabs.cli.cloud import app as cloud_app
+from remotivelabs.cli.connect.connect import app as connect_app
+from remotivelabs.cli.settings import Settings, settings
+from remotivelabs.cli.settings.migration.migrate_all_token_files import migrate_any_legacy_tokens
+from remotivelabs.cli.settings.migration.migrate_config_file import migrate_config_file
+from remotivelabs.cli.settings.migration.migrate_legacy_dirs import migrate_legacy_settings_dirs
+from remotivelabs.cli.tools.tools import app as tools_app
+from remotivelabs.cli.topology.cmd import app as topology_app
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils import versions
+from remotivelabs.cli.utils.console import print_generic_error, print_generic_message
+
+
+def is_featue_flag_enabled(env_var: str) -> bool:
+    """Check if an environment variable indicates a feature is enabled."""
+    return os.getenv(env_var, "").lower() in ("true", "1", "yes", "on")
+
+
+if os.getenv("GRPC_VERBOSITY") is None:
+    os.environ["GRPC_VERBOSITY"] = "NONE"
+
+app = typer_utils.create_typer(
+    rich_markup_mode="rich",
+    help="""
+Welcome to RemotiveLabs CLI - Simplify and automate tasks for cloud resources and brokers
+
+For documentation - https://docs.remotivelabs.com
+""",
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"remotivelabs-cli {versions.cli_version()} ({versions.platform_info()})")
+
+
+def test_callback(value: int) -> None:
+    if value:
+        print_generic_message(str(value))
+        raise typer.Exit()
+
+
+def check_for_newer_version(settings: Settings) -> None:
+    versions.check_for_update(settings)
+
+
+def run_migrations(settings: Settings) -> None:
+    """
+    Run all migration scripts.
+
+    Each migration script is responsible for a particular migration, and order matters.
+    """
+    # 1. Migrate legacy settings dirs
+    migrate_legacy_settings_dirs(settings.config_dir)
+
+    # 2. Migrate any legacy tokens
+    has_migrated_tokens = migrate_any_legacy_tokens(settings)
+
+    # 3. Migrate legacy config file format
+    migrate_config_file(settings.config_file_path, settings)
+
+    if has_migrated_tokens:
+        print_generic_error("Migrated old credentials and configuration files, you may need to login again or activate correct credentials")
+
+
+def set_default_org_as_env(settings: Settings) -> None:
+    """
+    If not already set, take the default organisation from file and set as env
+    This has to be done early before it is read
+    """
+    if "REMOTIVE_CLOUD_ORGANIZATION" not in os.environ:
+        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()
+def main(
+    _the_version: bool = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Print current version",
+    ),
+) -> None:
+    run_migrations(settings)
+    check_for_newer_version(settings)
+    set_default_org_as_env(settings)
+    # Do other global stuff, handle other global options here
+
+
+@app.command()
+def tui(ctx: typer.Context) -> None:
+    """
+    Explore remotive-cli and generate commands with this textual user interface application
+    """
+
+    Trogon(get_group(app), click_context=ctx).run()
+
+
+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(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
+
+Read more at https://docs.remotivelabs.com/docs/remotive-topology
+""",
+)