remotivelabs-cli 0.3.5__tar.gz → 0.3.6b1__tar.gz

{remotivelabs_cli-0.3.5 → remotivelabs_cli-0.3.6b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: remotivelabs-cli
-Version: 0.3.5
+Version: 0.3.6b1
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: asyncer (>=0.0.9,<0.0.10)
 Requires-Dist: click (<8.2.0)
 Requires-Dist: email-validator (>=2.2.0,<3.0.0)
 Requires-Dist: grpc-stubs (>=1.53.0.5)
@@ -20,7 +21,7 @@ Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Requires-Dist: pyjwt (>=2.6,<3.0)
 Requires-Dist: python-can (>=4.3.1)
 Requires-Dist: python-socketio (>=4.6.1)
-Requires-Dist: remotivelabs-broker (>=0.9.1,<0.10.0)
+Requires-Dist: remotivelabs-broker (==0.9.2b4)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
 Requires-Dist: rich (>=13.7.0,<13.8.0)
 Requires-Dist: trogon (>=0.5.0)

{remotivelabs_cli-0.3.5 → remotivelabs_cli-0.3.6b1}/cli/broker/__init__.py

@@ -4,6 +4,7 @@ import os
 
 import typer
 
+from cli.broker import recording_session
 from cli.broker.discovery import discover as discover_cmd
 from cli.typer import typer_utils
 
@@ -25,12 +26,11 @@ app.callback()(cb)
 
 # subcommands
 app.add_typer(playback.app, name="playback", help="Manage playing recordings")
+if "PLAYBACK_V2" in os.environ:
+    app.add_typer(recording_session.app, name="playback-v2")
 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")
-
-if __name__ == "__main__":
-    app()

remotivelabs_cli-0.3.6b1/cli/broker/defaults.py

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

remotivelabs_cli-0.3.6b1/cli/broker/recording_session/__init__.py

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

remotivelabs_cli-0.3.6b1/cli/broker/recording_session/client.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import AsyncGenerator, Iterable, Optional, Set
+
+from remotivelabs.broker.auth import ApiKeyAuth, NoAuth
+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, broker_url: str, api_key: Optional[str]):
+        self._broker_client = RecordingSessionClient(url=broker_url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth())
+
+    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

