remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/api/cloud/tokens.py

@@ -0,0 +1,62 @@
+import dataclasses
+from typing import Any
+
+import requests
+
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+#
+# Attempt to start cloud-api.
+# Might be better to generate somehow instead.
+# Lets discuss further
+#
+
+
+@dataclasses.dataclass
+class EmptyResponse:
+    is_success: bool
+    status_code: int
+
+
+@dataclasses.dataclass
+class JsonResponse:
+    is_success: bool
+    status_code: int
+    __response: requests.Response
+
+    def json(self) -> Any:
+        return self.__response.json()
+
+    def text(self) -> str:
+        return self.__response.text
+
+
+def __delete_response_from_response(response: requests.Response) -> EmptyResponse:
+    if 200 > response.status_code > 299:
+        ok = False
+    else:
+        ok = True
+    return EmptyResponse(is_success=ok, status_code=response.status_code)
+
+
+def __json_response_from_response(response: requests.Response) -> JsonResponse:
+    if 200 > response.status_code > 299:
+        ok = False
+    else:
+        ok = True
+    return JsonResponse(is_success=ok, status_code=response.status_code, __response=response)
+
+
+def create() -> JsonResponse:
+    response = Rest.handle_post(url="/api/me/keys", return_response=True)
+    return __json_response_from_response(response)
+
+
+def revoke(name: str) -> EmptyResponse:
+    res_revoke = Rest.handle_patch(f"/api/me/keys/{name}/revoke", quiet=True, allow_status_codes=[404, 401])
+    return __delete_response_from_response(res_revoke)
+
+
+def delete(name: str) -> EmptyResponse:
+    res_delete = Rest.handle_delete(f"/api/me/keys/{name}", quiet=True, allow_status_codes=[404, 401])
+    return __delete_response_from_response(res_delete)

remotivelabs/cli/broker/__init__.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import os
+
+import typer
+
+from remotivelabs.cli.broker import export, files, licenses, record, recording_session, scripting, signals
+from remotivelabs.cli.broker.discovery import discover as discover_cmd
+from remotivelabs.cli.typer import typer_utils
+
+app = typer_utils.create_typer(rich_markup_mode="rich")
+
+
+# TODO: remove this?
+def cb(url: str = typer.Option(None, is_eager=False, help="Broker URL", envvar="REMOTIVE_BROKER_URL")) -> None:
+    # This can be used to override the --url per command, lets see if this is a better approach
+    if url is not None:
+        os.environ["REMOTIVE_BROKER_URL"] = url
+
+
+# TODO: move broker commands to subcommand instead?
+app.command(help="Discover brokers on this network")(discover_cmd)
+app.callback()(cb)
+
+# subcommands
+
+app.add_typer(recording_session.app, name="playback")
+app.add_typer(record.app, name="record", help="Record data on buses")
+app.add_typer(files.app, name="files", help="Upload/Download configurations and recordings")
+app.add_typer(signals.app, name="signals", help="Find and subscribe to signals")
+app.add_typer(export.app, name="export", help="Export to external formats")
+app.add_typer(scripting.app, name="scripting", help="LUA scripting utilities")
+app.add_typer(licenses.app, name="license", help="View and request license to broker")

remotivelabs/cli/broker/defaults.py

@@ -0,0 +1 @@
+DEFAULT_GRPC_URL = "http://localhost:50051"

remotivelabs/cli/broker/discovery.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from time import sleep
+
+from zeroconf import IPVersion, ServiceBrowser, ServiceStateChange, Zeroconf
+
+from remotivelabs.cli.utils.console import print_generic_message, print_newline
+
+
+def discover() -> None:
+    zeroconf = Zeroconf(ip_version=IPVersion.V4Only)
+    services = ["_remotivebroker._tcp.local."]
+
+    print_generic_message("Looking for RemotiveBrokers on your network, press Ctrl-C to exit...")
+    ServiceBrowser(zeroconf, services, handlers=[on_service_state_change])
+
+    try:
+        while True:
+            sleep(0.1)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        zeroconf.close()
+
+
+def on_service_state_change(zeroconf: Zeroconf, service_type: str, name: str, state_change: ServiceStateChange) -> None:
+    """TODO: use log instead of print for debug information?"""
+    if state_change is ServiceStateChange.Removed:
+        print_generic_message(f"Service {name} was removed")
+
+    if state_change is ServiceStateChange.Updated:
+        print_generic_message(f"Service {name} was updated")
+
+    if state_change is ServiceStateChange.Added:
+        print_generic_message(f"[ {name} ]")
+        info = zeroconf.get_service_info(service_type, name)
+        if info:
+            for addr in info.parsed_scoped_addresses():
+                print_generic_message(f"RemotiveBrokerApp: http://{addr}:8080")
+                print_generic_message(f"RemotiveBroker http://{addr}:50051")
+        else:
+            print_generic_message("  No info")
+        print_newline()

