remotivelabs-cli 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

cli/broker/lib/broker.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import binascii
+import hashlib
+import itertools
 import ntpath
 import os
 import posixpath
@@ -11,22 +13,25 @@ import tempfile
 import time
 import zipfile
 from dataclasses import dataclass
+from glob import glob
 from threading import Thread
-from typing import Any, Callable, Dict, Iterable, List, Sequence, Union
+from typing import Any, BinaryIO, Callable, Dict, Generator, Iterable, List, Sequence, Union
 
 import grpc
-import remotivelabs.broker.generated.sync.network_api_pb2 as network_api
-import remotivelabs.broker.generated.sync.traffic_api_pb2 as traffic_api
-import remotivelabs.broker.sync as br
-import remotivelabs.broker.sync.helper as br_helper
+import remotivelabs.broker._generated.common_pb2 as common
+import remotivelabs.broker._generated.network_api_pb2 as network_api
+import remotivelabs.broker._generated.network_api_pb2_grpc as network_api_grpc
+import remotivelabs.broker._generated.system_api_pb2 as system_api
+import remotivelabs.broker._generated.system_api_pb2_grpc as system_api_grpc
+import remotivelabs.broker._generated.traffic_api_pb2 as traffic_api
+import remotivelabs.broker._generated.traffic_api_pb2_grpc as traffic_api_grpc
 import typer
 from google.protobuf.json_format import MessageToDict
-from rich.console import Console
 
-from cli.errors import ErrorPrinter
+from cli.broker.lib.helper import act_on_scripted_signal, act_on_signal, create_channel
+from cli.broker.lib.signalcreator import SignalCreator
 from cli.settings import settings
-
-err_console = Console(stderr=True)
+from cli.utils.console import print_generic_error, print_hint, print_success
 
 
 @dataclass
@@ -43,6 +48,27 @@ class LicenseInfo:
     machine_id: str
 
 
+def get_sha256(path: str) -> str:
+    """
+    Calculate SHA256 for a file.
+    """
+    with open(path, "rb") as f:
+        b = f.read()  # read entire file as bytes
+        return hashlib.sha256(b).hexdigest()
+
+
+def generate_data(file: BinaryIO, dest_path: str, chunk_size: int, sha256: str) -> Generator[system_api.FileUploadRequest, None, None]:
+    for x in itertools.count(start=0):
+        if x == 0:
+            file_description = system_api.FileDescription(sha256=sha256, path=dest_path)
+            yield system_api.FileUploadRequest(fileDescription=file_description)
+        else:
+            buf = file.read(chunk_size)
+            if not buf:
+                break
+            yield system_api.FileUploadRequest(chunk=buf)
+
+
 class Broker:
     def __init__(self, url: str, api_key: Union[str, None] = None) -> None:
         self.url = url
@@ -53,138 +79,138 @@ class Broker:
 
         if api_key is None or api_key == "":
             if url.startswith("https"):
-                self.intercept_channel = br.create_channel(url, None, settings.get_active_token())
+                self.intercept_channel = create_channel(url, None, settings.get_active_token())
                 # TODO - Temporary solution to print proper error message, remove ENV once api-key is gone
                 os.environ["ACCESS_TOKEN"] = "true"
             else:
                 os.environ["ACCESS_TOKEN"] = "false"
-                self.intercept_channel = br.create_channel(url, None, None)
+                self.intercept_channel = create_channel(url, None, None)
         else:
-            err_console.print("Option --api-key will is deprecated and will be removed. Use access access tokens by logging in with cli.")
+            print_hint("Option --api-key will is deprecated and will be removed. Use access access tokens by logging in with cli.")
             os.environ["ACCESS_TOKEN"] = "false"
-            self.intercept_channel = br.create_channel(url, api_key, None)
+            self.intercept_channel = create_channel(url, api_key, None)
 
-        self.network_stub = br.network_api_pb2_grpc.NetworkServiceStub(self.intercept_channel)
-        self.system_stub = br.system_api_pb2_grpc.SystemServiceStub(self.intercept_channel)
-        self.traffic_stub = br.traffic_api_pb2_grpc.TrafficServiceStub(self.intercept_channel)
-        self.signal_creator = br.SignalCreator(self.system_stub)
+        self.network_stub = network_api_grpc.NetworkServiceStub(self.intercept_channel)
+        self.system_stub = system_api_grpc.SystemServiceStub(self.intercept_channel)
+        self.traffic_stub = traffic_api_grpc.TrafficServiceStub(self.intercept_channel)
+        self.signal_creator = SignalCreator(self.system_stub)
 
     @staticmethod
