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

qbraid_cli/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.8.0.dev1'
-__version_tuple__ = version_tuple = (0, 8, 0, 'dev1')
+__version__ = version = '0.8.0.dev4'
+__version_tuple__ = version_tuple = (0, 8, 0, 'dev4')

qbraid_cli/configure/__init__.py

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

qbraid_cli/configure/actions.py

@@ -0,0 +1,111 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining actions invoked by 'qbraid configure' command(s).
+
+"""
+
+import configparser
+import re
+from copy import deepcopy
+from typing import Dict, Optional
+
+import typer
+from qbraid_core.config import (
+    DEFAULT_CONFIG_SECTION,
+    DEFAULT_ENDPOINT_URL,
+    USER_CONFIG_PATH,
+    load_config,
+    save_config,
+)
+from rich.console import Console
+
+from qbraid_cli.handlers import handle_filesystem_operation
+
+
+def validate_input(key: str, value: str) -> str:
+    """Validate the user input based on the key.
+
+    Args:
+        key (str): The configuration key
+        value (str): The user input value
+
+    Returns:
+        str: The validated value
+
+    Raises:
+        typer.BadParameter: If the value is invalid
+    """
+    if key == "url":
+        if not re.match(r"^https?://\S+$", value):
+            raise typer.BadParameter("Invalid URL format.")
+    elif key == "email":
+        if not re.match(r"^\S+@\S+\.\S+$", value):
+            raise typer.BadParameter("Invalid email format.")
+    elif key == "api-key":
+        if not re.match(r"^[a-zA-Z0-9]{11}$", value):
+            raise typer.BadParameter("Invalid API key format.")
+    return value
+
+
+def prompt_for_config(
+    config: configparser.ConfigParser,
+    section: str,
+    key: str,
+    default_values: Optional[Dict[str, str]] = None,
+) -> str:
+    """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
+    hide_input = False
+    show_default = True
+
+    if section == DEFAULT_CONFIG_SECTION:
+        if key == "url":
+            return current_value
+
+        if key == "api-key":
+            if current_value:
+                display_value = "*" * len(current_value[:-4]) + current_value[-4:]
+            hide_input = True
+            show_default = False
+
+    new_value = typer.prompt(
+        f"Enter {key}", default=display_value, show_default=show_default, hide_input=hide_input
+    ).strip()
+
+    if new_value == display_value:
+        return current_value
+
+    return validate_input(key, new_value)
+
+
+def default_action(section: str = DEFAULT_CONFIG_SECTION):
+    """Configure qBraid CLI options."""
+    config = load_config()
+    original_config = deepcopy(config)
+
+    if section not in config:
+        config[section] = {}
+
+    default_values = {"url": DEFAULT_ENDPOINT_URL}
+
+    config[section]["url"] = prompt_for_config(config, section, "url", 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]
+
+    console = Console()
+    if config == original_config:
+        console.print("\n[bold grey70]Configuration saved, unchanged.")
+    else:
+
+        def _save_config():
+            save_config(config)
+
+        handle_filesystem_operation(_save_config, USER_CONFIG_PATH)
+        console.print("\n[bold green]Configuration updated successfully.")

qbraid_cli/configure/app.py

