remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/broker/license_flows.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+import time
+from typing import Union
+
+import grpc
+import requests
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from remotivelabs.cli.broker.lib.broker import Broker, LicenseInfo
+from remotivelabs.cli.utils.console import print_unformatted_to_stderr
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+
+class LicenseFlow:
+    def describe_with_url(self, url: str) -> LicenseInfo:
+        b = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching license from broker ({url})...",
+            on_error_progress_label=f"Fetching license from broker ({url})... make sure broker is running.",
+        )
+        return b.get_license()
+
+    def describe_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051") -> LicenseInfo:
+        if url is None:
+            url = "http://192.168.4.1:50051"
+
+        b = LicenseFlow.__try_connect_to_broker(
+            url=url, progress_label=f"Fetching license from broker using hotspot ({url})... Make sure to switch to remotivelabs-xxx Wi-Fi"
+        )
+        return b.get_license()
+
+    def request_with_url_with_internet(self, url: str) -> None:
+        print_unformatted_to_stderr("This requires internet connection from your computer during the entire licensing process")
+
+        email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching existing broker license...({url})...",
+        )
+
+        existing_license = broker_to_license.get_license()
+        if existing_license.valid:
+            apply = typer.confirm(
+                f"This broker already has a valid license, and is licensed to {existing_license.email}. Do you still wish to proceed?"
+            )
+            if not apply:
+                return
+
+        print_unformatted_to_stderr(
+            ":point_right: [bold yellow]This will request a new license or use an existing license if "
+            "this hardware has already been licensed[/bold yellow]"
+        )
+        apply_license = typer.confirm("Do you want to continue and agree to terms and conditions at https://remotivelabs.com/license?")
+        if not apply_license:
+            return
+
+        existing_license = broker_to_license.get_license()
+        license_data_b64 = LicenseFlow.__try_request_license(email, existing_license, "Requesting license...")
+
+        with use_progress("Applying license to broker..."):
+            new_license = broker_to_license.apply_license(license_data_b64)
+        if new_license.valid:
+            print_unformatted_to_stderr(f":thumbsup: Successfully applied license, it remains valid until {new_license.expires}")
+
+    def request_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051") -> None:
+        """
+        This flow expects changes between networks and tries to guide the user accordingly
+        :param url: If None it will use the default hotspot IP
+        """
+        if url is None:
+            url = "http://192.168.4.1:50051"
+
+        print_unformatted_to_stderr(
+            "Licensing a broker over its wifi hotspot will require you to switch between internet connectivity "
+            "and remotivelabs-xxx wifi hotspot"
+        )
+
+        email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching license from broker using hotspot ({url})... Make sure to switch to remotivelabs-xxx wifi",
+        )
+        existing_license = broker_to_license.get_license()
+        if existing_license.valid:
+            apply = typer.confirm(
+                f"This broker already has a valid license and is licensed to {existing_license.email}. Do you still wish to proceed?"
+            )
+            if not apply:
+                return
+
+        print_unformatted_to_stderr(
+            ":point_right: [bold yellow]This will request a new license or use an existing license if "
+            "this hardware has already been licensed[/bold yellow]"
+        )
+        apply_license = typer.confirm("Do you want to continue and agree to terms and conditions at https://remotivelabs.com/license?")
+        if not apply_license:
+            return
+
+        license_data_b64 = LicenseFlow.__try_request_license(email, existing_license)
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label="Applying license to broker...  Make sure to switch back to remotivelabs-xxx wifi hotspot",
+        )
+        new_license = broker_to_license.apply_license(license_data_b64)
+        print_unformatted_to_stderr(f":thumbsup: Successfully applied license, expires {new_license.expires}")
+
+    @staticmethod
+    def __try_connect_to_broker(url: str, progress_label: str, on_error_progress_label: Union[str, None] = None) -> Broker:
+        with use_progress(progress_label) as p:
+            while True:
+                try:
+                    broker_to_license = Broker(url=url)
+                    break
+                except grpc.RpcError:
+                    if on_error_progress_label is not None:
+                        p.update(
+                            p.task_ids[0],
+                            description=on_error_progress_label,
+                        )
+                    time.sleep(1)
+        if on_error_progress_label is None:
+            print_unformatted_to_stderr(f":white_check_mark: {progress_label}")
+        else:
+            print_unformatted_to_stderr(f":white_check_mark: {on_error_progress_label}")
+        return broker_to_license
+
+    @staticmethod
+    def __try_authenticate_and_get_email_from_cloud() -> str:
+        with use_progress("Fetching user info from cloud... Make sure you are connected to internet"):
+            while True:
+                try:
+                    r = Rest.handle_get("/api/whoami", return_response=True, use_progress_indicator=False, timeout=5)
+                    break
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    time.sleep(1)
+        print_unformatted_to_stderr(":white_check_mark: Fetching user info from cloud... Make sure you are connected to internet")
+        if r is None:
+            return ""
+        return str(r.json()["email"])
+
+    @staticmethod
+    def __try_request_license(
+        email: str,
+        existing_license: LicenseInfo,
+        progress_label: str = "Requesting license... make sure to switch back to network with internet access",
+    ) -> bytes:
+        with use_progress(progress_label):
+            while True:
+                try:
+                    license_data_b64 = Rest.request_license(email, json.loads(existing_license.machine_id)).encode()
+                    break
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    time.sleep(1)
+        print_unformatted_to_stderr(f":white_check_mark: {progress_label}")
+        return bytes(license_data_b64)
+
+
+def use_progress(label: str) -> Progress:
+    p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True, expand=False)
+    p.add_task(label, total=1)
+    return p

