qbraid-cli 0.8.0.dev1__py3-none-any.whl → 0.9.6__py3-none-any.whl

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.
 
@@ -5,11 +8,12 @@ Module supporting 'qbraid jobs enable/disable braket' and commands.
 
 import logging
 import os
+import re
 import subprocess
-import sys
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 
+import requests
 import typer
 
 from qbraid_cli.exceptions import QbraidException
@@ -19,46 +23,59 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def get_package_data(package: str) -> Tuple[str, str, str]:
+def fetch_botocore_version() -> Optional[str]:
+    """Fetch the latest version of the botocore package from the qBraid GitHub repository."""
+    url = "https://raw.githubusercontent.com/qBraid/botocore/develop/botocore/__init__.py"
+    response = requests.get(url, timeout=5)
+    if response.status_code == 200:
+        content = response.text
+        version_match = re.search(r"__version__\s*=\s*['\"]([^'\"]+)['\"]", content)
+        if version_match:
+            return version_match.group(1)
+    return None
+
+
+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 (
-        get_active_site_packages_path,
-        get_latest_package_version,
-        get_local_package_version,
-    )
-    from qbraid.exceptions import QbraidError
+    # pylint: disable=import-outside-toplevel
+    from qbraid_core.system.exceptions import QbraidSystemError
+    from qbraid_core.system.executables import get_active_python_path
+    from qbraid_core.system.packages import get_active_site_packages_path
+    from qbraid_core.system.versions import get_latest_package_version, get_local_package_version
 
     try:
-        installed_version = get_local_package_version(package)
-        latest_version = get_latest_package_version(package)
-    except QbraidError as err:
-        raise QbraidException("Failed to retrieve package version information") from err
+        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)
 
-    try:
-        site_packages_path = get_active_site_packages_path()
-    except QbraidError as err:
-        raise QbraidException("Failed to retrieve site-package location") from err
+        latest_version = None
+        if package in ["botocore", "boto3"]:
+            latest_version = fetch_botocore_version()
+        latest_version = latest_version or get_latest_package_version(package)
 
-    return installed_version, latest_version, site_packages_path
+    except QbraidSystemError as err:
+        raise QbraidException("Failed to retrieve required system and/or package metadata") from err
+
+    return installed_version, latest_version, str(site_packages_path), str(python_pathlib)
 
 
 def confirm_updates(
     mode: str,
     site_packages_path: str,
     installed_version: Optional[str] = None,
-    latest_version: Optional[str] = None,
+    target_version: Optional[str] = None,
 ) -> None:
     """
     Prompts the user to proceed with enabling or disabling qBraid Quantum Jobs.
@@ -68,10 +85,7 @@ def confirm_updates(
         site_packages_path (str): The location of the site-packages directory where
                                   target package(s) will be updated.
         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
+        target_version (optional, str): The latest version of the target package available on PyPI.
 
     Raises:
         ValueError: If an invalid mode is provided.
@@ -89,15 +103,15 @@ def confirm_updates(
     else:
         raise ValueError(f"Invalid mode: {mode}. Expected 'enable' or 'disable'.")
 
-    typer.echo(f"\n==> WARNING: {provider}/{core_package} package required <==")
+    typer.echo(f"==> WARNING: {provider}/{core_package} package required <==")
     if (
         installed_version is not None
-        and latest_version is not None
-        and installed_version != latest_version
+        and target_version is not None
+        and installed_version != target_version
     ):
-        typer.echo(f"==> WARNING: A newer version of {versioned_package} exists. <==")
+        typer.echo(f"==> WARNING: A different version of {versioned_package} is required. <==")
         typer.echo(f"  current version: {installed_version}")
-        typer.echo(f"  latest version: {latest_version}")
+        typer.echo(f"  target version: {target_version}")
 
     gerund = mode[:-2].capitalize() + "ing"
 
@@ -117,81 +131,61 @@ def confirm_updates(
         typer.echo("\nqBraidSystemExit: Exiting.")
         raise typer.Exit()
 
-    typer.echo("")
-
 
 def aws_configure_dummy() -> None:
     """
     Initializes AWS configuration and credentials files with placeholder values.
 
