divbase-cli 0.1.0.dev2__py3-none-any.whl → 0.1.0.dev3__py3-none-any.whl

divbase_cli/cli_commands/task_history_cli.py

@@ -6,11 +6,9 @@ Submits a query for fetching the Celery task history for the user to the DivBase
 """
 
 import logging
-from pathlib import Path
 
 import typer
 
-from divbase_cli.cli_commands.user_config_cli import CONFIG_FILE_OPTION
 from divbase_cli.cli_exceptions import AuthenticationError
 from divbase_cli.display_task_history import TaskHistoryDisplayManager
 from divbase_cli.user_auth import make_authenticated_request
@@ -28,7 +26,6 @@ task_history_app = typer.Typer(
 
 @task_history_app.command("user")
 def list_task_history_for_user(
-    config_file: Path = CONFIG_FILE_OPTION,
     limit: int = typer.Option(10, help="Maximum number of tasks to display in the terminal. Sorted by recency."),
     project: str | None = typer.Option(
         None, help="Optional project name to filter the user's task history by project."
@@ -40,7 +37,7 @@ def list_task_history_for_user(
 
     # TODO add option to sort ASC/DESC by task timestamp
 
-    config = load_user_config(config_file)
+    config = load_user_config()
     logged_in_url = config.logged_in_url
 
     if not logged_in_url:
@@ -73,13 +70,12 @@ def list_task_history_for_user(
 @task_history_app.command("id")
 def task_history_by_id(
     task_id: int | None = typer.Argument(..., help="Task ID to check the status of a specific query job."),
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """
     Check status of a specific task submitted by the user by its task ID.
     """
 
-    config = load_user_config(config_file)
+    config = load_user_config()
     logged_in_url = config.logged_in_url
 
     if not logged_in_url:
@@ -104,7 +100,6 @@ def task_history_by_id(
 
 @task_history_app.command("project")
 def list_task_history_for_project(
-    config_file: Path = CONFIG_FILE_OPTION,
     limit: int = typer.Option(10, help="Maximum number of tasks to display in the terminal. Sorted by recency."),
     project: str = typer.Argument(..., help="Project name to check the task history for."),
 ):
@@ -115,7 +110,7 @@ def list_task_history_for_project(
     # TODO add option to sort ASC/DESC by task timestamp
     # TODO use default project from config if not --project specified
 
-    config = load_user_config(config_file)
+    config = load_user_config()
     logged_in_url = config.logged_in_url
 
     if not logged_in_url:

divbase_cli/cli_commands/user_config_cli.py

@@ -4,8 +4,6 @@ config subcommand for the divbase-cli package.
 Controls the user config file stored at "~/.config/.divbase_tools.yaml" (unless specified otherwise).
 """
 
-from pathlib import Path
-
 import typer
 from rich import print
 from rich.console import Console
@@ -13,34 +11,12 @@ from rich.table import Table
 
 from divbase_cli.cli_config import cli_settings
 from divbase_cli.user_config import (
-    create_user_config,
     load_user_config,
 )
 
-CONFIG_FILE_OPTION = typer.Option(
-    cli_settings.CONFIG_PATH,
-    "--config",
-    "-c",
-    help="Path to your user configuration file. If you didn't specify a custom path when you created it, you don't need to set this.",
-)
-
 config_app = typer.Typer(help="Manage your user configuration file for the DivBase CLI.", no_args_is_help=True)
 
 
