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

qbraid_cli/envs/app.py

@@ -1,180 +1,256 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module defining commands in the 'qbraid envs' namespace.
 
 """
 
-import json
 import shutil
+import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Optional
 
 import typer
+from qbraid_core.services.environments.schema import EnvironmentConfig
 from rich.console import Console
 
-from qbraid_cli.handlers import QbraidException, run_progress_task
+from qbraid_cli.envs.create import create_qbraid_env_assets, create_venv
+from qbraid_cli.envs.data_handling import get_envs_data as installed_envs_data
+from qbraid_cli.envs.data_handling import validate_env_name
+from qbraid_cli.handlers import QbraidException, handle_error, run_progress_task
 
-app = typer.Typer(help="Manage qBraid environments.")
+if TYPE_CHECKING:
+    from qbraid_core.services.environments.client import EnvironmentManagerClient as EMC
 
+envs_app = typer.Typer(help="Manage qBraid environments.", no_args_is_help=True)
 
-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 = {}
+@envs_app.command(name="create")
+def envs_create(  # pylint: disable=too-many-statements
+    name: str = typer.Option(None, "--name", "-n", help="Name of the environment to create"),
+    description: Optional[str] = typer.Option(
+        None, "--description", "-d", help="Short description of the environment"
+    ),
+    file_path: str = typer.Option(
+        None, "--file", "-f", help="Path to a .yml file containing the environment details"
+    ),
+    auto_confirm: bool = typer.Option(
+        False, "--yes", "-y", help="Automatically answer 'yes' to all prompts"
+    ),
+) -> None:
+    """Create a new qBraid environment."""
+    env_description = description or ""
+    if name:
+        if not validate_env_name(name):
+            handle_error(
+                error_type="ValueError",
+                include_traceback=False,
+                message=f"Invalid environment name '{name}'. ",
+            )
+
+    env_details_in_cli = name is not None and env_description != ""
+    custom_env_data = None
+    if env_details_in_cli and file_path:
+        handle_error(
+            error_type="ArgumentConflictError",
+            include_traceback=False,
+            message="Cannot use --file with --name or --description while creating an environment",
+        )
+    elif not env_details_in_cli and not file_path:
+        handle_error(
+            error_type="MalformedCommandError",
+            include_traceback=False,
+            message="Must provide either --name and --description or --file "
+            "while creating an environment",
+        )
+    else:
+        try:
+            if file_path:
+                custom_env_data: EnvironmentConfig = EnvironmentConfig.from_yaml(file_path)
+        except ValueError as err:
+            handle_error(error_type="YamlValidationError", message=str(err))
 
-    qbraid_env_paths: List[Path] = get_qbraid_envs_paths()
+    if not name:
+        name = custom_env_data.name
 
-    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
+    def create_environment(*args, **kwargs) -> "tuple[dict, EMC]":
+        """Create a qBraid environment."""
+        from qbraid_core.services.environments.client import EnvironmentManagerClient
 
-                if entry.name == "qbraid_000000":
-                    aliases["default"] = entry.name
-                    continue
+        client = EnvironmentManagerClient()
+        return client.create_environment(*args, **kwargs), client
 
-                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
+    def gather_local_data() -> tuple[Path, str]:
+        """Gather environment data and return the slug."""
+        from qbraid_core.services.environments import get_default_envs_paths
 
-    return installed, aliases
+        env_path = get_default_envs_paths()[0]
 
+        result = subprocess.run(
+            [sys.executable, "--version"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
 
-@app.command(name="create")
-def envs_create(
-    name: str = typer.Option(..., "--name", "-n", help="Name of the environment to create"),
-    description: Optional[str] = typer.Option(
-        None, "--description", "-d", help="Short description of the environment"
-    ),
-) -> None:
-    """Create a new qBraid environment.
+        python_version = result.stdout or result.stderr
 
