remotivelabs-cli 0.0.41__py3-none-any.whl → 0.1.0a1__py3-none-any.whl

cli/cloud/auth_tokens.py

@@ -1,33 +1,316 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
 import typer
+from rich.console import Console
+from rich.table import Table
 
-from cli.settings import settings
+from cli.api.cloud import tokens
+from cli.cloud.organisations import do_select_default_org
+from cli.errors import ErrorPrinter
+from cli.settings import TokenFile, TokenNotFoundError, settings
 from cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper as Rest
 
-from .rest_helper import RestHelper as Rest
+console = Console(stderr=False)
+err_console = Console(stderr=True)
 
 app = typer_utils.create_typer()
 
 
-# TODO: add add interactive flag to set target directory # pylint: disable=fixme
-@app.command(name="create", help="Create and download a new personal access token")
-def create(activate: bool = typer.Option(False, help="Activate the token for use after download")) -> None:  # pylint: disable=W0621
-    response = Rest.handle_post(url="/api/me/keys", return_response=True)
-    pat = settings.add_personal_token(response.text)
+def _prompt_choice(  # noqa: C901, PLR0912
+    choices: List[TokenFile],
+    skip_prompt: bool = False,
+    info_message: Optional[str] = None,
+) -> Optional[Union[TokenFile, None]]:
+    accounts = settings.get_cli_config().accounts
+
+    try:
+        active_account = settings.get_cli_config().get_active()
+    except TokenNotFoundError:
+        active_account = None
+
+    table = Table("#", "Active", "Type", "Token", "Account", "Created", "Expires")
+
+    included_tokens: list[TokenFile] = []
+    excluded_tokens: list[TokenFile] = []
+
+    for token in choices:
+        account = accounts.get(token.account.email)
+        if account and account.credentials_name and account.credentials_name in (token.name or ""):
+            included_tokens.append(token)
+        else:
+            excluded_tokens.append(token)
+    if len(excluded_tokens) > 0:
+        err_console.print("The following credentials were not included in account config and cannot be activated")
+        for token in excluded_tokens:
+            err_console.print(f" * {token.name} - {token.account.email}")
+
+    if len(included_tokens) == 0:
+        return None
+
+    if info_message is not None:
+        console.print(info_message)
+
+    included_tokens.sort(key=lambda token: token.created, reverse=True)
+
+    for idx, choice in enumerate(included_tokens, start=1):
+        table.add_row(
+            f"[yellow]{idx}",
+            ":white_check_mark:" if active_account is not None and active_account.credentials_name == choice.name else "",
+            "user" if choice.type == "authorized_user" else "sa",
+            choice.name,
+            f"[bold]{choice.account.email if choice.account else 'unknown'}[/bold]",
+            str(choice.created),
+            str(choice.expires),
+        )
+
+    # console.print("It seems like you have access tokens from previous login, you can select one of these instead of logging in")
+    console.print(table)
+
+    if skip_prompt:
+        return None
+
+    typer.echo("")
+    selection = typer.prompt(f"Enter the number(# 1-{len(included_tokens)}) of the token to select (or q to skip)")
+
+    if selection == "q":
+        return None
+    try:
+        index = int(selection) - 1
+        if 0 <= index < len(included_tokens):
+            return included_tokens[index]
+        raise ValueError
+    except ValueError:
+        typer.echo("Invalid choice, please try again")
+        return _prompt_choice(included_tokens, skip_prompt, info_message)
+
+
+# @app.command(name="create")
+def create(
+    activate: bool = typer.Option(False, help="Activate the token for use after download"),
+) -> None:
+    """
+    Create a new personal access token in [bold]cloud[/bold] and download locally
+    """
+    response = tokens.create()
+    pat = settings.add_personal_token(response.text())
     print(f"Personal access token added: {pat.name}")
 
     if not activate:
         print(f"Use 'remotive cloud auth tokens activate {pat.name}' to use this access token from cli")
     else:
-        settings.activate_token(pat.name)
+        settings.activate_token(pat)
         print("Token file activated and ready for use")
     print("\033[93m This file contains secrets and must be kept safe")
 
 
-@app.command(name="list", help="List personal access tokens")
+# @app.command(name="list", help="List personal credentials in [bold]cloud[/bold]")
 def list_tokens() -> None:
     Rest.handle_get("/api/me/keys")
 
 
-@app.command(name="revoke", help="Revoke personal access token")
-def revoke(name: str = typer.Argument(help="Access token name")) -> None:
-    Rest.handle_delete(f"/api/me/keys/{name}")
+# @app.command(name="revoke")
+def revoke(
+    name: str = typer.Argument(help="Access token name"),
+    delete: bool = typer.Option(True, help="Also delete token"),
+) -> None:
+    """
+    Revoke personal credentials in cloud and removes the file from filesystem
+
+    If cloud token is not found but token is found on file system it will delete it and
+    vice versa.
+    """
+    _revoke_and_delete_personal_token(name, delete)
+
+
+# @app.command(name="activate")
+def activate(
+    token_name: str = typer.Argument(..., help="Token path, filename or name to activate"),
+) -> None:
+    """
+    Activate a credential file to be used for authentication using filename, path or name.
+
+    This will be used as the current access token in all requests.
+    """
+    try:
+        token_file = settings.get_token_file(token_name)
+        settings.activate_token(token_file)
+    except TokenNotFoundError:
+        err_console.print(f":boom: [bold red] Error: [/bold red] Token with filename or name {token_name} could not be found")
+
+
+@app.command("activate")
+def select_personal_token(
+    token_name: str = typer.Argument(None, help="Name, filename or path to a credentials file"),
+) -> None:
+    """
+    Prompts user to select and activate one of the available credential files
+    """
+    if token_name is not None:
+        token_selected = True
+        try:
+            token_file = settings.get_token_file(token_name)
+            settings.activate_token(token_file)
+        except TokenNotFoundError:
+            token_selected = False
+            err_console.print(f":boom: [bold red] Error: [/bold red] Token with filename or name {token_name} could not be found")
+    else:
+        token_files = settings.list_personal_tokens()
+        token_files.extend(settings.list_service_account_tokens())
+        if len(token_files) > 0:
+            token_selected = list_and_select_personal_token(include_service_accounts=True)
+
+            if token_selected:
+                is_logged_in = Rest.has_access("/api/whoami")
+                if not is_logged_in:
+                    ErrorPrinter.print_generic_error("Could not access RemotiveCloud with selected token")
+                else:
+                    console.print("[green]Success![/green] Access to RemotiveCloud granted")
+        else:
+            ErrorPrinter.print_hint("No credentials available, login to activate credentials")
+
+    if settings.get_cli_config().get_active_default_organisation() is None:
+        set_default_organisation = typer.confirm(
+            "You have not set a default organisation\nWould you like to choose one now?",
+            abort=False,
+            default=True,
+        )
+        if set_default_organisation:
+            do_select_default_org(get=False)
+
+
+def list_and_select_personal_token(
+    skip_prompt: bool = False,
+    include_service_accounts: bool = False,
+    info_message: Optional[str] = None,
+) -> bool:
+    personal_tokens = settings.list_personal_tokens()
+
+    if include_service_accounts:
+        sa_tokens = settings.list_service_account_tokens()
+        personal_tokens.extend(sa_tokens)
+
+    # merged = _merge_local_tokens_with_cloud(personal_tokens)
+
+    selected_token = _prompt_choice(personal_tokens, skip_prompt=skip_prompt, info_message=info_message)
+    if selected_token is not None:
+        settings.activate_token(selected_token)
+        return True
+    return False
+
+
+# @app.command("select-revoke")
+def select_revoke_personal_token() -> None:
+    """
+    Prompts a user to select one of the credential files to revoke and delete
+    """
+    personal_tokens = settings.list_personal_tokens()
+    sa_tokens = settings.list_service_account_tokens()
+    personal_tokens.extend(sa_tokens)
+
+    is_logged_in = Rest.has_access("/api/whoami")
+    if not is_logged_in:
+        ErrorPrinter.print_hint("You must be logged in")
+        raise typer.Exit(0)
+
+    # merged = _merge_local_tokens_with_cloud(personal_tokens)
+
+    selected_token = _prompt_choice(personal_tokens)
+
+    if selected_token is not None:
+        _revoke_and_delete_personal_token(selected_token.name, True)
+        # Rest.handle_patch(f"/api/me/keys/{selected_token.name}/revoke", quiet=True, access_token=selected_token.token)
+        # Rest.handle_delete(f"/api/me/keys/{selected_token.name}", quiet=True, access_token=selected_token.token)
+        # settings.remove_token_file(selected_token.name)
+        # active_token = settings.get_active_token_file()
+        # if active_token.name == selected_token.name:
+        #    settings.clear_active_token()
+        # select_revoke_personal_token()
+
+
+# @app.command("test-all")
+def test_all_personal_tokens() -> None:
+    """
+    Tests each credential file to see if it is valid
+    """
+    personal_tokens = settings.list_personal_tokens()
+    personal_tokens.extend(settings.list_service_account_tokens())
+    if len(personal_tokens) == 0:
+        console.print("No personal tokens found on disk")
+        return
+
+    for token in personal_tokens:
+        r = Rest.handle_get(
+            "/api/whoami",
+            allow_status_codes=[401],
+            access_token=token.token,
+            use_progress_indicator=True,
+            return_response=True,
+        )
+        if r.status_code == 200:
+            if token.account is not None:
+                console.print(f"{token.account.email} ({token.name}) :white_check_mark:")
+            else:
+                console.print(f"{token.name} :white_check_mark:")
+        elif token.account is not None:
+            console.print(f"{token.account.email} ({token.name}) :x: Failed")
+        else:
+            console.print(f"{token.name} :x: Failed")
+
+
+# @app.command(name="list-service-account-tokens-files")
+def list_sats_files() -> None:
+    """
+    List service account access token files in remotivelabs config directory
+    """
+    service_account_files = settings.list_service_account_token_files()
+    for file in service_account_files:
+        print(file)
+
+
+@app.command(name="list")
+def list_pats_files() -> None:
+    """
+    Lists available credential files on filesystem
+    """
+    personal_files = settings.list_personal_token_files()
+    service_account_files = settings.list_service_account_token_files()
+    personal_files.extend(service_account_files)
+    for file in personal_files:
+        print(file)
+
+
+def _revoke_and_delete_personal_token(name: str, delete: bool) -> None:
+    token_file = None
+
+    # First we try to find the file and make sure its not the currently active
+    try:
+        token_file = settings.get_token_file(name)
+        active_token = settings.get_active_token_file()
+        if token_file.name == active_token.name:
+            ErrorPrinter.print_hint("You cannot revoke the current active token")
+            return
+    except TokenNotFoundError:
+        pass
+
+    # The lets try to revoke from cloud
+    res_revoke = tokens.revoke(name)
+    if delete:
+        res_delete = tokens.delete(name)
+        if res_delete.is_success:
+            ErrorPrinter.print_generic_message("Token successfully revoked and deleted")
+        else:
+            ErrorPrinter.print_hint(f"Failed to revoke and delete token in cloud: {res_delete.status_code}")
+    elif res_revoke.is_success:
+        ErrorPrinter.print_generic_message("Token successfully revoked")
+    else:
+        ErrorPrinter.print_hint("Failed to revoke and delete token in cloud")
+
+    # Finally try to remove the file if exists
+    if token_file is not None:
+        settings.remove_token_file(token_file.name)
+        console.print("Successfully deleted token on filesystem")
+    else:
+        ErrorPrinter.print_hint("Token not found on filesystem")