-@config_app.command("create")
-def create_user_config_command(
-    config_file: Path = typer.Option(
-        cli_settings.CONFIG_PATH,
-        "--config",
-        "-c",
-        help="Where to store your config file locally on your pc.",
-    ),
-):
-    """Create a user configuration file for divbase-cli."""
-    create_user_config(config_path=config_file)
-    print(f"User configuration file created at {config_file.resolve()}.")
-
-
 @config_app.command("add")
 def add_project_command(
     name: str = typer.Argument(..., help="Name of the project to add to your config file."),
@@ -56,17 +32,16 @@ def add_project_command(
         "-d",
         help="Set this project as the default project in your config file.",
     ),
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Add a new project to your user configuration file."""
-    config = load_user_config(config_file)
+    config = load_user_config()
     project = config.add_project(
         name=name,
         divbase_url=divbase_url,
         is_default=make_default,
     )
 
-    print(f"Project: '{project.name}' added to your config file located at {config_file.resolve()}.")
+    print(f"Project: '{project.name}' added to your config.")
     print(f"The URL: {project.divbase_url} was set as the DivBase API URL for this project.")
 
     if make_default:
@@ -75,17 +50,16 @@ def add_project_command(
         print(f"To make '{project.name}' your default project you can run: 'divbase config set-default {project.name}'")
 
 
-@config_app.command("remove")
+@config_app.command("rm")
 def remove_project_command(
     name: str = typer.Argument(..., help="Name of the project to remove from your user configuration file."),
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Remove a project from your user configuration file."""
-    config = load_user_config(config_file)
+    config = load_user_config()
     removed_project = config.remove_project(name)
 
     if not removed_project:
-        print(f"The project '{name}' was not found in your config file located at {config_file.resolve()}.")
+        print(f"Nothing to do, the project '{name}' was not found in your user config")
     else:
         print(f"The project '{removed_project}' was removed from your config.")
 
@@ -93,20 +67,17 @@ def remove_project_command(
 @config_app.command("set-default")
 def set_default_project_command(
     name: str = typer.Argument(..., help="Name of the project to add to the user configuration file."),
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Set your default project to use in all divbase-cli commands."""
-    config = load_user_config(config_file)
+    config = load_user_config()
     default_project_name = config.set_default_project(name=name)
     print(f"Default project is now set to '{default_project_name}'.")
 
 
 @config_app.command("show-default")
-def show_default_project_command(
-    config_file: Path = CONFIG_FILE_OPTION,
-) -> None:
+def show_default_project_command() -> None:
     """Print the currently set default project to the console."""
-    config = load_user_config(config_file)
+    config = load_user_config()
 
     if config.default_project:
         print(config.default_project)
@@ -123,10 +94,9 @@ def set_default_dload_dir_command(
         You can specify an absolute path. 
         You can use '.' to refer to the directory you run the command from.""",
     ),
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Set the default download dir"""
-    config = load_user_config(config_file)
+    config = load_user_config()
     dload_dir = config.set_default_download_dir(download_dir=download_dir)
     if dload_dir == ".":
         print("The default download directory will be whereever you run the command from.")
@@ -135,14 +105,14 @@ def set_default_dload_dir_command(
 
 
 @config_app.command("show")
-def show_user_config(
-    config_file: Path = CONFIG_FILE_OPTION,
-):
+def show_user_config():
     """Pretty print the contents of your current config file."""
-    config = load_user_config(config_file)
+    config = load_user_config()
     console = Console()
 
-    console.print(f"[bold]Your DivBase user configuration file's contents located at:[/bold] '{config_file}'")
+    console.print(
+        f"[bold]Your DivBase user configuration file's contents located at:[/bold] '{cli_settings.CONFIG_PATH.resolve()}'\n"
+    )
 
     if not config.default_download_dir:
         dload_dir_info = "Not specified, meaning the working directory of wherever you run the download command from."

divbase_cli/cli_commands/version_cli.py

@@ -1,28 +1,21 @@
 """CLI commands for managing project versions in DivBase."""
 
 from datetime import datetime
-from pathlib import Path
 from zoneinfo import ZoneInfo
 
 import typer
 from rich import print
-from rich.console import Console
 from rich.table import Table
 
-from divbase_cli.cli_commands.user_config_cli import CONFIG_FILE_OPTION
+from divbase_cli.cli_commands.shared_args_options import FORMAT_AS_TSV_OPTION, PROJECT_NAME_OPTION
 from divbase_cli.config_resolver import ensure_logged_in, resolve_project
-from divbase_cli.services import (
+from divbase_cli.services.project_versions import (
     add_version_command,
     delete_version_command,
     get_version_details_command,
     list_versions_command,
 )
-
-PROJECT_NAME_OPTION = typer.Option(
-    None,
-    help="Name of the DivBase project, if not provided uses the default in your DivBase config file",
-    show_default=False,
-)
+from divbase_cli.utils import print_rich_table_as_tsv
 
 version_app = typer.Typer(
     no_args_is_help=True,
@@ -42,11 +35,10 @@ def add_version(
     name: str = typer.Argument(help="Name of the version (e.g., semantic version).", show_default=False),
     description: str = typer.Option("", help="Optional description of the version."),
     project: str | None = PROJECT_NAME_OPTION,
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Add a new project version entry which specifies the current state of all files in the project at the current timestamp."""
-    project_config = resolve_project(project_name=project, config_path=config_file)
-    logged_in_url = ensure_logged_in(config_path=config_file, desired_url=project_config.divbase_url)
+    project_config = resolve_project(project_name=project)
+    logged_in_url = ensure_logged_in(desired_url=project_config.divbase_url)
 
     add_version_response = add_version_command(
         name=name,
@@ -60,8 +52,8 @@ def add_version(
 @version_app.command("list")
 def list_versions(
     project: str | None = PROJECT_NAME_OPTION,
-    config_file: Path = CONFIG_FILE_OPTION,
     include_deleted: bool = typer.Option(False, help="Include soft-deleted versions in the listing."),
+    format_output_as_tsv: bool = FORMAT_AS_TSV_OPTION,
 ):
     """
     List all entries in the project versioning file.
@@ -70,8 +62,8 @@ def list_versions(
     If you specify --include-deleted, soft-deleted versions will also be shown.
     Soft-deleted versions can be restored by a DivBase admin within 30 days of deletion.
     """
-    project_config = resolve_project(project_name=project, config_path=config_file)
-    logged_in_url = ensure_logged_in(config_path=config_file, desired_url=project_config.divbase_url)
+    project_config = resolve_project(project_name=project)
+    logged_in_url = ensure_logged_in(desired_url=project_config.divbase_url)
 
     versions_info = list_versions_command(
         project_name=project_config.name, include_deleted=include_deleted, divbase_base_url=logged_in_url
@@ -81,7 +73,6 @@ def list_versions(
         print(f"No versions found for project: {project_config.name}.")
         return
 
-    console = Console()
     table = Table(title=f"Versions for {project_config.name}")
     table.add_column("Version", style="cyan", no_wrap=True)
     table.add_column("Created ", style="magenta")
@@ -99,18 +90,20 @@ def list_versions(
         else:
             table.add_row(name, created_at, desc)
 
-    console.print(table)
+    if not format_output_as_tsv:
+        print(table)
+    else:
+        print_rich_table_as_tsv(table=table)
 
 
 @version_app.command("info")
 def get_version_info(
     version: str = typer.Argument(help="Specific version to retrieve information for"),
     project: str | None = PROJECT_NAME_OPTION,
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """Provide detailed information about a user specified project version, including all files present and their unique hashes."""
-    project_config = resolve_project(project_name=project, config_path=config_file)
-    logged_in_url = ensure_logged_in(config_path=config_file, desired_url=project_config.divbase_url)
+    project_config = resolve_project(project_name=project)
+    logged_in_url = ensure_logged_in(desired_url=project_config.divbase_url)
 
     version_details = get_version_details_command(
         project_name=project_config.name, divbase_base_url=logged_in_url, version_name=version
@@ -133,15 +126,14 @@ def get_version_info(
 def delete_version(
     name: str = typer.Argument(help="Name of the version (e.g., semantic version).", show_default=False),
     project: str | None = PROJECT_NAME_OPTION,
-    config_file: Path = CONFIG_FILE_OPTION,
 ):
     """
     Delete a version entry in the project versioning table. This does not delete the files themselves.
     Deleted version entries older than 30 days will be permanently deleted.
     You can ask a DivBase admin to restore a deleted version within that time period.
     """
-    project_config = resolve_project(project_name=project, config_path=config_file)
-    logged_in_url = ensure_logged_in(config_path=config_file, desired_url=project_config.divbase_url)
+    project_config = resolve_project(project_name=project)
+    logged_in_url = ensure_logged_in(desired_url=project_config.divbase_url)
 
     deleted_version = delete_version_command(
         project_name=project_config.name, divbase_base_url=logged_in_url, version_name=name

divbase_cli/cli_config.py

@@ -2,16 +2,24 @@
 Settings for DivBase CLI.
 
 This class creates a single 'settings' object at module load time that can be imported and used throughout the entire package.
+
+The user config and tokens are stored in the user local app dir:
+https://typer.tiangolo.com/tutorial/app-dir/
 """
 
 import os
 from dataclasses import dataclass
 from pathlib import Path
 
-DEFAULT_CONFIG_PATH = Path.home() / ".config" / "divbase" / "config.yaml"
-DEFAULT_TOKENS_PATH = Path.home() / ".config" / "divbase" / ".secrets"
+import typer
+
+APP_NAME = "divbase-cli"
+APP_DIR = Path(typer.get_app_dir(APP_NAME))
+CONFIG_PATH = APP_DIR / "config.yaml"
+TOKENS_PATH = APP_DIR / ".secrets"
 DEFAULT_METADATA_TSV_NAME = "sample_metadata.tsv"
-DEFAULT_DIVBASE_API_URL = "http://localhost:8000/api"  # TODO - change to production URL when time comes
+# TODO - change to production URL when time comes
+DEFAULT_DIVBASE_API_URL = "https://divbase-dev.scilifelab-2-dev.sys.kth.se/api/"
 
 
 @dataclass
@@ -19,12 +27,12 @@ class DivBaseCLISettings:
     """
     Settings for DivBase CLI.
 
-    NOTE: Do not create an instance of this class yourself,
-    import the 'settings' instance created at this module's load time.
+    Your do not need to create an instance of this class yourself,
+    instead, import the 'cli_settings' instance created at this module's load time.
     """
 
-    CONFIG_PATH: Path = Path(os.getenv("DIVBASE_CONFIG_PATH", DEFAULT_CONFIG_PATH))
-    TOKENS_PATH: Path = Path(os.getenv("DIVBASE_TOKENS_PATH", DEFAULT_TOKENS_PATH))
+    CONFIG_PATH: Path = Path(os.getenv("DIVBASE_CLI_CONFIG_PATH", CONFIG_PATH))
+    TOKENS_PATH: Path = Path(os.getenv("DIVBASE_CLI_TOKENS_PATH", TOKENS_PATH))
     DIVBASE_API_URL: str = os.getenv("DIVBASE_API_URL", DEFAULT_DIVBASE_API_URL)
     METADATA_TSV_NAME: str = os.getenv("DIVBASE_METADATA_TSV_NAME", DEFAULT_METADATA_TSV_NAME)
     LOGGING_ON: bool = bool(os.getenv("DIVBASE_LOGGING_ON", "True") == "True")
@@ -35,5 +43,8 @@ class DivBaseCLISettings:
         if self.LOG_LEVEL not in valid_levels:
             raise ValueError(f"Invalid LOG_LEVEL: {self.LOG_LEVEL}. Must be one of {valid_levels}.")
 
+        if self.DIVBASE_API_URL.endswith("/"):
+            self.DIVBASE_API_URL = self.DIVBASE_API_URL[:-1]
+
 
 cli_settings = DivBaseCLISettings()

divbase_cli/cli_exceptions.py

@@ -4,7 +4,7 @@ Custom exceptions for the divbase CLI.
 
 from pathlib import Path
 
-from divbase_lib.api_schemas.s3 import ExistingFileResponse
+from divbase_lib.divbase_constants import SUPPORTED_DIVBASE_FILE_TYPES, UNSUPPORTED_CHARACTERS_IN_FILENAMES
 
 
 class DivBaseCLIError(Exception):
@@ -41,7 +41,7 @@ class DivBaseAPIError(DivBaseCLIError):
         self,
         error_details: str = "Not Provided",
         error_type: str = "unknown",
-        status_code: int = None,
+        status_code: int = 500,
         http_method: str = "unknown",
         url: str = "unknown",
     ):
@@ -87,8 +87,10 @@ class FilesAlreadyInProjectError(DivBaseCLIError):
     and the user does not want to accidently create a new version of any file.
     """
 
-    def __init__(self, existing_files: list[ExistingFileResponse], project_name: str):
-        files_list = "\n".join(f"- '{obj.object_name}'" for obj in existing_files)
+    def __init__(self, existing_files: dict[Path, str], project_name: str):
+        files_list = "\n".join(
+            f"'{file_path}' (Checksum: {checksum})" for file_path, checksum in existing_files.items()
+        )
         self.existing_files = existing_files
         self.project_name = project_name
 
@@ -106,12 +108,12 @@ class ProjectNameNotSpecifiedError(DivBaseCLIError):
     no default project is set in the user config file.
     """
 
-    def __init__(self, config_path: Path):
-        self.config_path = config_path
+    def __init__(self):
         error_message = (
-            "No project name provided. \n"
-            f"Please either set a default project in your user configuration file at '{config_path.resolve()}'.\n"
-            f"or pass the flag '--project <project_name>' to this command.\n"
+            "No project name provided.\n"
+            "Please either set a default project in your user configuration file.\n"
+            "or pass the flag '--project <project_name>' to this command.\n"
+            "To set a default project, you can run 'divbase-cli config set-default <project_name>'.\n"
         )
         super().__init__(error_message)
 
@@ -135,17 +137,30 @@ class ProjectNotInConfigError(DivBaseCLIError):
         super().__init__(error_message)
 
 
-class ConfigFileNotFoundError(DivBaseCLIError):
-    """Raised when the user's config file cannot be found."""
+class UnsupportedFileTypeError(DivBaseCLIError):
+    """Raised when one or more files to be uploaded are not supported by DivBase (based on file extension)."""
 
-    def __init__(
-        self,
-        error_message: str = (
-            "You're DivBase configuration file was not found or does not exist.\n"
-            "To create a user configuration file, run 'divbase-cli config create'.\n"
-            "If you already have a user configuration file that but it is not stored in the default location, "
-            "you can pass the '--config <path>' flag to specify the location. \n"
-            "You very probably want to just run 'divbase-cli config create' though."
-        ),
-    ):
-        super().__init__(error_message)
+    def __init__(self, unsupported_files: list[Path], supported_types: tuple[str, ...] = SUPPORTED_DIVBASE_FILE_TYPES):
+        self.unsupported_files = unsupported_files
+        self.supported_types = supported_types
+        message = (
+            f"The following file(s) have types that are not supported by DivBase and therefore cannot be uploaded: \n"
+            f"{'\n'.join(str(file) for file in unsupported_files)}\n"
+            f"DivBase currently supports the following file types: {', '.join(SUPPORTED_DIVBASE_FILE_TYPES)}\n"
+            "If you want us to support another file type, please let us know."
+        )
+        super().__init__(message)
+
+
+class UnsupportedFileNameError(DivBaseCLIError):
+    """Raised when one or more files to be uploaded have unsupported characters in their filenames."""
+
+    def __init__(self, unsupported_files: list[Path]):
+        self.unsupported_files = unsupported_files
+        message = (
+            f"The following file(s) have unsupported characters in their filenames and therefore cannot be uploaded: \n"
+            f"{'\n'.join(str(file) for file in unsupported_files)}\n"
+            f"Filenames cannot contain any of the following characters: {', '.join(UNSUPPORTED_CHARACTERS_IN_FILENAMES)}\n"
+            "Please rename the files and try again."
+        )
+        super().__init__(message)

divbase_cli/config_resolver.py

@@ -3,7 +3,7 @@ Functions that resolve for the CLI commands things like:
     - which project to use
     - which download directory to use
     - which DivBase API URL to use
-Based on provider user input and their config file.
+Based on provided user input and their config file.
 """
 
 from pathlib import Path
@@ -12,7 +12,7 @@ from divbase_cli.cli_exceptions import AuthenticationError, ProjectNameNotSpecif
 from divbase_cli.user_config import ProjectConfig, load_user_config
 
 
-def ensure_logged_in(config_path: Path, desired_url: str | None = None) -> str:
+def ensure_logged_in(desired_url: str | None = None) -> str:
     """
     Ensure the user is logged in by checking the logged_in_url value in the user config.
 
@@ -20,7 +20,7 @@ def ensure_logged_in(config_path: Path, desired_url: str | None = None) -> str:
 
     Returns the logged_in_url if valid, otherwise raises an AuthenticationError.
     """
-    config = load_user_config(config_path)
+    config = load_user_config()
     if not config.logged_in_url:
         raise AuthenticationError("You are not logged in. Please log in with 'divbase-cli auth login [EMAIL]'.")
     if desired_url and config.logged_in_url != desired_url:
@@ -30,7 +30,7 @@ def ensure_logged_in(config_path: Path, desired_url: str | None = None) -> str:
     return config.logged_in_url
 
 
-def resolve_project(project_name: str | None, config_path: Path) -> ProjectConfig:
+def resolve_project(project_name: str | None) -> ProjectConfig:
     """
     Helper function to resolve the project to use for a CLI command.
     Falls back to the default project set in the user config if not explicitly provided.
@@ -38,15 +38,15 @@ def resolve_project(project_name: str | None, config_path: Path) -> ProjectConfi
     Once the project is resolved a ProjectConfig object is returned,
     which contains the name and API URL of the project.
     """
-    config = load_user_config(config_path)
+    config = load_user_config()
     if not project_name:
         project_name = config.default_project
     if not project_name:
-        raise ProjectNameNotSpecifiedError(config_path=config_path)
+        raise ProjectNameNotSpecifiedError()
     return config.project_info(project_name)
 
 
-def resolve_divbase_api_url(url: str | None, config_path: Path) -> str:
+def resolve_divbase_api_url(url: str | None) -> str:
     """
     Helper function to resolve the DivBase API URL to use for a CLI command.
 
@@ -56,7 +56,7 @@ def resolve_divbase_api_url(url: str | None, config_path: Path) -> str:
     if url:
         return url
 
-    config = load_user_config(config_path=config_path)
+    config = load_user_config()
 
     if not config.default_project:
         raise ValueError(
@@ -68,7 +68,7 @@ def resolve_divbase_api_url(url: str | None, config_path: Path) -> str:
     return project_config.divbase_url
 
 
-def resolve_download_dir(download_dir: str | None, config_path: Path) -> Path:
+def resolve_download_dir(download_dir: str | None) -> Path:
     """
     Helper function to resolve the download directory to use for a CLI command involving downloading files.
 
@@ -76,7 +76,7 @@ def resolve_download_dir(download_dir: str | None, config_path: Path) -> Path:
     Note: "." or None should default to the current working directory.
     """
     if not download_dir:
-        config = load_user_config(config_path)
+        config = load_user_config()
         download_dir = config.default_download_dir
 
     if download_dir and download_dir != ".":

divbase_cli/divbase_cli.py

@@ -67,7 +67,7 @@ app.add_typer(task_history_app, name="task-history")
 
 def main():
     if cli_settings.LOGGING_ON:
-        logging.basicConfig(level=cli_settings.LOG_LEVEL, handlers=[logging.StreamHandler(sys.stdout)])
+        logging.basicConfig(level=cli_settings.LOG_LEVEL, handlers=[logging.StreamHandler(sys.stderr)])
         logger.info(f"Starting divbase_cli CLI application with logging level: {cli_settings.LOG_LEVEL}")
     app()
 

divbase_cli/retries.py

@@ -0,0 +1,34 @@
+"""
+Retry logic for the divbase-cli package.
+
+Defines functions to determine whether to retry based on the type of exceptions raised.
+Functions are used in stamina (package) decorators.
+"""
+
+import httpx
+
+from divbase_cli.cli_exceptions import DivBaseAPIConnectionError, DivBaseAPIError
+
+
+def retry_only_on_retryable_http_errors(exc: Exception) -> bool:
+    """
+    Used by stamina's (library for retries) decorators to determine whether to retry the function or not.
+    We avoid retrying on HTTPStatusError for 4xx errors as no point (e.g. 404 Not Found or 403 Forbidden etc...).
+    """
+    if isinstance(exc, httpx.HTTPStatusError):
+        return exc.response.status_code >= 500
+
+    # Want to retry on other HTTPError (parent of HTTPStatusError),
+    # as this includes timeouts, connection errors, etc.
+    return isinstance(exc, httpx.HTTPError)
+
+
+def retry_only_on_retryable_divbase_api_errors(exception: Exception) -> bool:
+    """
+    Retry condition function for stamina to only retry on retryable DivBase API errors.
+    """
+    if isinstance(exception, DivBaseAPIConnectionError):
+        return True
+
+    # Retry only for server errors (5xx) and rate limiting (429)
+    return isinstance(exception, DivBaseAPIError) and (exception.status_code == 429 or exception.status_code >= 500)