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

qbraid_cli/envs/app.py

@@ -1,150 +1,27 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid envs' namespace.
 
 """
 
-import json
-import keyword
-import re
 import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 import typer
 from rich.console import Console
 
+from qbraid_cli.envs.data_handling import installed_envs_data, request_delete_env, validate_env_name
 from qbraid_cli.handlers import QbraidException, run_progress_task
 
-app = typer.Typer(help="Manage qBraid environments.")
-
-
-def is_valid_env_name(env_name: str) -> bool:  # pylint: disable=too-many-return-statements
-    """
-    Validates a Python virtual environment name against best practices.
-
-    This function checks if the given environment name is valid based on certain
-    criteria, including length, use of special characters, reserved names, and
-    operating system-specific restrictions.
-
-    Args:
-        env_name (str): The name of the Python virtual environment to validate.
-
-    Returns:
-        bool: True if the name is valid, False otherwise.
-
-    Raises:
-        ValueError: If the environment name is not a string or is empty.
-    """
-    # Basic checks for empty names or purely whitespace names
-    if not env_name or env_name.isspace():
-        return False
-
-    # Check for invalid characters, including shell metacharacters and spaces
-    if re.search(r'[<>:"/\\|?*\s&;()$[\]#~!{}]', env_name):
-        return False
-
-    if env_name.startswith("tmp"):
-        return False
-
-    # Reserved names for Windows (example list, can be expanded)
-    reserved_names = [
-        "CON",
-        "PRN",
-        "AUX",
-        "NUL",
-        "COM1",
-        "COM2",
-        "COM3",
-        "COM4",
-        "COM5",
-        "COM6",
-        "COM7",
-        "COM8",
-        "COM9",
-        "LPT1",
-        "LPT2",
-        "LPT3",
-        "LPT4",
-        "LPT5",
-        "LPT6",
-        "LPT7",
-        "LPT8",
-        "LPT9",
-    ]
-    if env_name.upper() in reserved_names:
-        return False
-
-    if len(env_name) > 20:
-        return False
-
-    # Check against Python reserved words
-    if keyword.iskeyword(env_name):
-        return False
-
-    # Check if it starts with a number, which is not a good practice
-    if env_name[0].isdigit():
-        return False
-
-    return True
-
-
-def validate_env_name(value: str) -> str:
-    """Validate environment name."""
-    if not is_valid_env_name(value):
-        raise typer.BadParameter(
-            f"Invalid environment name '{value}'. " "Please use a valid Python environment name."
-        )
-    return value
-
-
-def installed_envs_data() -> Tuple[Dict[str, Path], Dict[str, str]]:
-    """Gather paths and aliases for all installed qBraid environments."""
-    from qbraid.api.system import get_qbraid_envs_paths, is_valid_slug
-
-    installed = {}
-    aliases = {}
-
-    qbraid_env_paths: List[Path] = get_qbraid_envs_paths()
-
-    for env_path in qbraid_env_paths:
-        for entry in env_path.iterdir():
-            if entry.is_dir() and is_valid_slug(entry.name):
-                installed[entry.name] = entry
+envs_app = typer.Typer(help="Manage qBraid environments.")
 
-                if entry.name == "qbraid_000000":
-                    aliases["default"] = entry.name
-                    continue
 
-                state_json_path = entry / "state.json"
-                if state_json_path.exists():
-                    try:
-                        with open(state_json_path, "r", encoding="utf-8") as f:
-                            data = json.load(f)
-                        aliases[data.get("name", entry.name[:-7])] = entry.name
-                    # pylint: disable-next=broad-exception-caught
-                    except (json.JSONDecodeError, Exception):
-                        aliases[entry.name[:-7]] = entry.name
-                else:
-                    aliases[entry.name[:-7]] = entry.name
-
-    return installed, aliases
-
-
-def request_delete_env(slug: str) -> str:
-    """Send request to delete environment given slug."""
-    from qbraid.api import QbraidSession, RequestsApiError
-
-    session = QbraidSession()
-
-    try:
-        session.delete(f"/environments/{slug}")
-    except RequestsApiError as err:
-        raise QbraidException("Delete environment request failed") from err
-
-
-@app.command(name="create")
+@envs_app.command(name="create")
 def envs_create(  # pylint: disable=too-many-statements
     name: str = typer.Option(
         ..., "--name", "-n", help="Name of the environment to create", callback=validate_env_name
@@ -152,13 +29,16 @@ def envs_create(  # pylint: disable=too-many-statements
     description: Optional[str] = typer.Option(
         None, "--description", "-d", help="Short description of the environment"
     ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Create a new qBraid environment."""
     from .create import create_qbraid_env_assets, create_venv
 
     def request_new_env(req_body: Dict[str, str]) -> Dict[str, Any]:
         """Send request to create new environment and return the slug."""