-    NOTE: Requires updated API route from https://github.com/qBraid/api/pull/482,
-    This command will not work until that PR is merged, and the updates are deployed.
-    """
-    from .create import create_qbraid_env
+        return env_path, python_version
 
-    def request_new_env(req_body: Dict[str, str]) -> str:
-        """Send request to create new environment and return the slug."""
-        from qbraid.api import QbraidSession, RequestsApiError
+    if not custom_env_data:
+        custom_env_data = EnvironmentConfig(
+            name=name,
+            description=env_description,
+        )
 
-        session = QbraidSession()
+    environment, emc = run_progress_task(
+        create_environment,
+        custom_env_data,
+        description="Validating request...",
+        error_message="Failed to create qBraid environment",
+    )
 
-        try:
-            resp = session.post("/environments/create", json=req_body).json()
-        except RequestsApiError as err:
-            raise QbraidException("Create environment request failed") from err
-
-        slug = resp.get("slug")
-        if slug is None:
-            raise QbraidException(f"Create environment request returned invalid slug, {slug}")
-
-        return slug
-
-    req_body = {
-        "name": name,
-        "description": description or "",
-        "tags": "",  # comma separated list of tags
-        "code": "",  # newline separated list of packages
-        "visibility": "private",
-        "kernelName": "",
-        "prompt": "",
-    }
-    slug = run_progress_task(
-        request_new_env,
-        req_body,
-        description="Validating...",
+    env_path, python_version = run_progress_task(
+        gather_local_data,
+        description="Solving environment...",
         error_message="Failed to create qBraid environment",
     )
 
+    slug = environment.get("slug")
+    display_name = environment.get("displayName")
+    prompt = environment.get("prompt")
+    description = environment.get("description")
+    tags = environment.get("tags")
+    kernel_name = environment.get("kernelName")
+
+    slug_path = env_path / slug
+    description = "None" if description == "" else description
+
+    typer.echo("## qBraid Metadata ##\n")
+    typer.echo(f"  name: {display_name}")
+    typer.echo(f"  description: {description}")
+    typer.echo(f"  tags: {tags}")
+    typer.echo(f"  slug: {slug}")
+    typer.echo(f"  shellPrompt: {prompt}")
+    typer.echo(f"  kernelName: {kernel_name}")
+
+    typer.echo("\n\n## Environment Plan ##\n")
+    typer.echo(f"  location: {slug_path}")
+    typer.echo(f"  version: {python_version}\n")
+
+    user_confirmation = auto_confirm or typer.confirm("Proceed", default=True)
+    typer.echo("")
+    if not user_confirmation:
+        emc.delete_environment(slug)
+        typer.echo("qBraidSystemExit: Exiting.")
+        raise typer.Exit()
+
     run_progress_task(
-        create_qbraid_env,
+        create_qbraid_env_assets,
         slug,
-        name,
-        description="Creating qBraid environment...",
+        prompt,
+        kernel_name,
+        slug_path,
+        description="Generating qBraid assets...",
+        error_message="Failed to create qBraid environment",
+    )
+
+    run_progress_task(
+        create_venv,
+        slug_path,
+        prompt,
+        description="Creating virtual environment...",
         error_message="Failed to create qBraid environment",
     )
 
-    # TODO: Add the command they can use to activate the environment to end of success message
     console = Console()
     console.print(
-        f"\n[bold green]Successfully created qBraid environment: "
+        f"[bold green]Successfully created qBraid environment: "
         f"[/bold green][bold magenta]{name}[/bold magenta]\n"
     )
+    typer.echo("# To activate this environment, use")
+    typer.echo("#")
+    typer.echo(f"#     $ qbraid envs activate {name}")
+    typer.echo("#")
+    typer.echo("# To deactivate an active environment, use")
+    typer.echo("#")
+    typer.echo("#     $ deactivate")
+
+
+@envs_app.command(name="remove")
+def envs_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."""
 
+    def delete_environment(slug: str) -> None:
+        """Delete a qBraid environment."""
+        from qbraid_core.services.environments.client import EnvironmentManagerClient
 
-@app.command(name="delete")
-def envs_delete(name: str = typer.Argument(..., help="Name of the environment to delete")) -> None:
-    """Delete a qBraid environment.
-
-    NOTE: Requires updated API route from https://github.com/qBraid/api/pull/482,
-    This command will not work until that PR is merged, and the updates are deployed.
-    """
-
-    def request_delete_env(name: str) -> str:
-        """Send request to create new environment and return the slug."""
-        from qbraid.api import QbraidSession, RequestsApiError
-
-        session = QbraidSession()
+        emc = EnvironmentManagerClient()
+        emc.delete_environment(slug)
 
+    def gather_local_data(env_name: str) -> tuple[Path, str]:
+        """Get environment path and slug from name (alias)."""
         installed, aliases = installed_envs_data()
-        for alias, slug_name in aliases.items():
-            if alias == name:
-                slug = slug_name
-                path = installed[slug_name]
-
-                try:
-                    session.delete(f"/environments/{slug}")
-                except RequestsApiError as err:
-                    raise QbraidException("Create environment request failed") from err
+        for alias, slug in aliases.items():
+            if alias == env_name:
+                path = installed[slug]
 
-                return path
+                return path, slug
 
         raise QbraidException(f"Environment '{name}' not found.")
 
-    path = run_progress_task(
-        request_delete_env,
-        name,
-        description="Deleting remote environment data...",
-        error_message="Failed to delete qBraid environment",
-    )
+    slug_path, slug = gather_local_data(name)
 
-    run_progress_task(
-        shutil.rmtree,
-        path,
-        description="Deleting local environment...",
-        error_message="Failed to delete qBraid environment",
-    )
-
-    console = Console()
-    console.print(
-        f"\n[bold green]Successfully delete qBraid environment: "
-        f"[/bold green][bold magenta]{name}[/bold magenta]\n"
+    confirmation_message = (
+        f"⚠️  Warning: You are about to delete the environment '{name}' "
+        f"located at '{slug_path}'.\n"
+        "This will remove all local packages and permanently delete all "
+        "of its associated qBraid environment metadata.\n"
+        "This operation CANNOT be undone.\n\n"
+        "Are you sure you want to continue?"
     )
 
-
-@app.command(name="list")
+    if auto_confirm or typer.confirm(confirmation_message, abort=True):
+        typer.echo("")
+        run_progress_task(
+            delete_environment,
+            slug,
+            description="Deleting remote environment data...",
+            error_message="Failed to delete qBraid environment",
+        )
+
+        run_progress_task(
+            shutil.rmtree,
+            slug_path,
+            description="Deleting local environment...",
+            error_message="Failed to delete qBraid environment",
+        )
+        typer.echo(f"Environment '{name}' successfully removed.")
+
+
+@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]),
@@ -183,23 +259,31 @@ 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("# installed environments:")
-    print("#")
-    print("")
+    output_lines = []
+    output_lines.append("# qbraid environments:")
+    output_lines.append("#")
+    output_lines.append("")
+
     for alias, path in sorted_alias_path_pairs:
