remotivelabs-cli 0.0.25__py3-none-any.whl → 0.0.27__py3-none-any.whl

cli/broker/brokers.py

@@ -19,7 +19,7 @@ app = typer.Typer(rich_markup_mode="rich")
 @app.callback()
 def main(
     url: str = typer.Option(None, is_eager=False, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
-):
+) -> None:
     # This can be used to override the --url per command, lets see if this is a better approach
     if url is not None:
         os.environ["REMOTIVE_BROKER_URL"] = url
@@ -28,7 +28,7 @@ def main(
 
 
 @app.command(help="Discover brokers on this network")
-def discover():
+def discover() -> None:
     # print("Not implemented")
 
     zeroconf = Zeroconf(ip_version=IPVersion.V4Only)

cli/broker/export.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 import signal as os_signal
-from typing import List
+from typing import Any, List
 
 import grpc
 import typer
@@ -28,7 +28,7 @@ def influxdb(
     # namespace: str = typer.Option(..., help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
     on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
     output: str = typer.Option(None, help="Write results to file, defaults to stdout"),
-):
+) -> None:
     """
     Exports subscribed signals to InfluxDB line-protocol, really useful to dump some signals into
     influxdb for offline analysis and insights.
@@ -53,12 +53,12 @@ def influxdb(
     if output is not None:
         f = open(output, "w")
 
-    def exit_on_ctrlc(sig, frame):
+    def exit_on_ctrlc(sig: Any, frame: Any) -> None:
         if output is not None:
             f.close()
         os._exit(0)
 
-    def per_frame_influx_line_protocol(x):
+    def per_frame_influx_line_protocol(x: Any) -> None:
         signals = list(x)
         if len(signals) == 0:
             return
@@ -107,7 +107,7 @@ def influxdb(
     # signals2 = list(map( lambda s: s['signal'], broker.list_signal_names2(namespace)))
     try:
 
-        def to_subscribable_signal(sig: str):
+        def to_subscribable_signal(sig: str) -> SubscribableSignal:
             arr = sig.split(":")
             if len(arr) != 2:
                 ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")

cli/broker/files.py

@@ -11,14 +11,14 @@ from cli.errors import ErrorPrinter
 
 from .lib.broker import Broker
 
-app = typer.Typer(help=help)
+app = typer.Typer(help=help)  # type: ignore
 
 
 @app.command()
 def reload_configuration(
     url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
     api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
-):
+) -> None:
     try:
         broker = Broker(url, api_key)
         broker.reload_config()
@@ -33,7 +33,7 @@ def delete(
     exit_on_failure: bool = typer.Option(False, help="Exits if there was a problem deleting a file"),
     url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
     api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
-):
+) -> None:
     """
     Deletes the specified files from the broker
     """
@@ -55,7 +55,7 @@ def download(
     output: str = typer.Option("", help="Optional output file name"),
     url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
     api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
-):
+) -> None:
     """
     Downloads a file from a broker
     """
@@ -85,7 +85,7 @@ def upload(
     output: str = typer.Option("", help="Optional output path on broker"),
     url: str = typer.Option(..., help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
     api_key: str = typer.Option("offline", help="Cloud Broker API-KEY or access token", envvar="REMOTIVE_BROKER_API_KEY"),
-):
+) -> None:
     """
     Uploads a file to a broker - physical or in cloud.
     """

cli/broker/lib/broker.py

@@ -8,11 +8,10 @@ import queue
 import signal as os_signal
 import tempfile
 import time
-import typing
 import zipfile
 from dataclasses import dataclass
 from threading import Thread
-from typing import Callable, List, Sequence, Union
+from typing import Any, Callable, Dict, Iterable, List, Sequence, Union
 
 import grpc
 import remotivelabs.broker.generated.sync.traffic_api_pb2 as traffic_api
@@ -42,10 +41,10 @@ class LicenseInfo:
 
 
 class Broker:
-    def __init__(self, url: str, api_key: Union[str, None] = None):
+    def __init__(self, url: str, api_key: Union[str, None] = None) -> None:
         self.url = url
         self.api_key = api_key
-        self.q = queue.Queue()
+        self.q: queue.Queue[Any] = queue.Queue()
         """Main function, checking arguments passed to script, setting up stubs, configuration and starting Threads."""
         # Setting up stubs and configuration
 
@@ -70,7 +69,7 @@ class Broker:
         self.signal_creator = br.SignalCreator(self.system_stub)
 
     @staticmethod
-    def __check_playbackmode_result(status):
+    def __check_playbackmode_result(status: br.traffic_api_pb2.PlaybackInfos) -> None:
         err_cnt = 0
         for mode in status.playbackInfo:
             if mode.playbackMode.errorMessage:
@@ -79,8 +78,8 @@ class Broker:
         if err_cnt > 0:
             raise typer.Exit(1)
 
-    def seek(self, recording_and_namespace: List, offset: int, silent: bool = True):
-        def to_playback(rec):
+    def seek(self, recording_and_namespace: List[Any], offset: int, silent: bool = True) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(rec: Any) -> Dict[str, Any]:
             return {"namespace": rec["namespace"], "path": rec["recording"], "mode": br.traffic_api_pb2.Mode.SEEK, "offsettime": offset}
 
         playback_list = map(to_playback, recording_and_namespace)
@@ -91,8 +90,8 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def play(self, recording_and_namespace: List, silent: bool = False):
-        def to_playback(rec):
+    def play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
@@ -109,8 +108,8 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def stop_play(self, recording_and_namespace: List, silent: bool = False):
-        def to_playback(rec):
+    def stop_play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
@@ -126,8 +125,8 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def pause_play(self, recording_and_namespace: List, silent: bool = False):
-        def to_playback(rec):
+    def pause_play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
@@ -143,8 +142,8 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def record_multiple(self, namespaces: List[str], path: str):
-        def to_playback(namespace):
+    def record_multiple(self, namespaces: List[str], path: str) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(namespace: str) -> Dict[str, Any]:
             return {
                 "namespace": namespace,
                 "path": path + "_" + namespace,
@@ -159,7 +158,7 @@ class Broker:
         self.__check_playbackmode_result(status)
         return status
 
-    def record(self, namespace: str, path: str):
+    def record(self, namespace: str, path: str) -> br.traffic_api_pb2.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
@@ -174,7 +173,7 @@ class Broker:
         self.__check_playbackmode_result(status)
         return status
 
-    def stop(self, namespace: str, path: str, silent: bool = False):
+    def stop(self, namespace: str, path: str, silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
@@ -190,20 +189,22 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def listen_on_playback(self, repeat: bool, recording_and_namespace: List, callback: Callable[[int, int, str], None]):
+    def listen_on_playback(self, repeat: bool, recording_and_namespace: List[Any], callback: Callable[[int, int, str], None]) -> None:
         # include recording_and_namespace if we want to loop the recording
         # This can probably be improved
-        def get_mode(mode: int):
+        def get_mode(mode: int) -> str:
             if mode == 0:
                 return "playing"
             if mode == 1:
                 return "paused"
             if mode == 2:
                 return "stopped"
+            raise ValueError("Unknown Mode")
 
         sub = self.traffic_stub.PlayTrafficStatus(br.common_pb2.Empty())
         for playback_state in sub:
-            p = typing.cast(br.traffic_api_pb2.PlaybackInfos, playback_state)
+            # p = typing.cast(br.traffic_api_pb2.PlaybackInfos, playback_state) # REDUNDANT CAST
+            p = playback_state
             offset_length = int(p.playbackInfo[0].playbackMode.offsetTime / 1000000)
             start_time = p.playbackInfo[0].playbackMode.startTime
             end_time = p.playbackInfo[0].playbackMode.endTime
@@ -218,7 +219,7 @@ class Broker:
                     self.play(recording_and_namespace)
             callback(offset_length, total_length, get_mode(mode))
 
-    def pause(self, namespace: str, path: str, silent: bool = False):
+    def pause(self, namespace: str, path: str, silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
@@ -234,8 +235,8 @@ class Broker:
             self.__check_playbackmode_result(status)
         return status
 
-    def stop_multiple(self, namespaces: List[str], path: str):
-        def to_playback(namespace):
+    def stop_multiple(self, namespaces: List[str], path: str) -> br.traffic_api_pb2.PlaybackInfos:
+        def to_playback(namespace: str) -> Dict[str, Any]:
             return {
                 "namespace": namespace,
                 "path": path + "_" + namespace,
@@ -250,17 +251,17 @@ class Broker:
         self.__check_playbackmode_result(status)
         return status
 
-    def diagnose_stop(self, namespace: List[str]):
+    def diagnose_stop(self, namespace: List[str]) -> None:
         recording_name = "diagnose__"
         self.stop_multiple(namespace, recording_name)
 
-    def diagnose(self, namespace: List[str], wait_for_traffic: bool = False):
+    def diagnose(self, namespace: List[str], wait_for_traffic: bool = False) -> None:
         recording_name = "diagnose__"
 
         keep_running = True
         keep_running_during_recording = True
 
-        def exit_on_ctrlc(sig, frame):
+        def exit_on_ctrlc(sig: Any, frame: Any) -> None:
             nonlocal keep_running
             keep_running = False
             nonlocal keep_running_during_recording
@@ -299,7 +300,7 @@ class Broker:
                     if not wait_for_traffic or (not keep_running and not keep_running_during_recording):
                         print(f'Namespace {r["namespace"]} did not receive any traffic')
 
-    def upload(self, file: str, dest: str):
+    def upload(self, file: str, dest: str) -> None:
         try:
             br.helper.upload_file(system_stub=self.system_stub, path=file, dest_path=dest)
         except grpc.RpcError as rpc_error:
@@ -321,14 +322,14 @@ class Broker:
 
     # rpc BatchDeleteFiles (FileDescriptions) returns (Empty) {}
 
-    def upload_folder(self, folder: str):
+    def upload_folder(self, folder: str) -> None:
         try:
             br.helper.upload_folder(system_stub=self.system_stub, folder=folder)
         except grpc.RpcError as rpc_error:
             print(f"Failed to upload file - {rpc_error.details()} ({rpc_error.code()})")
             raise typer.Exit(1)
 
-    def download(self, file: str, dest: str, delegate_err: bool = False):
+    def download(self, file: str, dest: str, delegate_err: bool = False) -> None:
         try:
             br_helper.download_file(system_stub=self.system_stub, path=file, dest_path=dest)
         except grpc.RpcError as rpc_error:
@@ -339,7 +340,7 @@ class Broker:
             os.remove(dest)
             raise typer.Exit(1)
 
-    def reload_config(self):
+    def reload_config(self) -> None:
         try:
             request = br.common_pb2.Empty()
             response = self.system_stub.ReloadConfiguration(request, timeout=60000)
@@ -351,7 +352,7 @@ class Broker:
             print(f"Failed to reload configuration - {rpc_error.details()} ({rpc_error.code()})")
             raise typer.Exit(1)
 
-    def list_namespaces(self):
+    def list_namespaces(self) -> List[str]:
         # Lists available signals
         configuration = self.system_stub.GetConfiguration(br.common_pb2.Empty())
         namespaces = []
@@ -359,7 +360,7 @@ class Broker:
             namespaces.append(network_info.namespace.name)
         return namespaces
 
-    def list_signal_names(self):
+    def list_signal_names(self) -> List[Dict[str, Any]]:
         # Lists available signals
         configuration = self.system_stub.GetConfiguration(br.common_pb2.Empty())
 
@@ -368,9 +369,30 @@ class Broker:
             res = self.system_stub.ListSignals(network_info.namespace)
             for finfo in res.frame:
                 # f: br.common_pb2.FrameInfo = finfo
-                signal_names.append({"signal": finfo.signalInfo.id.name, "namespace": network_info.namespace.name})
+                receivers = []
                 for sinfo in finfo.childInfo:
-                    signal_names.append({"signal": sinfo.id.name, "namespace": network_info.namespace.name})
+                    rec = list(map(lambda r: r, sinfo.metaData.receiver))
+                    receivers.extend(rec)
+                    signal_names.append(
+                        {
+                            "signal": sinfo.id.name,
+                            "namespace": network_info.namespace.name,
+                            "receivers": rec,
+                            "min": sinfo.metaData.min,
+                            "max": sinfo.metaData.max,
+                        }
+                    )
+
+                signal_names.append(
+                    {
+                        "signal": finfo.signalInfo.id.name,
+                        "namespace": network_info.namespace.name,
+                        "senders": list(map(lambda s: s, finfo.signalInfo.metaData.sender)),
+                        "receivers": list(set(receivers)),
+                        "cycletime": finfo.signalInfo.metaData.cycleTime,
+                    }
+                )
+
         return signal_names
 
     def subscribe_on_script(
@@ -378,7 +400,7 @@ class Broker:
         script: bytes,
         on_frame: Callable[[Sequence[br.network_api_pb2.Signal]], None],
         changed_values_only: bool = False,
-    ) -> grpc.RpcContext:
+    ) -> Any:
         client_id = br.common_pb2.ClientId(id="cli")
         # sync = queue.Queue()
         thread = Thread(
@@ -406,11 +428,11 @@ class Broker:
         # over namespaces
         # Begin
 
-        def verify_namespace(available_signal):
-            return list(filter(lambda namespace: available_signal["namespace"] == namespace, subscribed_namespaces))
+        def verify_namespace(available_signal: List[Dict[str, str]]) -> List[str]:
+            return list(filter(lambda namespace: available_signal["namespace"] == namespace, subscribed_namespaces))  # type: ignore
 
-        def find_subscribed_signal(available_signal):
-            return list(filter(lambda s: available_signal["signal"] == s, subscribed_signals))
+        def find_subscribed_signal(available_signal: List[Dict[str, str]]) -> List[str]:
+            return list(filter(lambda s: available_signal["signal"] == s, subscribed_signals))  # type: ignore
 
         existing_signals = self.list_signal_names()
         existing_ns = set(map(lambda s: s["namespace"], existing_signals))
@@ -424,8 +446,8 @@ class Broker:
             )
             exit(1)
 
-        available_signals = list(filter(verify_namespace, existing_signals))
-        signals_to_subscribe_to = list(filter(find_subscribed_signal, available_signals))
+        available_signals = list(filter(verify_namespace, existing_signals))  # type: ignore
+        signals_to_subscribe_to = list(filter(find_subscribed_signal, available_signals))  # type: ignore
 
         # Check if subscription is done on signal that is not in any of these namespaces
         signals_subscribed_to_but_does_not_exist = set(subscribed_signals) - set(map(lambda s: s["signal"], signals_to_subscribe_to))
@@ -436,7 +458,9 @@ class Broker:
 
         return list(map(lambda s: SubscribableSignal(s["signal"], s["namespace"]), signals_to_subscribe_to))
 
-    def long_name_subscribe(self, signals_to_subscribe_to: List[SubscribableSignal], on_frame, changed_values_only: bool = True):
+    def long_name_subscribe(
+        self, signals_to_subscribe_to: List[SubscribableSignal], on_frame: Callable[..., Any], changed_values_only: bool = True
+    ) -> Any:
         client_id = br.common_pb2.ClientId(id="cli")
 
         # TODO - This can be improved moving forward and we also need to move the validation into api
@@ -444,7 +468,7 @@ class Broker:
             list(map(lambda s: s.namespace, signals_to_subscribe_to)), (list(map(lambda s: s.name, signals_to_subscribe_to)))
         )
 
-        def to_protobuf_signal(s: SubscribableSignal):
+        def to_protobuf_signal(s: SubscribableSignal) -> br.common_pb2.SignalId:
             return self.signal_creator.signal(s.name, s.namespace)
 
         signals_to_subscribe_on = list(map(to_protobuf_signal, signals_to_subscribe_to))
@@ -464,14 +488,20 @@ class Broker:
         ecu, subscription = self.q.get()
         return subscription
 
-    def subscribe(self, subscribed_signals: list[str], subscribed_namespaces: list[str], on_frame, changed_values_only: bool = True):
+    def subscribe(
+        self,
+        subscribed_signals: list[str],
+        subscribed_namespaces: list[str],
+        on_frame: Callable[..., Any],
+        changed_values_only: bool = True,
+    ) -> Any:
         client_id = br.common_pb2.ClientId(id="cli")
 
         signals_to_subscribe_to: List[SubscribableSignal] = self.validate_and_get_subscribed_signals(
             subscribed_namespaces, subscribed_signals
         )
 
-        def to_protobuf_signal(s: SubscribableSignal):
+        def to_protobuf_signal(s: SubscribableSignal) -> br.common_pb2.SignalId:
             return self.signal_creator.signal(s.name, s.namespace)
 
         signals_to_subscribe_on = list(map(to_protobuf_signal, signals_to_subscribe_to))
@@ -491,7 +521,7 @@ class Broker:
         ecu, subscription = self.q.get()
         return subscription
 
-    def __each_signal(self, signals, callback):
+    def __each_signal(self, signals: Iterable[br.network_api_pb2.Signal], callback: Callable[..., Any]) -> None:
         callback(
             map(
                 lambda s: {"timestamp_us": s.timestamp, "namespace": s.id.namespace.name, "name": s.id.name, "value": self.__get_value(s)},
@@ -500,7 +530,7 @@ class Broker:
         )
 
     @staticmethod
-    def __get_value(signal):
+    def __get_value(signal: br.network_api_pb2.Signal) -> Any:
         if signal.raw != b"":
             return "0x" + binascii.hexlify(signal.raw).decode("ascii")
         if signal.HasField("integer"):
@@ -512,7 +542,7 @@ class Broker:
         return "empty"
 
     @staticmethod
-    def __create_playback_config(item):
+    def __create_playback_config(item: Dict[str, Any]) -> br.traffic_api_pb2.PlaybackInfo:
         """Creating configuration for playback
 
         Parameters
