qbraid-cli 0.8.0.dev1__py3-none-any.whl → 0.9.5__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.9.5'
+__version_tuple__ = version_tuple = (0, 9, 5)

qbraid_cli/account/__init__.py

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

qbraid_cli/account/app.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid user' namespace.
+
+"""
+
+from typing import Any
+
+import rich
+import typer
+
+from qbraid_cli.handlers import run_progress_task
+
+account_app = typer.Typer(help="Manage qBraid account.", no_args_is_help=True)
+
+
+@account_app.command(name="credits")
+def account_credits():
+    """Get number of qBraid credits remaining."""
+
+    def get_credits() -> float:
+        from qbraid_core import QbraidClient
+
+        client = QbraidClient()
+        return client.user_credits_value()
+
+    qbraid_credits: float = run_progress_task(get_credits)
+    typer.secho(
+        f"{typer.style('qBraid credits remaining:')} "
+        f"{typer.style(f'{qbraid_credits:.4f}', fg=typer.colors.MAGENTA, bold=True)}",
+        nl=True,  # Ensure a newline after output (default is True)
+    )
+    rich.print("\nFor more information, visit: https://docs.qbraid.com/home/pricing#credits")
+
+
+@account_app.command(name="info")
+def account_info():
+    """Get qBraid account (user) metadata."""
+
+    def get_user() -> dict[str, Any]:
+        from qbraid_core import QbraidSession
+
+        session = QbraidSession()
+        user = session.get_user()
+        personal_info: dict = user.get("personalInformation", {})
+        metadata = {
+            "_id": user.get("_id"),
+            "userName": user.get("userName"),
+            "email": user.get("email"),
+            "joinedDate": user.get("createdAt", "Unknown"),
+            "activePlan": user.get("activePlan", "") or "Free",
+            "organization": personal_info.get("organization", "") or "qbraid",
+            "role": personal_info.get("role", "") or "guest",
+        }
+
+        return metadata
+
+    info = run_progress_task(get_user)
+    rich.print(info)
+
+
+if __name__ == "__main__":
+    account_app()

qbraid_cli/admin/__init__.py

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

qbraid_cli/admin/app.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid admin' namespace.
+
+"""
+
+from typing import Optional
+
+import typer
+
+from qbraid_cli.admin.headers import check_and_fix_headers
+from qbraid_cli.admin.validation import validate_header_type, validate_paths_exist
+
+admin_app = typer.Typer(
+    help="CI/CD commands for qBraid maintainers.",
+    pretty_exceptions_show_locals=False,
+    no_args_is_help=True,
+)
+
+
+@admin_app.command(name="headers")
+def admin_headers(
+    src_paths: list[str] = typer.Argument(
+        ..., help="Source file or directory paths to verify.", callback=validate_paths_exist
+    ),
+    header_type: str = typer.Option(
+        "default",
+        "--type",
+        "-t",
+        help="Type of header to use ('default' or 'gpl').",
+        callback=validate_header_type,
+    ),
+    skip_files: list[str] = typer.Option(
+        [], "--skip", "-s", help="Files to skip during verification.", callback=validate_paths_exist
+    ),
+    fix: bool = typer.Option(
+        False, "--fix", "-f", help="Whether to fix the headers instead of just verifying."
+    ),
+    project_name: Optional[str] = typer.Option(
+        "the qBraid-SDK", "--project", "-p", help="Name of the project to use in the header."
+    ),
+):
+    """
+    Verifies and optionally fixes qBraid headers in specified files and directories.
+
+    """
+    check_and_fix_headers(
+        src_paths,
+        header_type=header_type,
+        skip_files=skip_files,
+        fix=fix,
+        project_name=project_name,
+    )
+
+
+if __name__ == "__main__":
+    admin_app()

qbraid_cli/admin/headers.py