-        mark = "*  " if path == current_env_path else "   "
-        print(f"{alias.ljust(max_alias_length + 11)}{mark}{str(path).ljust(max_path_length)}")
+        mark = "*" if path == current_env_path else " "
+        line = f"{alias.ljust(max_alias_length + 3)}{mark} {path}"
+        output_lines.append(line)
+
+    final_output = "\n".join(output_lines)
 
+    console.print(final_output)
 
-@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'.")
+    name: str = typer.Argument(
+        ..., help="Name of the environment. Values from 'qbraid envs list'."
+    ),
 ):
     """Activate qBraid environment.
 
@@ -219,4 +303,4 @@ def envs_activate(
 
 
 if __name__ == "__main__":
-    app()
+    envs_app()

qbraid_cli/envs/create.py

@@ -1,135 +1,29 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
 """
 Module supporting 'qbraid envs create' command.
 
 """
 
-import json
-import os
-import shutil
-import subprocess
-import sys
-from typing import Optional
-
-
-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_state_json(
-    slug_path: str,
-    install_complete: int,
-    install_success: int,
-    message: Optional[str] = None,
-    env_name: 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": {}}
+def create_venv(*args, **kwargs) -> None:
+    """Create a python virtual environment for the qBraid environment."""
+    from qbraid_core.services.environments import create_local_venv
 
-    # Update the data
-    data["install"]["complete"] = install_complete
-    data["install"]["success"] = install_success
-    data["install"]["message"] = message
+    return create_local_venv(*args, **kwargs)
 
-    if env_name is not None:
-        data["name"] = env_name.lower()
 
-    # 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 update_state_json(*ags, **kwargs) -> None:
+    """Update the state.json file for the qBraid environment."""
+    from qbraid_core.services.environments.state import update_state_json as update_state
 
+    return update_state(*ags, **kwargs)
 
-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)
 
-    # Determine the correct directory for activation scripts based on the operating system
-    if sys.platform == "win32":
-        scripts_path = os.path.join(venv_path, "Scripts")
-        activate_files = ["activate.bat", "Activate.ps1"]
-    else:
-        scripts_path = os.path.join(venv_path, "bin")
-        activate_files = ["activate", "activate.csh", "activate.fish"]
-
-    for file in activate_files:
-        file_path = os.path.join(scripts_path, file)
-        if os.path.isfile(file_path):
-            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_state_json(slug_path, 1, 1)
-
-
-def create_qbraid_env(slug: str, name: str) -> None:
+def create_qbraid_env_assets(slug: str, alias: str, kernel_name: str, slug_path: str) -> None:
     """Create a qBraid environment including python venv, PS1 configs,
     kernel resource files, and qBraid state.json."""
-    # pylint: disable-next=import-outside-toplevel
-    from jupyter_client.kernelspec import KernelSpecManager
-    from qbraid.api.system import get_qbraid_envs_paths
-
-    alias = create_alias(slug)
-    display_name = f"Python 3 [{alias}]"
-    envs_dir_path = get_qbraid_envs_paths()[0]
-    slug_path = os.path.join(str(envs_dir_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_state_json(slug_path, 0, 0, env_name=name)
-
-    # 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"]
-    if sys.platform == "win32":
-        python_exec_path = os.path.join(slug_path, "pyenv", "Scripts", "python.exe")
-    else:
-        python_exec_path = os.path.join(slug_path, "pyenv", "bin", "python")
-    kernel_data["argv"][0] = python_exec_path
-    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)
+    from qbraid_core.services.environments.create import create_qbraid_env_assets as create_assets
 
-    # create python venv
-    create_venv(slug_path, alias)
+    return create_assets(slug, alias, kernel_name, slug_path)

qbraid_cli/envs/data_handling.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for handling data related to qBraid environments.
+
+"""
+
+import typer
+
+from qbraid_cli.handlers import QbraidException
+
+
+def get_envs_data(*args, **kwargs) -> dict:
+    """Get data for installed environments."""
+    from qbraid_core.services.environments.paths import installed_envs_data
+
+    return installed_envs_data(*args, **kwargs)
+
+
+def is_valid_env_name(value: str) -> bool:
+    """Check if a given string is a valid Python environment name."""
+    from qbraid_core.services.environments.validate import is_valid_env_name as is_valid
+
+    return is_valid(value)
+
+
+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 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/files/__init__.py

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