kleinkram 0.48.0.dev20250723090520__py3-none-any.whl → 0.58.0.dev20260110152317__py3-none-any.whl

kleinkram/cli/_run.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import os
+import re
+import sys
+import tarfile
+import time
+from typing import List
+from typing import Optional
+
+import requests
+import typer
+
+import kleinkram.api.routes
+from kleinkram.api.client import AuthenticatedClient
+from kleinkram.api.query import RunQuery
+from kleinkram.config import get_shared_state
+from kleinkram.models import LogEntry
+from kleinkram.models import Run
+from kleinkram.printing import print_run_info
+from kleinkram.printing import print_run_logs
+from kleinkram.printing import print_runs_table
+from kleinkram.utils import split_args
+
+HELP = """\
+Manage and inspect action runs.
+
+You can list action runs, get detailed information about specific runs, stream their logs,
+cancel runs in progress, and retry failed runs.
+"""
+
+run_typer = typer.Typer(
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help=HELP,
+)
+
+LIST_HELP = "List action runs. Optionally filter by mission or project."
+INFO_HELP = "Get detailed information about a specific action run."
+LOGS_HELP = "Stream the logs for a specific action run."
+CANCEL_HELP = "Cancel an action run that is in progress."
+RETRY_HELP = "Retry a failed action run."
+DOWNLOAD_HELP = "Download artifacts for a specific action run."
+
+
+@run_typer.command(help=LIST_HELP, name="list")
+def list_runs(
+    mission: Optional[str] = typer.Option(None, "--mission", "-m", help="Mission ID or name to filter by."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project ID or name to filter by."),
+) -> None:
+    """
+    List action runs.
+    """
+    client = AuthenticatedClient()
+
+    mission_ids, mission_patterns = split_args([mission] if mission else [])
+    project_ids, project_patterns = split_args([project] if project else [])
+
+    query = RunQuery(
+        mission_ids=mission_ids,
+        mission_patterns=mission_patterns,
+        project_ids=project_ids,
+        project_patterns=project_patterns,
+    )
+
+    runs = list(kleinkram.api.routes.get_runs(client, query=query))
+    print_runs_table(runs, pprint=get_shared_state().verbose)
+
+
+@run_typer.command(name="info", help=INFO_HELP)
+def get_info(run_id: str = typer.Argument(..., help="The ID of the run to get information for.")) -> None:
+    """
+    Get detailed information for a single run.
+    """
+    client = AuthenticatedClient()
+    run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+    print_run_info(run, pprint=get_shared_state().verbose)
+
+
+@run_typer.command(help=LOGS_HELP)
+def logs(
+    run_id: str = typer.Argument(..., help="The ID of the run to fetch logs for."),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow the log output in real-time."),
+) -> None:
+    """
+    Fetch and display logs for a specific run.
+    """
+    client = AuthenticatedClient()
+
+    if follow:
+        typer.echo(f"Watching logs for run {run_id}. Press Ctrl+C to stop.")
+        try:
+
+            # TODO: fine for now, but ideally we would have a streaming endpoint
+            # currently there is no following, thus we just poll every 2 seconds
+            # from the get_run endpoint
+            last_log_index = 0
+            while True:
+                run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+                log_entries: List[LogEntry] = run.logs
+                new_log_entries = log_entries[last_log_index:]
+                if new_log_entries:
+                    print_run_logs(new_log_entries, pprint=get_shared_state().verbose)
+                    last_log_index += len(new_log_entries)
+
+                time.sleep(2)
+
+        except KeyboardInterrupt:
+            typer.echo("Stopped following logs.")
+            sys.exit(0)
+    else:
+        log_entries = kleinkram.api.routes.get_run(client, run_id=run_id).logs
+        print_run_logs(log_entries, pprint=get_shared_state().verbose)
+
+
+def _get_filename_from_cd(cd: str) -> Optional[str]:
+    """Extract filename from Content-Disposition header."""
+    if not cd:
+        return None
+    fname = re.findall("filename=(.+)", cd)
+    if len(fname) == 0:
+        return None
+    return fname[0].strip().strip('"')
+
+
+@run_typer.command(name="download", help=DOWNLOAD_HELP)
+def download_artifacts(
+    run_id: str = typer.Argument(..., help="The ID of the run to download artifacts for."),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Path or filename to save the artifacts to."),
+    extract: bool = typer.Option(
+        False,
+        "--extract",
+        "-x",
+        help="Automatically extract the archive after downloading.",
+    ),
+) -> None:
+    """
+    Download the artifacts (.tar.gz) for a finished run.
+    """
+    client = AuthenticatedClient()
+
+    # Fetch Run Details
+    try:
+        run: Run = kleinkram.api.routes.get_run(client, run_id=run_id)
+    except Exception as e:
+        typer.secho(f"Failed to fetch run details: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    if not run.artifact_url:
+        typer.secho(
+            f"No artifacts found for run {run_id}. The run might not be finished or artifacts expired.",
+            fg=typer.colors.YELLOW,
+        )
+        raise typer.Exit(1)
+
+    typer.echo(f"Downloading artifacts for run {run_id}...")
+
+    # Stream Download
+    try:
+        with requests.get(run.artifact_url, stream=True) as r:
+            r.raise_for_status()
+
+            # Determine Filename
+            filename = output
+            if not filename:
+                filename = _get_filename_from_cd(r.headers.get("content-disposition"))
+
+            if not filename:
+                filename = f"{run_id}.tar.gz"
+
+            # If output is a directory, join with filename
+            if output and os.path.isdir(output):
+                filename = os.path.join(
+                    output,
+                    _get_filename_from_cd(r.headers.get("content-disposition")) or f"{run_id}.tar.gz",
+                )
+
+            total_length = int(r.headers.get("content-length", 0))
+
+            # Write to file with Progress Bar
+            with open(filename, "wb") as f:
+                with typer.progressbar(length=total_length, label=f"Saving to {filename}") as progress:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+                            progress.update(len(chunk))
+
+            typer.secho(f"\nSuccessfully downloaded to {filename}", fg=typer.colors.GREEN)
+
+            # Extraction Logic
+            if extract:
+                try:
+                    # Determine extraction directory (based on filename without extension)
+                    # e.g., "downloads/my-run.tar" -> "downloads/my-run"
+                    base_name = os.path.basename(filename)
+                    folder_name = base_name.split(".")[0]
+
+                    # Get the parent directory of the downloaded file
+                    parent_dir = os.path.dirname(os.path.abspath(filename))
+                    extract_path = os.path.join(parent_dir, folder_name)
+
+                    typer.echo(f"Extracting to: {extract_path}...")
+
+                    with tarfile.open(filename, "r:gz") as tar:
+
+                        # Safety check: filter_data prevents extraction outside target dir (CVE-2007-4559)
+                        # Available in Python 3.12+, for older python use generic extractall
+                        if hasattr(tarfile, "data_filter"):
+                            tar.extractall(path=extract_path, filter="data")
+                        else:
+                            tar.extractall(path=extract_path)
+
+                    typer.secho("Successfully extracted.", fg=typer.colors.GREEN)
+
+                except tarfile.TarError as e:
+                    typer.secho(f"Failed to extract archive: {e}", fg=typer.colors.RED)
+
+    except requests.exceptions.RequestException as e:
+        typer.secho(f"Error downloading file: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)

kleinkram/cli/_upload.py

@@ -11,8 +11,9 @@ import kleinkram.utils
 from kleinkram.api.client import AuthenticatedClient
 from kleinkram.api.query import MissionQuery
 from kleinkram.api.query import ProjectQuery
+from kleinkram.cli._file_validator import FileValidator
+from kleinkram.cli._file_validator import _report_skipped_files
 from kleinkram.config import get_shared_state
-from kleinkram.errors import FileNameNotSupported
 from kleinkram.errors import MissionNotFound
 from kleinkram.utils import load_metadata
 from kleinkram.utils import split_args
@@ -29,55 +30,86 @@ upload_typer = typer.Typer(
 )
 
 
+def _build_mission_query(mission: str, project: Optional[str]) -> MissionQuery:
+    """Constructs the MissionQuery object from CLI args."""
+    mission_ids, mission_patterns = split_args([mission])
+    project_ids, project_patterns = split_args([project] if project else [])
+
+    project_query = ProjectQuery(ids=project_ids, patterns=project_patterns)
+    return MissionQuery(
+        ids=mission_ids,
+        patterns=mission_patterns,
+        project_query=project_query,
+    )
+
+
+def _handle_no_files_to_upload(original_count: int, uploaded_count: int) -> None:
+    """Checks if any files are left to upload and exits if not."""
+    if uploaded_count > 0:
+        return
+
+    if original_count > 0:
+        typer.echo(
+            typer.style("All paths were skipped. No files to upload.", fg=typer.colors.RED),
+            err=True,
+        )
+    else:
+        typer.echo(typer.style("No files provided to upload.", fg=typer.colors.RED), err=True)
+    raise typer.Exit(code=1)
+
+
 @upload_typer.callback()
 def upload(
     files: List[str] = typer.Argument(help="files to upload"),
-    project: Optional[str] = typer.Option(
-        None, "--project", "-p", help="project id or name"
-    ),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="project id or name"),
     mission: str = typer.Option(..., "--mission", "-m", help="mission id or name"),
     create: bool = typer.Option(False, help="create mission if it does not exist"),
-    metadata: Optional[str] = typer.Option(
-        None, help="path to metadata file (json or yaml)"
-    ),
+    metadata: Optional[str] = typer.Option(None, help="path to metadata file (json or yaml)"),
     fix_filenames: bool = typer.Option(
         False,
         help="fix filenames before upload, this does not change the filenames locally",
     ),
+    skip: bool = typer.Option(
+        False,
+        "--skip",
+        "-s",
+        help="skip unsupported file types, badly named files, or directories instead of erroring",
+    ),
+    experimental_datatypes: bool = typer.Option(False, help="allow experimental datatypes (yaml, svo2, db3, tum)"),
     ignore_missing_tags: bool = typer.Option(False, help="ignore mission tags"),
 ) -> None:
-    # get filepaths
-    file_paths = [Path(file) for file in files]
+    original_file_paths = [Path(file) for file in files]
+    mission_query = _build_mission_query(mission, project)
 
-    mission_ids, mission_patterns = split_args([mission])
-    project_ids, project_patterns = split_args([project] if project else [])
-
-    project_query = ProjectQuery(ids=project_ids, patterns=project_patterns)
-    mission_query = MissionQuery(
-        ids=mission_ids,
-        patterns=mission_patterns,
-        project_query=project_query,
+    validator = FileValidator(
+        skip=skip,
+        experimental_datatypes=experimental_datatypes,
     )
 
-    if not fix_filenames:
-        for file in file_paths:
-            if not kleinkram.utils.check_filename_is_sanatized(file.stem):
-                raise FileNameNotSupported(
-                    f"Only `{''.join(kleinkram.utils.INTERNAL_ALLOWED_CHARS)}` are "
-                    f"allowed in filenames and at most 50 chars: {file}. "
-                    f"Consider using `--fix-filenames`"
-                )
+    # This function will raise an error if skip=False and a file is invalid
+    files_to_upload = validator.filter_files(original_file_paths)
+
+    _report_skipped_files(validator.skipped_files)
+
+    _handle_no_files_to_upload(original_count=len(original_file_paths), uploaded_count=len(files_to_upload))
 
     try:
         kleinkram.core.upload(
             client=AuthenticatedClient(),
             query=mission_query,
-            file_paths=file_paths,
+            file_paths=files_to_upload,
             create=create,
             metadata=load_metadata(Path(metadata)) if metadata else None,
             ignore_missing_metadata=ignore_missing_tags,
             verbose=get_shared_state().verbose,
         )
+        typer.echo(
+            typer.style(
+                f"\nSuccessfully uploaded {len(files_to_upload)} file(s).",
+                fg=typer.colors.GREEN,
+            )
+        )
+
     except MissionNotFound:
         if create:
             raise  # dont change the error message

kleinkram/cli/_verify.py

@@ -9,15 +9,14 @@ import typer
 
 import kleinkram.core
 from kleinkram.api.client import AuthenticatedClient
-from kleinkram.api.query import MissionQuery
-from kleinkram.api.query import ProjectQuery
+from kleinkram.cli._file_validator import FileValidator
+from kleinkram.cli._file_validator import _report_skipped_files
+from kleinkram.cli._upload import _build_mission_query
 from kleinkram.config import get_shared_state
 from kleinkram.printing import print_file_verification_status
-from kleinkram.utils import split_args
 
 logger = logging.getLogger(__name__)
 
-
 HELP = """\
 Verify if files were uploaded correctly.
 """
@@ -25,13 +24,36 @@ Verify if files were uploaded correctly.
 verify_typer = typer.Typer(name="verify", invoke_without_command=True, help=HELP)
 
 
+def _handle_no_files_to_process(original_count: int, processed_count: int, action: str = "verify") -> None:
+    """Checks if any files are left and exits if not."""
+    if processed_count > 0:
+        return
+
+    if original_count > 0:
+        typer.echo(
+            typer.style(f"All paths were skipped. No files to {action}.", fg=typer.colors.RED),
+            err=True,
+        )
+    else:
+        typer.echo(
+            typer.style(f"No files provided to {action}.", fg=typer.colors.RED),
+            err=True,
+        )
+    raise typer.Exit(code=1)
+
+
 @verify_typer.callback()
 def verify(
-    files: List[str] = typer.Argument(help="files to upload"),
-    project: Optional[str] = typer.Option(
-        None, "--project", "-p", help="project id or name"
-    ),
+    files: List[str] = typer.Argument(help="files to verify"),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="project id or name"),
     mission: str = typer.Option(..., "--mission", "-m", help="mission id or name"),
+    skip: bool = typer.Option(
+        False,
+        "--skip",
+        "-s",
+        help="skip unsupported file types, badly named files, or directories instead of erroring",
+    ),
+    experimental_datatypes: bool = typer.Option(False, help="allow experimental datatypes (yaml, svo2, db3, tum)"),
     skip_hash: bool = typer.Option(None, help="skip hash check"),
     check_file_hash: bool = typer.Option(
         True,
@@ -43,21 +65,32 @@ def verify(
     ),
 ) -> None:
     # get all filepaths
-    file_paths = [Path(file) for file in files]
+    original_file_paths = [Path(file) for file in files]
 
     # get mission query
-    mission_ids, mission_patterns = split_args([mission])
-    project_ids, project_patterns = split_args([project] if project else [])
-    project_query = ProjectQuery(ids=project_ids, patterns=project_patterns)
-    mission_query = MissionQuery(
-        ids=mission_ids, patterns=mission_patterns, project_query=project_query
+    mission_query = _build_mission_query(mission, project)
+
+    validator = FileValidator(
+        skip=skip,
+        experimental_datatypes=experimental_datatypes,
+    )
+    files_to_verify = validator.filter_files(original_file_paths)
+
+    # Report skipped files (if any)
+    _report_skipped_files(validator.skipped_files)
+
+    # Check if we have anything left to do
+    _handle_no_files_to_process(
+        original_count=len(original_file_paths),
+        processed_count=len(files_to_verify),
+        action="verify",
     )
 
     verbose = get_shared_state().verbose
     file_status = kleinkram.core.verify(
         client=AuthenticatedClient(),
         query=mission_query,
-        file_paths=file_paths,
+        file_paths=files_to_verify,
         skip_hash=skip_hash,
         check_file_hash=check_file_hash,
         check_file_size=check_file_size,

kleinkram/cli/app.py

@@ -19,12 +19,14 @@ from kleinkram.api.client import AuthenticatedClient
 from kleinkram.api.routes import _claim_admin
 from kleinkram.api.routes import _get_api_version
 from kleinkram.auth import login_flow
+from kleinkram.cli._action import action_typer
 from kleinkram.cli._download import download_typer
 from kleinkram.cli._endpoint import endpoint_typer
 from kleinkram.cli._file import file_typer
 from kleinkram.cli._list import list_typer
 from kleinkram.cli._mission import mission_typer
 from kleinkram.cli._project import project_typer
+from kleinkram.cli._run import run_typer
 from kleinkram.cli._upload import upload_typer
 from kleinkram.cli._verify import verify_typer
 from kleinkram.cli.error_handling import ErrorHandledTyper
@@ -59,7 +61,7 @@ Kleinkram CLI
 
 The Kleinkram CLI is a command line interface for Kleinkram.
 For a list of available commands, run `klein --help` or visit \
-https://docs.datasets.leggedrobotics.com/usage/python/getting-started.html \
+https://docs.datasets.leggedrobotics.com/usage/python/setup \
 for more information.
 """
 
@@ -85,6 +87,7 @@ class CommandTypes(str, Enum):
     AUTH = "Authentication Commands"
     CORE = "Core Commands"
     CRUD = "Create Update Delete Commands"
+    ACTION = "Kleinkram Action Commands"
 
 
 class OrderCommands(TyperGroup):
@@ -110,6 +113,8 @@ app.add_typer(list_typer, name="list", rich_help_panel=CommandTypes.CORE)
 app.add_typer(file_typer, name="file", rich_help_panel=CommandTypes.CRUD)
 app.add_typer(mission_typer, name="mission", rich_help_panel=CommandTypes.CRUD)
 app.add_typer(project_typer, name="project", rich_help_panel=CommandTypes.CRUD)
+app.add_typer(action_typer, name="action", rich_help_panel=CommandTypes.ACTION)
+app.add_typer(run_typer, name="run", rich_help_panel=CommandTypes.ACTION)
 
 
 # attach error handler to app
@@ -127,10 +132,42 @@ def base_handler(exc: Exception) -> int:
 
 @app.command(rich_help_panel=CommandTypes.AUTH)
 def login(
+    oAuthProvider: str = typer.Option(
+        "auto",
+        "--oauth-provider",
+        "-p",
+        help="OAuth provider to use for login. Supported providers: google, github, fake-oauth.",
+        show_default=True,
+    ),
     key: Optional[str] = typer.Option(None, help="CLI key"),
     headless: bool = typer.Option(False),
+    user: Optional[str] = typer.Option(
+        None,
+        "--user",
+        "-u",
+        help="Auto-select user ID for fake-oauth (e.g., 1, 2, 3). Only works with fake-oauth provider.",
+    ),
 ) -> None:
-    login_flow(key=key, headless=headless)
+
+    # logic to resolve the "auto" default
+    if oAuthProvider == "auto":
+        config = get_config()
+        if config.selected_endpoint == "local":
+            oAuthProvider = "fake-oauth"
+        else:
+            oAuthProvider = "google"
+
+    # validate oAuthProvider
+    if oAuthProvider not in ["google", "github", "fake-oauth"]:
+        raise typer.BadParameter(
+            f"Unsupported OAuth provider '{oAuthProvider}'. Supported providers: google, github, fake-oauth."
+        )
+
+    # validate that user parameter is only used with fake-oauth
+    if user is not None and oAuthProvider != "fake-oauth":
+        raise typer.BadParameter("--user parameter can only be used with fake-oauth provider")
+
+    login_flow(oAuthProvider=oAuthProvider, key=key, headless=headless, user=user)
 
 
 @app.command(rich_help_panel=CommandTypes.AUTH)
@@ -156,29 +193,35 @@ def _version_callback(value: bool) -> None:
         raise typer.Exit()
 
 
-def check_version_compatiblity() -> None:
+def check_version_compatibility() -> None:
     cli_version = get_supported_api_version()
     api_version = _get_api_version()
     api_vers_str = ".".join(map(str, api_version))
 
     if cli_version[0] != api_version[0]:
         raise InvalidCLIVersion(
-            f"CLI version {__version__} is not compatible with API version {api_vers_str}"
+            f"You are using an unsupported CLI version ({__version__}). "
+            f"Please upgrade the CLI to version {api_vers_str} to continue using the CLI."
         )
 
     if cli_version[1] != api_version[1]:
-        msg = f"CLI version {__version__} might not be compatible with API version {api_vers_str}"
-        Console(file=sys.stderr).print(msg, style="red")
-        logger.warning(msg)
+        if cli_version < api_version:
+            msg = f"You are using an outdated CLI version ({__version__}). "
+            msg += f"Please consider upgrading the CLI to version {api_vers_str}."
+            Console(file=sys.stderr).print(msg, style="red")
+            logger.warning(msg)
+        elif cli_version > api_version:
+            msg = f"You are using a CLI version ({__version__}) that is newer than the server version ({api_vers_str}). "
+            msg += "Please ask the admin to update the server."
+            Console(file=sys.stderr).print(msg, style="yellow")
+            logger.warning(msg)
 
 
 @app.callback()
 def cli(
     verbose: bool = typer.Option(True, help="Enable verbose mode."),
     debug: bool = typer.Option(False, help="Enable debug mode."),
-    version: Optional[bool] = typer.Option(
-        None, "--version", "-v", callback=_version_callback
-    ),
+    version: Optional[bool] = typer.Option(None, "--version", "-v", callback=_version_callback),
     log_level: Optional[LogLevel] = typer.Option(None, help="Set log level."),
     max_lines: int = typer.Option(
         MAX_TABLE_SIZE,
@@ -205,19 +248,15 @@ def cli(
         log_level = LogLevel.WARNING
 
     LOG_DIR.mkdir(parents=True, exist_ok=True)
-    logging.basicConfig(
-        level=LOG_LEVEL_MAP[log_level], filename=LOG_FILE, format=LOG_FORMAT
-    )
+    logging.basicConfig(level=LOG_LEVEL_MAP[log_level], filename=LOG_FILE, format=LOG_FORMAT)
     logger.info(f"CLI version: {__version__}")
 
     try:
-        check_version_compatiblity()
+        check_version_compatibility()
     except InvalidCLIVersion as e:
         logger.error(format_traceback(e))
         raise
     except Exception:
         err = "failed to check version compatibility"
-        Console(file=sys.stderr).print(
-            err, style="yellow" if shared_state.verbose else None
-        )
+        Console(file=sys.stderr).print(err, style="yellow" if shared_state.verbose else None)
         logger.error(err)

kleinkram/cli/error_handling.py

@@ -23,9 +23,7 @@ class ErrorHandledTyper(typer.Typer):
 
     _error_handlers: OrderedDict[Type[Exception], ExceptionHandler]
 
-    def error_handler(
-        self, exc: Type[Exception]
-    ) -> Callable[[ExceptionHandler], ExceptionHandler]:
+    def error_handler(self, exc: Type[Exception]) -> Callable[[ExceptionHandler], ExceptionHandler]:
         def dec(func: ExceptionHandler) -> ExceptionHandler:
             self._error_handlers[exc] = func
             return func

kleinkram/config.py

@@ -120,13 +120,9 @@ def _get_default_credentials() -> Dict[str, Credentials]:
 @dataclass
 class Config:
     version: str = __version__
-    selected_endpoint: str = field(
-        default_factory=lambda: _get_default_selected_endpoint().name
-    )
+    selected_endpoint: str = field(default_factory=lambda: _get_default_selected_endpoint().name)
     endpoints: Dict[str, Endpoint] = field(default_factory=_get_default_endpoints)
-    endpoint_credentials: Dict[str, Credentials] = field(
-        default_factory=_get_default_credentials
-    )
+    endpoint_credentials: Dict[str, Credentials] = field(default_factory=_get_default_credentials)
 
     @property
     def endpoint(self) -> Endpoint:
@@ -149,9 +145,7 @@ def _config_to_dict(config: Config) -> Dict[str, Any]:
     return {
         "version": config.version,
         "endpoints": {key: value._asdict() for key, value in config.endpoints.items()},
-        "endpoint_credentials": {
-            key: value._asdict() for key, value in config.endpoint_credentials.items()
-        },
+        "endpoint_credentials": {key: value._asdict() for key, value in config.endpoint_credentials.items()},
         "selected_endpoint": config.endpoint.name,
     }
 
@@ -161,16 +155,11 @@ def _config_from_dict(dct: Dict[str, Any]) -> Config:
         dct["version"],
         dct["selected_endpoint"],
         {key: Endpoint(**value) for key, value in dct["endpoints"].items()},
-        {
-            key: Credentials(**value)
-            for key, value in dct["endpoint_credentials"].items()
-        },
+        {key: Credentials(**value) for key, value in dct["endpoint_credentials"].items()},
     )
 
 
-def _safe_config_write(
-    config: Config, path: Path, tmp_dir: Optional[Path] = None
-) -> None:
+def _safe_config_write(config: Config, path: Path, tmp_dir: Optional[Path] = None) -> None:
     fd, temp_path = tempfile.mkstemp(dir=tmp_dir)
     with os.fdopen(fd, "w") as f:
         json.dump(_config_to_dict(config), f)
@@ -248,11 +237,7 @@ def endpoint_table(config: Config) -> Table:
     table.add_column("S3", style="cyan")
 
     for name, endpoint in config.endpoints.items():
-        display_name = (
-            Text(f"* {name}", style="bold yellow")
-            if name == config.selected_endpoint
-            else Text(f"  {name}")
-        )
+        display_name = Text(f"* {name}", style="bold yellow") if name == config.selected_endpoint else Text(f"  {name}")
         table.add_row(display_name, endpoint.api, endpoint.s3)
     return table