remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/broker/recording_session/cmd.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+from typing import Any, AsyncIterator, Optional
+
+import typer
+
+from remotivelabs.broker.auth import ApiKeyAuth, NoAuth
+from remotivelabs.broker.recording_session import RecordingSessionClient, RecordingSessionPlaybackStatus
+from remotivelabs.cli.broker.defaults import DEFAULT_GRPC_URL
+from remotivelabs.cli.broker.recording_session.client import RecursiveFilesListingClient
+from remotivelabs.cli.broker.recording_session.time import time_offset_to_us
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.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.
+    Sample 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")
+
+
+async def _list_files_async(path: str, recursive: bool, url: str, api_key: str) -> None:
+    if recursive:
+        client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth())
+        file_listing_client = RecursiveFilesListingClient(client)
+        print_result(
+            await file_listing_client.list_all_files(path, file_types=None),
+            default=_custom_types,
+        )
+    else:
+        client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth())
+        print_result(await client.list_recording_files(path), default=_custom_types)
+
+
+@app.command()
+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:
+        asyncio.run(_list_files_async(path, recursive, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+# --------------------------------------------------------------------------- #
+# play
+# --------------------------------------------------------------------------- #
+
+
+async def _play_async(path: str, offset: str, url: str, api_key: str) -> None:
+    client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth())
+    result = await client.get_session(path=path).play(offset=_int_or_none(offset))
+    print_result(result, default=_custom_types)
+
+
+@app.command(
+    help=f"""
+Starts playing the recording at current offset or from specified offset
+{_print_offset_help("--offset")}
+"""
+)
+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:
+        asyncio.run(_play_async(path, offset, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _repeat_async(path: str, start_offset: str, end_offset: str, clear: bool, url: str, api_key: str) -> None:  # noqa: PLR0913
+    session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth()).get_session(path)
+    if clear:
+        result = await session.set_repeat(start_offset=None, end_offset=None)
+    else:
+        result = await session.set_repeat(start_offset=int(start_offset), end_offset=_int_or_none(end_offset))
+    print_result(result, _custom_types)
+
+
+@app.command(
+    help=f"""
+Repeat RecordingSession in specific interval or complete recording
+To remove existing repeat config, use --clear flag.
+{_print_offset_help("--start-offset/--end-offset")}
+"""
+)
+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:
+        asyncio.run(_repeat_async(path, start_offset, end_offset, clear, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _pause_async(path: str, offset: str, url: str, api_key: str) -> None:
+    session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth()).get_session(path)
+    result = await session.pause(offset=_int_or_none(offset))
+    print_result(result, default=_custom_types)
+
+
+@app.command(
+    help=f"""
+    Pause the recording at current offset or specified offset
+    {_print_offset_help("--offset")}
+    """
+)
+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:
+        asyncio.run(_pause_async(path, offset, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _seek_async(path: str, offset: str, url: str, api_key: str) -> None:
+    session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth()).get_session(path)
+    result = await session.seek(offset=int(offset))
+    print_result(result, default=_custom_types)
+
+
+@app.command(
+    help=f"""
+    Seek to specified offset
+    {_print_offset_help("--offset")}
+    """
+)
+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:
+        asyncio.run(_seek_async(path, offset, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _open_async(path: str, force: bool, url: str, api_key: str) -> None:
+    session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth()).get_session(path)
+    result = await session.open(force_reopen=force)
+    print_result(result, default=_custom_types)
+
+
+@app.command()
+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:
+        asyncio.run(_open_async(path, force, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _close_async(path: str, url: str, api_key: str) -> None:
+    session = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key else NoAuth()).get_session(path)
+    result = await session.close()
+    print_result(result, default=_custom_types)
+
+
+@app.command()
+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:
+        asyncio.run(_close_async(path, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))
+
+
+async def _status_async(stream: bool, url: str, api_key: str) -> None:
+    client = RecordingSessionClient(url, auth=ApiKeyAuth(api_key) if api_key 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)
+            if not stream:
+                break
+
+    await _async_playback_stream()
+
+
+@app.command()
+def status(
+    stream: bool = typer.Option(False, help="Blocks and continuously streams statuses"),
+    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 all opened Recording sessions
+    """
+    try:
+        asyncio.run(_status_async(stream, url, api_key))
+    except Exception as e:
+        print_generic_error(str(e))

remotivelabs/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/broker/scripting.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import sys
+from string import Template
+from typing import List
+
+import typer
+
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_message, print_hint
+
+app = typer_utils.create_typer(
+    rich_markup_mode="rich",
+    help="""
+[Experimental] - Generate template lua script for input and output signals
+""",
+)
+
+
+def write(signal_name: str, script: str) -> None:
+    path = f"{signal_name}.lua"
+    with open(path, "w") as f:
+        f.write(script)
+    print_generic_message(f"Secret token written to {path}")
+
+
+@app.command("new-script")
+def new_script(
+    input_signal: List[str] = typer.Option(..., help="Required input signal names"),
+    output_signal: str = typer.Option(..., help="Name of output signal"),
+    save: bool = typer.Option(False, help="Save file to disk - Default stored as __output_signal__.lua"),
+) -> None:
+    def to_subscribable_signal(sig: str) -> tuple[str, str]:
+        arr = sig.split(":")
+        if len(arr) != 2:
+            print_hint(f"--input-signal must have format namespace:signal ({sig})")
+            sys.exit(1)
+        return arr[0], arr[1]
+
+    signals_to_subscribe_to = list(map(to_subscribable_signal, input_signal))
+
+    def to_local_signal(sig_name: tuple[str, str]) -> str:
+        t = Template(
+            """
+    {
+        name = "$sig_name",
+        namespace = "$namespace"
+    }"""
+        )
+        return t.substitute(sig_name=sig_name[1], namespace=sig_name[0])
+
+    local_signals = ",".join(list(map(to_local_signal, signals_to_subscribe_to)))
+
+    def to_subscribe_pattern(sig_name: tuple[str, str]) -> str:
+        t = Template(
+            """
+    if (signals["$sig_name"] ~= nil) then
+        return return_value_or_bytes(signals["$sig_name"])
+    end
+    """
+        )
+        return t.substitute(sig_name=sig_name[1])
+
+    subscribe_pattern = "".join(list(map(to_subscribe_pattern, signals_to_subscribe_to)))
+
+    template = Template(
+        """
+--
+-- Docs available at https://docs.remotivelabs.com/docs/remotive-broker/scripted_signals
+--
+
+local local_signals = {$local_signals
+}
+
+-- Required, declare which input is needed to operate this program.
+function input_signals()
+    return local_signals
+end
+
+-- Provided parameters are used for populating metadata when listing signals.
+function output_signal()
+    return "$output_signal"
+end
+
+-- Required, declare what frequency you like to get "timer" invoked. 0 means no calls to "timer".
+function timer_frequency_hz()
+    return 0
+end
+
+-- Invoked with the frequency returned by "timer_frequency_hz".
+-- @param system_timestamp_us: system time stamp
+function timer(system_timestamp_us)
+    return return_value_or_bytes("your value")
+end
+
+-- Invoked when ANY signal declared in "local_signals" arrive
+-- @param signals_timestamp_us: signal time stamp
+-- @param system_timestamp_us
+-- @param signals: array of signals containing all or a subset of signals declared in "local_signals". Make sure to nil check before use.
+function signals(signals, namespace, signals_timestamp_us, system_timestamp_us)
+    -- TODO - replace this code with what you want todo
+
+    $subscribe_pattern
+    return return_nothing()
+end
+
+-- helper return function, make sure to use return_value_or_bytes or return_nothing.
+function return_value_or_bytes(value_or_bytes)
+    return value_or_bytes
+end
+
+-- helper return function, make sure to use return_value_or_bytes or return_nothing.
+function return_nothing()
+    return
+end
+
+"""
+    )
+
+    script = template.substitute(
+        local_signals=local_signals,
+        subscribe_pattern=subscribe_pattern,
+        output_signal=output_signal,
+    )
+
+    if save:
+        write(output_signal, script)
+    else:
+        print_generic_message(script)

remotivelabs/cli/broker/signals.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+import numbers
+import os
+import signal as os_signal
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, TypedDict, Union
+
+import grpc
+import plotext as plt  # type: ignore
+import typer
+
+from remotivelabs.cli.broker.defaults import DEFAULT_GRPC_URL
+from remotivelabs.cli.broker.lib.broker import Broker, SubscribableSignal
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_hint
+
+app = typer_utils.create_typer(help=help)
+
+
+class Signals(TypedDict):
+    name: str
+    signals: List[Any]
+
+
+signal_values: Dict[Any, Any] = {}
+
+
+@app.command(name="list")
+def list_signals(
+    url: str = typer.Option(DEFAULT_GRPC_URL, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option(None, help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+    name_starts_with: Union[str, None] = typer.Option(None, help="Signal name prefix to include"),
+    name_ends_with: Union[str, None] = typer.Option(None, help="Signal name suffix to include"),
+) -> None:
+    """
+    List signal metadata on a broker
+
+    Filter are inclusive so --name-starts-with and --name-ends-with will include name that matches both
+    """
+    try:
+        broker = Broker(url, api_key)
+        available_signals = broker.list_signal_names(prefix=name_starts_with, suffix=name_ends_with)
+        print_generic_message(json.dumps(available_signals))
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)
+
+
+def read_scripted_code_file(file_path: Path) -> bytes:
+    try:
+        print_generic_message(str(file_path))
+        with open(file_path, "rb") as file:
+            return file.read()
+    except FileNotFoundError:
+        print_generic_error("File not found. Please check your file path.")
+        sys.exit(1)
+
+
+@app.command()
+def subscribe(  # noqa: C901, PLR0913, PLR0915
+    url: str = typer.Option(DEFAULT_GRPC_URL, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option(None, help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+    signal: List[str] = typer.Option([], help="Signal names to subscribe to, mandatory when not using script"),
+    script: Path = typer.Option(
+        None,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="Supply a path to Lua script that to use for signal transformation",
+    ),
+    on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
+    x_plot: bool = typer.Option(default=False, help="Experimental: Plot the signal in terminal. Note graphs are not aligned by time"),
+    x_plot_size: int = typer.Option(default=100, help="Experimental: how many points show for each plot"),
+    # samples: int = typer.Option(default=0, he)
+) -> None:
+    """
+    Subscribe to a selection of signals
+
+    Subscribe to two signals and have it printed to terminal
+    ```
+    remotive broker signals subscribe  --url http://localhost:50051 --signal can1:signal1 --signal can0:signal2
+    ```
+
+    Subscribe using a LUA script with signal transformations, read more about scripted signals at https://docs.remotivelabs.com/docs/remotive-broker
+    ```
+    remotive broker signals subscribe  --url http://localhost:50051 --script myvss_script.lua
+    ```
+    """
+
+    if script is None:
+        if len(signal) == 0:
+            print_generic_error("You must use --signal or use --script when subscribing")
+            sys.exit(1)
+
+    if script is not None:
+        if len(signal) > 0:
+            print_generic_error("You must must not specify --signal when using --script")
+            sys.exit(1)
+
+    plt.title("Signals")
+
+    def exit_on_ctrlc(_sig: Any, _frame: Any) -> None:
+        os._exit(0)
+
+    def on_frame_plot(x: Iterable[Any]) -> None:
+        plt.clt()  # to clear the terminal
+        plt.cld()  # to clear the data only
+        frames = list(x)
+        plt.clf()
+        plt.subplots(len(list(filter(lambda n: n.startswith("ts_"), signal_values.keys()))))
+        plt.theme("pro")
+
+        for frame in frames:
+            name = frame["name"]
+
+            if not isinstance(frame["value"], numbers.Number):
+                # Skip non numberic values
+                # TODO - would exit and print info message if I knew how to
+                continue
+
+            y = [frame["value"]]
+            t = [frame["timestamp_us"]]
+
+            if name not in signal_values:
+                signal_values[name] = [None] * x_plot_size
+                signal_values[f"ts_{name}"] = [None] * x_plot_size
+            signal_values[name] = signal_values[name] + y
+            signal_values[f"ts_{name}"] = signal_values[f"ts_{name}"] + t
+
+            if len(signal_values[name]) > x_plot_size:
+                signal_values[name] = signal_values[name][len(signal_values[name]) - x_plot_size :]
+
+            if len(signal_values[f"ts_{name}"]) > x_plot_size:
+                signal_values[f"ts_{name}"] = signal_values[f"ts_{name}"][len(signal_values[f"ts_{name}"]) - x_plot_size :]
+
+        cnt = 1
+        for key, value in signal_values.items():
+            if not key.startswith("ts_"):
+                plt.subplot(cnt, 1).plot(signal_values[f"ts_{key}"], value, label=key, color=cnt)
+                cnt = cnt + 1
+        plt.sleep(0.001)  # to add
+        plt.show()
+
+    def on_frame_print(x: Iterable[Any]) -> None:
+        # TODO: use log instead of print for debug information?
+        print_generic_message(json.dumps(list(x)))
+
+    os_signal.signal(os_signal.SIGINT, exit_on_ctrlc)
+
+    if x_plot:
+        on_frame_func = on_frame_plot
+    else:
+        on_frame_func = on_frame_print
+
+    try:
+        if script is not None:
+            script_src = read_scripted_code_file(script)
+            broker = Broker(url, api_key)
+            broker.subscribe_on_script(script_src, on_frame_func, on_change_only)
+        else:
+
+            def to_subscribable_signal(sig: str):
+                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, on_frame_func, on_change_only)
+        print_generic_message("Subscribing to signals, press Ctrl+C to exit")
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)
+
+
+@app.command(help="List namespaces on broker")
+def namespaces(
+    url: str = typer.Option(DEFAULT_GRPC_URL, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option(None, help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+) -> None:
+    try:
+        broker = Broker(url, api_key)
+        namespaces_json = broker.list_namespaces()
+        print_generic_message(json.dumps(namespaces_json))
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)
+
+
+@app.command()
+def frame_distribution(
+    url: str = typer.Option(DEFAULT_GRPC_URL, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+    api_key: str = typer.Option(None, help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
+    namespace: str = typer.Option(..., help="Namespace"),
+) -> None:
+    """
+    Use this command to get frames currently available on the specified namespace.
+    """
+    try:
+        broker = Broker(url, api_key)
+
+        def on_data(data: Dict[str, Any]) -> None:
+            timestamp: str = datetime.now().strftime("%H:%M:%S")
+            distribution = data["countsByFrameId"]
+            if len(distribution) == 0:
+                print_hint(f"{timestamp} - No frames available")
+            else:
+                for d in distribution:
+                    print_generic_message(f"{timestamp}: {d}")
+
+        broker.listen_on_frame_distribution(namespace, on_data)
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)

remotivelabs/cli/broker/version.py

@@ -0,0 +1,31 @@
+import semver
+
+
+def ensure_version_is_at_least(version: str, min_version: str) -> None:
+    """
+    Ensures that broker version is at least a specific version.
+    """
+
+    try:
+        # use finalize() to use the release version of this version regardless of pre-release or build
+        broker_version = semver.parse_version_info(version).finalize_version()
+        required_version = semver.parse_version_info(min_version).finalize_version()
+    except ValueError as e:
+        raise InvalidBrokerVersionError(str(e))
+
+    if broker_version < required_version:
+        raise UnsupportedBrokerVersionError(current_version=broker_version, min_version=min_version)
+
+
+class UnsupportedBrokerVersionError(Exception):
+    """Raised when broker version is below the minimum supported version."""
+
+    def __init__(self, current_version: str, min_version: str):
+        self.current_version = current_version
+        self.min_version = min_version
+
+
+class InvalidBrokerVersionError(Exception):
+    """Raised when version is not major.minor.patch"""
+
+    pass