remotivelabs/cli/broker/licenses.py

@@ -0,0 +1,98 @@
+import dataclasses
+import json
+from enum import Enum
+
+import typer
+from rich import print_json
+
+from remotivelabs.cli.broker.license_flows import LicenseFlow
+from remotivelabs.cli.typer import typer_utils
+
+app = typer_utils.create_typer()
+
+help_text = """
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+      url      = Connects to the broker with the specified url, this is
+      hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+                 broker over its wifi hotspot. Getting the license from a RemotiveBox over its wifi hotspot
+                 requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+                 'xxx' is a random generated id.
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+
+
+class Connection(str, Enum):
+    hotspot = "hotspot"
+    url = "url"
+    # TODO - Support discover using mdns
+
+
+@app.command()
+def describe(
+    connect: Connection = typer.Option("url", case_sensitive=False, help="How to connect to broker"),
+    url: str = typer.Option("http://localhost:50051", is_eager=False, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+) -> None:
+    """
+    Show licence information
+
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+    url      = Connects to the broker with the specified url, this is
+    hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+               broker over its wifi hotspot. Getting the license from a RemotiveBox over its wifi hotspot
+               requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+               'xxx' is a random generated id.
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+    license_flow = LicenseFlow()
+    if connect == Connection.url:
+        existing_license = license_flow.describe_with_url(url)
+        print_json(json.dumps(dataclasses.asdict(existing_license)))
+    if connect == Connection.hotspot:
+        existing_license = license_flow.describe_with_hotspot(url if url != "http://localhost:50051" else None)
+        print_json(json.dumps(dataclasses.asdict(existing_license)))
+
+
+@app.command()
+def request(
+    connect: Connection = typer.Option("url", case_sensitive=False, help="How to connect to broker"),
+    url: str = typer.Option(
+        "http://localhost:50051",
+        is_eager=False,
+        help="Broker url, this is mandatory when connect type is 'url'",
+        envvar="REMOTIVE_BROKER_URL",
+    ),
+) -> None:
+    """
+    Requests and applies a new or existing License to a broker, Note that internet access is required on your
+    computer
+
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+    url      = Use url to connect to broker (use --url)
+    hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+               broker over its wifi hotspot. Licensing a broker on a RemotiveBox over its wifi hotspot
+               requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+               'xxx' is a random generated id.
+               https://docs.remotivelabs.com/docs/remotive-broker/getting-started/remotive-box
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+
+    license_flow = LicenseFlow()
+    if connect == Connection.url:
+        license_flow.request_with_url_with_internet(url)
+    if connect == Connection.hotspot:
+        license_flow.request_with_hotspot(url if url != "http://localhost:50051" else None)

remotivelabs/cli/broker/playback.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+import grpc
+import typer
+
+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_generic_message, print_grpc_error, print_success
+
+app = typer_utils.create_typer(help=help)
+
+
+def recording_and_namespace(recording: str) -> Dict[str, str]:
+    splitted = recording.split("::")
+    if len(splitted) != 2:
+        print_generic_error("Invalid --recording option, expected file_name::namespace")
+        raise typer.Exit(1)
+    return {"recording": splitted[0], "namespace": splitted[1]}
+
+
+@app.command()
+def play(
+    recording: List[str] = typer.Option(..., help="Which recording and which namespace to play"),
+    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:
+    """
+    Play recording files on broker.
+
+    Separate recording file and namespace with ::
+
+    remotive broker playback play --recording myrecording_can0::can0 --recording myrecording_can1::can1
+    """
+
+    rec = list(map(recording_and_namespace, recording))
+    try:
+        broker = Broker(url, api_key)
+        status = broker.play(rec)
+        # TODO: use log instead of print for debug information?
+        print_generic_message(str(status))
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def stop(
+    recording: List[str] = typer.Option(..., help="Which recording and which namespace to stop"),
+    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:
+    """
+    Stop recordings that are beeing played on brokers are done with the same syntax as when you start them.
+
+    Separate recording file and namespace with ::
+
+    remotive broker playback stop --recording myrecording_can0::can0 --recording myrecording_can1::can1
+    """
+
+    rec = list(map(recording_and_namespace, recording))
+
+    try:
+        broker = Broker(url, api_key)
+        broker.stop_play(rec)
+        print_success("Recording stopped")
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def pause(
+    recording: List[str] = typer.Option(..., help="Which recording and which namespace to stop"),
+    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:
+    """
+    Pause recordings that are beeing played on brokers are done with the same syntax as when you start them.
+
+    Separate recording file and namespace with ::
+
+    remotive broker playback pause --recording myrecording_can0::can0 --recording myrecording_can1::can1
+    """
+
+    rec = list(map(recording_and_namespace, recording))
+    try:
+        broker = Broker(url, api_key)
+        broker.pause_play(rec)
+        print_success("Recording paused")
+    except grpc.RpcError as err:
+        print_grpc_error(err)
+
+
+@app.command()
+def seek(
+    recording: List[str] = typer.Option(..., help="Which recording and which namespace to stop"),
+    seconds: float = typer.Option(..., help="Target offset in seconds"),
+    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:
+    """
+    Seeks to a position in seconds into the recording
+
+    Separate recording file and namespace with ::
+
+    remotive broker playback seek --recording myrecording_can0::can0 --recording myrecording_can1::can1 --seconds 23
+    """
+
+    broker = Broker(url, api_key)
+
+    rec = list(map(recording_and_namespace, recording))
+
+    try:
+        broker = Broker(url, api_key)
+        broker.seek(rec, int(seconds * 1000000))
+    except grpc.RpcError as err:
+        print_grpc_error(err)

remotivelabs/cli/broker/record.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import List
+
+import grpc
+import typer
+
+from remotivelabs.cli.broker.lib.broker import Broker
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_grpc_error, print_success
+
+app = typer_utils.create_typer(help=help)
+
+
+@app.command()
+def start(
+    filename: str = typer.Argument(..., help="Path to local file to upload"),
+    namespace: List[str] = typer.Option(..., help="Namespace to record"),
+    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.record_multiple(namespace, filename)
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)
+
+
+@app.command()
+def stop(
+    filename: str = typer.Argument(..., help="Path to local file to upload"),
+    namespace: List[str] = typer.Option(..., help="Namespace to record"),
+    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.stop_multiple(namespace, filename)
+        print_success("Recording stopped")
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)

remotivelabs/cli/broker/recording_session/__init__.py

@@ -0,0 +1,3 @@
+from remotivelabs.cli.broker.recording_session.cmd import app
+
+__all__ = ["app"]

remotivelabs/cli/broker/recording_session/client.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import AsyncGenerator, Iterable, Optional, Set
+
+from remotivelabs.broker.recording_session import File, RecordingSessionClient
+from remotivelabs.broker.recording_session.file import FileType
+
+
+class RecursiveFilesListingClient:
+    """
+    Client for recursively listing files using a broker API.
+
+    This class provides functionality to recursively list files and directories using
+    a RecordingSessionClient. It retrieves files from specified paths and can process them
+    with customizable options such as filtering by file types or including directories
+    in the results.
+
+    Attributes:
+        broker_url (str): The URL of the broker API.
+        api_key (Optional[str]): The API key used for authentication, if required by the
+            broker API.
+    """
+
+    def __init__(self, client: RecordingSessionClient):
+        self._broker_client = client
+
+    async def _list_files(self, path: str = "/") -> list[File]:
+        return await self._broker_client.list_recording_files(path=path)
+
+    async def list_all_files(
+        self,
+        path: str = "/",
+        file_types: Optional[Iterable[FileType]] = None,
+    ) -> list[File]:
+        files: list[File] = []
+        async for f in self._iter_files_recursive(root=path, return_types=file_types):
+            files.append(f)
+        return files
+
+    async def _iter_files_recursive(
+        self,
+        root: str = "/",
+        *,
+        return_types: Optional[Iterable[FileType]] = None,
+        include_dirs: bool = False,
+    ) -> AsyncGenerator[File, None]:
+        seen: Set[str] = set()
+
+        async def _walk(path: str) -> AsyncGenerator[File, None]:
+            if path in seen:
+                return
+            seen.add(path)
+
+            resp = await self._list_files(path)
+            for f in resp or []:
+                if f.type == FileType.FILE_TYPE_FOLDER:
+                    # Optionally yield the directory itself
+                    if include_dirs and (return_types is None or f.type in return_types):
+                        yield f
+                    # Recurse into the folder
+                    async for file in _walk(f.path):
+                        yield file
+                elif return_types is None or f.type in return_types:
+                    yield f
+
+        async for file in _walk(root):
+            yield file