-        from qbraid.api import QbraidSession, RequestsApiError
+        from qbraid_core import QbraidSession, RequestsApiError
 
         session = QbraidSession()
 
@@ -176,9 +56,9 @@ def envs_create(  # pylint: disable=too-many-statements
 
     def gather_local_data() -> Tuple[Path, str]:
         """Gather environment data and return the slug."""
-        from qbraid.api.system import get_qbraid_envs_paths
+        from qbraid_core.services.environments import get_default_envs_paths
 
-        env_path = get_qbraid_envs_paths()[0]
+        env_path = get_default_envs_paths()[0]
 
         result = subprocess.run(
             [sys.executable, "--version"],
@@ -237,7 +117,7 @@ def envs_create(  # pylint: disable=too-many-statements
     typer.echo(f"  location: {slug_path}")
     typer.echo(f"  version: {python_version}\n")
 
-    user_confirmation = typer.confirm("Proceed", default=True)
+    user_confirmation = auto_confirm or typer.confirm("Proceed", default=True)
     typer.echo("")
     if not user_confirmation:
         request_delete_env(slug)
@@ -276,9 +156,12 @@ def envs_create(  # pylint: disable=too-many-statements
     typer.echo("#     $ deactivate")
 
 
-@app.command(name="remove")
+@envs_app.command(name="remove")
 def envs_remove(
-    name: str = typer.Option(..., "-n", "--name", help="Name of the environment to remove")
+    name: str = typer.Option(..., "-n", "--name", help="Name of the environment to remove"),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Delete a qBraid environment."""
 
@@ -304,8 +187,7 @@ def envs_remove(
         "Are you sure you want to continue?"
     )
 
-    # Ask for user confirmation
-    if typer.confirm(confirmation_message, abort=True):
+    if auto_confirm or typer.confirm(confirmation_message, abort=True):
         typer.echo("")
         run_progress_task(
             request_delete_env,
@@ -321,25 +203,24 @@ def envs_remove(
             error_message="Failed to delete qBraid environment",
         )
         typer.echo(f"\nEnvironment '{name}' successfully removed.")
-        # console = Console()
-        # console.print(
-        #     f"\n[bold green]Successfully deleted qBraid environment: "
-        #     f"[/bold green][bold magenta]{name}[/bold magenta]\n"
-        # )
 
 
-@app.command(name="list")
+@envs_app.command(name="list")
 def envs_list():
     """List installed qBraid environments."""
     installed, aliases = installed_envs_data()
 
+    console = Console()
+
     if len(installed) == 0:
-        print("No qBraid environments installed.")
-        print("\nUse 'qbraid envs create' to create a new environment.")
+        console.print(
+            "No qBraid environments installed.\n\n"
+            + "Use 'qbraid envs create' to create a new environment.",
+            style="yellow",
+        )
         return
 
     alias_path_pairs = [(alias, installed[slug_name]) for alias, slug_name in aliases.items()]
-
     sorted_alias_path_pairs = sorted(
         alias_path_pairs,
         key=lambda x: (x[0] != "default", str(x[1]).startswith(str(Path.home())), x[0]),
@@ -348,21 +229,23 @@ def envs_list():
     current_env_path = Path(sys.executable).parent.parent.parent
 
     max_alias_length = (
-        max(len(alias) for alias, _ in sorted_alias_path_pairs) if sorted_alias_path_pairs else 0
-    )
-    max_path_length = (
-        max(len(str(path)) for _, path in sorted_alias_path_pairs) if sorted_alias_path_pairs else 0
+        max(len(str(alias)) for alias, envpath in sorted_alias_path_pairs)
+        if sorted_alias_path_pairs
+        else 0
     )
 
     print("# qbraid environments:")
     print("#")
     print("")
+
     for alias, path in sorted_alias_path_pairs:
-        mark = "*  " if path == current_env_path else "   "
-        print(f"{alias.ljust(max_alias_length + 7)}{mark}{str(path).ljust(max_path_length)}")
+        mark = "*" if path == current_env_path else " "
+        # Format each line with spacing based on the longest alias for alignment
+        line = f"{alias.ljust(max_alias_length+3)}{mark} {path}"  # fix the most optimal spacing
+        console.print(line)
 
 
-@app.command(name="activate")
+@envs_app.command(name="activate")
 def envs_activate(
     name: str = typer.Argument(..., help="Name of the environment. Values from 'qbraid envs list'.")
 ):
@@ -384,4 +267,4 @@ def envs_activate(
 
 
 if __name__ == "__main__":
-    app()
+    envs_app()

qbraid_cli/envs/create.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module supporting 'qbraid envs create' command.
 

qbraid_cli/envs/data_handling.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for handling data related to qBraid environments.
+
+"""
+
+import json
+import keyword
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import typer
+
+from qbraid_cli.handlers import QbraidException
+
+
+def is_valid_env_name(env_name: str) -> bool:  # pylint: disable=too-many-return-statements
+    """
+    Validates a Python virtual environment name against best practices.
+
+    This function checks if the given environment name is valid based on certain
+    criteria, including length, use of special characters, reserved names, and
+    operating system-specific restrictions.
+
+    Args:
+        env_name (str): The name of the Python virtual environment to validate.
+
+    Returns:
+        bool: True if the name is valid, False otherwise.
+
+    Raises:
+        ValueError: If the environment name is not a string or is empty.
+    """
+    # Basic checks for empty names or purely whitespace names
+    if not env_name or env_name.isspace():
+        return False
+
+    # Check for invalid characters, including shell metacharacters and spaces
+    if re.search(r'[<>:"/\\|?*\s&;()$[\]#~!{}]', env_name):
+        return False
+
+    if env_name.startswith("tmp"):
+        return False
+
+    # Reserved names for Windows (example list, can be expanded)
+    reserved_names = [
+        "CON",
+        "PRN",
+        "AUX",
+        "NUL",
+        "COM1",
+        "COM2",
+        "COM3",
+        "COM4",
+        "COM5",
+        "COM6",
+        "COM7",
+        "COM8",
+        "COM9",
+        "LPT1",
+        "LPT2",
+        "LPT3",
+        "LPT4",
+        "LPT5",
+        "LPT6",
+        "LPT7",
+        "LPT8",
+        "LPT9",
+    ]
+    if env_name.upper() in reserved_names:
+        return False
+
+    if len(env_name) > 20:
+        return False
+
+    # Check against Python reserved words
+    if keyword.iskeyword(env_name):
+        return False
+
+    # Check if it starts with a number, which is not a good practice
+    if env_name[0].isdigit():
+        return False
+
+    return True
+
+
+def validate_env_name(value: str) -> str:
+    """Validate environment name."""
+    if not is_valid_env_name(value):
+        raise typer.BadParameter(
+            f"Invalid environment name '{value}'. " "Please use a valid Python environment name."
+        )
+    return value
+
+
+def installed_envs_data() -> Tuple[Dict[str, Path], Dict[str, str]]:
+    """Gather paths and aliases for all installed qBraid environments."""
+    from qbraid_core.services.environments.paths import get_default_envs_paths, is_valid_slug
+
+    installed = {}
+    aliases = {}
+
+    qbraid_env_paths: List[Path] = get_default_envs_paths()
+
+    for env_path in qbraid_env_paths:
+        for entry in env_path.iterdir():
+            if entry.is_dir() and is_valid_slug(entry.name):
+                installed[entry.name] = entry
+
+                if entry.name == "qbraid_000000":
+                    aliases["default"] = entry.name
+                    continue
+
+                state_json_path = entry / "state.json"
+                if state_json_path.exists():
+                    try:
+                        with open(state_json_path, "r", encoding="utf-8") as f:
+                            data = json.load(f)
+                        aliases[data.get("name", entry.name[:-7])] = entry.name
+                    # pylint: disable-next=broad-exception-caught
+                    except (json.JSONDecodeError, Exception):
+                        aliases[entry.name[:-7]] = entry.name
+                else:
+                    aliases[entry.name[:-7]] = entry.name
+    return installed, aliases
+
+
+def request_delete_env(slug: str) -> str:
+    """Send request to delete environment given slug."""
+    from qbraid_core import QbraidSession, RequestsApiError
+
+    session = QbraidSession()
+
+    try:
+        session.delete(f"/environments/{slug}")
+    except RequestsApiError as err:
+        raise QbraidException("Delete environment request failed") from err

qbraid_cli/exceptions.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining custom exceptions for the qBraid CLI.
 

qbraid_cli/handlers.py

@@ -1,3 +1,6 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module providing application support utilities, including abstractions for error handling
 and executing operations with progress tracking within the qBraid CLI.

qbraid_cli/jobs/__init__.py

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

qbraid_cli/jobs/app.py

@@ -1,119 +1,65 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
 
 import sys
-from typing import Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Dict, 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 jobs.")
-
-QJOB_LIBS = ["braket"]
-
-
-def validate_library(value: str) -> str:
-    """Validate quantum jobs library."""
-    return validate_item(value, QJOB_LIBS, "Library")
-
-
-def get_state(library: Optional[str] = None) -> Dict[str, Tuple[bool, bool]]:
-    """Get the state of qBraid Quantum Jobs for the specified library."""
-    from qbraid.api.system import qbraid_jobs_state
-
-    state_values = {}
-
-    if library:
-        libraries_to_check = [library]
-    else:
-        libraries_to_check = QJOB_LIBS
-
-    for lib in libraries_to_check:
-        state_values[lib] = qbraid_jobs_state(lib)
-
-    return state_values
-
-
-def run_progress_get_state(library: Optional[str] = None) -> 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: Dict[str, Tuple[bool, bool]] = run_progress_get_state(library)
-    installed, enabled = state_values[library]
-
-    if not installed:
-        handle_error(message=f"{library} not installed.")
-    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]."
-        )
-        console.print(
-            "To check the state of all quantum jobs libraries in this environment, "
-            "use: `[bold]qbraid jobs state[/bold]`"
-        )
-        raise typer.Exit()
+from qbraid_cli.handlers import handle_error, run_progress_task
+from qbraid_cli.jobs.toggle_braket import disable_braket, enable_braket
+from qbraid_cli.jobs.validation import handle_jobs_state, run_progress_get_state, validate_library
 
-    action_callback()  # Perform the specific enable/disable action
+jobs_app = typer.Typer(help="Manage qBraid quantum jobs.")
 
 
-@app.command(name="enable")
+@jobs_app.command(name="enable")
 def jobs_enable(
     library: str = typer.Argument(
         ..., help="Software library with quantum jobs support.", callback=validate_library
-    )
+    ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Enable qBraid Quantum Jobs."""
 
     def enable_action():
         if library == "braket":
-            from .toggle_braket import enable_braket
-
-            enable_braket()
+            enable_braket(auto_confirm=auto_confirm)
         else:
             raise RuntimeError(f"Unsupported device library: '{library}'.")
 
     handle_jobs_state(library, "enable", enable_action)
 
 
-@app.command(name="disable")
+@jobs_app.command(name="disable")
 def jobs_disable(
     library: str = typer.Argument(
         ..., help="Software library with quantum jobs support.", callback=validate_library
-    )
+    ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
 ) -> None:
     """Disable qBraid Quantum Jobs."""
 
     def disable_action():
         if library == "braket":
-            from .toggle_braket import disable_braket
-
-            disable_braket()
+            disable_braket(auto_confirm=auto_confirm)
         else:
             raise RuntimeError(f"Unsupported device library: '{library}'.")
 
     handle_jobs_state(library, "disable", disable_action)
 
 
-@app.command(name="state")
+@jobs_app.command(name="state")
 def jobs_state(
     library: str = typer.Argument(
         default=None,
@@ -142,7 +88,7 @@ def jobs_state(
         console.print(f"{lib:<{padding-1}}", state_str, end="\n")
 
 
-@app.command(name="list")
+@jobs_app.command(name="list")
 def jobs_list(
     limit: int = typer.Option(
         10, "--limit", "-l", help="Limit the maximum number of results returned"
@@ -150,20 +96,55 @@ def jobs_list(
 ) -> None:
     """List qBraid Quantum Jobs."""
 
-    def import_jobs() -> Tuple[Callable, Exception]:
-        from qbraid import get_jobs
-        from qbraid.exceptions import QbraidError
+    def import_jobs() -> Tuple[Any, Callable]:
+        from qbraid_core.services.quantum import QuantumClient, process_job_data
+
+        client = QuantumClient()
 
-        return get_jobs, QbraidError
+        return client, process_job_data
 
-    result: Tuple[Callable, Exception] = run_progress_task(import_jobs)
-    get_jobs, QbraidError = result
+    result: Tuple[Any, Callable] = run_progress_task(import_jobs)
+    client, process_job_data = result
+    # https://github.com/qBraid/api/issues/644
+    # raw_data = client.search_jobs(query={"numResults": limit})
+    raw_data = client.search_jobs(query={})
+    job_data, msg = process_job_data(raw_data)
+    job_data = job_data[:limit]
 
+    longest_job_id = max(len(item[0]) for item in job_data)
+    spacing = longest_job_id + 5
     try:
-        get_jobs(filters={"numResults": limit})
-    except QbraidError:
+        console = Console()
+        header_1 = "Job ID"
+        header_2 = "Submitted"
+        header_3 = "Status"
+        console.print(f"\n[bold]{header_1.ljust(spacing)}{header_2.ljust(36)}{header_3}[/bold]")
+        for job_id, submitted, status in job_data:
+            if status == "COMPLETED":
+                status_color = "green"
+            elif status in ["FAILED", "CANCELLED"]:
+                status_color = "red"
+            elif status in [
+                "INITIALIZING",
+                "INITIALIZED",
+                "CREATED",
+                "QUEUED",
+                "VALIDATING",
+                "RUNNING",
+            ]:
+                status_color = "blue"
+            else:
+                status_color = "grey"
+            console.print(
+                f"{job_id.ljust(spacing)}{submitted.ljust(35)}",
+                f"[{status_color}]{status}[/{status_color}]",
+            )
+
+        console.print(f"\n{msg}", style="italic", justify="left")
+
+    except Exception:  # pylint: disable=broad-exception-caught
         handle_error(message="Failed to fetch quantum jobs.")
 
 
 if __name__ == "__main__":
-    app()
+    jobs_app()