qbraid-cli 0.8.0.dev0__py3-none-any.whl → 0.8.0.dev3__py3-none-any.whl

qbraid_cli/jobs/app.py

@@ -1,118 +1,65 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
 
-from typing import Callable, Dict, Optional, Tuple
+import sys
+from typing import Any, Callable, Dict, Tuple
 
 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 = {}
-
-    if library:
-        libraries_to_check = [library]
-    else:
-        libraries_to_check = QJOB_LIBS
-
-    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()
+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
 
-    action_callback()  # Perform the specific enable/disable action
+jobs_app = typer.Typer(help="Manage qBraid quantum jobs.")
 
 
-@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,
@@ -122,23 +69,26 @@ def jobs_state(
 ) -> None:
     """Display the state of qBraid Quantum Jobs for the current environment."""
     state_values: Dict[str, Tuple[bool, bool]] = run_progress_get_state(library)
+    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
 
-    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="")
+    console.print(f"Executable: {sys.executable}")
+    console.print(f"\n{header_1:<{padding}}{header_2}", style="bold")
 
-    console.print("\n")
+    for lib, (installed, enabled) in state_values.items():
+        state_str = (
+            "[green]enabled"
+            if enabled and installed
+            else "[red]disabled" if installed else "[grey70]unavailable"
+        )
+        console.print(f"{lib:<{padding-1}}", state_str, end="\n")
 
 
-@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"
@@ -146,20 +96,55 @@ def jobs_list(
 ) -> 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
+
+        client = QuantumClient()
 
-        return get_jobs, QbraidError
+        return client, process_job_data
 
-    result: Tuple[Callable, Exception] = run_progress_task(import_jobs)
-    get_jobs, QbraidError = result
+    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"\n[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()

qbraid_cli/jobs/toggle_braket.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module supporting 'qbraid jobs enable/disable braket' and commands.
 
@@ -11,6 +14,12 @@ from pathlib import Path
 from typing import Optional, Tuple
 
 import typer
+from qbraid_core.system import (
+    QbraidSystemError,
+    get_active_site_packages_path,
+    get_latest_package_version,
+    get_local_package_version,
+)
 
 from qbraid_cli.exceptions import QbraidException
 from qbraid_cli.handlers import handle_error, handle_filesystem_operation, run_progress_task
