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

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 rich.console import Console
 
-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,13 +32,16 @@ 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"),
     profile: str = typer.Option("default", help="Profile name"),
 ):
     """Set configuration value in qbraidrc file."""
+    # pylint: disable-next=import-outside-toplevel
+    from qbraid_core.config import load_config, save_config
+
     config = load_config()
 
     if profile not in config:
@@ -147,5 +53,25 @@ def configure_set(
     typer.echo("Configuration updated successfully.")
 
 
+@configure_app.command(name="magic")
+def configure_magic():
+    """Enable qBraid IPython magic commands."""
+    # pylint: disable-next=import-outside-toplevel
+    from qbraid_core.services.environments import add_magic_config
+
+    add_magic_config()
+
+    console = Console()
+
+    in_1 = (
+        "[green]In [[/green][yellow]1[/yellow][green]]:[/green] [blue]%[/blue]load_ext qbraid_magic"
+    )
+    in_2 = "[green]In [[/green][yellow]2[/yellow][green]]:[/green] [blue]%[/blue]qbraid"
+
+    console.print("\nSuccessfully configured qBraid IPython magic commands.\n")
+    console.print("You can now use the qBraid-CLI from inside a Jupyter notebook as follows:")
+    console.print(f"\n\t{in_1}\n\n\t{in_2}\n")
+
+
 if __name__ == "__main__":
-    app()
+    configure_app()

qbraid_cli/devices/__init__.py

@@ -1,6 +1,11 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining the qbraid devices namespace
 
 """
 
-from .app import app
+from .app import devices_app
+
+__all__ = ["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
 
 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.", no_args_is_help=True)
 
-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"[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,26 @@
+# 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,11 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining the qbraid envs namespace
 
 """
 
-from .app import app
+from .app import envs_app
+
+__all__ = ["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(