-    def __check_playbackmode_result(status: br.traffic_api_pb2.PlaybackInfos) -> None:
+    def __check_playbackmode_result(status: traffic_api.PlaybackInfos) -> None:
         err_cnt = 0
         for mode in status.playbackInfo:
             if mode.playbackMode.errorMessage:
-                print(mode.playbackMode.errorMessage)
+                print_generic_error(mode.playbackMode.errorMessage)
                 err_cnt = err_cnt + 1
         if err_cnt > 0:
             raise typer.Exit(1)
 
-    def seek(self, recording_and_namespace: List[Any], offset: int, silent: bool = True) -> br.traffic_api_pb2.PlaybackInfos:
+    def seek(self, recording_and_namespace: List[Any], offset: int, silent: bool = True) -> traffic_api.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}
+            return {"namespace": rec["namespace"], "path": rec["recording"], "mode": traffic_api.Mode.SEEK, "offsettime": offset}
 
         playback_list = map(to_playback, recording_and_namespace)
 
-        infos = br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
-        status = self.traffic_stub.PlayTraffic(infos)
+        infos = traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(infos)
         if not silent:
             self.__check_playbackmode_result(status)
         return status
 
-    def play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+    def play(self, recording_and_namespace: List[Any], silent: bool = False) -> traffic_api.PlaybackInfos:
         def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
-                "mode": br.traffic_api_pb2.Mode.PLAY,
+                "mode": traffic_api.Mode.PLAY,
             }
 
         playback_list = map(to_playback, recording_and_namespace)
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
 
         if not silent:
             self.__check_playbackmode_result(status)
         return status
 
-    def stop_play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+    def stop_play(self, recording_and_namespace: List[Any], silent: bool = False) -> traffic_api.PlaybackInfos:
         def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
-                "mode": br.traffic_api_pb2.Mode.STOP,
+                "mode": traffic_api.Mode.STOP,
             }
 
         playback_list = map(to_playback, recording_and_namespace)
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         if not silent:
             self.__check_playbackmode_result(status)
         return status
 
-    def pause_play(self, recording_and_namespace: List[Any], silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+    def pause_play(self, recording_and_namespace: List[Any], silent: bool = False) -> traffic_api.PlaybackInfos:
         def to_playback(rec: Any) -> Dict[str, Any]:
             return {
                 "namespace": rec["namespace"],
                 "path": rec["recording"],
-                "mode": br.traffic_api_pb2.Mode.PAUSE,
+                "mode": traffic_api.Mode.PAUSE,
             }
 
         playback_list = map(to_playback, recording_and_namespace)
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         if not silent:
             self.__check_playbackmode_result(status)
         return status
 
-    def record_multiple(self, namespaces: List[str], path: str) -> br.traffic_api_pb2.PlaybackInfos:
+    def record_multiple(self, namespaces: List[str], path: str) -> traffic_api.PlaybackInfos:
         def to_playback(namespace: str) -> Dict[str, Any]:
             return {
                 "namespace": namespace,
                 "path": path + "_" + namespace,
-                "mode": br.traffic_api_pb2.Mode.RECORD,
+                "mode": traffic_api.Mode.RECORD,
             }
 
         playback_list = list(map(to_playback, namespaces))
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         self.__check_playbackmode_result(status)
         return status
 
-    def record(self, namespace: str, path: str) -> br.traffic_api_pb2.PlaybackInfos:
+    def record(self, namespace: str, path: str) -> traffic_api.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
                 "path": path,
-                "mode": br.traffic_api_pb2.Mode.RECORD,
+                "mode": traffic_api.Mode.RECORD,
             }
         ]
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         self.__check_playbackmode_result(status)
         return status
 
-    def stop(self, namespace: str, path: str, silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+    def stop(self, namespace: str, path: str, silent: bool = False) -> traffic_api.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
                 "path": path,
-                "mode": br.traffic_api_pb2.Mode.STOP,
+                "mode": traffic_api.Mode.STOP,
             }
         ]
 
         status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         if not silent:
             self.__check_playbackmode_result(status)
@@ -202,7 +228,7 @@ class Broker:
                 return "stopped"
             raise ValueError("Unknown Mode")
 
-        sub = self.traffic_stub.PlayTrafficStatus(br.common_pb2.Empty())
+        sub = self.traffic_stub.PlayTrafficStatus(common.Empty())
         for playback_state in sub:
             # p = typing.cast(br.traffic_api_pb2.PlaybackInfos, playback_state) # REDUNDANT CAST
             p = playback_state