@@ -33,22 +42,16 @@ def get_package_data(package: str) -> Tuple[str, str, str]:
         QbraidException: If package version or location data cannot be retrieved.
 
     """
-    from qbraid.api.system import (
-        get_active_site_packages_path,
-        get_latest_package_version,
-        get_local_package_version,
-    )
-    from qbraid.exceptions import QbraidError
 
     try:
         installed_version = get_local_package_version(package)
         latest_version = get_latest_package_version(package)
-    except QbraidError as err:
+    except QbraidSystemError as err:
         raise QbraidException("Failed to retrieve package version information") from err
 
     try:
         site_packages_path = get_active_site_packages_path()
-    except QbraidError as err:
+    except QbraidSystemError as err:
         raise QbraidException("Failed to retrieve site-package location") from err
 
     return installed_version, latest_version, site_packages_path
@@ -70,9 +73,6 @@ def confirm_updates(
         installed_version (optional, str): The installed version of the target package.
         latest_version (optional, str): The latest version of the target package available on PyPI.
 
-    Returns:
-        None
-
     Raises:
         ValueError: If an invalid mode is provided.
         typer.Exit: If the user declines to proceed with enabling or disabling qBraid Quantum Jobs.
@@ -154,14 +154,16 @@ def aws_configure_dummy() -> None:
         handle_error(message="Failed to configure qBraid quantum jobs.")
 
 
-def enable_braket():
+def enable_braket(auto_confirm: bool = False):
     """Enable qBraid quantum jobs for Amazon Braket."""
-    installed_version, latest_version, site_packages_path = run_progress_task(
+    installed, latest, path = run_progress_task(
         get_package_data, "boto3", description="Solving environment..."
     )
-    confirm_updates("enable", site_packages_path, installed_version, latest_version)
-    aws_configure_dummy()  # TODO: possibly add another confirmation for writing aws config files
 
+    if not auto_confirm:
+        confirm_updates("enable", path, installed_version=installed, latest_version=latest)
+
+    aws_configure_dummy()  # TODO: possibly add another confirmation for writing aws config files
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "boto3"])
         subprocess.check_call(
@@ -174,19 +176,19 @@ def enable_braket():
         handle_error(message="Failed to enable qBraid quantum jobs.")
 
     typer.secho("\nSuccessfully enabled qBraid quantum jobs.", fg=typer.colors.GREEN, bold=True)
-    typer.secho(
-        "\nTo disable, run: `qbraid jobs disable braket`\n", fg=typer.colors.GREEN, bold=True
-    )
+    typer.secho("\nTo disable, run: \n\n\t$ qbraid jobs disable braket\n")
 
 
-def disable_braket():
+def disable_braket(auto_confirm: bool = False):
     """Disable qBraid quantum jobs for Amazon Braket."""
     package = "botocore"
-    installed_version, latest_version, site_packages_path = run_progress_task(
+    installed, latest, path = run_progress_task(
         get_package_data, package, description="Solving environment..."
     )
-    package = f"{package}~={installed_version}" if installed_version < latest_version else package
-    confirm_updates("disable", site_packages_path)
+    package = f"{package}~={installed}" if installed < latest else package
+
+    if not auto_confirm:
+        confirm_updates("disable", path)
 
     try:
         subprocess.check_call(
@@ -204,4 +206,4 @@ def disable_braket():
         handle_error(message="Failed to disable qBraid quantum jobs.")
 
     typer.secho("\nSuccessfully disabled qBraid quantum jobs.", fg=typer.colors.GREEN, bold=True)
-    typer.secho("\nTo enable, run: `qbraid jobs enable braket`\n", fg=typer.colors.GREEN, bold=True)
+    typer.secho("\nTo enable, run: \n\n\t$ qbraid jobs enable braket\n")

qbraid_cli/jobs/validation.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for validating command arguments for qBraid Quantum Jobs.
+
+"""
+
+from typing import Callable, Dict, Optional, Tuple
+
+import typer
+from qbraid_core.services.quantum.proxy import SUPPORTED_QJOB_LIBS, quantum_lib_proxy_state
+from rich.console import Console
+
+from qbraid_cli.handlers import handle_error, run_progress_task, validate_item
+
+
+def validate_library(value: str) -> str:
+    """Validate quantum jobs library."""
+    return validate_item(value, SUPPORTED_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."""
+
+    state_values = {}
+
+    if library:
+        libraries_to_check = [library]
+    else:
+        libraries_to_check = SUPPORTED_QJOB_LIBS
+
+    for lib in libraries_to_check:
+        state = quantum_lib_proxy_state(lib)
+        state_values[lib] = state["supported"], state["enabled"]
+
+    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: \n\n\t$ qbraid jobs state\n"
+        )
+        raise typer.Exit()
+
+    action_callback()  # Perform the specific enable/disable action

qbraid_cli/kernels/__init__.py

@@ -1,6 +1,9 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining the qbraid kernels namespace
 
 """
 
-from .app import app
+from .app import kernels_app

qbraid_cli/kernels/app.py

@@ -1,29 +1,111 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
-
-import subprocess
+import sys
+from pathlib import Path
 
 import typer
+from jupyter_client.kernelspec import KernelSpecManager
+from rich.console import Console
 
+from qbraid_cli.envs.data_handling import installed_envs_data
 from qbraid_cli.handlers import handle_error
 
-app = typer.Typer(help="Manage qBraid kernels.")
+kernels_app = typer.Typer(help="Manage qBraid kernels.")
+
+
+def _get_kernels_path(environment: str) -> Path:
+    """Get the path to the kernels directory for the given environment."""
+    slug_to_path, name_to_slug = installed_envs_data()
+
+    if environment in name_to_slug:
+        slug = name_to_slug.get(environment, None)
+    else:
+        slug = environment
+
+    if slug not in slug_to_path:
+        raise ValueError(f"Environment '{environment}' not found.")
 
+    env_path = slug_to_path[slug]
+    kernels_path = env_path / "kernels"
+    return kernels_path
 
-@app.command(name="list")
+
+@kernels_app.command(name="list")
 def kernels_list():
     """List all available kernels."""
+    console = Console()
+
+    kernel_spec_manager = KernelSpecManager()
+    kernelspecs = kernel_spec_manager.get_all_specs()
+
+    if len(kernelspecs) == 0:
+        console.print("No qBraid kernels are active.")
+        console.print("\nUse 'qbraid kernels add' to add a new kernel.")
+        return
+
+    longest_kernel_name = max(len(kernel_name) for kernel_name in kernelspecs)
+    spacing = longest_kernel_name + 10
+
+    console.print("# qbraid kernels:\n#\n")
+
+    # Ensure 'python3' kernel is printed first if it exists
+    default_kernel_name = "python3"
+    python3_kernel_info = kernelspecs.pop(default_kernel_name, None)
+    if python3_kernel_info:
+        console.print(f"{default_kernel_name.ljust(spacing)}{python3_kernel_info['resource_dir']}")
+
+    # Print the rest of the kernels
+    for kernel_name, kernel_info in sorted(kernelspecs.items()):
+        console.print(f"{kernel_name.ljust(spacing)}{kernel_info['resource_dir']}")
+
+
+@kernels_app.command(name="add")
+def kernels_add(
+    environment: str = typer.Argument(
+        ..., help="Name of environment for which to add ipykernel. Values from 'qbraid envs list'."
+    )
+):
+    """Add a kernel."""
+
     try:
-        result = subprocess.run(
-            ["jupyter", "kernelspec", "list"], capture_output=True, text=True, check=True
-        )
+        kernels_path = _get_kernels_path(environment)
+    except ValueError:
+        handle_error(message=f"Environment '{environment}' not found.", include_traceback=False)
+        return
+
+    is_local = str(kernels_path).startswith(str(Path.home()))
+    resource_path = str(Path.home() / ".local") if is_local else sys.prefix
+
+    kernel_spec_manager = KernelSpecManager()
+
+    for kernel in kernels_path.iterdir():
+        kernel_spec_manager.install_kernel_spec(source_dir=str(kernel), prefix=resource_path)
+
+
+@kernels_app.command(name="remove")
+def kernels_remove(
+    environment: str = typer.Argument(
+        ...,
+        help=("Name of environment for which to remove ipykernel. Values from 'qbraid envs list'."),
+    )
+):
+    """Remove a kernel."""
+    try:
+        kernels_path = _get_kernels_path(environment)
+    except ValueError:
+        handle_error(message=f"Environment '{environment}' not found.", include_traceback=False)
+        return
+
+    kernel_spec_manager = KernelSpecManager()
 
-        print(result.stdout)
-    except subprocess.CalledProcessError:
-        handle_error("Failed to list kernels.")
+    for kernel in kernels_path.iterdir():
+        kernel_spec_manager.remove_kernel_spec(kernel.name)
 
 
 if __name__ == "__main__":
-    app()
+    kernels_app()

qbraid_cli/main.py

@@ -1,18 +1,22 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Entrypoint for the qBraid CLI.
 
 """
 
 import typer
+import urllib3
 
-from .configure import app as configure_app
-from .credits import app as credits_app
-from .devices import app as devices_app
-from .envs import app as envs_app
-from .jobs import app as jobs_app
-from .kernels import app as kernels_app
+from qbraid_cli.configure.app import configure_app
+from qbraid_cli.credits.app import credits_app
+from qbraid_cli.devices.app import devices_app
+from qbraid_cli.envs.app import envs_app
+from qbraid_cli.jobs.app import jobs_app
+from qbraid_cli.kernels.app import kernels_app
 
-app = typer.Typer()
+app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
 app.add_typer(configure_app, name="configure")
 app.add_typer(envs_app, name="envs")
 app.add_typer(jobs_app, name="jobs")
@@ -20,6 +24,8 @@ app.add_typer(devices_app, name="devices")
 app.add_typer(kernels_app, name="kernels")
 app.add_typer(credits_app, name="credits")
 
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
 
 def version_callback(value: bool):
     """Show the version and exit."""
@@ -50,7 +56,7 @@ def show_banner():
     typer.echo("")
     typer.echo("- Use 'qbraid --version' to see the current version.")
     typer.echo("")
-    typer.echo("Reference Docs: https://docs.qbraid.com/projects/cli/en/latest/cli/qbraid.html")
+    typer.echo("Reference Docs: https://docs.qbraid.com/projects/cli/en/stable/guide/overview.html")
 
 
 @app.callback(invoke_without_command=True)
@@ -59,6 +65,7 @@ def main(
     version: bool = typer.Option(
         None,
         "--version",
+        "-v",
         callback=version_callback,
         is_eager=True,
         help="Show the version and exit.",