qbraid-cli 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

qbraid_cli/configure.py

@@ -1,113 +0,0 @@
-"""
-Update qbraidrc configuration file
-
-"""
-
-import configparser
-import re
-from pathlib import Path
-from typing import Optional
-
-
-def load_config():
-    """Load the configuration from the file."""
-    config_path = Path.home() / ".qbraid" / "qbraidrc"
-    config = configparser.ConfigParser()
-    config.read(config_path)
-    return config
-
-
-def save_config(config):
-    """Save the configuration to the file."""
-    config_path = Path.home() / ".qbraid"
-
-    # Create the .qbraid directory if it doesn't exist
-    config_path.mkdir(parents=True, exist_ok=True)
-
-    # Write the configuration to the qbraidrc file
-    with (config_path / "qbraidrc").open("w") as configfile:
-        config.write(configfile)
-
-
-def validate_input(key, value):
-    """Validate the user input based on the key."""
-    if key == "url":
-        if not re.match(r"^https?://\S+$", value):
-            raise ValueError("Invalid URL format.")
-    elif key == "email":
-        if not re.match(r"^\S+@\S+\.\S+$", value):
-            raise ValueError("Invalid email format.")
-    elif key == "api-key":
-        if not re.match(r"^[a-zA-Z0-9]{11}$", value):
-            raise ValueError("Invalid API key format.")
-    return value
-
-
-def prompt_for_config(config, section, key, default_values=None):
-    """Prompt the user for a configuration setting, showing the current value as default."""
-    default_values = default_values or {}
-    current_value = config.get(section, key, fallback=default_values.get(key, ""))
-    display_value = "None" if not current_value else current_value
-
-    while True:
-        try:
-            new_value = input(f"Enter {key} [{display_value}]: ").strip()
-            new_value = new_value or current_value
-            return validate_input(key, new_value)
-        except ValueError as e:
-            print(f"Error: {e}")
-
-
-def configure():
-    """Prompt the user to configure each setting."""
-    try:
-        config = load_config()
-    except Exception as e:  # pylint: disable=broad-exception-caught
-        print(f"Error loading configuration: {e}")
-        return
-
-    section = "default"
-
-    if section not in config:
-        config[section] = {}
-
-    default_values = {"url": "https://api.qbraid.com/api"}
-
-    try:
-        config[section]["url"] = prompt_for_config(
-            config, section, "url", default_values
-        )
-        config[section]["email"] = prompt_for_config(
-            config, section, "email", default_values
-        )
-        config[section]["api-key"] = prompt_for_config(
-            config, section, "api-key", default_values
-        )
-
-        for key in list(config[section]):
-            if not config[section][key]:
-                del config[section][key]
-
-        save_config(config)
-        print("Configuration updated successfully.")
-    except Exception as e:  # pylint: disable=broad-exception-caught
-        print(f"Error updating configuration: {e}")
-
-
-def configure_set(key: str, value: str, profile: Optional[str] = None):
-    """Set a configuration setting."""
-    try:
-        config = load_config()
-    except Exception as e:  # pylint: disable=broad-exception-caught
-        print(f"Error loading configuration: {e}")
-        return
-
-    section = profile or "default"
-
-    if section not in config:
-        config[section] = {}
-
-    config[section][key] = value
-
-    save_config(config)
-    print("Configuration updated successfully.")

qbraid_cli/envs.py