@@ -221,40 +247,40 @@ class Broker:
             callback(offset_length, total_length, get_mode(mode))
 
     def listen_on_frame_distribution(self, namespace: str, callback: Callable[[Dict[str, Any]], None]) -> None:
-        config = network_api.FramesDistributionConfig(namespace=br.common_pb2.NameSpace(name=namespace))
+        config = network_api.FramesDistributionConfig(namespace=common.NameSpace(name=namespace))
         frame_distribution_stream = self.network_stub.SubscribeToFramesDistribution(config)
         for frame in frame_distribution_stream:
-            f = MessageToDict(frame, including_default_value_fields=True, preserving_proto_field_name=True)
+            f = MessageToDict(frame, preserving_proto_field_name=True)
             callback(f)
 
-    def pause(self, namespace: str, path: str, silent: bool = False) -> br.traffic_api_pb2.PlaybackInfos:
+    def pause(self, namespace: str, path: str, silent: bool = False) -> traffic_api.PlaybackInfos:
         playback_list = [
             {
                 "namespace": namespace,
                 "path": path,
-                "mode": br.traffic_api_pb2.Mode.PAUSE,
+                "mode": traffic_api.Mode.PAUSE,
             }
         ]
 
         status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         if not silent:
             self.__check_playbackmode_result(status)
         return status
 
-    def stop_multiple(self, namespaces: List[str], path: str) -> br.traffic_api_pb2.PlaybackInfos:
+    def stop_multiple(self, namespaces: List[str], path: str) -> traffic_api.PlaybackInfos:
         def to_playback(namespace: str) -> Dict[str, Any]:
             return {
                 "namespace": namespace,
                 "path": path + "_" + namespace,
-                "mode": br.traffic_api_pb2.Mode.STOP,
+                "mode": traffic_api.Mode.STOP,
             }
 
         playback_list = list(map(to_playback, namespaces))
 
-        status = self.traffic_stub.PlayTraffic(
-            br.traffic_api_pb2.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
+        status: traffic_api.PlaybackInfos = self.traffic_stub.PlayTraffic(
+            traffic_api.PlaybackInfos(playbackInfo=list(map(self.__create_playback_config, playback_list)))
         )
         self.__check_playbackmode_result(status)
         return status
@@ -302,66 +328,69 @@ class Broker:
 
             for r in response:
                 if r["data"]:
-                    print(f"Successfully received traffic on {r['namespace']}")
+                    print_success(f"Received traffic on {r['namespace']}")
                     keep_running = False
                 elif not wait_for_traffic or (not keep_running and not keep_running_during_recording):
-                    print(f"Namespace {r['namespace']} did not receive any traffic")
+                    print_generic_error(f"Namespace {r['namespace']} did not receive any traffic")
 
     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:
-            print(f"Failed to upload file - {rpc_error.details()} ({rpc_error.code()})")
-            raise typer.Exit(1)
+        sha256 = get_sha256(file)
+        with open(file, "rb") as f:
+            upload_iterator = generate_data(f, dest.replace(ntpath.sep, posixpath.sep), 1000000, sha256)
+            try:
+                self.system_stub.UploadFile(upload_iterator, compression=grpc.Compression.Gzip)
+            except grpc.RpcError as rpc_error:
+                print_generic_error(f"Failed to upload file - {rpc_error.details()} ({rpc_error.code()})")
+                raise typer.Exit(1)
 
     def delete_files(self, path: List[str], exit_on_faliure: bool) -> None:
         for file in path:
             try:
                 self.system_stub.BatchDeleteFiles(
-                    br.system_api_pb2.FileDescriptions(
-                        fileDescriptions=[br.system_api_pb2.FileDescription(path=file.replace(ntpath.sep, posixpath.sep))]
-                    )
+                    system_api.FileDescriptions(fileDescriptions=[system_api.FileDescription(path=file.replace(ntpath.sep, posixpath.sep))])
                 )
             except grpc.RpcError as rpc_error:
-                print(f"Failed to delete file - {rpc_error.details()} ({rpc_error.code()})")
+                print_generic_error(f"Failed to delete file - {rpc_error.details()} ({rpc_error.code()})")
                 if exit_on_faliure:
                     raise typer.Exit(1)
 
-    # rpc BatchDeleteFiles (FileDescriptions) returns (Empty) {}
-
     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)