@@ -0,0 +1,235 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Script to verify qBraid copyright file headers
+
+"""
+
+import datetime
+import os
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from qbraid_cli.handlers import handle_error
+
+# pylint: disable=too-many-branches,too-many-statements
+CURR_YEAR = datetime.datetime.now().year
+PREV_YEAR = CURR_YEAR - 1
+VALID_EXTS = (".py", ".js", ".ts")
+
+
+DEFAULT_HEADER = f"""# Copyright (c) {str(CURR_YEAR)}, qBraid Development Team
+# All rights reserved.
+"""
+
+DEFAULT_HEADER_GPL = (
+    f"""# Copyright (C) {str(CURR_YEAR)} qBraid"""
+    + """#
+# This file is part of {project_name}
+#
+# {project_name_start} is free software released under the GNU General Public License v3
+# or later. You can redistribute and/or modify it under the terms of the GPL v3.
+# See the LICENSE file in the project root or <https://www.gnu.org/licenses/gpl-3.0.html>.
+#
+# THERE IS NO WARRANTY for {project_name}, as per Section 15 of the GPL v3.
+"""
+)
+
+HEADER_TYPES = {
+    "default": DEFAULT_HEADER,
+    "gpl": DEFAULT_HEADER_GPL,
+}
+
+
+def get_formatted_header(header_type: str, project_name: str) -> str:
+    """Get the formatted header based on the header type
+
+    Args:
+        header_type (str): The type of header to use.
+        project_name (str): The name of the project to use in the header.
+
+    Returns:
+        str: The formatted header
+    """
+
+    header = HEADER_TYPES[header_type]
+    if header_type == "gpl":
+        return header.format(
+            project_name=project_name, project_name_start=project_name[0].upper() + project_name[1:]
+        )
+    return header
+
+
+def check_and_fix_headers(
+    src_paths: list[str],
+    header_type: str = "default",
+    skip_files: Optional[list[str]] = None,
+    fix: bool = False,
+    project_name: Optional[str] = None,
+) -> None:
+    """Script to add or verify qBraid copyright file headers"""
+    try:
+        header = get_formatted_header(header_type, project_name)
+    except KeyError:
+        handle_error(
+            error_type="ValueError",
+            message=(
+                f"Invalid header type: {HEADER_TYPES}. Expected one of {list(HEADER_TYPES.keys())}"
+            ),
+        )
+
+    for path in src_paths:
+        if not os.path.exists(path):
+            handle_error(error_type="FileNotFoundError", message=f"Path '{path}' does not exist.")
+
+    header_prev_year = header.replace(str(CURR_YEAR), str(PREV_YEAR))
+
+    skip_files = skip_files or []
+
+    failed_headers = []
+    fixed_headers = []
+
+    console = Console()
+
+    def should_skip(file_path: str, content: str) -> bool:
+        if file_path in skip_files:
+            return True
+
+        if os.path.basename(file_path) == "__init__.py":
+            return not content.strip()
+
+        skip_header_tag = "# qbraid: skip-header"
+        line_number = 0
+
+        for line in content.splitlines():
+            line_number += 1
+            if 5 <= line_number <= 30 and skip_header_tag in line:
+                return True
+            if line_number > 30:
+                break
+
+        return False
+
+    def replace_or_add_header(file_path: str, fix: bool = False) -> None:
+        with open(file_path, "r", encoding="ISO-8859-1") as f:
+            content = f.read()
+
+        # Get the file extension
+        file_ext = os.path.splitext(file_path)[1]
+
+        if file_ext == ".py":
+            comment_marker = "#"
+        elif file_ext in (".js", ".ts"):
+            comment_marker = "//"
+
+        # This finds the start of the actual content after skipping initial whitespace and comments.
+        lines = content.splitlines()
+        first_non_comment_line_index = next(
+            (i for i, line in enumerate(lines) if not line.strip().startswith(comment_marker)), None
+        )
+
+        # Prepare the content by stripping leading and trailing whitespace and separating into lines
+        actual_content = (
+            "\n".join(lines[first_non_comment_line_index:]).strip()
+            if first_non_comment_line_index is not None
+            else ""
+        )
+
+        updated_header = header.replace("#", comment_marker)
+        updated_prev_header = header_prev_year.replace("#", comment_marker)
+
+        # Check if the content already starts with the header or if the file should be skipped
+        if (
+            content.lstrip().startswith(updated_header)
+            or content.lstrip().startswith(updated_prev_header)
+            or should_skip(file_path, content)
+        ):
+            return
+
+        if not fix:
+            failed_headers.append(file_path)
+        else:
+            # Form the new content by combining the header, one blank line, and the actual content
+            new_content = updated_header.strip() + "\n\n" + actual_content
+            with open(file_path, "w", encoding="ISO-8859-1") as f:
+                f.write(new_content)
+            fixed_headers.append(file_path)
+
+    def process_files_in_directory(directory: str, fix: bool = False) -> int:
+        count = 0
+        if not os.path.isdir(directory):
+            return count
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if file.endswith(VALID_EXTS):
+                    file_path = os.path.join(root, file)
+                    replace_or_add_header(file_path, fix)
+                    count += 1
+        return count
+
+    checked = 0
+    for item in src_paths:
+        if os.path.isdir(item):
+            checked += process_files_in_directory(item, fix)
+        elif os.path.isfile(item) and item.endswith(VALID_EXTS):
+            replace_or_add_header(item, fix)
+            checked += 1
+        else:
+            if not os.path.isfile(item):
+                handle_error(
+                    error_type="FileNotFoundError", message=f"Path '{item}' does not exist."
+                )
+
+    if checked == 0:
+        console.print(f"[bold]No {VALID_EXTS} files present. Nothing to do[/bold] 😴")
+        raise typer.Exit(0)
+
+    if not fix:
+        if failed_headers:
+            for file in failed_headers:
+                console.print(f"[bold]would fix {file}[/bold]")
+            num_failed = len(failed_headers)
+            num_passed = checked - num_failed
+            s1, s2 = ("", "s") if num_failed == 1 else ("s", "")
+            s_passed = "" if num_passed == 1 else "s"
+            console.print("[bold]\nOh no![/bold] 💥 💔 💥")
+            if num_passed > 0:
+                punc = ", "
+                passed_msg = f"[blue]{num_passed}[/blue] file{s_passed} would be left unchanged."
+            else:
+                punc = "."
+                passed_msg = ""
+
+            failed_msg = f"[bold][blue]{num_failed}[/blue] file{s1} need{s2} updating{punc}[/bold]"
+            console.print(f"{failed_msg}{passed_msg}")
+            raise typer.Exit(1)
+
+        s_checked = "" if checked == 1 else "s"
+        console.print("[bold]All done![/bold] ✨ 🚀 ✨")
+        console.print(f"[blue]{checked}[/blue] file{s_checked} would be left unchanged.")
+        raise typer.Exit(0)
+
+    for file in fixed_headers:
+        console.print(f"[bold]fixed {file}[/bold]")
+    num_fixed = len(fixed_headers)
+    num_ok = checked - num_fixed
+    s_fixed = "" if num_fixed == 1 else "s"
+    s_ok = "" if num_ok == 1 else "s"
+    console.print("\n[bold]All done![/bold] ✨ 🚀 ✨")
+    if num_ok > 0:
+        punc = ", "
+        unchanged_msg = f"[blue]{num_ok}[/blue] file{s_ok} left unchanged."
+    else:
+        punc = "."
+        unchanged_msg = ""
+
+    if num_fixed > 0:
+        fixed_msg = f"[bold][blue]{num_fixed}[/blue] file{s_fixed} fixed{punc}[/bold]"
+    else:
+        fixed_msg = ""
+
+    console.print(f"{fixed_msg}{unchanged_msg}")
+    raise typer.Exit(0)