@@ -1,120 +1,23 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid configure' namespace.
 
 """
 
-import configparser
-import re
-from copy import deepcopy
-from pathlib import Path
-from typing import Dict, Optional
-
 import typer
+from qbraid_core.config import load_config, save_config
 
-from qbraid_cli.exceptions import QbraidException
-from qbraid_cli.handlers import handle_filesystem_operation
+from qbraid_cli.configure.actions import default_action
 
 # disable pretty_exceptions_show_locals to avoid printing sensative information in the traceback
-app = typer.Typer(help="Configure qBraid CLI options.", pretty_exceptions_show_locals=False)
-
-
-def load_config() -> configparser.ConfigParser:
-    """Load the configuration from the file."""
-    config_path = Path.home() / ".qbraid" / "qbraidrc"
-    config = configparser.ConfigParser()
-    try:
-        config.read(config_path)
-    except (FileNotFoundError, PermissionError, configparser.Error) as err:
-        raise QbraidException(f"Failed to load configuration from {config_path}.") from err
-
-    return config
-
-
-def save_config(config: configparser.ConfigParser) -> None:
-    """Save configuration to qbraidrc file."""
-    config_path = Path.home() / ".qbraid"
-
-    def save_operation():
-        config_path.mkdir(parents=True, exist_ok=True)
-        with (config_path / "qbraidrc").open("w") as configfile:
-            config.write(configfile)
-
-    handle_filesystem_operation(save_operation, config_path)
-
-
-def validate_input(key: str, value: str) -> str:
-    """Validate the user input based on the key.
-
-    Args:
-        key (str): The configuration key
-        value (str): The user input value
-
-    Returns:
-        str: The validated value
-
-    Raises:
-        typer.BadParameter: If the value is invalid
-    """
-    if key == "url":
-        if not re.match(r"^https?://\S+$", value):
-            raise typer.BadParameter("Invalid URL format.")
-    elif key == "email":
-        if not re.match(r"^\S+@\S+\.\S+$", value):
-            raise typer.BadParameter("Invalid email format.")
-    elif key == "api-key":
-        if not re.match(r"^[a-zA-Z0-9]{11}$", value):
-            raise typer.BadParameter("Invalid API key format.")
-    return value
-
-
-def prompt_for_config(
-    config: configparser.ConfigParser,
-    section: str,
-    key: str,
-    default_values: Optional[Dict[str, str]] = None,
-) -> str:
-    """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
-
-    if key == "api-key" and current_value:
-        display_value = "*" * len(current_value[:-4]) + current_value[-4:]
-
-    new_value = typer.prompt(f"Enter {key}", default=display_value, show_default=True).strip()
-
-    if new_value == display_value:
-        return current_value
-
-    return validate_input(key, new_value)
-
-
-def default_action(section: str = "default"):
-    """Configure qBraid CLI options."""
-    config = load_config()
-    original_config = deepcopy(config)
-
-    if section not in config:
-        config[section] = {}
-
-    default_values = {"url": "https://api.qbraid.com/api"}
-
-    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]
-
-    if config == original_config:
-        typer.echo("\nConfiguration saved, unchanged.")
-    else:
-        save_config(config)
-        typer.echo("\nConfiguration updated successfully.")
+configure_app = typer.Typer(
+    help="Configure qBraid CLI options.", pretty_exceptions_show_locals=False
+)
 
 
-@app.callback(invoke_without_command=True)
+@configure_app.callback(invoke_without_command=True)
 def configure(ctx: typer.Context):
     """
     Prompts user for configuration values such as your qBraid API Key.
@@ -129,7 +32,7 @@ def configure(ctx: typer.Context):
         default_action()
 
 
-@app.command(name="set")
+@configure_app.command(name="set")
 def configure_set(
     name: str = typer.Argument(..., help="Config name"),
     value: str = typer.Argument(..., help="Config value"),
@@ -148,4 +51,4 @@ def configure_set(
 
 
 if __name__ == "__main__":
-    app()
+    configure_app()

qbraid_cli/credits/__init__.py

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

qbraid_cli/credits/app.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid credits' namespace.
 
@@ -7,24 +10,23 @@ import typer
 
 from qbraid_cli.handlers import run_progress_task
 
-app = typer.Typer(help="Manage qBraid credits.")
+credits_app = typer.Typer(help="Manage qBraid credits.")
 
 
-@app.command(name="value")
+@credits_app.command(name="value")
 def credits_value():
     """Get number of qBraid credits remaining."""
 
-    def get_credits() -> int:
-        from qbraid.api import QbraidSession
+    def get_credits() -> float:
+        from qbraid_core import QbraidClient
 
-        session = QbraidSession()
-        res = session.get("/billing/credits/get-user-credits").json()
-        return res["qbraidCredits"]
+        client = QbraidClient()
+        return client.user_credits_value()
 
-    qbraid_credits: int = run_progress_task(get_credits)
-    credits_text = typer.style(str(qbraid_credits), fg=typer.colors.GREEN, bold=True)
+    qbraid_credits: float = run_progress_task(get_credits)
+    credits_text = typer.style(f"{qbraid_credits:.2f}", fg=typer.colors.GREEN, bold=True)
     typer.secho(f"\nqBraid credits: {credits_text}")
 
 
 if __name__ == "__main__":
-    app()
+    credits_app()

qbraid_cli/devices/__init__.py

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

qbraid_cli/devices/app.py

@@ -1,34 +1,24 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid devices' namespace.
 
 """
 
-from typing import Callable, Optional, Tuple, Union
+from typing import Any, Callable, Optional, 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 devices.")
-
-
-def validate_status(value: Optional[str]) -> Union[str, None]:
-    """Validate device status query parameter."""
-    return validate_item(value, ["ONLINE", "OFFLINE", "RETIRED"], "Status")
-
-
-def validate_type(value: Optional[str]) -> Union[str, None]:
-    """Validate device type query parameter."""
-    return validate_item(value, ["QPU", "SIMULATOR"], "Type")
+from qbraid_cli.devices.validation import validate_provider, validate_status, validate_type
+from qbraid_cli.handlers import run_progress_task
 
+devices_app = typer.Typer(help="Manage qBraid quantum devices.")
 
-def validate_provider(value: Optional[str]) -> Union[str, None]:
-    """Validate device provider query parameter."""
-    return validate_item(value, ["AWS", "IBM", "IonQ", "Rigetti", "OQC", "QuEra"], "Provider")
 