@@ -1,195 +0,0 @@
-"""
-Module for interfacing with qBraid environments.
-
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-import threading
-from typing import List, Optional
-
-from jupyter_client.kernelspec import KernelSpecManager
-from qbraid.api import QbraidSession
-
-from ._display import print_progress_cycle
-
-DEFAULT_VISIBILITY = "private"
-
-DEFAULT_ENVS_PATH = os.path.join(os.path.expanduser("~"), ".qbraid", "environments")
-QBRAID_ENVS_PATH = os.getenv("QBRAID_USR_ENVS", DEFAULT_ENVS_PATH)
-
-
-def create_alias(slug: str) -> str:
-    """Create an alias from a slug."""
-    return slug[:-7].replace("_", "-").strip("-")
-
-
-def replace_str(target: str, replacement: str, file_path: str) -> None:
-    """Replace all instances of string in file"""
-    with open(file_path, "r", encoding="utf-8") as file:
-        content = file.read()
-
-    content = content.replace(target, replacement)
-
-    with open(file_path, "w", encoding="utf-8") as file:
-        file.write(content)
-
-
-def update_install_status(
-    slug_path: str, complete: int, success: int, message: Optional[str] = None
-) -> None:
-    """Update environment's install status values in a JSON file.
-    Truth table values: 0 = False, 1 = True, -1 = Unknown
-    """
-    # Set default message if none provided
-    message = "" if message is None else message.replace("\n", " ")
-
-    # File path for state.json
-    state_json_path = os.path.join(slug_path, "state.json")
-
-    # Read existing data or use default structure
-    if os.path.exists(state_json_path):
-        with open(state_json_path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-    else:
-        data = {"install": {}}
-
-    # Update the data
-    data["install"]["complete"] = complete
-    data["install"]["success"] = success
-    data["install"]["message"] = message
-
-    # Write updated data back to state.json
-    with open(state_json_path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=4)
-
-
-def create_venv(slug_path: str, prompt: str) -> None:
-    """Create virtual environment and swap PS1 display name."""
-    venv_path = os.path.join(slug_path, "pyenv")
-    subprocess.run([sys.executable, "-m", "venv", venv_path], check=True)
-
-    bin_path = os.path.join(venv_path, "bin")
-    activate_files = ["activate", "activate.csh", "activate.fish"]
-
-    for file in activate_files:
-        file_path = os.path.join(bin_path, file)
-        replace_str("(pyenv)", f"({prompt})", file_path)
-
-    replace_str(
-        "include-system-site-packages = false",
-        "include-system-site-packages = true",
-        os.path.join(venv_path, "pyvenv.cfg"),
-    )
-
-    update_install_status(slug_path, 1, 1)
-
-
-def create_qbraid_env(slug: str, prompt: str, display_name: str) -> None:
-    """Create a qBraid environment including python venv, PS1 configs,
-    kernel resource files, and qBraid state.json."""
-    slug_path = os.path.join(QBRAID_ENVS_PATH, slug)
-    local_resource_dir = os.path.join(slug_path, "kernels", f"python3_{slug}")
-    os.makedirs(local_resource_dir, exist_ok=True)
-
-    # create state.json
-    update_install_status(slug_path, 0, 0)
-
-    # create kernel.json
-    kernel_json_path = os.path.join(local_resource_dir, "kernel.json")
-    kernel_spec_manager = KernelSpecManager()
-    kernelspec_dict = kernel_spec_manager.get_all_specs()
-    kernel_data = kernelspec_dict["python3"]["spec"]
-    kernel_data["argv"][0] = os.path.join(slug_path, "pyenv", "bin", "python")
-    kernel_data["display_name"] = display_name
-    with open(kernel_json_path, "w", encoding="utf-8") as file:
-        json.dump(kernel_data, file, indent=4)
-
-    # copy logo files
-    sys_resource_dir = kernelspec_dict["python3"]["resource_dir"]
-    logo_files = ["logo-32x32.png", "logo-64x64.png", "logo-svg.svg"]
-
-    for file in logo_files:
-        sys_path = os.path.join(sys_resource_dir, file)
-        loc_path = os.path.join(local_resource_dir, file)
-        if os.path.isfile(sys_path):
-            shutil.copy(sys_path, loc_path)
-
-    # create python venv
-    create_venv(slug_path, prompt)
-
-
-# pylint: disable-next=too-many-arguments,too-many-locals
-def create(
-    name: str,
-    description: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    code: Optional[str] = None,
-    visibility: Optional[str] = None,
-    kernel_name: Optional[str] = None,
-    prompt: Optional[str] = None,
-) -> None:
-    """
-    Create a new qBraid environment.
-
-    Args:
-        name (str): Name of the environment.
-        description (Optional[str]): Description of the environment.
-        tags (Optional[List[str]]): List of tags associated with the environment.
-        code (Optional[str]): package list in requirements.txt format.
-        visibility (Optional[str]): Visibility status (e.g., 'private').
-        kernel_name (Optional[str]): Name of the kernel.
-        prompt (Optional[str]): Prompt for the environment.
-
-    Returns:
-        None
-    """
-    req_body = {
-        "name": name,
-        "description": description or "",
-        "tags": tags or "",  # comma separated list of tags
-        "code": code or "",  # newline separated list of packages
-        "visibility": visibility or DEFAULT_VISIBILITY,
-        "kernelName": kernel_name or "",
-        "prompt": prompt or "",
-    }
-
-    session = QbraidSession()
-
-    try:
-        resp = session.post("/environments/create", json=req_body).json()
-    except Exception as e:  # pylint: disable=broad-exception-caught
-        print(f"Failed to create environment: {e}")
-        return
-
-    slug = resp.get("slug")
-    if slug is None:
-        print("Failed to create environment: no slug returned")
-        return
-
-    alias = create_alias(slug)
-    kernel_name = kernel_name if kernel_name else f"Python 3 [{alias}]"
-    prompt = prompt if prompt else alias
-
-    stop_event = threading.Event()
-    message = "Creating qBraid environment"
-    interval = 0.5
-
-    # Start the progress bar in a separate thread
-    progress_thread = threading.Thread(
-        target=print_progress_cycle,
-        args=(
-            stop_event,
-            message,
-            interval,
-        ),
-    )
-    progress_thread.start()
-    create_qbraid_env(slug, prompt, kernel_name)
-    stop_event.set()
-    progress_thread.join()
-
-    print(f"\nSuccessfully created qBraid environment: {slug}\n")

qbraid_cli/jobs.py

@@ -1,226 +0,0 @@
-"""
-Module containing functions to enable/disable quantum jobs.
-
-"""
-
-import os
-import site
-import subprocess
-import sys
-import threading
-from importlib.metadata import PackageNotFoundError, version
-
-import requests
-
-from ._display import print_progress_linear
-from .exceptions import QuantumJobsException
-
-
-def get_latest_boto3_version() -> str:
-    """Retrieves the latest version of botocore from PyPI."""
-    url = "https://pypi.org/pypi/boto3/json"
-    try:
-        response = requests.get(url, timeout=5)
-        response.raise_for_status()
-        data = response.json()
-        return data["info"]["version"]
-    except requests.RequestException as err:
-        raise QuantumJobsException("Failed to retrieve latest boto3 version.") from err
-
-
-def get_local_boto3_version() -> str:
-    """Retrieves the local version of boto3."""
-    try:
-        return version("boto3")
-    except PackageNotFoundError as err:
-        raise QuantumJobsException(
-            "boto3 is not installed in the current environment."
-        ) from err
-
-
-def get_target_site_packages_path() -> str:
-    """Retrieves the site-packages path of the current Python environment."""
-
-    # List of all site-packages directories
-    site_packages_paths = site.getsitepackages()
-
-    if len(site_packages_paths) == 1:
-        return site_packages_paths[0]
-
-    # Path to the currently running Python interpreter
-    python_executable_path = sys.executable
-
-    # Base path of the Python environment
-    env_base_path = os.path.dirname(os.path.dirname(python_executable_path))
-
-    # Find the site-packages path that is within the same environment
-    for path in site_packages_paths:
-        if env_base_path in path:
-            return path
-
-    raise QuantumJobsException("Failed to find site-packages path.")
-
-
-def get_local_boto3_path() -> str:
-    """Retrieves the local path of boto3."""
-    try:
-        site_packages_path = get_target_site_packages_path()
-        return os.path.join(site_packages_path, "boto3")
-    except PackageNotFoundError as err:
-        raise QuantumJobsException(
-            "boto3 is not installed in the current environment."
-        ) from err
-
-
-def verify_boto3_compatible() -> None:
-    """Verifies that the local version of boto3 is compatible with qBraid Quantum Jobs."""
-    stop_event = threading.Event()
-    message = "Collecting package metadata..."
-    interval = 0.1
-
-    # Start the progress bar in a separate thread
-    progress_thread = threading.Thread(
-        target=print_progress_linear,
-        args=(
-            stop_event,
-            message,
-            interval,
-        ),
-    )
-    progress_thread.start()
-
-    installed_version = get_local_boto3_version()
-    latest_version = get_latest_boto3_version()
-
-    installed_major, intalled_minor, _ = installed_version.split(".")
-    latest_major, latest_minor, _ = latest_version.split(".")
-
-    # Signal the progress thread to stop
-    stop_event.set()
-    progress_thread.join()
-
-    if installed_major == latest_major and intalled_minor == latest_minor:
-        return None
-
-    boto3_location = get_local_boto3_path()
-
-    print("==> WARNING: A newer version of boto3 exists. <==")
-    print(f"  current version: {installed_version}")
-    print(f"  latest version: {latest_version}\n\n")
-    print(
-        "Enabling quantum jobs will automatically update boto3, "
-        "which may cause incompatibilities with the amazon-braket-sdk and/or awscli.\n\n"
-    )
-    print("## Package Plan ##\n")
-    print(f"  boto3 location: {boto3_location}\n\n")
-    user_input = input("Proceed ([y]/n)? ")
-
-    if user_input.lower() in ["n", "no"]:
-        print("\nqBraidSystemExit: Exiting.")
-        sys.exit()
-
-    print("")
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "--upgrade", "boto3"]
-    )
-    print("")
-
-    return None
-
-
-def manage_package(action, package, exception_message) -> None:
-    """Generic function to install or uninstall packages.
-
-    Args:
-        action (str): 'install' or 'uninstall'
-        package (str): The package to install or uninstall
-        exception_message (str): Error message to raise in case of exception
-
-    Returns:
-        None
-
-    Raises:
-        QuantumJobsException: If the action fails.
-    """
-    try:
-        if action == "uninstall":
-            subprocess.check_call(
-                [sys.executable, "-m", "pip", "uninstall", package, "-y", "--quiet"]
-            )
-        elif action == "install":
-            subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", package, "--quiet"]
-            )
-    except subprocess.CalledProcessError as err:
-        raise QuantumJobsException(exception_message) from err
-
-
-def enable_quantum_jobs() -> None:
-    """Enables qBraid quantum jobs."""
-    try:
-        verify_boto3_compatible()
-        stop_event = threading.Event()
-        message = "Installing qBraid botocore..."
-        interval = 1.5
-
-        # Start the progress bar in a separate thread
-        progress_thread = threading.Thread(
-            target=print_progress_linear,
-            args=(
-                stop_event,
-                message,
-                interval,
-            ),
-        )
-        progress_thread.start()
-        manage_package(
-            "uninstall",
-            "botocore",
-            "Failed to install qBraid botocore.",
-        )
-        manage_package(
-            "install",
-            "git+https://github.com/qBraid/botocore.git",
-            "Failed to install qBraid botocore.",
-        )
-        stop_event.set()
-        progress_thread.join()
-    except Exception as err:
-        stop_event.set()
-        progress_thread.join()
-        raise QuantumJobsException("Failed to enable qBraid quantum jobs.") from err
-
-    print("\nSuccessfully enabled qBraid quantum jobs.\n")
-
-
-def disable_quantum_jobs() -> None:
-    """Disables qBraid quantum jobs."""
-    try:
-        stop_event = threading.Event()
-        message = "Uninstalling qBraid botocore..."
-        interval = 0.5
-
-        # Start the progress bar in a separate thread
-        progress_thread = threading.Thread(
-            target=print_progress_linear,
-            args=(
-                stop_event,
-                message,
-                interval,
-            ),
-        )
-        progress_thread.start()
-        manage_package(
-            "uninstall",
-            "botocore",
-            "Failed to uninstall qBraid botocore.",
-        )
-        manage_package("install", "botocore", "Failed to reinstall original boto3.")
-        stop_event.set()
-        progress_thread.join()
-    except Exception as err:
-        stop_event.set()
-        progress_thread.join()
-        raise QuantumJobsException("Failed to disable qBraid quantum jobs.") from err
-
-    print("\nSuccessfully disabled qBraid quantum jobs.\n")

qbraid_cli/wrapper.py

@@ -1,103 +0,0 @@
-"""
-Module to run the qbraid command line interface.
-
-Lazy loading is used to avoid loading the qbraid package until it is needed.
-
-"""
-
-import os
-import subprocess
-import sys
-
-PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
-
-# pylint: disable=import-outside-toplevel
-
-
-def flag_help_command():
-    """Check if the help command should be triggered."""
-    if len(sys.argv) > 0:
-        last_arg = sys.argv[-1]
-        if last_arg in ["-h", "--help", "help"]:
-            return True
-    return False
-
-
-def is_help_command(arg_index):
-    """Check if the help command should be triggered for the given argument index"""
-    if flag_help_command() and arg_index == len(sys.argv) - 1:
-        return True
-    return False
-
-
-def get_credits():
-    """Get the number of credits available to the user."""
-    from qbraid.api import QbraidSession
-
-    session = QbraidSession()
-    res = session.get("/billing/credits/get-user-credits").json()
-    qbraid_credits = res["qbraidCredits"]
-    print(qbraid_credits)
-
-
-def main():
-    """The subprocess.run function is used to run the script and pass arguments."""
-    if len(sys.argv) == 2 and sys.argv[1] == "configure":
-        from .configure import configure
-
-        configure()
-    if len(sys.argv) == 5 and sys.argv[1:3] == ["configure", "set"]:
-        from .configure import configure_set
-
-        configure_set(sys.argv[3], sys.argv[4])
-    elif len(sys.argv) == 2 and sys.argv[1] == "credits":
-        get_credits()
-    elif sys.argv[1:] == ["--version"] or sys.argv[1:] == ["-V"]:
-        from ._version import __version__
-
-        print(f"qbraid-cli/{__version__}")
-    elif len(sys.argv) == 3 and sys.argv[1:] == ["jobs", "list"]:
-        from qbraid import get_jobs
-
-        get_jobs()
-    elif len(sys.argv) == 3 and sys.argv[1:] == ["devices", "list"]:
-        from qbraid import get_devices
-
-        get_devices()
-    elif (
-        len(sys.argv) == 5
-        and sys.argv[1:3] == ["envs", "create"]
-        and sys.argv[3] in ["-n", "--name"]
-    ):
-        from .envs import create
-
-        create(sys.argv[4])
-    else:
-        result = subprocess.run(
-            [os.path.join(PROJECT_ROOT, "bin", "qbraid.sh")] + sys.argv[1:],
-            text=True,
-            capture_output=True,
-            check=False,
-        )
-
-        if result.stdout:
-            if len(sys.argv) == 4 and sys.argv[2] == "activate":
-                line_lst = result.stdout.split("\n")
-                line_lst = line_lst[:-1]  # remove trailing blank line
-                bin_path = line_lst.pop()  # last line contains bin_path
-                std_out = "\n".join(line_lst)  # all other lines are regular stdout
-                print(std_out)
-                # activate python environment using bin_path
-                os.system(
-                    f"cat ~/.bashrc {bin_path}/activate > {bin_path}/activate2 && "
-                    rf"sed -i 's/echo -e/\# echo -e/' {bin_path}/activate2 && "
-                    f"/bin/bash --rcfile {bin_path}/activate2"
-                )
-            else:
-                print(result.stdout)
-        if result.stderr:
-            print(result.stderr)
-
-
-if __name__ == "__main__":
-    main()