remotivelabs_cli-0.3.6b1/cli/broker/recording_session/cmd.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import datetime
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+from functools import partial
+from typing import Any, AsyncIterator, Optional
+
+import typer
+from asyncer import syncify
+from remotivelabs.broker.auth import ApiKeyAuth, NoAuth
+from remotivelabs.broker.recording_session import RecordingSessionClient, RecordingSessionPlaybackStatus
+
+from cli.broker.defaults import DEFAULT_GRPC_URL
+from cli.broker.recording_session.client import RecursiveFilesListingClient
+from cli.broker.recording_session.time import time_offset_to_us
+from cli.typer import typer_utils
+from cli.utils.console import print_generic_error, print_result
+
+app = typer_utils.create_typer(
+    help="""
+Manage playback of recording sessions
+
+All offsets are in microseconds (μs)
+"""
+)
+
+
+def _int_or_none(offset: Optional[str | int]) -> Optional[int]:
+    return offset if offset is None else int(offset)
+
+
+def _print_offset_help(cmd: str) -> str:
+    return f"""
+    Offsets can be specified in minutes (1:15min), seconds(10s), millis(10000ms) or micros(10000000us), default without suffix is micros.
+    Samples offsets
+    {cmd} 1.15min, 10s, 10000ms, 10000000us, 10000000,
+    """
+
+
+def _custom_types(o: Any) -> Any:
+    if isinstance(o, Enum):
+        return o.name
+    if is_dataclass(type(o)):
+        return asdict(o)
+    if isinstance(o, datetime.datetime):
+        return o.isoformat(timespec="seconds")
+    raise TypeError(f"Object of type {o.__class__.__name__} is not JSON serializable")
+
+
+@app.command()
+@partial(syncify, raise_sync_error=False)
+async def list_files(
+    path: str = typer.Argument("/", help="Optional subdirectory to list files in, defaults to /"),
+    recursive: bool = typer.Option(False, help="List subdirectories recursively"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+    """
+    List files on broker.
+    """
+    try:
+        if recursive:
+            file_listing_client = RecursiveFilesListingClient(broker_url=url, api_key=api_key)
+            print_result(
+                await file_listing_client.list_all_files(path, file_types=None),  # Expose file-types in next version
+                default=_custom_types,
+            )
+        else:
+            client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth())
+            print_result(await client.list_recording_files(path), default=_custom_types)
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command(
+    help=f"""
+Starts playing the recording at current offset or from specified offset
+{_print_offset_help("--offset")}
+"""
+)
+@partial(syncify, raise_sync_error=False)
+async def play(  # noqa: PLR0913
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    offset: str = typer.Option(None, callback=time_offset_to_us, help="Offset to play from"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+        client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth())
+        print_result(await client.get_session(path=path).play(offset=_int_or_none(offset)), default=_custom_types)
+
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command(
+    help=f"""
+Repeat RecordingSession in specific interval or complete recording
+To remove existing repeat config, use --clear flag.
+{_print_offset_help("--startOffset/--endOffset")}
+"""
+)
+@partial(syncify, raise_sync_error=False)
+async def repeat(  # noqa: PLR0913
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    start_offset: str = typer.Option(0, callback=time_offset_to_us, help="Repeat start offset, defaults to start"),
+    end_offset: str = typer.Option(None, callback=time_offset_to_us, help="Repeat end offset, defaults to end"),
+    clear: bool = typer.Option(False, help="Clear repeat"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+        session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth()).get_session(path)
+        if clear:
+            print_result(await session.set_repeat(start_offset=None, end_offset=None), _custom_types)
+        else:
+            print_result(
+                await session.set_repeat(start_offset=int(start_offset), end_offset=_int_or_none(end_offset)),
+                _custom_types,
+            )
+
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command(
+    help=f"""
+    Pause the recording at current offset or specified offset
+    {_print_offset_help("--offset")}
+    """
+)
+@partial(syncify, raise_sync_error=False)
+async def pause(
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    offset: str = typer.Option(None, callback=time_offset_to_us, help="Offset to play from"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+        session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth()).get_session(path)
+        print_result(await session.pause(offset=_int_or_none(offset)), default=_custom_types)
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command(
+    help=f"""
+    Seek to specified offset
+    {_print_offset_help("--offset")}
+    """
+)
+@partial(syncify, raise_sync_error=False)
+async def seek(
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    offset: str = typer.Option(..., callback=time_offset_to_us, help="Offset to seek to"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+        session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth()).get_session(path)
+        print_result(await session.seek(offset=int(offset)), default=_custom_types)
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command()
+@partial(syncify, raise_sync_error=False)
+async def open(  # noqa: PLR0913
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    force: bool = typer.Option(False, help="Force close and re-open recording session if exists"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+    """
+    Open a recording session.
+    """
+    try:
+        session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth()).get_session(path)
+        print_result(await session.open(force_reopen=force), default=_custom_types)
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command()
+@partial(syncify, raise_sync_error=False)
+async def close(
+    path: str = typer.Argument(..., help="Path to the recording session", envvar="REMOTIVE_RECORDING_SESSION_PATH"),
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+    """
+    Close a recording session.
+    """
+
+    try:
+        session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth()).get_session(path)
+        print_result(await session.close(), default=_custom_types)
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+@app.command()
+@partial(syncify, raise_sync_error=False)
+async def status(
+    url: str = typer.Option(DEFAULT_GRPC_URL, 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:
+    """
+    Get the status of a recording session.
+    """
+    try:
+        client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key is not None else NoAuth())
+
+        async def _async_playback_stream() -> None:
+            stream: AsyncIterator[list[RecordingSessionPlaybackStatus]] = client.playback_status()
+            async for f in stream:
+                print_result(f, default=_custom_types)
+
+        await _async_playback_stream()
+    except Exception as e:
+        print_generic_error(str(e))

remotivelabs_cli-0.3.6b1/cli/broker/recording_session/time.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import typer
+
+
+class InvalidOffsetException(typer.BadParameter):  # noqa: N818
+    """
+    Thrown if invalid time, extends BadParameter to hook into typer validation
+    """
+
+
+def time_offset_to_us(value: Optional[str]) -> Optional[int]:
+    """
+    Parse a time string like '1s', '1ms', '1us', '1.02min' or '30' (default µs) into microseconds (int).
+    For minutes: 1.02min == 1 minute 2 seconds
+    """
+    if value is None:
+        return None
+
+    value = value.strip().lower()
+
+    # Check if it's a minute format with decimal or colon
+    min_match = re.fullmatch(r"([+-]?\d+)[.:](\d+)min", value)
+    if min_match:
+        minutes = int(min_match.group(1))
+        seconds = int(min_match.group(2))
+        return (minutes * 60 + seconds) * 1_000_000
+
+    # Support optional + or - sign before the number
+    match = re.fullmatch(r"([+-]?\d+(?:\.\d+)?)(?:\s*(us|µs|ms|s|min))?", value)
+    if not match:
+        raise InvalidOffsetException(f"Invalid time format: '{value}'")
+
+    amount, unit = match.groups()
+    amount = float(amount)
+    unit = unit or "us"  # Default to microseconds
+
+    unit_multipliers = {
+        "min": 60_000_000,
+        "s": 1_000_000,
+        "ms": 1_000,
+        "us": 1,
+        "µs": 1,
+    }
+
+    return int(amount * unit_multipliers[unit])

{remotivelabs_cli-0.3.5 → remotivelabs_cli-0.3.6b1}/cli/broker/signals.py

@@ -16,12 +16,11 @@ import typer
 from cli.typer import typer_utils
 from cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_hint
 
+from .defaults import DEFAULT_GRPC_URL
 from .lib.broker import Broker, SubscribableSignal
 
 app = typer_utils.create_typer(help=help)
 
-DEFAULT_GRPC_URL = "http://localhost:50051"
-
 
 class Signals(TypedDict):
     name: str

{remotivelabs_cli-0.3.5 → remotivelabs_cli-0.3.6b1}/cli/utils/console.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import sys
 from typing import Any
@@ -12,6 +13,7 @@ err_console = Console(stderr=True, soft_wrap=True)
 
 
 def print_grpc_error(error: grpc.RpcError) -> None:
+    """TODO: remove me"""
     if error.code() == grpc.StatusCode.UNAUTHENTICATED:
         is_access_token = os.environ["ACCESS_TOKEN"]
         if is_access_token is not None and is_access_token == "true":
@@ -26,24 +28,8 @@ def print_grpc_error(error: grpc.RpcError) -> None:
     sys.exit(1)
 
 
-def print_hint(message: str) -> None:
-    err_console.print(f":point_right: [bold]{message}[/bold]")
-
-
-def print_generic_error(message: str) -> None:
-    err_console.print(f":boom: [bold red]Failed[/bold red]: {message}")
-
-
-def print_success(message: str) -> None:
-    console.print(f"[bold green]Success![/bold green] {message}")
-
-
-def print_generic_message(message: str) -> None:
-    console.print(f"[bold]{message}[/bold]")
-
-
 def print_newline() -> None:
-    """TODO: is this needed?"""
+    """TODO: remove me"""
     console.print("\n")
 
 
@@ -52,10 +38,62 @@ def print_url(url: str) -> None:
 
 
 def print_unformatted(message: Any) -> None:
-    """TODO: should we allow this?"""
+    """TODO: remove me"""
     console.print(message)
 
 
 def print_unformatted_to_stderr(message: Any) -> None:
-    """TODO: should we allow this?"""
+    """TODO: remove me"""
     err_console.print(message)
+
+
+def print_success(message: str | None = None) -> None:
+    """
+    Print a success message to stdout
+
+    TODO: use stderr instead.
+    """
+    msg = "[bold green]Success![/bold green]"
+    if message:
+        msg += f" {message}"
+    console.print(msg)
+
+
+def print_generic_error(message: str | None = None) -> None:
+    """
+    Print a failure message to stderr
+
+    TODO: rename to print_failure
+    """
+    msg = ":boom: [bold red]Failed[/bold red]"
+    if message:
+        msg += f": {message}"
+    err_console.print(msg)
+
+
+def print_generic_message(message: str) -> None:
+    """
+    Print a message to the user.
+
+    TODO: rename to print_message
+    TODO: use stderr instead.
+    """
+    console.print(f"[bold]{message}[/bold]")
+
+
+def print_hint(message: str) -> None:
+    """
+    Print a hint to stderr.
+
+    Useful when nudging the user to a suitable solution.
+    """
+    err_console.print(f":point_right: [bold]{message}[/bold]")
+
+
+def print_result(result: Any, default: Any = None) -> None:
+    """
+    Print a result to stdout
+
+    TODO: Decide on how to handle output. In broker lib (to_json)?
+    """
+    console.print(json.dumps(result, indent=2, default=default))

{remotivelabs_cli-0.3.5 → remotivelabs_cli-0.3.6b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "remotivelabs-cli"
-version = "0.3.5"
+version = "0.3.6b1"
 description = "CLI for operating RemotiveCloud and RemotiveBroker"
 authors = ["Johan Rask <johan.rask@remotivelabs.com>"]
 readme = "README.md"
@@ -15,7 +15,7 @@ python = ">=3.9,<4"
 trogon = ">=0.5.0"
 typer = "0.12.5"
 click = "<8.2.0"
-remotivelabs-broker = "~=0.9.1"
+remotivelabs-broker = "0.9.2b4"
 rich = "~=13.7.0"
 pyjwt = "~=2.6"
 zeroconf = "~=0.127.0"
@@ -29,6 +29,7 @@ types-requests = "^2.32.0.20240622"
 pydantic = "^2.11.7"
 email-validator = "^2.2.0"
 requests = "^2.32.4"
+asyncer = "^0.0.9"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^8.3"