-    This function ensures the existence of AWS config and credentials files in the user's home
-    directory. If these files do not already exist, it creates them and populates them with
-    placeholder values for the AWS access key and secret access key. While AWS credentials are not
-    required when submitting quantum tasks through qBraid, Amazon Braket requires these files to be
-    present to prevent configuration errors.
     """
-    aws_dir = Path.home() / ".aws"
-    config_path = aws_dir / "config"
-    credentials_path = aws_dir / "credentials"
-
-    def configure_aws():
-        aws_dir.mkdir(exist_ok=True)
-        if not config_path.exists():
-            config_content = "[default]\nregion = us-east-1\noutput = json\n"
-            config_path.write_text(config_content)
-        if not credentials_path.exists():
-            access_key, secret_key = "MYACCESSKEY", "MYSECRETKEY"
-            credentials_content = (
-                f"[default]\n"
-                f"aws_access_key_id = {access_key}\n"
-                f"aws_secret_access_key = {secret_key}\n"
-            )
-            credentials_path.write_text(credentials_content)
+    from qbraid_core.services.quantum.proxy_braket import aws_configure
 
     try:
-        handle_filesystem_operation(configure_aws, aws_dir)
+        handle_filesystem_operation(aws_configure, Path.home() / ".aws")
     except QbraidException:
         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, target, 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, target_version=target)
+    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([python_exe, "-m", "pip", "install", f"boto3=={target}"])
+        subprocess.check_call([python_exe, "-m", "pip", "uninstall", "botocore", "-y", "--quiet"])
         subprocess.check_call(
-            [sys.executable, "-m", "pip", "uninstall", "botocore", "-y", "--quiet"]
+            [python_exe, "-m", "pip", "install", "git+https://github.com/qBraid/botocore.git"]
         )
-        subprocess.check_call(
-            [sys.executable, "-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 +194,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,94 @@
+# 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, Optional
+
+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,11 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining the qbraid kernels namespace
 
 """
 
-from .app import app
+from .app import kernels_app
+
+__all__ = ["kernels_app"]

qbraid_cli/kernels/app.py

@@ -1,42 +1,99 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
-Module defining commands in the 'qbraid jobs' namespace.
+Module defining commands in the 'qbraid kernels' namespace.
 
 """
 
 import typer
+from rich.console import Console
+
+from qbraid_cli.handlers import handle_error
 
-app = typer.Typer(help="Manage qBraid kernels.")
+kernels_app = typer.Typer(help="Manage qBraid kernels.", no_args_is_help=True)
 
 
-@app.command(name="list")
+@kernels_app.command(name="list")
 def kernels_list():
     """List all available kernels."""
-    from jupyter_client.kernelspec import KernelSpecManager
+    from qbraid_core.services.environments.kernels import get_all_kernels
 
-    kernel_spec_manager = KernelSpecManager()
-    kernelspecs = kernel_spec_manager.get_all_specs()
+    console = Console()
+    # Get the list of kernelspecs
+    kernelspecs: dict = get_all_kernels()
 
     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("")
+    output_lines = []
+    output_lines.append("# qbraid kernels:")
+    output_lines.append("#")
+    output_lines.append("")
 
     # 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"])
-
-    # Print the rest of the kernels
+        line = f"{default_kernel_name.ljust(spacing)}{python3_kernel_info['resource_dir']}"
+        output_lines.append(line)
+    # print rest of the kernels
     for kernel_name, kernel_info in sorted(kernelspecs.items()):
-        print(f"{kernel_name.ljust(spacing)}{kernel_info['resource_dir']}")
+        line = f"{kernel_name.ljust(spacing)}{kernel_info['resource_dir']}"
+        output_lines.append(line)
+
+    final_output = "\n".join(output_lines)
+
+    console.print(final_output)
+
+
+@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."""
+    from qbraid_core.services.environments.kernels import add_kernels
+
+    try:
+        add_kernels(environment)
+    except ValueError:
+        handle_error(
+            message="Failed to add kernel(s). Please verify that the environment exists.",
+            include_traceback=True,
+        )
+
+    console = Console()
+    console.print(f"\nSuccessfully added '{environment}' kernel(s).", highlight=False)
+
+
+@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."""
+    from qbraid_core.services.environments.kernels import remove_kernels
+
+    try:
+        remove_kernels(environment)
+    except ValueError:
+        handle_error(
+            message="Failed to remove kernel(s). Please verify that the environment exists.",
+            include_traceback=True,
+        )
+
+    console = Console()
+    console.print(f"\nSuccessfully removed '{environment}' kernel(s).", highlight=False)
 
 
 if __name__ == "__main__":
-    app()
+    kernels_app()

qbraid_cli/main.py

@@ -1,33 +1,55 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Entrypoint for the qBraid CLI.
 
 """
 
+import click
+import rich
 import typer
 
