divbase-cli 0.1.0a1__py3-none-any.whl

divbase_cli/display_task_history.py

@@ -0,0 +1,197 @@
+import logging
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+from rich.console import Console
+from rich.table import Table
+
+from divbase_cli.utils import print_rich_table_as_tsv
+from divbase_lib.api_schemas.task_history import (
+    BcftoolsQueryTaskResult,
+    DimensionUpdateTaskResult,
+    SampleMetadataQueryTaskResult,
+    TaskHistoryResult,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TaskHistoryDisplayManager:
+    """
+    A class that manages displaying task history results to the user's terminal.
+    """
+
+    STATE_COLOURS = {
+        "SUCCESS": "green",
+        "FAILURE": "red",
+        "PENDING": "yellow",
+        "STARTED": "blue",
+        "RETRY": "blue",
+        "REVOKED": "magenta",
+    }
+    # These are the states known by the worker. The state when a task is in the queue is handled by the broker and PENDING is typically used for that purpose.
+    # For user display purposes, we want to show QUEUING instead of PENDING for tasks that are not yet started.
+    # To avoid having separate CRUD logic for the enqueued state, check task status against the worker state and return QUEUING to user's terminal.
+    CELERY_STATES_EXCLUDING_PENDING = {"STARTED", "SUCCESS", "FAILURE", "RETRY", "REVOKED"}
+
+    def __init__(
+        self,
+        task_items: list[TaskHistoryResult],
+        user_email: str | None,
+        project_name: str | None,
+        mode: str,
+        display_limit: int = 10,
+        format_output_as_tsv: bool = False,
+    ):
+        self.task_items = task_items
+        self.user_email = user_email
+        self.project_name = project_name
+        self.mode = mode
+        self.display_limit = display_limit
+        self.format_output_as_tsv = format_output_as_tsv
+
+    def print_task_history(self) -> None:
+        """Display the task history fetched from the results backend in a formatted table."""
+
+        sorted_tasks = sorted(self.task_items, key=lambda x: x.created_at or "", reverse=True)
+        display_limit = self.display_limit
+        limited_tasks = sorted_tasks[:display_limit]
+
+        table = self._create_task_history_table()
+
+        for task in limited_tasks:
+            raw_status = task.status
+            if raw_status and raw_status.upper() in self.CELERY_STATES_EXCLUDING_PENDING:
+                state = raw_status.upper()
+            else:
+                state = "QUEUING"
+
+            if self.format_output_as_tsv:
+                state_with_colour = state
+            else:
+                colour = self.STATE_COLOURS.get(state, "white")
+                state_with_colour = f"[{colour}]{state}[/{colour}]"
+
+            submitter = task.submitter_email or "Unknown"
+            result = self._format_result(task, state)
+
+            table.add_row(
+                submitter,
+                str(task.id),
+                state_with_colour,
+                self._to_cet(task.created_at),
+                self._to_cet(task.started_at),
+                str(task.runtime if task.runtime is not None else "N/A"),
+                result,
+            )
+
+        if self.format_output_as_tsv:
+            print_rich_table_as_tsv(table=table)
+        else:
+            console = Console()
+            console.print(table)
+
+    def _create_task_history_table(self):
+        """
+        Use the Rich library to initiate a table for displaying task history.
+        """
+        title_prefix = "DivBase Task History"
+        if self.mode == "user":
+            title = f"{title_prefix} for User: {self.user_email or 'Unknown'}"
+        elif self.mode == "user_project":
+            title = (
+                f"{title_prefix} for User: {self.user_email or 'Unknown'} and Project: {self.project_name or 'Unknown'}"
+            )
+        elif self.mode == "id":
+            title = f"{title_prefix} for Task ID: {self.task_items[0].id if self.task_items else 'Unknown'}"
+        elif self.mode == "project":
+            title = f"{title_prefix} for Project: {self.project_name or 'Unknown'}"
+        else:
+            title = title_prefix
+
+        table = Table(title=title, show_lines=True)
+        table.add_column("Submitting user", width=12, overflow="fold")
+        table.add_column("Task ID", style="cyan")
+        table.add_column("State", width=8)
+        table.add_column("Created at", style="yellow", width=19, overflow="fold")
+        table.add_column("Started at", style="yellow", width=19, overflow="fold")
+        table.add_column("Runtime (s)", style="blue", width=10, overflow="fold")
+        table.add_column("Result", style="white", width=35, overflow="fold")
+        return table
+
+    def _format_result(self, task, state):
+        """
+        Format the result message based on the task state and type.
+        """
+        colour = self.STATE_COLOURS.get(state, "white")
+
+        if state == "FAILURE":
+            if isinstance(task.result, dict):
+                error_msg = task.result.get("error")
+                if not error_msg:
+                    exc_message = task.result.get("exc_message")
+                    if isinstance(exc_message, list) and exc_message:
+                        error_msg = " ".join(str(msg) for msg in exc_message)
+                    elif exc_message:
+                        error_msg = str(exc_message)
+                if not error_msg:
+                    exc_type = task.result.get("exc_type")
+                    error_msg = exc_type if exc_type else "Unknown error"
+            else:
+                error_msg = str(task.result) or "Unknown error"
+
+            return self._colourize_if_enabled(str(error_msg), colour)
+
+        if isinstance(task.result, BcftoolsQueryTaskResult):
+            result_message = f"Output file ready for download: {task.result.output_file}"
+            return self._colourize_if_enabled(result_message, colour)
+
+        elif isinstance(task.result, SampleMetadataQueryTaskResult):
+            result_message = (
+                f"Unique sample IDs:\n  {task.result.unique_sample_ids}\n"
+                f"VCF files containing the sample IDs:\n  {task.result.unique_filenames}\n"
+                f"Sample metadata query:\n  {task.result.query_message}"
+            )
+            return self._colourize_if_enabled(result_message, colour)
+
+        elif isinstance(task.result, DimensionUpdateTaskResult):
+            result_message = (
+                f"VCF file dimensions index added or updated:\n  {task.result.VCF_files_added}\n"
+                f"VCF files skipped by this job (previous DivBase-generated result VCFs):\n  {task.result.VCF_files_skipped}\n"
+                f"VCF files that have been deleted from the project and now are dropped from the index:\n  {task.result.VCF_files_deleted}"
+            )
+            return self._colourize_if_enabled(result_message, colour)
+
+        if isinstance(task.result, dict) and ("exc_type" in task.result or "error" in task.result):
+            # Handle any remaining error dicts that weren't caught by FAILURE state check
+            error_msg = task.result.get("error")
+            if not error_msg:
+                exc_message = task.result.get("exc_message")
+                if isinstance(exc_message, list) and exc_message:
+                    error_msg = " ".join(str(msg) for msg in exc_message)
+                elif exc_message:
+                    error_msg = str(exc_message)
+                else:
+                    error_msg = task.result.get("exc_type", "Unknown error")
+            return self._colourize_if_enabled(str(error_msg), colour)
+
+        result_message = str(task.result)
+        return self._colourize_if_enabled(result_message, colour)
+
+    def _colourize_if_enabled(self, text: str, colour: str) -> str:
+        if self.format_output_as_tsv:
+            return text
+        return f"[{colour}]{text}[/{colour}]"
+
+    def _to_cet(self, timestamp_str):
+        """
+        Convert a UTC timestamp string in '%Y-%m-%d %H:%M:%S UTC' format to CET.
+        """
+        if not timestamp_str or timestamp_str == "N/A":
+            return "N/A"
+        try:
+            dt = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S %Z")
+            cet_dt = dt.astimezone(ZoneInfo("Europe/Stockholm"))
+            return cet_dt.strftime("%Y-%m-%d %H:%M:%S %Z")
+        except Exception:
+            return timestamp_str

divbase_cli/divbase_cli.py

@@ -0,0 +1,76 @@
+"""
+The entry point for the DivBase CLI tool that lets users interact with DivBase project.
+"""
+
+import logging
+import sys
+
+import typer
+
+from divbase_cli import __version__
+from divbase_cli.cli_commands.auth_cli import auth_app
+from divbase_cli.cli_commands.dimensions_cli import dimensions_app
+from divbase_cli.cli_commands.file_cli import file_app
+from divbase_cli.cli_commands.query_cli import query_app
+from divbase_cli.cli_commands.task_history_cli import task_history_app
+from divbase_cli.cli_commands.user_config_cli import config_app
+from divbase_cli.cli_commands.version_cli import version_app
+from divbase_cli.cli_config import cli_settings
+
+logger = logging.getLogger(__name__)
+
+
+app = typer.Typer(
+    help="""
+    This tool lets you interact with your DivBase project(s) in order to: \n
+        - Query the metadata for the VCF files stored in the project. \n
+        - Upload/download files to/from the project. \n
+        - Version the state of all files in the entire project at a given timestamp.
+    """,
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def version_callback(show_version: bool) -> None:
+    """
+    Callback function to display the installed version of the divbase-cli package.
+    See https://typer.tiangolo.com/tutorial/options/version/#fix-with-is_eager
+    """
+    if show_version:
+        typer.echo(f"divbase-cli version: {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def show_installed_version(
+    show_version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the currently installed version of the divbase-cli package.",
+    ),
+) -> None:
+    pass
+
+
+app.add_typer(version_app, name="version")
+app.add_typer(file_app, name="files")
+app.add_typer(config_app, name="config")
+app.add_typer(query_app, name="query")
+app.add_typer(dimensions_app, name="dimensions")
+app.add_typer(auth_app, name="auth")
+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.stderr)])
+        logger.info(f"Starting divbase_cli CLI application with logging level: {cli_settings.LOG_LEVEL}")
+    app()
+
+
+if __name__ == "__main__":
+    main()

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)