cli/cloud/brokers.py

@@ -10,14 +10,13 @@ import typer
 import websocket
 
 from cli.typer import typer_utils
-
-from .rest_helper import RestHelper as Rest
+from cli.utils.rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer()
 
 
 @app.command("list", help="Lists brokers in project")
-def list(project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT")) -> None:  # pylint: disable=W0622
+def list(project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT")) -> None:
     Rest.handle_get(f"/api/project/{project}/brokers")
 
 
@@ -94,7 +93,7 @@ def logs(
     def on_message(_wsapp: Any, message: str) -> None:
         print(message)
 
-    def on_error(_wsapp: Any, err: str) -> None:  # pylint: disable=W0613
+    def on_error(_wsapp: Any, err: str) -> None:
         print("EXAMPLE error encountered: ", err)
 
     Rest.ensure_auth_token()

cli/cloud/cloud_cli.py

@@ -1,8 +1,8 @@
 import typer
 
 from cli.cloud import auth, brokers, configs, organisations, projects, recordings, sample_recordings, service_accounts, storage
-from cli.cloud.rest_helper import RestHelper
 from cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper
 
 app = typer_utils.create_typer()
 
@@ -15,7 +15,7 @@ def licenses(
     RestHelper.handle_get(f"/api/bu/{organisation}/licenses", {"filter": filter_option})
 
 
-app.add_typer(organisations.app, name="organisations", help="Manage organisations")
+app.add_typer(organisations.app, name="organisations", help="Manage organizations")
 app.add_typer(projects.app, name="projects", help="Manage projects")
 app.add_typer(auth.app, name="auth")
 app.add_typer(brokers.app, name="brokers", help="Manage cloud broker lifecycle")

cli/cloud/configs.py

@@ -8,8 +8,7 @@ import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.typer import typer_utils
-
-from .rest_helper import RestHelper as Rest
+from cli.utils.rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer()
 

cli/cloud/organisations.py

@@ -1,29 +1,101 @@
+from __future__ import annotations
+
 import json
-import sys
+from dataclasses import dataclass
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
 
-from cli.cloud.rest_helper import RestHelper
+from cli.settings import settings
 from cli.typer import typer_utils
+from cli.utils.rest_helper import RestHelper
 
+console = Console(stderr=False)
 app = typer_utils.create_typer()
 
 
-@app.command(name="list", help="List your available organisations")
-def list_orgs() -> None:
-    r = RestHelper.handle_get("/api/home", return_response=True)
-    if r is None:
-        return
-    if r.status_code == 200:
-        j = list(
-            map(
-                lambda x: {
-                    "uid": x["billableUnitUser"]["billableUnit"]["uid"],
-                    "displayName": x["billableUnitUser"]["billableUnit"]["displayName"],
-                },
-                r.json(),
-            )
+@dataclass
+class Organisation:
+    display_name: str
+    uid: str
+
+
+def _prompt_choice(choices: List[Organisation]) -> Optional[Organisation]:
+    table = Table("#", "Name", "Uid", "Default")
+
+    token = settings.get_active_token_file()
+    config = settings.get_cli_config()
+
+    current_default_org = config.accounts[token.account.email].default_organization if token is not None else None
+
+    for idx, choice in enumerate(choices, start=1):
+        table.add_row(
+            f"[yellow]{idx}",
+            f"[bold]{choice.display_name}[/bold]",
+            choice.uid,
+            ":thumbsup:" if current_default_org is not None and current_default_org == choice.uid else "",
         )
-        print(json.dumps(j))
+    console.print(table)
+
+    typer.echo("")
+    selection = typer.prompt(f"Enter the number(# 1-{len(choices)}) of the organisation to select (or q to quit)")
+
+    if selection == "q":
+        return None
+    try:
+        index = int(selection) - 1
+        if 0 <= index < len(choices):
+            return choices[index]
+        raise ValueError
+    except ValueError:
+        typer.echo("Invalid choice, please try again")
+        return _prompt_choice(choices)
+
+
+@app.command("default")
+def select_default_org(
+    organisation_uid: str = typer.Argument(None, help="Organisation uid or empty to select one"),
+    get: bool = typer.Option(False, help="Print current default organisation"),
+) -> None:
+    do_select_default_org(organisation_uid, get)
+
+
+def do_select_default_org(organisation_uid: Optional[str] = None, get: bool = False) -> None:
+    r"""
+    Set default organisation for the currently activated user, empty to choose from available organizations or organization uid as argument
+
+    remotive cloud organizations default my_org \[set specific org uid]
+    remotive cloud organizations default \[select one from prompt]
+    remotive cloud organizations default --get \[print current default]
+
+    Note that service-accounts does Not have permission to list organizations and will get a 403 Forbidden response so you must
+    select the organization uid as argument
+    """
+    if get:
+        default_organisation = settings.get_cli_config().get_active_default_organisation()
+        if default_organisation is not None:
+            console.print(default_organisation)
+        else:
+            console.print("No default organisation set")
+    elif organisation_uid is not None:
+        settings.set_default_organisation(organisation_uid)
     else:
-        print(f"Got status code: {r.status_code}")
-        print(r.text)
-        sys.exit(1)
+        r = RestHelper.handle_get("/api/bu", return_response=True)
+        orgs = r.json()
+        orgs = [Organisation(display_name=o["organisation"]["displayName"], uid=o["organisation"]["uid"]) for o in orgs]
+
+        selected = _prompt_choice(orgs)
+
+        if selected is not None:
+            settings.get_cli_config()
+            typer.echo(f"Default organisation: {selected.display_name} (uid: {selected.uid})")
+            settings.set_default_organisation(selected.uid)
+
+
+@app.command(name="list", help="List your available organizations")
+def list_orgs() -> None:
+    r = RestHelper.handle_get("/api/bu", return_response=True)
+    orgs = [{"uid": org["organisation"]["uid"], "displayName": org["organisation"]["displayName"]} for org in r.json()]
+    print(json.dumps(orgs))

cli/cloud/projects.py

@@ -3,8 +3,7 @@ import json
 import typer
 
 from cli.typer import typer_utils
-
-from .rest_helper import RestHelper as Rest
+from cli.utils.rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer()
 

cli/cloud/recordings.py

@@ -19,11 +19,11 @@ 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.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
-from .rest_helper import RestHelper as Rest
-from .rest_helper import err_console
 
 app = typer_utils.create_typer()
 app.add_typer(playback_app, name="playback")
@@ -129,7 +129,6 @@ def mount(  # noqa: C901
     transformation_name: str = typer.Option("default", help="Specify a custom signal transformation to use"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
 ) -> None:
-    # pylint: disable=R0912
     Rest.ensure_auth_token()
 
     Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
@@ -230,7 +229,7 @@ def delete_recording_file(
 
 
 @app.command()
-def upload(  # noqa: C901
+def upload(  # noqa: C901, PLR0912, PLR0915
     path: Path = typer.Argument(
         ...,
         exists=True,
@@ -244,7 +243,6 @@ def upload(  # noqa: C901
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
     recording_session: Optional[str] = typer.Option(default=None, help="Optional existing recording to upload file to"),
 ) -> None:
-    # pylint: disable=R0912,R0914,R0915
     """
     Uploads a recording to RemotiveCloud.
     Except for recordings from RemotiveBroker you can also upload Can ASC (.asc), Can BLF(.blf) and  Can LOG (.log, .txt)
@@ -281,8 +279,7 @@ def upload(  # noqa: C901
         return
 
     # Exact same as in cloud console
-    def get_processing_message(step: str) -> str:
-        # pylint: disable=R0911
+    def get_processing_message(step: str) -> str:  # noqa: PLR0911
         if step == "REQUESTED":
             return "Preparing file..."
         if step == "VALIDATING":
@@ -333,9 +330,9 @@ def upload(  # noqa: C901
         err_console.print(f":boom: [bold red]Got status code[/bold red]: {upload_response.status_code} {upload_response.text}")
 
 
-# TODO - Change to use Path for directory  # pylint: disable=W0511
+# TODO - Change to use Path for directory
 @app.command()
-def upload_broker_configuration(  # noqa: C901
+def upload_broker_configuration(
     directory: Path = typer.Argument(
         ...,
         exists=True,
@@ -353,8 +350,6 @@ def upload_broker_configuration(  # noqa: C901
     """
     Uploads a broker configuration directory
     """
-    # pylint: disable=R0914,R0915
-
     # Must end with /
 
     #
@@ -431,7 +426,7 @@ def upload_broker_configuration(  # noqa: C901
         path = file["local_path"]
         url = upload_urls[key]
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
-        r = requests.put(url, open(path, "rb"), headers=headers, timeout=60)  # pylint: disable=R1732
+        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)
@@ -529,11 +524,9 @@ def stop(
     _do_change_playback_mode("stop", recording_session, broker, project)
 
 
-# pylint: disable-next=C0301
-def _do_change_playback_mode(
+def _do_change_playback_mode(  # noqa: PLR0912
     mode: str, recording_session: str, broker_name: Optional[str], project: str, seconds: Optional[int] = None
-) -> None:  # noqa: C901
-    # pylint: disable=R0912,R0914,R0915
+) -> None:
     response = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
     if response is None:
         return

cli/cloud/recordings_playback.py

@@ -15,10 +15,10 @@ from rich import print as rich_print
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.errors import ErrorPrinter
+from cli.utils.rest_helper import RestHelper as Rest
 
 from ..broker.lib.broker import Broker, SubscribableSignal
 from ..typer import typer_utils
-from .rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer(
     help="""
@@ -101,9 +101,8 @@ def read_scripted_code_file(file_path: Path) -> bytes:
         return file.read()
 
 
-# pylint: disable=R0913
 @app.command()
-def subscribe(
+def subscribe(  # noqa: PLR0913
     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"),
@@ -156,12 +155,12 @@ def subscribe(
     except grpc.RpcError as rpc_error:
         ErrorPrinter.print_grpc_error(rpc_error)
 
-    except Exception as e:  # pylint: disable=W0718
+    except Exception as e:
         ErrorPrinter.print_generic_error(str(e))
         sys.exit(1)
 
 
-def _do_change_playback_mode(  # noqa: C901
+def _do_change_playback_mode(  # noqa: C901, PLR0913, PLR0912
     mode: str,
     recording_session: str,
     brokerstr: str,
@@ -169,8 +168,7 @@ def _do_change_playback_mode(  # noqa: C901
     seconds: int | None = None,
     progress_on_play: bool = False,
     repeat: bool = False,
-) -> None:  # noqa: C901
-    # pylint: disable=R0913,R0912
+) -> None:
     response = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
     if response is None:
         return
@@ -247,7 +245,7 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
                 ErrorPrinter.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:  # pylint: disable=no-member
+        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:

cli/cloud/sample_recordings.py

@@ -3,8 +3,7 @@ import json
 import typer
 
 from cli.typer import typer_utils
-
-from .rest_helper import RestHelper as Rest
+from cli.utils.rest_helper import RestHelper as Rest
 
 app = typer_utils.create_typer()
 
@@ -18,7 +17,7 @@ def do_import(
 
 
 @app.command("list")
-def list() -> None:  # pylint: disable=W0622
+def list() -> None:
     """
     List available sample recordings
     """