qbraid-cli 0.8.0.dev1__py3-none-any.whl → 0.8.0.dev4__py3-none-any.whl

qbraid_cli/jobs/app.py

@@ -1,119 +1,63 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
-
-import sys
-from typing import Callable, Dict, Optional, Tuple
+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")
-
+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
 
-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.",
-    )
+jobs_app = typer.Typer(help="Manage qBraid quantum jobs.")
 
 
-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,
@@ -122,7 +66,8 @@ 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)
+    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()
@@ -130,7 +75,7 @@ def jobs_state(
     max_lib_length = max((len(lib) for lib in state_values.keys()), default=len(header_1))
     padding = max_lib_length + 9
 
-    console.print(f"Executable: {sys.executable}")
+    console.print(f"Executable: {python_exe}")
     console.print(f"\n{header_1:<{padding}}{header_2}", style="bold")
 
     for lib, (installed, enabled) in state_values.items():
@@ -142,7 +87,7 @@ def jobs_state(
         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"
@@ -150,20 +95,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.
 
@@ -6,7 +9,6 @@ Module supporting 'qbraid jobs enable/disable braket' and commands.
 import logging
 import os
 import subprocess
-import sys
 from pathlib import Path
 from typing import Optional, Tuple
 
@@ -19,39 +21,38 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def get_package_data(package: str) -> Tuple[str, str, str]:
+def get_package_data(package: str) -> Tuple[str, str, str, str]:
     """Retrieve package version and location data.
 
     Args:
         package (str): The name of the package to retrieve data for.
 
     Returns:
-        Tuple[str, str, str]: The installed and latest versions of the package, and the
-                              local site-packages path where it is / would be installed.
+        Tuple[str, str, str, str]: The installed and latest versions of the package, and the
+                                   local site-packages path where it is / would be installed.
 
     Raises:
         QbraidException: If package version or location data cannot be retrieved.
 
     """
-    from qbraid.api.system import (
+    # pylint: disable=import-outside-toplevel
+    from qbraid_core.system import (
+        QbraidSystemError,
+        get_active_python_path,
         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)
+        python_pathlib = get_active_python_path()
+        site_packages_path = get_active_site_packages_path(python_path=python_pathlib)
+        installed_version = get_local_package_version(package, python_path=python_pathlib)
         latest_version = get_latest_package_version(package)
-    except QbraidError 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:
-        raise QbraidException("Failed to retrieve site-package location") from err
+    except QbraidSystemError as err:
+        raise QbraidException("Failed to retrieve required system and/or package metadata") from err
 
-    return installed_version, latest_version, site_packages_path
+    return installed_version, latest_version, str(site_packages_path), str(python_pathlib)
 
 
 def confirm_updates(
@@ -70,9 +71,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.
@@ -117,8 +115,6 @@ def confirm_updates(
         typer.echo("\nqBraidSystemExit: Exiting.")
         raise typer.Exit()
 
-    typer.echo("")
-
 
 def aws_configure_dummy() -> None:
     """
@@ -154,44 +150,47 @@ 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, python_exe = run_progress_task(
         get_package_data, "boto3", description="Solving environment..."
     )
-    confirm_updates("enable", site_packages_path, installed_version, latest_version)
+
+    if not auto_confirm:
+        confirm_updates("enable", path, installed_version=installed, latest_version=latest)
+    typer.echo("")
+
     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(
-            [sys.executable, "-m", "pip", "uninstall", "botocore", "-y", "--quiet"]
-        )
+        subprocess.check_call([python_exe, "-m", "pip", "install", "--upgrade", "boto3"])
+        subprocess.check_call([python_exe, "-m", "pip", "uninstall", "botocore", "-y", "--quiet"])
         subprocess.check_call(
-            [sys.executable, "-m", "pip", "install", "git+https://github.com/qBraid/botocore.git"]
+            [python_exe, "-m", "pip", "install", "git+https://github.com/qBraid/botocore.git"]
         )
-    except subprocess.CalledProcessError:
+    except (subprocess.CalledProcessError, FileNotFoundError):
         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, python_exe = 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)
+    typer.echo("")
 
     try:
         subprocess.check_call(
             [
-                sys.executable,
+                python_exe,
                 "-m",
                 "pip",
                 "install",
@@ -200,8 +199,8 @@ def disable_braket():
             ],
             stderr=subprocess.DEVNULL,
         )
-    except subprocess.CalledProcessError:
+    except (subprocess.CalledProcessError, FileNotFoundError):
         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,93 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for validating command arguments for qBraid Quantum Jobs.
+
+"""
+import sys
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import typer
+from rich.console import Console
+
+from qbraid_cli.handlers import handle_error, run_progress_task, validate_item
+
+LEGACY_ARGS: Dict[str, str] = {
+    "amazon_braket": "braket",
+    "aws_braket": "braket",
+}
+
+
+def validate_library(value: str) -> str:
+    """Validate quantum jobs library."""
+    # pylint:disable-next=import-outside-toplevel
+    from qbraid_core.services.quantum.proxy import SUPPORTED_QJOB_LIBS
+
+    qjobs_libs = list(SUPPORTED_QJOB_LIBS.keys())
+
+    if value in LEGACY_ARGS:
+        old_value = value
+        value = LEGACY_ARGS[value]
+
+        console = Console()
+        console.print(
+            f"[red]DeprecationWarning:[/red] Argument '{old_value}' "
+            f"is deprecated. Use '{value}' instead.\n"
+        )
+
+    return validate_item(value, qjobs_libs, "Library")
+
+
+def get_state(library: Optional[str] = None) -> Tuple[str, Dict[str, Tuple[bool, bool]]]:
+    """Get the state of qBraid Quantum Jobs for the specified library."""
+    from qbraid_core.services.quantum import QuantumClient
+
+    jobs_state = QuantumClient.qbraid_jobs_state(device_lib=library)
+
+    python_exe: str = jobs_state.get("exe", sys.executable)
+    libs_state: Dict[str, Any] = jobs_state.get("libs", {})
+
+    state_values = {
+        lib: (state["supported"], state["enabled"]) for lib, state in libs_state.items()
+    }
+
+    return python_exe, state_values
+
+
+def run_progress_get_state(
+    library: Optional[str] = None,
+) -> Tuple[str, 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 = run_progress_get_state(library)
+    installed, enabled = state_values[library]
+
+    if not installed:
+        handle_error(
+            message=f"{library} not installed."
+        )  # TODO: Provide command to install library?
+    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].\n\nCheck the state of all quantum jobs "
+            "libraries in this environment with: \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,42 +1,111 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
+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
+
+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
 
-app = typer.Typer(help="Manage qBraid kernels.")
+    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."""
-    from jupyter_client.kernelspec import KernelSpecManager
+    console = Console()
 
     kernel_spec_manager = KernelSpecManager()
     kernelspecs = kernel_spec_manager.get_all_specs()
 
     if len(kernelspecs) == 0:
-        print("No qBraid kernels active.")
-        # print("\nUse 'qbraid kernels add' to add a new kernel.")
+        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
 
-    print("# qbraid kernels:")
-    print("#")
-    print("")
+    console.print("# qbraid kernels:\n#\n")
 
     # Ensure 'python3' kernel is printed first if it exists
-    python3_kernel_info = kernelspecs.pop("python3", None)
+    default_kernel_name = "python3"
+    python3_kernel_info = kernelspecs.pop(default_kernel_name, None)
     if python3_kernel_info:
-        print("python3".ljust(spacing) + python3_kernel_info["resource_dir"])
+        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()):
-        print(f"{kernel_name.ljust(spacing)}{kernel_info['resource_dir']}")
+        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:
+        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()
+
+    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.",