divbase_cli/services/announcements.py

@@ -0,0 +1,46 @@
+"""
+Get announcements from divbase API and display them to the user.
+"""
+
+from rich import print
+
+from divbase_cli.user_auth import make_unauthenticated_request
+from divbase_lib.api_schemas.announcements import AnnouncementResponse
+
+COLOR_MAPPING = {
+    "info": "blue",
+    "success": "green",
+    "warning": "yellow",
+    "danger": "red",
+}
+
+
+def get_and_display_announcements(divbase_base_url: str) -> None:
+    """
+    Get announcements from the API and display them to the user.
+    Used when logging in to display any important messages to the user.
+    """
+    response = make_unauthenticated_request(
+        method="GET",
+        divbase_base_url=divbase_base_url,
+        api_route="/v1/core/announcements",
+    )
+    announcements_data = response.json()
+    if not announcements_data:
+        return
+    announcements = [AnnouncementResponse.model_validate(ann) for ann in announcements_data]
+
+    if len(announcements) == 1:
+        print("[bold]An Announcement from DivBase Server:[/bold]")
+        color = COLOR_MAPPING.get(announcements[0].level)
+        print(f"[bold {color}]{announcements[0].heading}[/bold {color}]")
+        if announcements[0].message:
+            print(f"{announcements[0].message}\n")
+        return
+
+    print("[bold]Announcements from DivBase Server:[/bold]")
+    for idx, ann in enumerate(announcements, start=1):
+        color = COLOR_MAPPING.get(ann.level)
+        print(f"[bold {color}]{idx}) {ann.heading}[/bold {color}]")
+        if ann.message:
+            print(f"{ann.message}\n")