remotivelabs-cli 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

cli/broker/brokers.py

@@ -11,7 +11,7 @@ from zeroconf import (
     Zeroconf,
 )
 
-from . import export, files, playback, record, scripting, signals
+from . import export, files, licenses, playback, record, scripting, signals
 
 app = typer.Typer(rich_markup_mode="rich")
 
@@ -85,7 +85,8 @@ 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")
+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()

cli/broker/export.py

@@ -36,7 +36,7 @@ def influxdb(
     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 --namespace VehicleBus  \\
+    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
 

cli/broker/lib/broker.py

@@ -12,7 +12,7 @@ import typing
 import zipfile
 from dataclasses import dataclass
 from threading import Thread
-from typing import Callable, List, Sequence
+from typing import Callable, List, Sequence, Union
 
 import grpc
 import remotivelabs.broker.generated.sync.traffic_api_pb2 as traffic_api
@@ -33,8 +33,16 @@ class SubscribableSignal:
     namespace: str
 
 
+@dataclass
+class LicenseInfo:
+    valid: bool
+    expires: str
+    email: str
+    machine_id: str
+
+
 class Broker:
-    def __init__(self, url: str, api_key):
+    def __init__(self, url: str, api_key: Union[str, None] = None):
         self.url = url
         self.api_key = api_key
         self.q = queue.Queue()
@@ -531,3 +539,19 @@ class Broker:
             playbackConfig=playback_config,
             playbackMode=br.traffic_api_pb2.PlaybackMode(mode=item["mode"], offsetTime=get_offset_time()),
         )
+
+    def get_license(self) -> LicenseInfo:
+        license_info = self.system_stub.GetLicenseInfo(br.common_pb2.Empty())
+        return LicenseInfo(
+            valid=license_info.status == br.system_api_pb2.LicenseStatus.VALID,
+            expires=license_info.expires,
+            email=license_info.requestId,
+            machine_id=license_info.requestMachineId.decode("utf-8"),
+        )
+
+    def apply_license(self, license_data_b64: bytes):
+        license = br.system_api_pb2.License()
+        license.data = license_data_b64
+        license.termsAgreement = True
+        self.system_stub.SetLicense(license)
+        return self.get_license()

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.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+import cli.cloud.rest_helper as rest
+from cli.broker.lib.broker import Broker, LicenseInfo
+
+console = Console(stderr=True)
+
+
+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"):
+        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):
+        console.print("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
+
+        console.print(
+            ":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:
+            console.print(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"):
+        """
+        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"
+
+        console.print(
+            "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
+
+        console.print(
+            ":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)
+        console.print(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:
+            console.print(f":white_check_mark: {progress_label}")
+        else:
+            console.print(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)
+        console.print(":white_check_mark: Fetching user info from cloud... Make sure you are connected to internet")
+        return 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)
+        console.print(f":white_check_mark: {progress_label}")
+        return license_data_b64
+
+
+def use_progress(label: str):
+    p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True, expand=False)
+    p.add_task(label, total=1)
+    return p

cli/broker/licenses.py

@@ -0,0 +1,97 @@
+import dataclasses
+import json
+from enum import Enum
+
+import typer
+from rich import print_json
+
+from .license_flows import LicenseFlow
+
+app = typer.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"),
+):
+    """
+    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",
+    ),
+):
+    """
+    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)

cli/broker/scripting.py

@@ -51,6 +51,18 @@ def new_script(
 
     local_signals = ",".join(list(map(to_local_signal, signals_to_subscribe_to)))
 
+    def to_subscribe_pattern(sig_name: tuple[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(
         """
 --
@@ -70,33 +82,26 @@ function output_signal()
     return "$output_signal"
 end
 
-local local_frequency_hz = 0
-
 -- Required, declare what frequency you like to get "timer" invoked. 0 means no calls to "timer".
 function timer_frequency_hz()
-    return local_frequency_hz
+    return 0
 end
 
--- Invoked with the frequecy returned by "timer_frequency_hz".
--- @param system_timestamp_us: system time stamp.
+-- 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
 
-    if signals["$signle_input_signal"] == 0 then
-        return return_value_or_bytes(0)
-    else
-        return return_value_or_bytes(signals["$signle_input_signal"] * 2)
-    end
+    $subscribe_pattern
+    return return_nothing()
 end
 
 -- helper return function, make sure to use return_value_or_bytes or return_nothing.
@@ -104,12 +109,18 @@ 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,
-        signle_input_signal=signals_to_subscribe_to[0][1],  # Take one signal and use signal name in tuple
+        # signle_input_signal=signals_to_subscribe_to[0][1],  # Take one signal and use signal name in tuple
+        subscribe_pattern=subscribe_pattern,
         output_signal=output_signal,
     )
 

