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

cli/cloud/recordings.py

@@ -9,32 +9,34 @@ import tempfile
 import time
 import urllib.parse
 from pathlib import Path
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Tuple, Union
+from urllib.parse import quote
 
 import grpc
 import requests
 import typer
-from rich.progress import Progress, SpinnerColumn, TextColumn, track
+from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn, track
 
 from cli.errors import ErrorPrinter
 
 from ..broker.lib.broker import Broker
-from . import rest_helper as rest
 from .recordings_playback import app as playback_app
+from .rest_helper import RestHelper as Rest
+from .rest_helper import err_console
 
 app = typer.Typer()
 app.add_typer(playback_app, name="playback")
 
 
-def uid(p):
+def uid(p: Any) -> Any:
     print(p)
     return p["uid"]
 
 
 # to be used in options
 # autocompletion=project_names)
-def project_names():
-    r = requests.get(f"{rest.base_url}/api/bu/{rest.org}/project", headers=rest.headers)
+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()
@@ -48,7 +50,7 @@ def project_names():
 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"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     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.
@@ -56,35 +58,35 @@ def list_recordings(
     """
 
     if is_processing:
-        rest.handle_get(f"/api/project/{project}/files/recording/processing")
+        Rest.handle_get(f"/api/project/{project}/files/recording/processing")
     else:
-        rest.handle_get(f"/api/project/{project}/files/recording")
+        Rest.handle_get(f"/api/project/{project}/files/recording")
 
 
 @app.command(help="Shows details about a specific recording in project")
 def describe(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}")
+) -> None:
+    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",
+#    Rest.handle_post(url=f"/api/project/{project}/files/recording/{recording_session}/copy",
 #                     body=json.dumps({'projectUid': target_project}))
 
 
-def do_start(name: str, project: str, api_key: str, return_response: bool = False):
+def do_start(name: str, project: str, api_key: str, return_response: bool = False) -> requests.Response | None:
     if api_key == "":
         body = {"size": "S"}
     else:
         body = {"size": "S", "apiKey": api_key}
 
     name = name if name is not None else "personal"
-    return rest.handle_post(
+    return Rest.handle_post(
         f"/api/project/{project}/brokers/{name}",
         body=json.dumps(body),
         return_response=return_response,
@@ -93,19 +95,20 @@ def do_start(name: str, project: str, api_key: str, return_response: bool = Fals
 
 
 @app.command(help="Prepares all recording files and transformations to be available for playback")
-def mount(
+def mount(  # noqa: C901
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     broker: str = typer.Option(None, help="Broker to use"),
     ensure_broker_started: bool = typer.Option(default=False, help="Ensure broker exists, start otherwise"),
     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"),
-):
-    rest.ensure_auth_token()
+) -> None:
+    # pylint: disable=R0912
+    Rest.ensure_auth_token()
 
-    rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+    Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
 
     if broker is None:
-        r = rest.handle_get(url=f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
+        r = Rest.handle_get(url=f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
 
         if r.status_code == 200:
             broker = r.json()["shortName"]
@@ -114,32 +117,35 @@ def mount(
             r = do_start(None, project, "", return_response=True)
             if r.status_code != 200:
                 print(r.text)
-                exit(0)
+                sys.exit(0)
             broker = r.json()["shortName"]
         else:
             sys.stderr.write(f"Got http status code {r.status_code}")
-            typer.Exit(0)
+            raise typer.Exit(0)
     else:
-        r = rest.handle_get(url=f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
+        r = Rest.handle_get(url=f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
 
+        if r is None:
+            sys.exit(1)
         if r.status_code == 404:
             if ensure_broker_started:
                 r = do_start(broker, project, "", return_response=True)
-
+                if r is None:
+                    sys.exit(1)
                 if r.status_code != 200:
                     print(r.text)
-                    exit(1)
+                    sys.exit(1)
             else:
                 ErrorPrinter.print_generic_error(f"Broker {broker} not running")
-                exit(1)
+                sys.exit(1)
         elif r.status_code != 200:
             sys.stderr.write(f"Got http status code {r.status_code}")
-            typer.Exit(1)
+            raise typer.Exit(1)
     broker_config_query = ""
     if transformation_name != "default":
         broker_config_query = f"?brokerConfigName={transformation_name}"
 
-    rest.handle_get(
+    Rest.handle_get(
         f"/api/project/{project}/files/recording/{recording_session}/upload{broker_config_query}",
         params={"brokerName": broker},
         return_response=True,
@@ -155,29 +161,33 @@ def download_recording_file(
         ..., help="Recording session id that this file belongs to", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"
     ),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.ensure_auth_token()
+) -> None:
+    Rest.ensure_auth_token()
+    recording_file_name_qouted = quote(recording_file_name, safe="")
     get_signed_url_resp = requests.get(
-        f"{rest.base_url}/api/project/{project}/files/recording/{recording_session}/recording-file/{recording_file_name}",
-        headers=rest.headers,
+        f"{Rest.get_base_url()}/api/project/{project}/files/recording/{recording_session}/recording-file/{recording_file_name_qouted}",
+        headers=Rest.get_headers(),
         allow_redirects=True,
+        timeout=60,
     )
     if get_signed_url_resp.status_code == 200:
         # Next download the actual file
-        rest.download_file(recording_file_name, get_signed_url_resp.json()["downloadUrl"])
+        Rest.download_file(recording_file_name, get_signed_url_resp.json()["downloadUrl"])
         print(f"Downloaded {recording_file_name}")
+    else:
+        print(get_signed_url_resp)
 
 
 @app.command(name="delete")
 def delete(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Deletes the specified recording session including all media files and configurations.
 
     """
-    rest.handle_delete(f"/api/project/{project}/files/recording/{recording_session}")
+    Rest.handle_delete(f"/api/project/{project}/files/recording/{recording_session}")
 
 
 @app.command(name="delete-recording-file")
@@ -187,12 +197,12 @@ def delete_recording_file(
         ..., help="Recording session id that this file belongs to", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"
     ),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Deletes the specified recording file
 
     """
-    rest.handle_delete(f"/api/project/{project}/files/recording/{recording_session}/recording-file/{recording_file_name}")
+    Rest.handle_delete(f"/api/project/{project}/files/recording/{recording_session}/recording-file/{recording_file_name}")
 
 
 @app.command()
@@ -209,19 +219,22 @@ def upload(  # noqa: C901
     ),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
     recording_session: 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)
     """
 
     filename = os.path.basename(path.name)
-    rest.ensure_auth_token()
+    Rest.ensure_auth_token()
 
     if recording_session is None:
-        r = rest.handle_post(f"/api/project/{project}/files/recording/{filename}", return_response=True)
+        r = Rest.handle_post(f"/api/project/{project}/files/recording/{filename}", return_response=True)
     else:
-        r = rest.handle_post(f"/api/project/{project}/files/recording/{recording_session}/recording-file/{filename}", return_response=True)
+        r = Rest.handle_post(f"/api/project/{project}/files/recording/{recording_session}/recording-file/{filename}", return_response=True)
+    if r is None:
+        return
 
     upload_url = r.text
     url_path = urllib.parse.urlparse(upload_url).path
@@ -234,14 +247,18 @@ def upload(  # noqa: C901
             "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")
-        exit(1)
+        sys.exit(1)
 
-    upload_response = rest.upload_file_with_signed_url(
+    upload_response = Rest.upload_file_with_signed_url(
         path=path, url=upload_url, upload_headers={"Content-Type": "application/x-www-form-urlencoded"}, return_response=True
     )
 
+    if upload_response is None:
+        return
+
     # Exact same as in cloud console
     def get_processing_message(step: str) -> str:
+        # pylint: disable=R0911
         if step == "REQUESTED":
             return "Preparing file..."
         if step == "VALIDATING":
@@ -264,10 +281,12 @@ def upload(  # noqa: C901
             t = p.add_task("Processing...", total=1)
             while True:
                 time.sleep(1)
-                r = rest.handle_get(
+                r = Rest.handle_get(
                     f"/api/project/{project}/files/recording/processing", return_response=True, use_progress_indicator=False
                 )
-                status_list: List[Dict[str, any]] = r.json()
+                if r is None:
+                    return
+                status_list: List[Dict[str, Any]] = r.json()
                 res = list(filter(lambda s: s["uploadId"] == upload_id, status_list))
                 if len(res) == 1:
                     tracking_state = res[0]
@@ -284,19 +303,20 @@ def upload(  # noqa: C901
                     break
         if error_message is not None:
             ErrorPrinter.print_generic_error(error_message)
-            exit(1)
+            sys.exit(1)
 
     else:
-        rest.err_console.print(f":boom: [bold red]Got status code[/bold red]: {upload_response.status_code} {upload_response.text}")
+        err_console.print(f":boom: [bold red]Got status code[/bold red]: {upload_response.status_code} {upload_response.text}")
 
 
 @app.command()
-def upload_broker_configuration(
+def upload_broker_configuration(  # noqa: C901
     directory: str = typer.Argument(..., help="Configuration directory"),
     recording_session: str = typer.Option(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
     overwrite: bool = typer.Option(False, help="Overwrite existing configuration if it exists"),
-):
+) -> None:
+    # pylint: disable=R0914,R0915
     # Must end with /
     if not directory.endswith("/"):
         directory = f"{directory}/"
@@ -319,14 +339,16 @@ def upload_broker_configuration(
     # name already exists
     #
     # task = progress.add_task(description=f"Preparing upload of {broker_config_dir_name}", total=1)
-    details_resp = rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+    details_resp = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+    if details_resp is None:
+        return
     details = details_resp.json()
     existing_configs = details["brokerConfigurations"]
     if len(existing_configs) > 0:
         data = list(filter(lambda x: x["name"] == broker_config_dir_name, existing_configs))
         if len(data) > 0:
             if overwrite:
-                rest.handle_delete(
+                Rest.handle_delete(
                     f"/api/project/{project}/files/recording/{recording_session}/configuration/{broker_config_dir_name}", quiet=True
                 )
             else:
@@ -349,11 +371,13 @@ def upload_broker_configuration(
     #
     json_request_upload_urls_req = {"name": "not_used", "paths": list(map(lambda x: x["remote_path"], file_infos))}
 
-    response = rest.handle_put(
+    response = Rest.handle_put(
         url=f"/api/project/{project}/files/recording/{recording_session}/configuration",
         return_response=True,
         body=json.dumps(json_request_upload_urls_req),
     )
+    if response is None:
+        return
     if response.status_code != 200:
         print("Failed to prepare configuration upload")
         print(f"{response.text} - {response.status_code}")
@@ -371,12 +395,12 @@ def upload_broker_configuration(
         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)
+        r = requests.put(url, open(path, "rb"), headers=headers, timeout=60)  # pylint: disable=R1732
         if r.status_code != 200:
             print("Failed to upload broker configuration")
             print(r.status_code)
             print(r.text)
-            typer.Exit(1)
+            raise typer.Exit(1)
 
     print(f"Successfully uploaded broker configuration {broker_config_dir_name}")
 
@@ -386,32 +410,36 @@ def download_configuration(
     broker_config_name: str = typer.Argument(..., help="Broker config name"),
     recording_session: str = typer.Option(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.ensure_auth_token()
-    r = rest.handle_get(
+) -> None:
+    Rest.ensure_auth_token()
+    r = Rest.handle_get(
         url=f"/api/project/{project}/files/recording/{recording_session}/configuration/{broker_config_name}", return_response=True
     )
+    if r is None:
+        return
     filename = get_filename_from_cd(r.headers.get("content-disposition"))
-    open(filename, "wb").write(r.content)
-    print(f"Downloaded file {filename}")
+    if filename is not None:
+        with open(filename, "wb") as f:
+            f.write(r.content)
+        print(f"Downloaded file {filename}")
 
 
-@app.command(help="Downloads the specified broker configuration directory as zip file")
+@app.command(help="Delete the specified broker configuration")
 def delete_configuration(
     broker_config_name: str = typer.Argument(..., help="Broker config name"),
     recording_session: str = typer.Option(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    rest.handle_delete(url=f"/api/project/{project}/files/recording/{recording_session}/configuration/{broker_config_name}")
+) -> None:
+    Rest.handle_delete(url=f"/api/project/{project}/files/recording/{recording_session}/configuration/{broker_config_name}")
 
 
 @app.command(help="Copy recording to another project")
 def copy(
     recording_session: str = typer.Argument(..., help="Recording session id"),
-    project: str = typer.Option(..., help="Project to import sample recording into", envvar="REMOTIVE_CLOUD_PROJECT"),
+    project: str = typer.Option(..., help="Source project", envvar="REMOTIVE_CLOUD_PROJECT"),
     destination_project: str = typer.Option(..., help="Destination project"),
-):
-    rest.handle_post(
+) -> None:
+    Rest.handle_post(
         url=f"/api/project/{project}/files/recording/{recording_session}/copy", body=json.dumps({"projectUid": destination_project})
     )
 
@@ -421,7 +449,7 @@ def play(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     broker: str = typer.Option(None, help="Broker to use"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Plays a recording (Deprecated - Use recordings playback play)"
     """
@@ -433,32 +461,20 @@ def pause(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     broker: str = typer.Option(None, help="Broker to use"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Pause recording (Deprecated - Use recordings playback pause")
     """
     _do_change_playback_mode("pause", recording_session, broker, project)
 
 
-@app.command(name="playback-status", deprecated=True)
-def playback_status(
-    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
-    broker: str = typer.Option(None, help="Broker to use"),
-    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
-    """
-    Playback progress (Deprecated - Use recordings playback progress)
-    """
-    _do_change_playback_mode("status", recording_session, broker, project)
-
-
 @app.command(deprecated=True)
 def seek(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     seconds: int = typer.Option(..., min=0, help="Target offset in seconds"),
     broker: str = typer.Option(None, help="Broker to use"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Seek into recording (Deprecated - Use recordings playback seek)
     """
@@ -470,30 +486,36 @@ def stop(
     recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
     broker: str = typer.Option(None, help="Broker to use"),
     project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
-):
+) -> None:
     """
     Stop recording (Deprecated - Use recordings playback stop)
     """
     _do_change_playback_mode("stop", recording_session, broker, project)
 
 
-def _do_change_playback_mode(mode: str, recording_session: str, broker: str, project: str, seconds: int | None = None):  # noqa: C901
-    response = rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+# pylint: disable-next=C0301
+def _do_change_playback_mode(mode: str, recording_session: str, broker_name: str, project: str, seconds: int | None = None) -> None:  # noqa: C901
+    # pylint: disable=R0912,R0914,R0915
+    response = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+    if response is None:
+        return
     r = json.loads(response.text)
-    recordings: list = r["recordings"]
+    recordings: List[Any] = r["recordings"]
     files = list(map(lambda rec: {"recording": rec["fileName"], "namespace": rec["metadata"]["namespace"]}, recordings))
 
-    if broker is not None:
-        response = rest.handle_get(f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
+    if broker_name is not None:
+        response = Rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
     else:
-        response = rest.handle_get(f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
+        response = Rest.handle_get(f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
+    if response is None:
+        return
     if response.status_code == 404:
         broker_arg = ""
-        if broker is not None:
-            broker_arg = f" --broker {broker} --ensure-broker-started"
+        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}")
-        exit(1)
+        sys.exit(1)
 
     broker_info = json.loads(response.text)
     broker = Broker(broker_info["url"], None)
@@ -503,7 +525,7 @@ def _do_change_playback_mode(mode: str, recording_session: str, broker: str, pro
         # error messages
         tmp = os.path.join(tempfile.gettempdir(), os.urandom(24).hex())
         broker.download(".cloud.context", tmp, True)
-        with open(tmp, "r") as f:
+        with open(tmp, "r", encoding="utf8") as f:
             json_context = json.loads(f.read())
             if json_context["recordingSessionId"] != recording_session:
                 ErrorPrinter.print_generic_error(
@@ -511,33 +533,30 @@ def _do_change_playback_mode(mode: str, recording_session: str, broker: str, pro
                     f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
                 )
                 ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
-                exit(1)
+                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)
-        exit(1)
+        # 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)
+        sys.exit(1)
     if mode == "pause":
         broker.pause_play(files, True)
     elif mode == "play":
         r = broker.play(files, True)
     elif mode == "seek":
-        broker.seek(files, int(seconds * 1000000), True)
+        if seconds is not None:
+            broker.seek(files, int(seconds * 1000000), True)
+        else:
+            broker.seek(files, 0, True)
     elif mode == "stop":
         broker.seek(files, 0, True)
-    elif mode == "status":
-        p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
-        t = p.add_task("label", total=1)
-
-        with p:
-            broker.listen_on_playback(lambda c: p.update(t, description=str(c)))
     else:
-        raise Exception(f"Illegal command {mode}")
+        raise ValueError(f"Illegal command {mode}")
 
 
-def get_filename_from_cd(cd):
+def get_filename_from_cd(cd: Union[str, None]) -> Union[str, None]:
     """
     Get filename from content-disposition
     """
@@ -546,10 +565,10 @@ def get_filename_from_cd(cd):
     fname = re.findall("filename=(.+)", cd)
     if len(fname) == 0:
         return None
-    return fname[0]
+    return str(fname[0])
 
 
-def use_progress(label: str):
+def use_progress(label: str) -> Tuple[Progress, TaskID]:
     p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
     t = p.add_task(label, total=1)
     return (p, t)