qbraid-cli 0.8.0.dev0__py3-none-any.whl → 0.9.5__py3-none-any.whl

qbraid_cli/files/app.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid files' namespace.
+
+"""
+
+from pathlib import Path
+from typing import Any
+
+import rich
+import typer
+
+from qbraid_cli.handlers import run_progress_task
+
+files_app = typer.Typer(help="Manage qBraid cloud storage files.", no_args_is_help=True)
+
+
+@files_app.command(name="upload")
+def files_upload(
+    filepath: Path = typer.Argument(
+        ...,
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+        help="Local path to the file to upload.",
+    ),
+    namespace: str = typer.Option(
+        "user",
+        "--namespace",
+        "-n",
+        help="Target qBraid namespace for the upload.",
+    ),
+    object_path: str = typer.Option(
+        None,
+        "--object-path",
+        "-p",
+        help=("Target object path. " "Defaults to original filename in namespace root."),
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        "-o",
+        help="Overwrite existing file if it already exists in the target location.",
+    ),
+):
+    """Upload a local file to qBraid storage."""
+
+    def upload_file() -> dict[str, Any]:
+        from qbraid_core.services.files import FileManagerClient
+
+        client = FileManagerClient()
+        data = client.upload_file(
+            filepath, namespace=namespace, object_path=object_path, overwrite=overwrite
+        )
+        return data
+
+    data: dict = run_progress_task(
+        upload_file, description="Uploading file...", include_error_traceback=False
+    )
+
+    rich.print("File uploaded successfully!")
+    namespace = data.get("namespace")
+    object_path = data.get("objectPath")
+
+    if namespace and object_path:
+        rich.print(f"\nNamespace: '{namespace}'")
+        rich.print(f"Object path: '{object_path}'")
+
+
+@files_app.command(name="download")
+def files_download(
+    object_path: str = typer.Argument(
+        ...,
+        help="The folder + filename describing the file to download.",
+    ),
+    namespace: str = typer.Option(
+        "user",
+        "--namespace",
+        "-n",
+        help="Source qBraid namespace for the download.",
+    ),
+    save_path: Path = typer.Option(
+        Path.cwd(),
+        "--save-path",
+        "-s",
+        resolve_path=True,
+        help="Local directory to save the downloaded file.",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        "-o",
+        help="Overwrite existing file if it already exists in the target location.",
+    ),
+):
+    """Download a file from qBraid storage."""
+
+    def download_file() -> Path:
+        from qbraid_core.services.files import FileManagerClient
+
+        client = FileManagerClient()
+        file_path = client.download_file(
+            object_path, namespace=namespace, save_path=save_path, overwrite=overwrite
+        )
+        return file_path
+
+    file_path: Path = run_progress_task(
+        download_file, description="Downloading file...", include_error_traceback=False
+    )
+
+    rich.print("File downloaded successfully!")
+    rich.print(f"Saved to: '{str(file_path)}'")
+
+
+if __name__ == "__main__":
+    files_app()

qbraid_cli/handlers.py

@@ -1,20 +1,38 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module providing application support utilities, including abstractions for error handling
 and executing operations with progress tracking within the qBraid CLI.
 
 """
 
+import os
 import traceback
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Union
+from time import sleep
+from typing import Any, Callable, Optional, Union
 
 import typer
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn
 
 from .exceptions import DEFAULT_ERROR_MESSAGE, QbraidException
 
 
+def _should_display_progress():
+    """Whether to display rich progress UI."""
+    return os.getenv("QBRAID_CLI_SHOW_PROGRESS", "true").lower() in ["true", "1", "t", "y", "yes"]
+
+
+def _update_completed_task(
+    progress: Progress, task_id: TaskID, success: bool = True, sleep_time: float = 0.15
+):
+    status = "Done" if success else "Failed"
+    progress.update(task_id, completed=100, status=status)
+    sleep(sleep_time)
+
+
 def handle_error(
     error_type: Optional[str] = None, message: Optional[str] = None, include_traceback: bool = True
 ) -> None:
@@ -38,10 +56,14 @@ def handle_error(
     error_type = error_type or "Error"
     message = message or DEFAULT_ERROR_MESSAGE
     error_prefix = typer.style(f"{error_type}:", fg=typer.colors.RED, bold=True)
-    full_message = f"{error_prefix} {message}\n"
+    full_message = f"\n{error_prefix} {message}\n"
     if include_traceback:
         tb_string = traceback.format_exc()
-        full_message += f"\n{tb_string}"
+        # TODO: find out reason for weird traceback emitted from
+        # qbraid jobs enable/disable when library not installed.
+        # For now, if matches, just don't print it.
+        if tb_string.strip() != "NoneType: None":
+            full_message += f"\n{tb_string}"
     typer.echo(full_message, err=True)
     raise typer.Exit(code=1)
 
@@ -72,6 +94,7 @@ def run_progress_task(
     *args,
     description: Optional[str] = None,
     error_message: Optional[str] = None,
+    include_error_traceback: bool = True,
     **kwargs,
 ) -> Any:
     """
@@ -89,6 +112,8 @@ def run_progress_task(
         error_message (optional, str): Custom error message to display if the operation.
                                        fails. Defaults to None, in which case the
                                        exception's message is used.
+        include_error_traceback (bool): Whether to include the traceback in the error message.
+                                        Defaults to True.
         **kwargs: Arbitrary keyword arguments for the operation.
 
     Returns:
@@ -97,6 +122,13 @@ def run_progress_task(
     Raises:
         typer.Exit: If the operation fails, after displaying the error message using typer.secho.
     """
+    if not _should_display_progress():
+        try:
+            return operation(*args, **kwargs)
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            custom_message = error_message if error_message else str(err)
+            return handle_error(message=custom_message, include_traceback=include_error_traceback)
+
     console = Console()
     with Progress(
         "[progress.description]{task.description}",
@@ -108,21 +140,23 @@ def run_progress_task(
         task = progress.add_task(description, status="In Progress", total=None)
         try:
             result = operation(*args, **kwargs)
-            progress.update(task, completed=100, status="Done")
+            _update_completed_task(progress, task, success=True)
             return result
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            progress.update(task, completed=100, status="Failed")
-            custom_message = error_message if error_message else str(e)
-            return handle_error(message=custom_message)
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            _update_completed_task(progress, task, success=False)
+            custom_message = error_message if error_message else str(err)
+            return handle_error(message=custom_message, include_traceback=include_error_traceback)
+        finally:
+            progress.remove_task(task)
 
 
-def _format_list_items(items: List[str]) -> str:
+def _format_list_items(items: list[str]) -> str:
     """
     Formats a list of items as a string with values comma-separated and
     each item surrounded by single quotes
 
     Args:
-        items (List[str]): The list of items to format.
+        items (list[str]): The list of items to format.
 
     Returns:
         str: The formatted string.
@@ -131,14 +165,14 @@ def _format_list_items(items: List[str]) -> str:
 
 
 def validate_item(
-    value: Optional[str], allowed_items: List[str], item_type: str
+    value: Optional[str], allowed_items: list[str], item_type: str
 ) -> Union[str, None]:
     """
     Generic item validation function.
 
     Args:
         value (optional, str): The value to validate.
-        allowed_items (List[str]): A list of allowed items.
+        allowed_items (list[str]): A list of allowed items.
         item_type (str): A description of the item type (e.g., 'provider', 'status', 'type') for
                          error messages.
 

qbraid_cli/jobs/__init__.py

@@ -1,6 +1,11 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining the qbraid jobs namespace
 
 """
 
-from .app import app
+from .app import jobs_app
+
+__all__ = ["jobs_app"]

qbraid_cli/jobs/app.py

@@ -1,165 +1,152 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
 
-from typing import Callable, Dict, Optional, Tuple
+from typing import Any, Callable
 
 import typer
 from rich.console import Console
 
-from qbraid_cli.handlers import handle_error, run_progress_task, validate_item
-
-app = typer.Typer(help="Manage qBraid quantum jobs.")
-
-QJOB_LIBS = ["braket"]
-
-
-def validate_library(value: str) -> str:
-    """Validate quantum jobs library."""
-    return validate_item(value, QJOB_LIBS, "Library")
-
-
-def get_state(library: Optional[str] = None) -> Dict[str, Tuple[bool, bool]]:
-    """Get the state of qBraid Quantum Jobs for the specified library."""
-    from qbraid.api.system import qbraid_jobs_state
-
-    state_values = {}
+from qbraid_cli.handlers import handle_error, run_progress_task
+from qbraid_cli.jobs.toggle_braket import disable_braket, enable_braket
+from qbraid_cli.jobs.validation import handle_jobs_state, run_progress_get_state, validate_library
 
-    if library:
-        libraries_to_check = [library]
-    else:
-        libraries_to_check = QJOB_LIBS
+jobs_app = typer.Typer(help="Manage qBraid quantum jobs.", no_args_is_help=True)
 
-    for lib in libraries_to_check:
-        state_values[lib] = qbraid_jobs_state(lib)
 
-    return state_values
-
-
-def run_progress_get_state(library: Optional[str] = None) -> Dict[str, Tuple[bool, bool]]:
-    """Run get state function with rich progress UI."""
-    return run_progress_task(
-        get_state,
-        library,
-        description="Collecting package metadata...",
-        error_message=f"Failed to collect {library} package metadata.",
-    )
-
-
-def handle_jobs_state(
-    library: str,
-    action: str,  # 'enable' or 'disable'
-    action_callback: Callable[[], None],
-) -> None:
-    """Handle the common logic for enabling or disabling qBraid Quantum Jobs."""
-    state_values: Dict[str, Tuple[bool, bool]] = run_progress_get_state(library)
-    installed, enabled = state_values[library]
-
-    if not installed:
-        handle_error(message=f"{library} not installed.")
-    if (enabled and action == "enable") or (not enabled and action == "disable"):
-        action_color = "green" if enabled else "red"
-        console = Console()
-        console.print(
-            f"\nqBraid quantum jobs already [bold {action_color}]{action}d[/bold {action_color}] "
-            f"for [magenta]{library}[/magenta]."
-        )
-        console.print(
-            "To check the state of all quantum jobs libraries in this environment, "
-            "use: `[bold]qbraid jobs state[/bold]`"
-        )
-        raise typer.Exit()
-
-    action_callback()  # Perform the specific enable/disable action
-
-
-@app.command(name="enable")
+@jobs_app.command(name="enable")
 def jobs_enable(
     library: str = typer.Argument(
         ..., help="Software library with quantum jobs support.", callback=validate_library
-    )
+    ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Enable qBraid Quantum Jobs."""
 
     def enable_action():
         if library == "braket":
-            from .toggle_braket import enable_braket
-
-            enable_braket()
+            enable_braket(auto_confirm=auto_confirm)
         else:
             raise RuntimeError(f"Unsupported device library: '{library}'.")
 
     handle_jobs_state(library, "enable", enable_action)
 
 
-@app.command(name="disable")
+@jobs_app.command(name="disable")
 def jobs_disable(
     library: str = typer.Argument(
         ..., help="Software library with quantum jobs support.", callback=validate_library
-    )
+    ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Disable qBraid Quantum Jobs."""
 
     def disable_action():
         if library == "braket":
-            from .toggle_braket import disable_braket
-
-            disable_braket()
+            disable_braket(auto_confirm=auto_confirm)
         else:
             raise RuntimeError(f"Unsupported device library: '{library}'.")
 
     handle_jobs_state(library, "disable", disable_action)
 
 
-@app.command(name="state")
+@jobs_app.command(name="state")
 def jobs_state(
     library: str = typer.Argument(
         default=None,
         help="Optional: Specify a software library with quantum jobs support to check its status.",
         callback=validate_library,
-    )
+    ),
 ) -> None:
     """Display the state of qBraid Quantum Jobs for the current environment."""
-    state_values: Dict[str, Tuple[bool, bool]] = run_progress_get_state(library)
+    result: tuple[str, dict[str, tuple[bool, bool]]] = run_progress_get_state(library)
+    python_exe, state_values = result
+    state_values = dict(sorted(state_values.items()))
 
     console = Console()
-    console.print("\nLibrary       State", style="bold")
+    header_1, header_2 = "Library", "State"
+    max_lib_length = max((len(lib) for lib in state_values.keys()), default=len(header_1))
+    padding = max_lib_length + 9
 
+    output = ""
     for lib, (installed, enabled) in state_values.items():
-        if installed:
-            if enabled:
-                console.print(f"{lib:<12} ", "[green]enabled", end="")
-            else:
-                console.print(f"{lib:<12} ", "[red]disabled", end="")
-        else:
-            console.print(f"{lib:<12} n/a", end="")
+        state_str = (
+            "[green]enabled"
+            if enabled and installed
+            else "[red]disabled" if installed else "[grey70]unavailable"
+        )
+        output += f"{lib:<{padding-1}} {state_str}\n"
 
-    console.print("\n")
+    console.print(f"Executable: {python_exe}")
+    console.print(f"\n{header_1:<{padding}}{header_2}", style="bold")
+    console.print(output)
 
 
-@app.command(name="list")
+@jobs_app.command(name="list")
 def jobs_list(
     limit: int = typer.Option(
         10, "--limit", "-l", help="Limit the maximum number of results returned"
-    )
+    ),
 ) -> None:
     """List qBraid Quantum Jobs."""
 
-    def import_jobs() -> Tuple[Callable, Exception]:
-        from qbraid import get_jobs
-        from qbraid.exceptions import QbraidError
+    def import_jobs() -> tuple[Any, Callable]:
+        from qbraid_core.services.quantum import QuantumClient, process_job_data
 
-        return get_jobs, QbraidError
+        client = QuantumClient()
 
-    result: Tuple[Callable, Exception] = run_progress_task(import_jobs)
-    get_jobs, QbraidError = result
+        return client, process_job_data
 
+    result: tuple[Any, Callable] = run_progress_task(import_jobs)
+    client, process_job_data = result
+    # https://github.com/qBraid/api/issues/644
+    # raw_data = client.search_jobs(query={"numResults": limit})
+    raw_data = client.search_jobs(query={})
+    job_data, msg = process_job_data(raw_data)
+    job_data = job_data[:limit]
+
+    longest_job_id = max(len(item[0]) for item in job_data)
+    spacing = longest_job_id + 5
     try:
-        get_jobs(filters={"numResults": limit})
-    except QbraidError:
+        console = Console()
+        header_1 = "Job ID"
+        header_2 = "Submitted"
+        header_3 = "Status"
+        console.print(f"[bold]{header_1.ljust(spacing)}{header_2.ljust(36)}{header_3}[/bold]")
+        for job_id, submitted, status in job_data:
+            if status == "COMPLETED":
+                status_color = "green"
+            elif status in ["FAILED", "CANCELLED"]:
+                status_color = "red"
+            elif status in [
+                "INITIALIZING",
+                "INITIALIZED",
+                "CREATED",
+                "QUEUED",
+                "VALIDATING",
+                "RUNNING",
+            ]:
+                status_color = "blue"
+            else:
+                status_color = "grey"
+            console.print(
+                f"{job_id.ljust(spacing)}{submitted.ljust(35)}",
+                f"[{status_color}]{status}[/{status_color}]",
+            )
+
+        console.print(f"\n{msg}", style="italic", justify="left")
+
+    except Exception:  # pylint: disable=broad-exception-caught
         handle_error(message="Failed to fetch quantum jobs.")
 
 
 if __name__ == "__main__":
-    app()
+    jobs_app()