-
-@app.command(name="list")
-def devices_list(
+@devices_app.command(name="list")
+def devices_list(  # pylint: disable=too-many-branches
     status: Optional[str] = typer.Option(
         None, "--status", "-s", help="'ONLINE'|'OFFLINE'|'RETIRED'", callback=validate_status
     ),
@@ -44,16 +34,6 @@ def devices_list(
     ),
 ) -> None:
     """List qBraid quantum devices."""
-
-    def import_devices() -> Tuple[Callable, Exception]:
-        from qbraid import get_devices
-        from qbraid.exceptions import QbraidError
-
-        return get_devices, QbraidError
-
-    result: Tuple[Callable, Exception] = run_progress_task(import_devices)
-    get_devices, QbraidError = result
-
     filters = {}
     if status:
         filters["status"] = status
@@ -62,11 +42,39 @@ def devices_list(
     if provider:
         filters["provider"] = provider
 
-    try:
-        get_devices(filters=filters)
-    except QbraidError:
-        handle_error(message="Failed to fetch quantum devices.")
+    def import_devices() -> Tuple[Any, Callable]:
+        from qbraid_core.services.quantum import QuantumClient, process_device_data
+
+        client = QuantumClient()
+
+        return client, process_device_data
+
+    result: Tuple[Callable, Callable] = run_progress_task(import_devices)
+    client, process_device_data = result
+    raw_data = client.search_devices(filters)
+    device_data, msg = process_device_data(raw_data)
+
+    console = Console()
+    header_1 = "Provider"
+    header_2 = "Device Name"
+    header_3 = "ID"
+    header_4 = "Status"
+    console.print(
+        f"\n[bold]{header_1.ljust(12)}{header_2.ljust(35)}{header_3.ljust(41)}{header_4}[/bold]"
+    )
+    for device_provider, device_name, device_id, device_status in device_data:
+        if device_status == "ONLINE":
+            status_color = "green"
+        elif device_status == "OFFLINE":
+            status_color = "red"
+        else:
+            status_color = "grey"
+        console.print(
+            f"{device_provider.ljust(12)}{device_name.ljust(35)}{device_id.ljust(40)}",
+            f"[{status_color}]{device_status}[/{status_color}]",
+        )
+    console.print(f"\n{msg}", style="italic", justify="left")
 
 
 if __name__ == "__main__":
-    app()
+    devices_app()

qbraid_cli/devices/validation.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for validating command arguments for qBraid devices commands.
+
+
+"""
+
+from typing import Optional, Union
+
+from qbraid_cli.handlers import validate_item
+
+
+def validate_status(value: Optional[str]) -> Union[str, None]:
+    """Validate device status query parameter."""
+    return validate_item(value, ["ONLINE", "OFFLINE", "RETIRED"], "Status")
+
+
+def validate_type(value: Optional[str]) -> Union[str, None]:
+    """Validate device type query parameter."""
+    return validate_item(value, ["QPU", "SIMULATOR"], "Type")
+
+
+def validate_provider(value: Optional[str]) -> Union[str, None]:
+    """Validate device provider query parameter."""
+    return validate_item(value, ["AWS", "IBM", "IonQ", "Rigetti", "OQC", "QuEra"], "Provider")

qbraid_cli/envs/__init__.py

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

qbraid_cli/envs/activate.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module supporting 'qbraid envs activate' command.
 
@@ -31,13 +34,13 @@ def print_activate_command(venv_path: Path) -> None:
         # Windows operating system
         activate_script = venv_path / "Scripts" / "activate"
         activate_script_ps = venv_path / "Scripts" / "Activate.ps1"
-        typer.echo("    " + str(activate_script))
+        typer.echo("\t$ " + str(activate_script))
         typer.echo("\nOr for PowerShell, use:\n")
-        typer.echo("    " + f"& {activate_script_ps}")
+        typer.echo("\t$ " + f"& {activate_script_ps}")
     else:
         # Unix-like operating systems (Linux/macOS)
         activate_script = venv_path / "bin" / "activate"
-        typer.echo("    " + f"source {activate_script}")
+        typer.echo("\t$ " + f"source {activate_script}")
     typer.echo("")
     raise typer.Exit()
 
@@ -48,12 +51,12 @@ def activate_pyvenv(venv_path: Path):
 
     if shell_path is None:
         print_activate_command(venv_path)
-
+        return  # Return early since we can't proceed without a shell
     try:
         shell_rc = find_shell_rc(shell_path)
     except (FileNotFoundError, ValueError):
         print_activate_command(venv_path)
-
+        return  # Return early since no suitable shell rc file was found
     bin_path = str(venv_path / "bin")
 
     os.system(