cli/broker/signals.py

@@ -95,7 +95,8 @@ def subscribe(  # noqa: C901
 
     if script is not None:
         if len(signal) > 0:
-            ErrorPrinter.print_generic_error("You must must not specify namespace or signal when using --script")
+            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            exit(1)
 
     plt.title("Signals")
 

cli/cloud/recordings.py

@@ -459,8 +459,7 @@ def _do_change_playback_mode(mode: str, recording_session: str, broker: str, pro
             if json_context["recordingSessionId"] != recording_session:
                 ErrorPrinter.print_generic_error(
                     f"The recording id mounted is '{json_context['recordingSessionId']}' "
-                    f"which  not the same as you are trying to {mode}, "
-                    "use cmd below to mount this recording"
+                    f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
                 )
                 ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 exit(1)

cli/cloud/recordings_playback.py

@@ -3,16 +3,18 @@ from __future__ import annotations
 import datetime
 import json
 import tempfile
-from typing import List
+from pathlib import Path
+from typing import List, Union
 
 import grpc
 import rich
 import typer
+from rich import print as rich_rprint
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.errors import ErrorPrinter
 
-from ..broker.lib.broker import Broker
+from ..broker.lib.broker import Broker, SubscribableSignal
 from . import rest_helper as rest
 
 app = typer.Typer(
@@ -89,6 +91,72 @@ def stop(
     _do_change_playback_mode("stop", recording_session, broker, project)
 
 
+# Copied from signals.py
+def read_scripted_code_file(file_path: Path) -> bytes:
+    # typer checks that the Path exists
+    with open(file_path, "rb") as file:
+        return file.read()
+
+
+@app.command()
+def subscribe(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    signal: List[str] = typer.Option(None, 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"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+):
+    """
+    Allows you to subscribe to signals based on a mounted recording without knowing the broker URL.
+    This simplifies when playing recordings from the cloud.
+
+    Terminal plotting is not yet supported here so we refer to remotive broker signals subscribe --x-plot for this.
+    """
+    if script is None:
+        if len(signal) == 0:
+            ErrorPrinter.print_generic_error("You must use include at least one signal and one namespace or use script when subscribing")
+            exit(1)
+    if script is not None:
+        if len(signal) > 0:
+            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            exit(1)
+
+    broker_client = _get_broker_info(project, recording_session, broker, "subscribe")
+
+    try:
+        if script is not None:
+            script_src = read_scripted_code_file(script)
+            broker_client.subscribe_on_script(script_src, lambda sig: rich_rprint(json.dumps(list(sig))), on_change_only)
+        else:
+
+            def to_subscribable_signal(sig: str):
+                arr = sig.split(":")
+                if len(arr) != 2:
+                    ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")
+                    exit(1)
+                return SubscribableSignal(namespace=arr[0], name=arr[1])
+
+            signals_to_subscribe_to = list(map(to_subscribable_signal, signal))
+            broker_client.long_name_subscribe(signals_to_subscribe_to, lambda sig: rich_rprint(json.dumps(list(sig))), on_change_only)
+            print("Subscribing to signals, press Ctrl+C to exit")
+    except grpc.RpcError as rpc_error:
+        ErrorPrinter.print_grpc_error(rpc_error)
+
+    except Exception as e:
+        ErrorPrinter.print_generic_error(e)
+        exit(1)
+
+
 def _do_change_playback_mode(
     mode: str,
     recording_session: str,
@@ -103,10 +171,8 @@ def _do_change_playback_mode(
     recordings: list = r["recordings"]
     files = list(map(lambda rec: {"recording": rec["fileName"], "namespace": rec["metadata"]["namespace"]}, recordings))
 
-    if broker is not None:
-        response = rest.handle_get(f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
-    else:
-        response = rest.handle_get(f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
+    broker_name = broker if broker is not None else "personal"
+    response = rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
     if response.status_code == 404:
         broker_arg = ""
         if broker is not None:
@@ -164,8 +230,7 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
             if json_context["recordingSessionId"] != recording_session:
                 ErrorPrinter.print_generic_error(
                     f"The recording id mounted is '{json_context['recordingSessionId']}' "
-                    f"which  not the same as you are trying to {mode}, "
-                    "use cmd below to mount this recording"
+                    f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
                 )
                 ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 exit(1)
@@ -176,3 +241,22 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
         else:
             ErrorPrinter.print_grpc_error(rpc_error)
         exit(1)
+
+
+def _get_broker_info(project: str, recording_session: str, broker: Union[str, None], mode: str) -> Broker:
+    # Verify it exists
+    rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+
+    broker_name = broker if broker is not None else "personal"
+    response = rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
+    if response.status_code == 404:
+        broker_arg = ""
+        if broker is not None:
+            broker_arg = f"--broker {broker} --ensure-broker-started"
+        ErrorPrinter.print_generic_error("You need to mount the recording before you play")
+        ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} {broker_arg} --project {project}")
+        exit(1)
+    broker_info = json.loads(response.text)
+    broker_client = Broker(broker_info["url"], None)
+    _verify_recording_on_broker(broker_client, recording_session, mode, project)
+    return broker_client

cli/cloud/rest_helper.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import base64
 import json
 import logging
 import os
 import shutil
 from importlib.metadata import version
 from pathlib import Path
-from typing import List, Union
+from typing import Dict, List, Union
 
 import requests
 from rich.console import Console
@@ -23,11 +24,16 @@ if "REMOTIVE_CLOUD_HTTP_LOGGING" in os.environ:
     requests_log.setLevel(logging.DEBUG)
     requests_log.propagate = True
 global baseurl
+global license_server_base_url
 base_url = "https://cloud.remotivelabs.com"
+license_server_base_url = "https://license.cloud.remotivelabs.com"
 
 if "REMOTIVE_CLOUD_BASE_URL" in os.environ:
     base_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
 
+if "cloud-dev" in base_url:
+    license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
+
 # if 'REMOTIVE_CLOUD_AUTH_TOKEN' not in os.environ:
 #    print('export REMOTIVE_CLOUD_AUTH_TOKEN=auth must be set')
 #    exit(0)
@@ -65,12 +71,23 @@ def ensure_auth_token():
     headers["User-Agent"] = f"remotivelabs-cli {cli_version}"
 
 
-def handle_get(url, params=None, return_response: bool = False, allow_status_codes=None, progress_label="Fetching..."):
+def handle_get(
+    url,
+    params=None,
+    return_response: bool = False,
+    allow_status_codes=None,
+    progress_label="Fetching...",
+    use_progress_indicator: bool = True,
+    timeout: int = 20,
+):
     if params is None:
         params = {}
     ensure_auth_token()
-    with use_progress(progress_label):
-        r = requests.get(f"{base_url}{url}", headers=headers, params=params)
+    if use_progress_indicator:
+        with use_progress(progress_label):
+            r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
+    else:
+        r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
 
     if return_response:
         check_api_result(r, allow_status_codes)
@@ -192,3 +209,18 @@ def download_file(save_file_name: str, url: str):
                 shutil.copyfileobj(stream_with_progress, out_file)
     else:
         check_api_result(download_resp)
+
+
+def request_license(email: str, machine_id: Dict[str, any]) -> str:
+    # Lets keep the email here so we have the same interface for both authenticated
+    # and not authenticated license requests.
+    # email will be validated in the license server to make sure it matches with the user of the
+    # access token so not any email is sent here
+    ensure_auth_token()
+    payload = {"id": email, "machine_id": machine_id}
+    b64_encoded_bytes = base64.encodebytes(json.dumps(payload).encode())
+    license_jsonb64 = {"licensejsonb64": b64_encoded_bytes.decode("utf-8")}
+    headers["content-type"] = "application/json"
+    r = requests.post(url=f"{license_server_base_url}/api/license/request", headers=headers, data=json.dumps(license_jsonb64))
+    check_api_result(r)
+    return r.json()["license_data"]

{remotivelabs_cli-0.0.16.dist-info → remotivelabs_cli-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: remotivelabs-cli
-Version: 0.0.16
+Version: 0.0.18
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com

{remotivelabs_cli-0.0.16.dist-info → remotivelabs_cli-0.0.18.dist-info}/RECORD

@@ -1,14 +1,16 @@
 cli/__about__.py,sha256=qXVkxWb3aPCF-4MjQhB0wqL2GEblEH4Qwk70o29UkJk,122
 cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/broker/brokers.py,sha256=sSX--mm5ln5RUFR60VFHQR6NWu4Qz7Jqi2Ws-4TJsDI,3052
-cli/broker/export.py,sha256=kPB8xRe-I-fte5d95E0Uy2wLvQp943e4yFARGPKySoY,4386
+cli/broker/brokers.py,sha256=jVbaiCnFoCxQBGhidePg6GxDhurzXtbn8mV59HkzAc4,3181
+cli/broker/export.py,sha256=Xhpz2P32VMow7DujImCzhiP-WqJvdR1-THErRV_4LPU,4363
 cli/broker/files.py,sha256=_8elBjbmJ5MEEeFGJ7QYkXzyuLDCDpO6UvEVXHbRy7U,4133
 cli/broker/lib/__about__.py,sha256=xnZ5V6ZcHW9dhWLWdMzVjYJbEnMKpeXm0_S_mbNzypE,141
-cli/broker/lib/broker.py,sha256=kpcSaHcjZlcsgNgxwDBEa13RYRtx0Uz-fbBg2pKAHI0,21174
+cli/broker/lib/broker.py,sha256=uolp_AaC3Z_pGeF4rP28FvHvtSRUJFuT5Dxe8aLhdgI,21957
+cli/broker/license_flows.py,sha256=AaKvZgy_hkP5Mv-1dXtQxQxXGidpvuVDVY3jP2AX0t0,7101
+cli/broker/licenses.py,sha256=iJeF6aWKUPhXb24t0pyufFRmMGNCFo-G_ZUz1rstqqs,3957
 cli/broker/playback.py,sha256=oOfC8Jn4Ib-nc9T6ob_uNXZSeCWfft7MrMQPafH4U2I,4846
 cli/broker/record.py,sha256=gEvo3myHbIl6UyXzhJE741NiwRrFf7doBg6HXzzp5z0,1382
-cli/broker/scripting.py,sha256=sLDtuktWsVk0fJ3RW4kYyh-_YAVJP3VM0xFIQR499Oo,3392
-cli/broker/signals.py,sha256=3z4vVivPdo8dfz8XY-s7Ga5I75uQaptWarixrfSsm-0,6547
+cli/broker/scripting.py,sha256=Nb6C8JjfuQXuvd_L8CtlTHEc5iTBRwI4RXMQdf_gWYg,3752
+cli/broker/signals.py,sha256=py_qOwTP5ongpOVLKznMfVPw68iB--1eIvnRdOLND7k,6556
 cli/cloud/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 cli/cloud/auth.py,sha256=xi47cQWjs6q7Kje4XUbTqEk_BgG3NJ1gMOYPU-_4tgw,3470
 cli/cloud/auth_tokens.py,sha256=5ox0Pxfij8aTgEcDwRBasaSQvDuLIGCJc-INjmIQN2M,3408
@@ -16,9 +18,9 @@ cli/cloud/brokers.py,sha256=wa3uMg91IZdrP0tMpTdO9cBIkZHtMHxQ-zEXwFiye_I,4127
 cli/cloud/cloud_cli.py,sha256=nRRXFF_IgUMayerxS-h7oqsNe6tt34Q5VeThq8gatEg,1443
 cli/cloud/configs.py,sha256=2p1mCHf5BwYNtwbY0Cbed5t6-79WHGKWU4Fv6LuJ21o,4069
 cli/cloud/projects.py,sha256=-uqltAOficwprOKaPd2R0Itm4sqTz3VJNs9Sc8jtO5k,1369
-cli/cloud/recordings.py,sha256=0xQw8iv-NjUUqxQjq5O4WqNYsew2lNlQ9Z0Qevl2f9E,20844
-cli/cloud/recordings_playback.py,sha256=ygJRBbJ_BYmrEZ7k0j2b11N3xrrgmOdL3jZckJ-f-uU,7120
-cli/cloud/rest_helper.py,sha256=g7lmGosAS0IDlo9Aso0bH0tdlLTCz0IYx3R71DXKtkc,6491
+cli/cloud/recordings.py,sha256=xbdqUYVmKyChV24cASK3zNPkmCPwIUmX9H5LsG98zfI,20820
+cli/cloud/recordings_playback.py,sha256=OXRvoE7Zc_jQrofpqjbWYKZ6pfhJVHBe0bQ9GEfv64Q,10879
+cli/cloud/rest_helper.py,sha256=WK5We-vWg0GwnTq37OyKVuQTc58RFkPuA0kq5wjDtCk,7769
 cli/cloud/sample_recordings.py,sha256=g1X6JTxvzWInSP9R1BJsDmL4WqvpEKqjdJR_xT4bo1U,639
 cli/cloud/service_account_tokens.py,sha256=7vjoMd6Xq7orWCUP7TVUVa86JA0OiX8O10NZcHUE6rM,2294
 cli/cloud/service_accounts.py,sha256=GCYdYPnP5uWVsg1bTIS67CmoPWDng5dupJHmlThrJ80,1606
@@ -33,8 +35,8 @@ cli/tools/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 cli/tools/can/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 cli/tools/can/can.py,sha256=kSd1c-nxxXyeKkm19oDILiDBZsKOcpjsUT0T3xox5Qs,2172
 cli/tools/tools.py,sha256=LwQdWMcJ19pCyKUsVfSB2B3R6ui61NxxFWP0Nrnd5Jk,198
-remotivelabs_cli-0.0.16.dist-info/LICENSE,sha256=qDPP_yfuv1fF-u7EfexN-cN3M8aFgGVndGhGLovLKz0,608
-remotivelabs_cli-0.0.16.dist-info/METADATA,sha256=A5ZA5VGXfw287Q187R5Pt4cPH5xOVmDWzeRq8offtPk,1224
-remotivelabs_cli-0.0.16.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-remotivelabs_cli-0.0.16.dist-info/entry_points.txt,sha256=lvDhPgagLqW_KTnLPCwKSqfYlEp-1uYVosRiPjsVj10,45
-remotivelabs_cli-0.0.16.dist-info/RECORD,,
+remotivelabs_cli-0.0.18.dist-info/LICENSE,sha256=qDPP_yfuv1fF-u7EfexN-cN3M8aFgGVndGhGLovLKz0,608
+remotivelabs_cli-0.0.18.dist-info/METADATA,sha256=lqsiXEeEjC4k1kbynvlJ5r5tQYZfArLUCLRXnA6v1xM,1224
+remotivelabs_cli-0.0.18.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+remotivelabs_cli-0.0.18.dist-info/entry_points.txt,sha256=lvDhPgagLqW_KTnLPCwKSqfYlEp-1uYVosRiPjsVj10,45
+remotivelabs_cli-0.0.18.dist-info/RECORD,,