@@ -527,9 +557,10 @@ class Broker:
 
         """
 
-        def get_offset_time():
+        def get_offset_time() -> int:
             if "offsettime" in item:
-                return item["offsettime"]
+                return int(item["offsettime"])
+            return 0
 
         playback_config = br.traffic_api_pb2.PlaybackConfig(
             fileDescription=br.system_api_pb2.FileDescription(path=item["path"]),
@@ -549,7 +580,7 @@ class Broker:
             machine_id=license_info.requestMachineId.decode("utf-8"),
         )
 
-    def apply_license(self, license_data_b64: bytes):
+    def apply_license(self, license_data_b64: bytes) -> LicenseInfo:
         license = br.system_api_pb2.License()
         license.data = license_data_b64
         license.termsAgreement = True

cli/broker/license_flows.py

@@ -10,8 +10,8 @@ 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
+from cli.cloud.rest_helper import RestHelper as Rest
 
 console = Console(stderr=True)
 
@@ -25,7 +25,7 @@ class LicenseFlow:
         )
         return b.get_license()
 
-    def describe_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051"):
+    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"
 
@@ -34,7 +34,7 @@ class LicenseFlow:
         )
         return b.get_license()
 
-    def request_with_url_with_internet(self, url: str):
+    def request_with_url_with_internet(self, url: str) -> None:
         console.print("This requires internet connection from your computer during the entire licensing process")
 
         email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
@@ -68,7 +68,7 @@ class LicenseFlow:
         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"):
+    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
@@ -137,12 +137,14 @@ class LicenseFlow:
         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)
+                    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"]
+        if r is None:
+            return ""
+        return str(r.json()["email"])
 
     @staticmethod
     def __try_request_license(
@@ -153,15 +155,15 @@ class LicenseFlow:
         with use_progress(progress_label):
             while True:
                 try:
-                    license_data_b64 = rest.request_license(email, json.loads(existing_license.machine_id)).encode()
+                    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
+        return bytes(license_data_b64)
 
 
-def use_progress(label: str):
+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

cli/broker/licenses.py

@@ -35,7 +35,7 @@ class Connection(str, Enum):
 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
 
@@ -70,7 +70,7 @@ def request(
         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