remotivelabs/cli/broker/export.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import signal as os_signal
+import sys
+from typing import Any, List
+
+import grpc
+import typer
+
+from remotivelabs.cli.broker.lib.broker import Broker, SubscribableSignal
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_message, print_grpc_error, print_hint
+
+app = typer_utils.create_typer(
+    rich_markup_mode="rich",
+    help="""
+Export subscribed signals to different formats, currently only InfluxDB line protocol
+but more formats will come soon
+""",
+)
+
+
+@app.command()
+def influxdb(
+    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"),
+    signal: List[str] = typer.Option(..., help="List of signal names to subscribe to in format namespace:signal_name"),
+    on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
+    output: str = typer.Option(None, help="Write results to file, defaults to stdout"),
+) -> None:
+    """
+    Exports subscribed signals to InfluxDB line-protocol, really useful to dump some signals into
+    influxdb for offline analysis and insights.
+
+    This is a sample for exporting and importing to InfluxDB using remotive-cli and influx-cli
+
+    Export:
+    remotive broker export influxdb --url [URL] --output signals.influx  \\
+        --signal vehiclebus:Control.SteeringWheel_Position --signal Control.Accelerator_PedalPosition \\
+        --signal vehiclebus:GpsPosition.GPS_Longitude --signal vehiclebus:GpsPosition.GPS_Latitude
+
+    Output:
+    Control, namespace:vehiclebus SteeringWheel_Position=1.0,Accelerator_PedalPosition=0,Speed=0 1664787032944374000
+    GpsPosition, namespace:vehiclebus GPS_Longitude=12.982076,GPS_Latitude=55.618748 1664787032948256000
+
+    Import:
+    influx write --org myorg -b my-bucket -p ns --format=lp  -f signals.influx
+
+
+    """
+
+    # TODO: file is not properly opened using a context manager
+    if output is not None:
+        f = open(output, "w")
+
+    def exit_on_ctrlc(_sig: Any, _frame: Any) -> None:
+        if output is not None:
+            f.close()
+        sys.exit(0)
+
+    def per_frame_influx_line_protocol(x: Any) -> None:
+        signals = list(x)
+        if len(signals) == 0:
+            return
+        sig: str = signals[0]["name"].rpartition(".")[-1]
+        frame = signals[0]["name"].rsplit(".", 1)[0]
+        namespace = signals[0]["namespace"]
+        signals_str = ",".join(list(map(lambda s: f"{sig}={s['value']}", signals)))
+        influx_lp = f"{frame},namespace={namespace} {signals_str} {round(signals[0]['timestamp_us'] * 1000)}"
+        if output is not None:
+            f.write(f"{influx_lp}\n")
+        else:
+            # TODO: Use log instead of print for debug information?
+            print_generic_message(f"{influx_lp}")
+
+    os_signal.signal(os_signal.SIGINT, exit_on_ctrlc)
+
+    try:
+
+        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])
+
+        signals_to_subscribe_to = list(map(to_subscribable_signal, signal))
+        broker = Broker(url, api_key)
+        broker.long_name_subscribe(signals_to_subscribe_to, per_frame_influx_line_protocol, on_change_only)
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)

remotivelabs/cli/broker/files.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import os
+from typing import List
+
+import grpc
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from remotivelabs.cli.broker.lib.broker import Broker
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_error, print_grpc_error, print_success
+
+app = typer_utils.create_typer(help=help)
+
+
+@app.command()
+def reload_configuration(
+    url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+) -> None:
+    try:
+        broker = Broker(url, api_key)
+        broker.reload_config()
+        print_success("Configuration reloaded")
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def delete(
+    path: List[str] = typer.Argument(..., help="Paths to files on broker to delete"),
+    exit_on_failure: bool = typer.Option(False, help="Exits if there was a problem deleting a file"),
+    url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+) -> None:
+    """
+    Deletes the specified files from the broker
+    """
+    try:
+        broker = Broker(url, api_key)
+
+        if len(path) == 0:
+            print_generic_error("At least one path must be suppled")
+            raise typer.Exit(1)
+
+        broker.delete_files(path, exit_on_failure)
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def download(
+    path: str = typer.Argument(..., help="Path to file on broker to download"),
+    output: str = typer.Option("", help="Optional output file name"),
+    url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+) -> None:
+    """
+    Downloads a file from a broker
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description=f"Downloading {path}...", total=None)
+            broker = Broker(url, api_key)
+            output_file = os.path.basename(path)
+            if output != "":
+                output_file = output
+            if os.path.exists(output_file):
+                print_generic_error(f"File already exist {output_file}, please use another output file name")
+            else:
+                broker.download(path, output_file)
+                print_success(f"{output_file} saved")
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def upload(
+    path: str = typer.Argument(..., help="Path to local file to upload"),
+    output: str = typer.Option("", help="Optional output path on broker"),
+    url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+) -> None:
+    """
+    Uploads a file to a broker - physical or in cloud.
+    """
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description=f"Uploading {path}...", total=None)
+
+            if path == ".":
+                path = "./"  ## Does not work otherwise
+
+            if not os.path.exists(path):
+                print_generic_error(f"File {path} does not exist")
+                raise typer.Exit(1)
+
+            broker = Broker(url, api_key)
+
+            if os.path.isdir(path):
+                broker.upload_folder(path)
+                print_success(f"{path} uploaded")
+            else:
+                output_file = os.path.basename(path)
+                if output != "":
+                    output_file = output
+                broker.upload(path, output_file)
+                print_success(f"{path} uploaded")
+    except grpc.RpcError as err:
+        print_grpc_error(err)

remotivelabs/cli/broker/lib/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2022-present remotiveLabs <support@remotivelabs.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+__version__ = "0.0.1"