remotivelabs-cli 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

cli/cloud/recordings.py

@@ -17,10 +17,17 @@ from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn, track
 from typing_extensions import Annotated
 
 from cli.cloud.uri import URI
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import (
+    print_generic_error,
+    print_generic_message,
+    print_grpc_error,
+    print_hint,
+    print_success,
+    print_unformatted,
+    print_unformatted_to_stderr,
+)
 from cli.utils.rest_helper import RestHelper as Rest
-from cli.utils.rest_helper import err_console
 
 from ..broker.lib.broker import Broker
 from .recordings_playback import app as playback_app
@@ -30,7 +37,8 @@ app.add_typer(playback_app, name="playback")
 
 
 def uid(p: Any) -> Any:
-    print(p)
+    # TODO: use log instead of print for debug information?
+    print_generic_message(p)
     return p["uid"]
 
 
@@ -38,19 +46,6 @@ def uid(p: Any) -> Any:
 # ruff: noqa: C901
 
 
-# to be used in options
-# autocompletion=project_names)
-def project_names() -> Any:
-    r = requests.get(f"{Rest.get_base_url()}/api/bu/{Rest.get_org()}/project", headers=Rest.get_headers(), timeout=60)
-    # sys.stderr.write(r.text)
-    if r.status_code == 200:
-        projects = r.json()
-        names = map(lambda p: p["uid"], projects)
-        return list(names)
-    sys.stderr.write(f"Could not list projects due to {r.status_code}\n")
-    raise typer.Exit(0)
-
-
 @app.command("list")
 def list_recordings(
     is_processing: bool = typer.Option(default=False, help="Use this option to see only those that are beeing processed or are invalid"),
@@ -59,13 +54,12 @@ def list_recordings(
     """
     List all recording sessions in a project. You can choose to see all valid recordings (default) or use
     --is-processing and you will get those that are currently beeing processed or that failed to be validated.
-
     """
 
     if is_processing:
         res = Rest.handle_get(f"/api/project/{project}/files/recording/processing", return_response=True)
         json_res: List[Dict[str, Any]] = res.json()
-        print(json.dumps(list(filter(lambda r: r["status"] == "RUNNING" or r["status"] == "FAILED", json_res))))
+        print_generic_message(json.dumps(list(filter(lambda r: r["status"] == "RUNNING" or r["status"] == "FAILED", json_res))))
     else:
         Rest.handle_get(f"/api/project/{project}/files/recording")
 
@@ -78,14 +72,6 @@ def describe(
     Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}")
 
 
-# @app.command(help="Shows details about a specific recording in project")
-# def copy(recording_session: str = typer.Argument(..., help="Recording session id"),
-#         target_project: str = typer.Option(..., help="Which project to copy the recording to"),
-#         project: str = typer.Option(..., help="Project ID", envvar='REMOTIVE_CLOUD_PROJECT')):
-#    Rest.handle_post(url=f"/api/project/{project}/files/recording/{recording_session}/copy",
-#                     body=json.dumps({'projectUid': target_project}))
-
-
 @app.command(name="import")
 def import_as_recording(
     uri: Annotated[URI, typer.Argument(help="Remote storage path", parser=URI, show_default=False)],
@@ -103,9 +89,7 @@ def import_as_recording(
         body=json.dumps({"path": uri.path}),
     )
 
-    ErrorPrinter.print_hint(
-        f"Import started, you can track progress with 'remotive cloud recordings list --is-processing --project {project}'"
-    )
+    print_hint(f"Import started, you can track progress with 'remotive cloud recordings list --is-processing --project {project}'")
 
 
 def do_start(name: str, project: str, api_key: str, return_response: bool = False) -> requests.Response:
@@ -142,10 +126,10 @@ def mount(  # noqa: C901
         elif r.status_code == 404:
             r = do_start("personal", project, "", return_response=True)
             if r.status_code != 200:
-                print(r.text)
+                print_generic_error(r.text)
                 sys.exit(0)
         else:
-            sys.stderr.write(f"Got http status code {r.status_code}")
+            print_generic_error(f"Got http status code {r.status_code}")
             raise typer.Exit(0)
     else:
         r = Rest.handle_get(url=f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
@@ -154,10 +138,10 @@ def mount(  # noqa: C901
             if ensure_broker_started:
                 r = do_start(broker, project, "", return_response=True)
                 if r.status_code != 200:
-                    print(r.text)
+                    print_generic_error(r.text)
                     sys.exit(1)
             else:
-                ErrorPrinter.print_generic_error(f"Broker {broker} not running")
+                print_generic_error(f"Broker {broker} not running")
                 sys.exit(1)
         elif r.status_code != 200:
             sys.stderr.write(f"Got http status code {r.status_code}")
@@ -175,8 +159,8 @@ def mount(  # noqa: C901
         return_response=True,
         progress_label="Preparing recording on broker...",
     )
-    err_console.print("Successfully mounted recording on broker")
-    print(json.dumps(broker_info))
+    print_unformatted_to_stderr("Successfully mounted recording on broker")
+    print_unformatted(json.dumps(broker_info))
 
 
 @app.command(help="Downloads the specified recording file to disk")
@@ -198,9 +182,9 @@ def download_recording_file(
     if get_signed_url_resp.status_code == 200:
         # Next download the actual file
         Rest.download_file(Path(recording_file_name), get_signed_url_resp.json()["downloadUrl"])
-        print(f"Downloaded {recording_file_name}")
+        print_success(f"Downloaded {recording_file_name}")
     else:
-        print(get_signed_url_resp)
+        print_generic_error(get_signed_url_resp.text)
 
 
 @app.command(name="delete")
@@ -267,10 +251,8 @@ def upload(  # noqa: C901, PLR0912, PLR0915
     if match:
         upload_id = match.group(1)
     else:
-        ErrorPrinter.print_generic_error(
-            "Something went wrong, please try again. Please contact RemotiveLabs support if this problem remains"
-        )
-        ErrorPrinter.print_hint("Please make sure to use the latest version of RemotiveCLI")
+        print_generic_error("Something went wrong, please try again. Please contact RemotiveLabs support if this problem remains")
+        print_hint("Please make sure to use the latest version of RemotiveCLI")
         sys.exit(1)
 
     upload_response = Rest.upload_file_with_signed_url(
@@ -296,7 +278,6 @@ def upload(  # noqa: C901, PLR0912, PLR0915
             return "Finishing up..."
         return "Processing..."
 
-    # print(response)
     if 200 <= upload_response.status_code < 300:
         # We need to print the error message outside the with Progress so the indicator is closed
         error_message: Union[str, None] = None
@@ -319,17 +300,17 @@ def upload(  # noqa: C901, PLR0912, PLR0915
                         if tracking_state["status"] == "FAILED":
                             error_message = f"Processing of uploaded file failed: {tracking_state['errors'][0]['message']}"
                         else:
-                            print("File successfully uploaded")
+                            print_success("File successfully uploaded")
                         break
                 else:
                     error_message = "Something went wrong, please try again. Please contact RemotiveLabs support if this problem remains"
                     break
         if error_message is not None:
-            ErrorPrinter.print_generic_error(error_message)
+            print_generic_error(error_message)
             sys.exit(1)
 
     else:
-        err_console.print(f":boom: [bold red]Got status code[/bold red]: {upload_response.status_code} {upload_response.text}")
+        print_generic_error(f"Got status code: {upload_response.status_code} {upload_response.text}")
 
 
 # TODO - Change to use Path for directory
@@ -412,8 +393,7 @@ def upload_broker_configuration(
     if response is None:
         return
     if response.status_code != 200:
-        print("Failed to prepare configuration upload")
-        print(f"{response.text} - {response.status_code}")
+        print_generic_error(f"Failed to prepare configuration upload: {response.text} - {response.status_code}")
         raise typer.Exit(1)
 
     #
@@ -430,12 +410,10 @@ def upload_broker_configuration(
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
         r = requests.put(url, open(path, "rb"), headers=headers, timeout=60)
         if r.status_code != 200:
-            print("Failed to upload broker configuration")
-            print(r.status_code)
-            print(r.text)
+            print_generic_error(f"Failed to upload broker configuration: {r.text} - {r.status_code}")
             raise typer.Exit(1)
 
-    print(f"Successfully uploaded broker configuration {broker_config_dir_name}")
+    print_success(f"Uploaded broker configuration {broker_config_dir_name}")
 
 
 @app.command(help="Downloads the specified broker configuration directory as zip file")
@@ -454,7 +432,7 @@ def download_broker_configuration(
     if filename is not None:
         with open(filename, "wb") as f:
             f.write(r.content)
-        print(f"Downloaded file {filename}")
+        print_success(f"Downloaded file {filename}")
 
 
 @app.command(help="Delete the specified broker configuration")
@@ -546,8 +524,8 @@ def _do_change_playback_mode(  # noqa: PLR0912
         broker_arg = ""
         if broker_name is not None:
             broker_arg = f" --broker {broker_name} --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}")
+        print_generic_error("You need to mount the recording before you play")
+        print_hint(f"remotive cloud recordings mount {recording_session}{broker_arg} --project {project}")
         sys.exit(1)
 
     broker_info = json.loads(response.text)
@@ -561,18 +539,14 @@ def _do_change_playback_mode(  # noqa: PLR0912
         with open(tmp, "r", encoding="utf8") as f:
             json_context = json.loads(f.read())
             if json_context["recordingSessionId"] != recording_session:
-                ErrorPrinter.print_generic_error(
+                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"
                 )
-                ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
+                print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 sys.exit(1)
     except grpc.RpcError as rpc_error:
-        # if rpc_error.code() == grpc.StatusCode.NOT_FOUND:
-        #     ErrorPrinter.print_generic_error(f"You must use mount to prepare a recording before you can use {mode}")
-        #     ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
-        # else:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
         sys.exit(1)
     if mode == "pause":
         broker.pause_play(files, True)

cli/cloud/recordings_playback.py

@@ -9,12 +9,10 @@ from pathlib import Path
 from typing import Any, List, Union
 
 import grpc
-import rich
 import typer
-from rich import print as rich_print
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
-from cli.errors import ErrorPrinter
+from cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_hint, print_unformatted
 from cli.utils.rest_helper import RestHelper as Rest
 
 from ..broker.lib.broker import Broker, SubscribableSignal
@@ -127,11 +125,11 @@ def subscribe(  # noqa: PLR0913
     """
     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")
+            print_generic_error("You must use include at least one signal and one namespace or use script when subscribing")
             sys.exit(1)
     if script is not None:
         if len(signal) > 0:
-            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            print_generic_error("You must must not specify --signal when using --script")
             sys.exit(1)
 
     broker_client = _get_broker_info(project, recording_session, broker, "subscribe")
@@ -139,24 +137,26 @@ def subscribe(  # noqa: PLR0913
     try:
         if script is not None:
             script_src = read_scripted_code_file(script)
-            broker_client.subscribe_on_script(script_src, lambda sig: rich_print(json.dumps(list(sig))), on_change_only)
+            broker_client.subscribe_on_script(script_src, lambda sig: print_generic_message(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})")
+                    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_client.long_name_subscribe(signals_to_subscribe_to, lambda sig: rich_print(json.dumps(list(sig))), on_change_only)
-            print("Subscribing to signals, press Ctrl+C to exit")
+            broker_client.long_name_subscribe(
+                signals_to_subscribe_to, lambda sig: print_generic_message(json.dumps(list(sig))), on_change_only
+            )
+            print_generic_message("Subscribing to signals, press Ctrl+C to exit")
     except grpc.RpcError as rpc_error:
-        ErrorPrinter.print_grpc_error(rpc_error)
+        print_grpc_error(rpc_error)
 
     except Exception as e:
-        ErrorPrinter.print_generic_error(str(e))
+        print_generic_error(str(e))
         sys.exit(1)
 
 
@@ -184,8 +184,8 @@ def _do_change_playback_mode(  # noqa: C901, PLR0913, PLR0912
         broker_arg = ""
         if brokerstr is not None:
             broker_arg = f" --broker {brokerstr} --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}")
+        print_generic_error("You need to mount the recording before you play")
+        print_hint(f"remotive cloud recordings mount {recording_session}{broker_arg} --project {project}")
         sys.exit(1)
 
     broker_info = json.loads(response.text)
@@ -216,7 +216,7 @@ def _track_progress(broker: Broker, repeat: bool, files: List[Any]) -> None:
     p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
     t = p.add_task("label", total=1)
     if repeat:
-        rich.print(":point_right: Keep this command running in terminal to keep the recording play with repeat")
+        print_unformatted(":point_right: Keep this command running in terminal to keep the recording play with repeat")
     with p:
 
         def print_progress(offset: int, total: int, current_mode: str) -> None:
@@ -238,18 +238,18 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
         with open(tmp, "r", encoding="utf8") as f:
             json_context = json.loads(f.read())
             if json_context["recordingSessionId"] != recording_session:
-                ErrorPrinter.print_generic_error(
+                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"
                 )
-                ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
+                print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 sys.exit(1)
     except grpc.RpcError as rpc_error:
         if rpc_error.code() == grpc.StatusCode.NOT_FOUND:
-            ErrorPrinter.print_generic_error(f"You must use mount to prepare a recording before you can use {mode}")
-            ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
+            print_generic_error(f"You must use mount to prepare a recording before you can use {mode}")
+            print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
         else:
-            ErrorPrinter.print_grpc_error(rpc_error)
+            print_grpc_error(rpc_error)
         sys.exit(1)
 
 
@@ -260,14 +260,14 @@ def _get_broker_info(project: str, recording_session: str, broker: Union[str, No
     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 is None:
-        ErrorPrinter.print_generic_error(f"No response from: /api/project/{project}/brokers/{broker_name}")
+        print_generic_error(f"No response from: /api/project/{project}/brokers/{broker_name}")
         sys.exit(1)
     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}")
+        print_generic_error("You need to mount the recording before you play")
+        print_hint(f"remotive cloud recordings mount {recording_session} {broker_arg} --project {project}")
         sys.exit(1)
     broker_info = json.loads(response.text)
     broker_client = Broker(broker_info["url"], None)

cli/cloud/resumable_upload.py

@@ -8,7 +8,7 @@ from typing import Dict
 import requests
 from rich.progress import wrap_file
 
-from ..errors import ErrorPrinter
+from cli.utils.console import print_generic_error, print_success
 
 
 def __get_uploaded_bytes(upload_url: str) -> int:
@@ -40,7 +40,7 @@ def with_resumable_upload_signed_url(signed_url: str, source_file_name: str, con
     headers = {"x-goog-resumable": "start", "content-type": content_type}
     response = requests.post(signed_url, headers=headers, timeout=60)
     if response.status_code not in (200, 201, 308):
-        ErrorPrinter.print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+        print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
         sys.exit(1)
 
     upload_url = response.headers["Location"]
@@ -61,10 +61,10 @@ def with_resumable_upload_signed_url(signed_url: str, source_file_name: str, con
                 headers = {"Content-Range": f"bytes {chunk_start}-{chunk_end}/{file_size}"}
                 response = requests.put(upload_url, headers=headers, data=chunk, timeout=60)
                 if response.status_code not in (200, 201, 308):
-                    ErrorPrinter.print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+                    print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
                     sys.exit(1)
 
-    print(f"File {source_file_name} uploaded successfully.")
+    print_success(f"File {source_file_name} uploaded successfully.")
 
 
 def upload_signed_url(signed_url: str, source_file_name: Path, headers: Dict[str, str]) -> None:
@@ -81,7 +81,7 @@ def upload_signed_url(signed_url: str, source_file_name: Path, headers: Dict[str
         with wrap_file(file, os.stat(source_file_name).st_size, description=f"Uploading {source_file_name}...") as f:
             response = requests.put(signed_url, headers=headers, timeout=60, data=f)
             if response.status_code not in (200, 201, 308):
-                ErrorPrinter.print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+                print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
                 sys.exit(1)
 
-    print(f"File {source_file_name} uploaded successfully.")
+    print_success(f"File {source_file_name} uploaded successfully.")

cli/cloud/service_account_tokens.py

@@ -4,6 +4,7 @@ import typer
 
 from cli.settings import settings
 from cli.typer import typer_utils
+from cli.utils.console import print_generic_message, print_success
 from cli.utils.rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer()
@@ -23,8 +24,8 @@ def create(
     )
 
     sat = settings.add_service_account_token(response.text)
-    print(f"Service account access token added: {sat.name}")
-    print("\033[93m This file contains secrets and must be kept safe")
+    print_success(f"Service account access token added: {sat.name}")
+    print_generic_message("This file contains secrets and must be kept safe")
 
 
 @app.command(name="list", help="List service account access tokens")

cli/cloud/storage/cmd.py

@@ -7,15 +7,14 @@ from cli.cloud.storage.copy import copy
 from cli.cloud.storage.uri_or_path import UriOrPath
 from cli.cloud.storage.uri_or_path import uri as uri_parser
 from cli.cloud.uri import URI, InvalidURIError, JoinURIError
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_hint
 from cli.utils.rest_helper import RestHelper as Rest
 
 HELP = """
 Manage files ([yellow]Beta feature not available for all customers[/yellow])
 
 Copy file from local to remote storage and vice versa, list and delete files.
-
 """
 
 app = typer_utils.create_typer(rich_markup_mode="rich", help=HELP)
@@ -73,5 +72,5 @@ def copy_file(
     try:
         return copy(project=project, source=source.value, dest=dest.value, overwrite=overwrite)
     except (InvalidURIError, JoinURIError, ValueError, FileNotFoundError, FileExistsError) as e:
-        ErrorPrinter.print_hint(str(e))
+        print_hint(str(e))
         sys.exit(1)

cli/cloud/storage/copy.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 from cli.cloud.resumable_upload import upload_signed_url
 from cli.cloud.uri import URI
+from cli.utils.console import print_success
 from cli.utils.rest_helper import RestHelper as Rest
 
 _RCS_STORAGE_PATH = "/api/project/{project}/files/storage{path}"
@@ -63,7 +64,7 @@ def _upload_single_file(source: Path, target_uri: URI, project: str, overwrite:
     headers = json_res["headers"]
     upload_signed_url(url, source, headers)
 
-    print(f"Uploaded {source} to {target_uri.path}")
+    print_success(f"Uploaded {source} to {target_uri.path}")
 
 
 def _download(source: URI, dest: Path, project: str, overwrite: bool = False) -> None:

cli/connect/connect.py

@@ -8,8 +8,8 @@ import typer
 from typing_extensions import List
 
 from cli.broker.lib.broker import SubscribableSignal
-from cli.errors import ErrorPrinter
 from cli.typer import typer_utils
+from cli.utils.console import print_hint
 
 from .protopie import protopie as ppie
 
@@ -81,18 +81,18 @@ def protopie(  # noqa: PLR0913
     """
 
     if len(signal) > 0 and config is not None:
-        ErrorPrinter.print_hint("You must choose either --signal or --config, not both")
+        print_hint("You must choose either --signal or --config, not both")
         sys.exit(1)
 
     if len(signal) == 0 and config is None:
-        ErrorPrinter.print_hint("You must choose either --signal or --config")
+        print_hint("You must choose either --signal or --config")
         sys.exit(1)
 
     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})")
+            print_hint(f"--signal must have format namespace:signal ({sig})")
             sys.exit(1)
 
         return SubscribableSignal(namespace=arr[0], name=arr[1])

cli/connect/protopie/protopie.py

@@ -5,27 +5,22 @@ import json
 import os
 import sys
 import time
-import traceback
 from pathlib import Path
 from typing import Any, Dict, List, Tuple, Union
 
 import grpc
 import socketio
-from rich import print as pretty_print
-from rich.console import Console
 from socketio.exceptions import ConnectionError as SocketIoConnectionError
 
 from cli.broker.lib.broker import SubscribableSignal
 from cli.broker.lib.client import BrokerException, Client, SignalIdentifier, SignalsInFrame
-from cli.errors import ErrorPrinter
 from cli.settings import settings
+from cli.utils.console import print_generic_error, print_generic_message, print_success, print_unformatted_to_stderr
 
 PP_CONNECT_APP_NAME = "RemotiveBridge"
 
 io = socketio.Client()
 
-err_console = Console(stderr=True)
-
 _has_received_signal = False
 is_connected = False
 config_path: Path
@@ -35,7 +30,7 @@ broker: Any
 
 @io.on("connect")
 def on_connect() -> None:
-    print("Connected to ProtoPie Connect")
+    print_success("Connected to ProtoPie Connect")
     io.emit("ppBridgeApp", {"name": PP_CONNECT_APP_NAME})
     io.emit("PLUGIN_STARTED", {"name": PP_CONNECT_APP_NAME})
 
@@ -72,8 +67,8 @@ def get_signal_name(expression: str, s_name: str) -> str:
             sig_name = eval(f"s_name.{expression}")
             return str(sig_name)
         except Exception as e:
-            ErrorPrinter.print_generic_error(f"Failed to evaluate your python expression {expression}")
-            err_console.print(e)
+            print_generic_error(f"Failed to evaluate your python expression {expression}")
+            print_unformatted_to_stderr(e)
             # This was the only way I could make this work, exiting on another thread than main
             os._exit(1)
     else:
@@ -91,7 +86,7 @@ def _connect_to_broker(
     def on_signals(frame: SignalsInFrame) -> None:
         global _has_received_signal  # noqa: PLW0603
         if not _has_received_signal:
-            pretty_print("Bridge-app is properly receiving signals, you are good to go :thumbsup:")
+            print_generic_message("Bridge-app is properly receiving signals, you are good to go :thumbsup:")
             _has_received_signal = True
 
         for s in frame:
@@ -114,42 +109,42 @@ def grpc_connect(
     on_signals: Any, signals_to_subscribe_to: Union[List[SignalIdentifier], None] = None, on_change_only: bool = False
 ) -> None:
     try:
-        pretty_print("Connecting and subscribing to broker...")
+        print_generic_message("Connecting and subscribing to broker...")
         subscription = None
         client = Client(client_id="cli")
         client.connect(url=broker, api_key=x_api_key)
         client.on_signals = on_signals
 
         if signals_to_subscribe_to is None:
-            print("No sigs")
+            # TODO: use logs instead of print?
+            print_generic_error("No signals to subscribe to")
             return
         subscription = client.subscribe(signals_to_subscribe_to=signals_to_subscribe_to, changed_values_only=on_change_only)
-        pretty_print("Subscription to broker completed")
-        pretty_print("Waiting for signals...")
+        print_generic_message("Subscription to broker completed")
+        print_generic_message("Waiting for signals...")
 
         while True:
             time.sleep(1)
 
     except grpc.RpcError as e:
-        err_console.print(":boom: [red]Problems connecting or subscribing[/red]")
+        print_generic_error("Problems connecting or subscribing")
         if isinstance(e, grpc.Call):
-            print(f"{e.code()} - {e.details()}")
+            print_generic_error(f"{e.code()} - {e.details()}")
         else:
-            print(e)
+            print_generic_error(e)
 
     except BrokerException as e:
-        print(e)
+        print_generic_error(e)
         if subscription is not None:
             subscription.cancel()
 
     except KeyboardInterrupt:
-        print("Keyboard interrupt received. Closing subscription.")
+        print_generic_message("Keyboard interrupt received. Closing subscription.")
         if subscription is not None:
             subscription.cancel()
 
     except Exception as e:
-        print(traceback.format_exc())
-        err_console.print(f":boom: {e}")
+        print_generic_error(e)
 
 
 def do_connect(  # noqa: PLR0913
@@ -168,7 +163,7 @@ def do_connect(  # noqa: PLR0913
 
     if broker_url.startswith("https"):
         if api_key is None:
-            print("No --api-key, reading token from file")
+            print_generic_message("No --api-key, reading token from file")
             x_api_key = settings.get_active_token_secret()
         else:
             x_api_key = api_key
@@ -176,18 +171,15 @@ def do_connect(  # noqa: PLR0913
         x_api_key = api_key
     try:
         io.connect(address)
-        # if config is None:
-        #    raise ValueError("Config is None")
         config_path = config
         while is_connected is None:
             time.sleep(1)
-        # if expression is not None:
         _connect_to_broker(signals_to_subscribe_to=signals, config=config, expression=expression, on_change_only=on_change_only)
     except SocketIoConnectionError as e:
-        err_console.print(":boom: [bold red]Failed to connect to ProtoPie Connect[/bold red]")
-        err_console.print(e)
+        print_generic_error("Failed to connect to ProtoPie Connect")
+        print_unformatted_to_stderr(e)
         sys.exit(1)
     except Exception as e:
-        err_console.print(":boom: [bold red]Unexpected error[/bold red]")
-        err_console.print(e)
+        print_generic_error("Unexpected error")
+        print_unformatted_to_stderr(e)
         sys.exit(1)