+        files = [y for x in os.walk(folder) for y in glob(os.path.join(x[0], "*")) if not os.path.isdir(y)]
+        assert len(files) != 0, "Specified upload folder is empty or does not exist"
+        for file in files:
+            self.upload(file, file.replace(folder, ""))
 
     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)
+            with open(dest, "wb") as f:
+                for response in self.system_stub.BatchDownloadFiles(
+                    system_api.FileDescriptions(fileDescriptions=[system_api.FileDescription(path=file.replace(ntpath.sep, posixpath.sep))])
+                ):
+                    assert not response.HasField("errorMessage"), f"Error uploading file, message is: {response.errorMessage}"
+                f.write(response.chunk)
         except grpc.RpcError as rpc_error:
             if delegate_err:
                 raise rpc_error
-            print(f"Failed to download file - {rpc_error.details()} ({rpc_error.code()})")
+            print_generic_error(f"Failed to download file - {rpc_error.details()} ({rpc_error.code()})")
             # There will be an empty file if the download fails so remove that one here
             os.remove(dest)
             raise typer.Exit(1)
 
     def reload_config(self) -> None:
         try:
-            request = br.common_pb2.Empty()
+            request = common.Empty()
             response = self.system_stub.ReloadConfiguration(request, timeout=60000)
             if response.errorMessage:
-                print(f"Failed to reload config: {response.errorMessage}")
+                print_generic_error(f"Failed to reload config: {response.errorMessage}")
                 raise typer.Exit(1)
             # br.helper.reload_configuration(system_stub=self.system_stub)
         except grpc.RpcError as rpc_error:
-            print(f"Failed to reload configuration - {rpc_error.details()} ({rpc_error.code()})")
+            print_generic_error(f"Failed to reload configuration - {rpc_error.details()} ({rpc_error.code()})")
             raise typer.Exit(1)
 
     def list_namespaces(self) -> List[str]:
         # Lists available signals
-        configuration = self.system_stub.GetConfiguration(br.common_pb2.Empty())
+        configuration = self.system_stub.GetConfiguration(common.Empty())
         namespaces = []
         for network_info in configuration.networkInfo:
             namespaces.append(network_info.namespace.name)
@@ -369,7 +398,7 @@ class Broker:
 
     def list_signal_names(self, prefix: Union[str, None], suffix: Union[str, None]) -> List[Dict[str, Any]]:
         # Lists available signals
-        configuration = self.system_stub.GetConfiguration(br.common_pb2.Empty())
+        configuration = self.system_stub.GetConfiguration(common.Empty())
 
         signal_names = []
         for network_info in configuration.networkInfo:
@@ -380,7 +409,6 @@ class Broker:
                 ):
                     metadata_dict = MessageToDict(
                         finfo.signalInfo.metaData,
-                        including_default_value_fields=True,
                         preserving_proto_field_name=True,
                     )
                     sig_dict = {
@@ -398,7 +426,6 @@ class Broker:
 
                     metadata_dict = MessageToDict(
                         sinfo.metaData,
-                        including_default_value_fields=True,
                         preserving_proto_field_name=True,
                     )
                     sig_dict = {
@@ -412,13 +439,12 @@ class Broker:
     def subscribe_on_script(
         self,
         script: bytes,
-        on_frame: Callable[[Sequence[br.network_api_pb2.Signal]], None],
+        on_frame: Callable[[Sequence[network_api.Signal]], None],
         changed_values_only: bool = False,
     ) -> Any:
-        client_id = br.common_pb2.ClientId(id="cli")
-        # sync = queue.Queue()
+        client_id = common.ClientId(id="cli")
         thread = Thread(
-            target=br.act_on_scripted_signal,
+            target=act_on_scripted_signal,
             args=(
                 client_id,
                 self.network_stub,
@@ -454,7 +480,7 @@ class Broker:
             if ns not in existing_ns:
                 ns_not_matching.append(ns)
         if len(ns_not_matching) > 0:
-            ErrorPrinter.print_hint(f"Namespace(s) {ns_not_matching} does not exist on broker. Namespaces found on broker: {existing_ns}")
+            print_hint(f"Namespace(s) {ns_not_matching} does not exist on broker. Namespaces found on broker: {existing_ns}")
             sys.exit(1)
 
         available_signals = list(filter(verify_namespace, existing_signals))  # type: ignore
@@ -464,7 +490,7 @@ class Broker:
         signals_subscribed_to_but_does_not_exist = set(subscribed_signals) - set(map(lambda s: s["signal"], signals_to_subscribe_to))
 
         if len(signals_subscribed_to_but_does_not_exist) > 0:
-            ErrorPrinter.print_hint(f"One or more signals you subscribed to does not exist {signals_subscribed_to_but_does_not_exist}")
+            print_hint(f"One or more signals you subscribed to does not exist {signals_subscribed_to_but_does_not_exist}")
             sys.exit(1)
 
         return list(map(lambda s: SubscribableSignal(s["signal"], s["namespace"]), signals_to_subscribe_to))
@@ -472,20 +498,20 @@ class Broker:
     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")
+        client_id = common.ClientId(id="cli")
 
         # TODO - This can be improved moving forward and we also need to move the validation into api
         self.validate_and_get_subscribed_signals(
             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) -> br.common_pb2.SignalId:
+        def to_protobuf_signal(s: SubscribableSignal) -> common.SignalId:
             return self.signal_creator.signal(s.name, s.namespace)
 
         signals_to_subscribe_on = list(map(to_protobuf_signal, signals_to_subscribe_to))
 
         Thread(
-            target=br.act_on_signal,
+            target=act_on_signal,
             args=(
                 client_id,
                 self.network_stub,
@@ -506,19 +532,19 @@ class Broker:
         on_frame: Callable[..., Any],
         changed_values_only: bool = True,
     ) -> Any:
-        client_id = br.common_pb2.ClientId(id="cli")
+        client_id = common.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) -> br.common_pb2.SignalId:
+        def to_protobuf_signal(s: SubscribableSignal) -> common.SignalId:
             return self.signal_creator.signal(s.name, s.namespace)
 
         signals_to_subscribe_on = list(map(to_protobuf_signal, signals_to_subscribe_to))
 
         Thread(
-            target=br.act_on_signal,
+            target=act_on_signal,
             args=(
                 client_id,
                 self.network_stub,
@@ -532,7 +558,7 @@ class Broker:
         ecu, subscription = self.q.get()
         return subscription
 
-    def __each_signal(self, signals: Iterable[br.network_api_pb2.Signal], callback: Callable[..., Any]) -> None:
+    def __each_signal(self, signals: Iterable[network_api.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)},
@@ -541,7 +567,7 @@ class Broker:
         )
 
     @staticmethod
-    def __get_value(signal: br.network_api_pb2.Signal) -> Any:
+    def __get_value(signal: network_api.Signal) -> Any:
         if signal.raw != b"":
             return "0x" + binascii.hexlify(signal.raw).decode("ascii")
         if signal.HasField("integer"):
@@ -553,7 +579,7 @@ class Broker:
         return "empty"
 
     @staticmethod
-    def __create_playback_config(item: Dict[str, Any]) -> br.traffic_api_pb2.PlaybackInfo:
+    def __create_playback_config(item: Dict[str, Any]) -> traffic_api.PlaybackInfo:
         """Creating configuration for playback
 
         Parameters
@@ -573,26 +599,26 @@ class Broker:
                 return int(item["offsettime"])
             return 0
 
-        playback_config = br.traffic_api_pb2.PlaybackConfig(
-            fileDescription=br.system_api_pb2.FileDescription(path=item["path"]),
-            namespace=br.common_pb2.NameSpace(name=item["namespace"]),
+        playback_config = traffic_api.PlaybackConfig(
+            fileDescription=system_api.FileDescription(path=item["path"]),
+            namespace=common.NameSpace(name=item["namespace"]),
         )
-        return br.traffic_api_pb2.PlaybackInfo(
+        return traffic_api.PlaybackInfo(
             playbackConfig=playback_config,
-            playbackMode=br.traffic_api_pb2.PlaybackMode(mode=item["mode"], offsetTime=get_offset_time()),
+            playbackMode=traffic_api.PlaybackMode(mode=item["mode"], offsetTime=get_offset_time()),
         )
 
     def get_license(self) -> LicenseInfo:
-        license_info = self.system_stub.GetLicenseInfo(br.common_pb2.Empty())
+        license_info = self.system_stub.GetLicenseInfo(common.Empty())
         return LicenseInfo(
-            valid=license_info.status == br.system_api_pb2.LicenseStatus.VALID,
+            valid=license_info.status == system_api.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) -> LicenseInfo:
-        license = br.system_api_pb2.License()
+        license = system_api.License()
         license.data = license_data_b64
         license.termsAgreement = True
         self.system_stub.SetLicense(license)