-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.account import account_app
+from qbraid_cli.admin import admin_app
+from qbraid_cli.chat import ChatFormat, list_models_callback, prompt_callback
+from qbraid_cli.configure import configure_app
+from qbraid_cli.devices import devices_app
+from qbraid_cli.files import files_app
+from qbraid_cli.jobs import jobs_app
+
+try:
+    from qbraid_cli.envs import envs_app
+    from qbraid_cli.kernels import kernels_app
+    from qbraid_cli.pip import pip_app
+
+    ENVS_COMMANDS = True
+except ImportError:
+    ENVS_COMMANDS = False
+
+app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
 
-app = typer.Typer()
+app.add_typer(admin_app, name="admin")
 app.add_typer(configure_app, name="configure")
-app.add_typer(envs_app, name="envs")
-app.add_typer(jobs_app, name="jobs")
+app.add_typer(account_app, name="account")
 app.add_typer(devices_app, name="devices")
-app.add_typer(kernels_app, name="kernels")
-app.add_typer(credits_app, name="credits")
+app.add_typer(files_app, name="files")
+app.add_typer(jobs_app, name="jobs")
+
+if ENVS_COMMANDS is True:
+    app.add_typer(envs_app, name="envs")
+    app.add_typer(kernels_app, name="kernels")
+    app.add_typer(pip_app, name="pip")
 
 
 def version_callback(value: bool):
     """Show the version and exit."""
     if value:
-        from ._version import __version__
+        # pylint: disable-next=import-error
+        from ._version import __version__  # type: ignore
 
         typer.echo(f"qbraid-cli/{__version__}")
-        raise typer.Exit()
+        raise typer.Exit(0)
 
 
 def show_banner():
@@ -50,7 +72,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")
+    rich.print("Reference Docs: https://docs.qbraid.com/cli/api-reference/qbraid")
 
 
 @app.callback(invoke_without_command=True)
@@ -59,6 +81,7 @@ def main(
     version: bool = typer.Option(
         None,
         "--version",
+        "-v",
         callback=version_callback,
         is_eager=True,
         help="Show the version and exit.",
@@ -69,5 +92,34 @@ def main(
         show_banner()
 
 
+@app.command(help="Interact with qBraid AI chat service.", no_args_is_help=True)
+def chat(
+    prompt: str = typer.Option(
+        None, "--prompt", "-p", help="The prompt to send to the chat service."
+    ),
+    model: str = typer.Option(None, "--model", "-m", help="The model to use for the chat service."),
+    response_format: ChatFormat = typer.Option(
+        ChatFormat.text, "--format", "-f", help="The format of the response."
+    ),
+    stream: bool = typer.Option(False, "--stream", "-s", help="Stream the response."),
+    list_models: bool = typer.Option(
+        False, "--list-models", "-l", help="List available chat models."
+    ),
+):
+    """
+    Interact with qBraid AI chat service.
+
+    """
+    if list_models:
+        list_models_callback()
+    elif prompt:
+        prompt_callback(prompt, model, response_format, stream)
+    else:
+        raise click.UsageError(
+            "Invalid command. Please provide a prompt using --prompt "
+            "or use --list-models to view available models."
+        )
+
+
 if __name__ == "__main__":
     app()

qbraid_cli/pip/__init__.py

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

qbraid_cli/pip/app.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid pip' namespace.
+
+"""
+
+import subprocess
+import sys
+
+import typer
+from qbraid_core.system.exceptions import QbraidSystemError
+from qbraid_core.system.executables import get_active_python_path
+
+from qbraid_cli.handlers import handle_error
+from qbraid_cli.pip.hooks import get_env_cfg_path, safe_set_include_sys_packages
+
+pip_app = typer.Typer(help="Run pip command in active qBraid environment.", no_args_is_help=True)
+
+
+@pip_app.command(
+    "install", context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+def pip_install(ctx: typer.Context):
+    """
+    Perform pip install action with open-ended arguments and options.
+
+    """
+    try:
+        python_exe = get_active_python_path()
+        cfg_path = get_env_cfg_path(python_exe)
+    except QbraidSystemError:
+        python_exe = sys.executable
+        cfg_path = None
+
+    safe_set_include_sys_packages(False, cfg_path)
+
+    command = [str(python_exe), "-m", "pip", "install"] + ctx.args
+
+    try:
+        subprocess.check_call(command)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        handle_error(message="Failed carry-out pip command.")
+    finally:
+        safe_set_include_sys_packages(True, cfg_path)
+
+
+if __name__ == "__main__":
+    pip_app()