qbraid_cli/admin/validation.py

@@ -0,0 +1,32 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for validating command arguments for qBraid admin commands.
+
+"""
+
+import os
+
+import typer
+
+from qbraid_cli.admin.headers import HEADER_TYPES
+from qbraid_cli.handlers import _format_list_items, validate_item
+
+
+def validate_header_type(value: str) -> str:
+    """Validate header type."""
+    header_types = list(HEADER_TYPES.keys())
+    return validate_item(value, header_types, "Header type")
+
+
+def validate_paths_exist(paths: list[str]) -> list[str]:
+    """Verifies that each path in the provided list exists."""
+    non_existent_paths = [path for path in paths if not os.path.exists(path)]
+    if non_existent_paths:
+        if len(non_existent_paths) == 1:
+            raise typer.BadParameter(f"Path '{non_existent_paths[0]}' does not exist")
+        raise typer.BadParameter(
+            f"The following paths do not exist: {_format_list_items(non_existent_paths)}"
+        )
+    return paths

qbraid_cli/chat/__init__.py

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

qbraid_cli/chat/app.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid chat' namespace.
+
+"""
+from enum import Enum
+
+from rich.console import Console
+from rich.table import Table
+
+from qbraid_cli.handlers import handle_error, run_progress_task
+
+
+class ChatFormat(str, Enum):
+    """Format of the response from the chat service."""
+
+    text = "text"  # pylint: disable=invalid-name
+    code = "code"  # pylint: disable=invalid-name
+
+
+def list_models_callback():
+    """List available chat models."""
+    # pylint: disable-next=import-outside-toplevel
+    from qbraid_core.services.chat import ChatClient
+
+    client = ChatClient()
+
+    models = run_progress_task(
+        client.get_models,
+        description="Connecting to chat service...",
+        include_error_traceback=False,
+    )
+
+    console = Console()
+    table = Table(title="Available Chat Models\n", show_lines=True, title_justify="left")
+
+    table.add_column("Model", style="cyan", no_wrap=True)
+    table.add_column("Pricing [not bold](1k tokens ~750 words)", style="magenta")
+    table.add_column("Description", style="green")
+
+    for model in models:
+        table.add_row(
+            model["model"],
+            f"{model['pricing']['input']} credits / 1M input tokens\n"
+            f"{model['pricing']['output']} credits / 1M output tokens",
+            model["description"],
+        )
+
+    console.print(table)
+
+
+def prompt_callback(prompt: str, model: str, response_format: ChatFormat, stream: bool):
+    """Send a chat prompt to the chat service."""
+    # pylint: disable-next=import-outside-toplevel
+    from qbraid_core.services.chat import ChatClient, ChatServiceRequestError
+
+    client = ChatClient()
+
+    if stream:
+        try:
+            for chunk in client.chat_stream(prompt, model, response_format):
+                print(chunk, end="")
+        except ChatServiceRequestError as err:
+            handle_error(message=str(err), include_traceback=False)
+    else:
+        content = run_progress_task(
+            client.chat,
+            prompt,
+            model,
+            response_format,
+            description="Connecting to chat service...",
+            include_error_traceback=False,
+        )
+        print(content)

qbraid_cli/configure/__init__.py

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