qbraid-cli 0.8.5a1__py3-none-any.whl → 0.12.0a0__py3-none-any.whl

qbraid_cli/envs/create.py

@@ -5,6 +5,7 @@
 Module supporting 'qbraid envs create' command.
 
 """
+from qbraid_core.services.environments.schema import EnvironmentConfig
 
 
 def create_venv(*args, **kwargs) -> None:
@@ -21,9 +22,9 @@ def update_state_json(*ags, **kwargs) -> None:
     return update_state(*ags, **kwargs)
 
 
-def create_qbraid_env_assets(slug: str, alias: str, kernel_name: str, slug_path: str) -> None:
+def create_qbraid_env_assets(env_id: str, env_id_path: str, env_config: EnvironmentConfig) -> None:
     """Create a qBraid environment including python venv, PS1 configs,
     kernel resource files, and qBraid state.json."""
     from qbraid_core.services.environments.create import create_qbraid_env_assets as create_assets
 
-    return create_assets(slug, alias, kernel_name, slug_path)
+    return create_assets(env_id, env_id_path, env_config)

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"]

qbraid_cli/files/app.py

@@ -0,0 +1,139 @@
+# Copyright (c) 2024, qBraid Development Team
+# All rights reserved.
+
+"""
+Module defining commands in the 'qbraid files' namespace.
+
+"""
+
+from pathlib import Path
+from typing import Any
+
+import rich
+import typer
+
+from qbraid_cli.handlers import handle_error, run_progress_task
+
+files_app = typer.Typer(help="Manage qBraid cloud storage files.", no_args_is_help=True)
+
+
+def is_file_less_than_10mb(file_path: Path) -> bool:
+    """
+    Check if the given file is less than 10MB in size.
+
+    Args:
+        file_path (Path): The path to the file to check.
+
+    Returns:
+        bool: True if the file is less than 10MB, False otherwise.
+    """
+    ten_mb = 10485760  # 10 MB in bytes (10 * 1024 * 1024)
+
+    try:
+        return file_path.stat().st_size < ten_mb
+    except OSError:
+        return False
+
+
+@files_app.command(name="upload")
+def files_upload(
+    filepath: Path = typer.Argument(
+        ...,
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+        help="Local path to the file to upload.",
+    ),
+    namespace: str = typer.Option(
+        "user",
+        "--namespace",
+        "-n",
+        help="Target qBraid namespace for the upload.",
+    ),
+    object_path: str = typer.Option(
+        None,
+        "--object-path",
+        "-p",
+        help=("Target object path. " "Defaults to original filename in namespace root."),
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        "-o",
+        help="Overwrite existing file if it already exists in the target location.",
+    ),
+):
+    """Upload a local file to qBraid storage."""
+
+    if not is_file_less_than_10mb(filepath):
+        handle_error("Error", "File too large. Must be less than 10MB for direct upload.")
+
+    def upload_file() -> dict[str, Any]:
+        from qbraid_core.services.storage import FileStorageClient
+
+        client = FileStorageClient()
+        data = client.upload_file(
+            filepath, namespace=namespace, object_path=object_path, overwrite=overwrite
+        )
+        return data
+
+    data: dict = run_progress_task(
+        upload_file, description="Uploading file...", include_error_traceback=False
+    )
+
+    rich.print("File uploaded successfully!")
+    namespace = data.get("namespace")
+    object_path = data.get("objectPath")
+
+    if namespace and object_path:
+        rich.print(f"\nNamespace: '{namespace}'")
+        rich.print(f"Object path: '{object_path}'")
+
+
+@files_app.command(name="download")
+def files_download(
+    object_path: str = typer.Argument(
+        ...,
+        help="The folder + filename describing the file to download.",
+    ),
+    namespace: str = typer.Option(
+        "user",
+        "--namespace",
+        "-n",
+        help="Source qBraid namespace for the download.",
+    ),
+    save_path: Path = typer.Option(
+        Path.cwd(),
+        "--save-path",
+        "-s",
+        resolve_path=True,
+        help="Local directory to save the downloaded file.",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        "-o",
+        help="Overwrite existing file if it already exists in the target location.",
+    ),
+):
+    """Download a file from qBraid storage."""
+
+    def download_file() -> Path:
+        from qbraid_core.services.storage import FileStorageClient
+
+        client = FileStorageClient()
+        file_path = client.download_file(
+            object_path, namespace=namespace, save_path=save_path, overwrite=overwrite
+        )
+        return file_path
+
+    file_path: Path = run_progress_task(
+        download_file, description="Downloading file...", include_error_traceback=False
+    )
+
+    rich.print("File downloaded successfully!")
+    rich.print(f"Saved to: '{str(file_path)}'")
+
+
+if __name__ == "__main__":
+    files_app()

qbraid_cli/handlers.py

@@ -10,11 +10,12 @@ and executing operations with progress tracking within the qBraid CLI.
 import os
 import traceback
 from pathlib import Path
+from time import sleep
 from typing import Any, Callable, Optional, Union
 
 import typer
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn
 
 from .exceptions import DEFAULT_ERROR_MESSAGE, QbraidException
 
@@ -24,6 +25,14 @@ def _should_display_progress():
     return os.getenv("QBRAID_CLI_SHOW_PROGRESS", "true").lower() in ["true", "1", "t", "y", "yes"]
 
 
+def _update_completed_task(
+    progress: Progress, task_id: TaskID, success: bool = True, sleep_time: float = 0.15
+):
+    status = "Done" if success else "Failed"
+    progress.update(task_id, completed=100, status=status)
+    sleep(sleep_time)
+
+
 def handle_error(
     error_type: Optional[str] = None, message: Optional[str] = None, include_traceback: bool = True
 ) -> None:
@@ -80,11 +89,28 @@ def handle_filesystem_operation(operation: Callable[[], None], path: Path) -> No
         raise QbraidException(f"Failed to save configuration to {path}: {err.strerror}") from err
 
 
+def print_formatted_data(data: Any, fmt: bool = True) -> None:
+    """
+    Print data with optional formatting using rich console.
+
+    Args:
+        data (Any): The data to be printed.
+        fmt (bool): If True, use rich console formatting. If False, use standard print.
+                   Defaults to True.
+    """
+    if fmt:
+        console = Console()
+        console.print(data)
+    else:
+        print(data)
+
+
 def run_progress_task(
     operation: Callable[..., Any],
     *args,
     description: Optional[str] = None,
     error_message: Optional[str] = None,
+    include_error_traceback: bool = True,
     **kwargs,
 ) -> Any:
     """
@@ -102,6 +128,8 @@ def run_progress_task(
         error_message (optional, str): Custom error message to display if the operation.
                                        fails. Defaults to None, in which case the
                                        exception's message is used.
+        include_error_traceback (bool): Whether to include the traceback in the error message.
+                                        Defaults to True.
         **kwargs: Arbitrary keyword arguments for the operation.
 
     Returns:
@@ -115,7 +143,7 @@ def run_progress_task(
             return operation(*args, **kwargs)
         except Exception as err:  # pylint: disable=broad-exception-caught
             custom_message = error_message if error_message else str(err)
-            return handle_error(message=custom_message)
+            return handle_error(message=custom_message, include_traceback=include_error_traceback)
 
     console = Console()
     with Progress(
@@ -128,12 +156,14 @@ def run_progress_task(
         task = progress.add_task(description, status="In Progress", total=None)
         try:
             result = operation(*args, **kwargs)
-            progress.update(task, completed=100, status="Done")
+            _update_completed_task(progress, task, success=True)
             return result
         except Exception as err:  # pylint: disable=broad-exception-caught
-            progress.update(task, completed=100, status="Failed")
+            _update_completed_task(progress, task, success=False)
             custom_message = error_message if error_message else str(err)
-            return handle_error(message=custom_message)
+            return handle_error(message=custom_message, include_traceback=include_error_traceback)
+        finally:
+            progress.remove_task(task)
 
 
 def _format_list_items(items: list[str]) -> str:

qbraid_cli/jobs/app.py

@@ -5,16 +5,17 @@
 Module defining commands in the 'qbraid jobs' namespace.
 
 """
+
 from typing import Any, Callable
 
 import typer
 from rich.console import Console
 
-from qbraid_cli.handlers import handle_error, run_progress_task
+from qbraid_cli.handlers import handle_error, print_formatted_data, 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
 
-jobs_app = typer.Typer(help="Manage qBraid quantum jobs.")
+jobs_app = typer.Typer(help="Manage qBraid quantum jobs.", no_args_is_help=True)
 
 
 @jobs_app.command(name="enable")
@@ -63,7 +64,7 @@ def jobs_state(
         default=None,
         help="Optional: Specify a software library with quantum jobs support to check its status.",
         callback=validate_library,
-    )
+    ),
 ) -> None:
     """Display the state of qBraid Quantum Jobs for the current environment."""
     result: tuple[str, dict[str, tuple[bool, bool]]] = run_progress_get_state(library)
@@ -75,23 +76,25 @@ def jobs_state(
     max_lib_length = max((len(lib) for lib in state_values.keys()), default=len(header_1))
     padding = max_lib_length + 9
 
-    console.print(f"Executable: {python_exe}")
-    console.print(f"\n{header_1:<{padding}}{header_2}", style="bold")
-
+    output = ""
     for lib, (installed, enabled) in state_values.items():
         state_str = (
             "[green]enabled"
             if enabled and installed
             else "[red]disabled" if installed else "[grey70]unavailable"
         )
-        console.print(f"{lib:<{padding-1}}", state_str, end="\n")
+        output += f"{lib:<{padding-1}} {state_str}\n"
+
+    console.print(f"Executable: {python_exe}")
+    console.print(f"\n{header_1:<{padding}}{header_2}", style="bold")
+    console.print(output)
 
 
 @jobs_app.command(name="list")
 def jobs_list(
     limit: int = typer.Option(
         10, "--limit", "-l", help="Limit the maximum number of results returned"
-    )
+    ),
 ) -> None:
     """List qBraid Quantum Jobs."""
 
@@ -104,11 +107,8 @@ def jobs_list(
 
     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={})
+    raw_data = client.search_jobs(query={"resultsPerPage": limit, "page": 0})
     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
@@ -117,7 +117,7 @@ def jobs_list(
         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]")
+        console.print(f"[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"
@@ -145,5 +145,25 @@ def jobs_list(
         handle_error(message="Failed to fetch quantum jobs.")
 
 
+@jobs_app.command(name="get")
+def jobs_get(
+    job_id: str = typer.Argument(..., help="The ID of the job to get."),
+    fmt: bool = typer.Option(
+        True, "--no-fmt", help="Disable rich console formatting (output raw data)"
+    ),
+) -> None:
+    """Get a qBraid Quantum Job."""
+
+    def get_job():
+        from qbraid_core.services.quantum import QuantumClient
+
+        client = QuantumClient()
+        return client.get_job(job_id)
+
+    data: dict[str, Any] = run_progress_task(get_job)
+
+    print_formatted_data(data, fmt)
+
+
 if __name__ == "__main__":
     jobs_app()

qbraid_cli/jobs/toggle_braket.py

@@ -5,6 +5,7 @@
 Module supporting 'qbraid jobs enable/disable braket' and commands.
 
 """
+
 import logging
 import os
 import re
@@ -102,7 +103,7 @@ def confirm_updates(
     else:
         raise ValueError(f"Invalid mode: {mode}. Expected 'enable' or 'disable'.")
 
-    typer.echo(f"\n==> WARNING: {provider}/{core_package} package required <==")
+    typer.echo(f"==> WARNING: {provider}/{core_package} package required <==")
     if (
         installed_version is not None
         and target_version is not None
@@ -157,18 +158,6 @@ def enable_braket(auto_confirm: bool = False):
     aws_configure_dummy()  # TODO: possibly add another confirmation for writing aws config files
 
     try:
-        subprocess.check_call(
-            [
-                python_exe,
-                "-m",
-                "pip",
-                "install",
-                "amazon-braket-sdk",
-                "--upgrade",
-                "--upgrade-strategy",
-                "eager",
-            ]
-        )
         subprocess.check_call([python_exe, "-m", "pip", "install", f"boto3=={target}"])
         subprocess.check_call([python_exe, "-m", "pip", "uninstall", "botocore", "-y", "--quiet"])
         subprocess.check_call(

qbraid_cli/jobs/validation.py

@@ -5,6 +5,7 @@
 Module for validating command arguments for qBraid Quantum Jobs.
 
 """
+
 import sys
 from typing import Any, Callable, Optional
 

qbraid_cli/kernels/app.py

@@ -5,12 +5,13 @@
 Module defining commands in the 'qbraid kernels' namespace.
 
 """
+
 import typer
 from rich.console import Console
 
 from qbraid_cli.handlers import handle_error
 
-kernels_app = typer.Typer(help="Manage qBraid kernels.")
+kernels_app = typer.Typer(help="Manage qBraid kernels.", no_args_is_help=True)
 
 
 @kernels_app.command(name="list")
@@ -55,7 +56,7 @@ def kernels_list():
 def kernels_add(
     environment: str = typer.Argument(
         ..., help="Name of environment for which to add ipykernel. Values from 'qbraid envs list'."
-    )
+    ),
 ):
     """Add a kernel."""
     from qbraid_core.services.environments.kernels import add_kernels
@@ -77,7 +78,7 @@ def kernels_remove(
     environment: str = typer.Argument(
         ...,
         help=("Name of environment for which to remove ipykernel. Values from 'qbraid envs list'."),
-    )
+    ),
 ):
     """Remove a kernel."""
     from qbraid_core.services.environments.kernels import remove_kernels

qbraid_cli/main.py

@@ -6,27 +6,42 @@ Entrypoint for the qBraid CLI.
 
 """
 
+import click
+import rich
 import typer
 
-from qbraid_cli.admin.app import admin_app
-from qbraid_cli.configure.app import configure_app
-from qbraid_cli.credits.app import credits_app
-from qbraid_cli.devices.app import devices_app
-from qbraid_cli.envs.app import envs_app
-from qbraid_cli.jobs.app import jobs_app
-from qbraid_cli.kernels.app import kernels_app
-from qbraid_cli.pip.app import pip_app
+from qbraid_cli.account import account_app
+from qbraid_cli.admin import admin_app
+from qbraid_cli.chat import ChatFormat, list_models_callback, prompt_callback
+from qbraid_cli.configure import configure_app
+from qbraid_cli.devices import devices_app
+from qbraid_cli.files import files_app
+from qbraid_cli.jobs import jobs_app
+from qbraid_cli.mcp import mcp_app
+
+try:
+    from qbraid_cli.envs import envs_app
+    from qbraid_cli.kernels import kernels_app
+    from qbraid_cli.pip import pip_app
+
+    ENVS_COMMANDS = True
+except ImportError:
+    ENVS_COMMANDS = False
 
 app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
 
 app.add_typer(admin_app, name="admin")
 app.add_typer(configure_app, name="configure")
-app.add_typer(credits_app, name="credits")
+app.add_typer(account_app, name="account")
 app.add_typer(devices_app, name="devices")
-app.add_typer(envs_app, name="envs")
+app.add_typer(files_app, name="files")
 app.add_typer(jobs_app, name="jobs")
-app.add_typer(kernels_app, name="kernels")
-app.add_typer(pip_app, name="pip")
+app.add_typer(mcp_app, name="mcp")
+
+if ENVS_COMMANDS is True:
+    app.add_typer(envs_app, name="envs")
+    app.add_typer(kernels_app, name="kernels")
+    app.add_typer(pip_app, name="pip")
 
 
 def version_callback(value: bool):
@@ -59,7 +74,7 @@ def show_banner():
     typer.echo("")
     typer.echo("- Use 'qbraid --version' to see the current version.")
     typer.echo("")
-    typer.echo("Reference Docs: https://docs.qbraid.com/cli/api-reference/qbraid")
+    rich.print("Reference Docs: https://docs.qbraid.com/cli/api-reference/qbraid")
 
 
 @app.callback(invoke_without_command=True)
@@ -79,5 +94,34 @@ def main(
         show_banner()
 
 
+@app.command(help="Interact with qBraid AI chat service.", no_args_is_help=True)
+def chat(
+    prompt: str = typer.Option(
+        None, "--prompt", "-p", help="The prompt to send to the chat service."
+    ),
+    model: str = typer.Option(None, "--model", "-m", help="The model to use for the chat service."),
+    response_format: ChatFormat = typer.Option(
+        ChatFormat.text, "--format", "-f", help="The format of the response."
+    ),
+    stream: bool = typer.Option(False, "--stream", "-s", help="Stream the response."),
+    list_models: bool = typer.Option(
+        False, "--list-models", "-l", help="List available chat models."
+    ),
+):
+    """
+    Interact with qBraid AI chat service.
+
+    """
+    if list_models:
+        list_models_callback()
+    elif prompt:
+        prompt_callback(prompt, model, response_format, stream)
+    else:
+        raise click.UsageError(
+            "Invalid command. Please provide a prompt using --prompt "
+            "or use --list-models to view available models."
+        )
+
+
 if __name__ == "__main__":
     app()

qbraid_cli/mcp/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025, qBraid Development Team
+# All rights reserved.
+
+"""
+Module for qBraid MCP (Model Context Protocol) aggregator commands.
+
+"""
+from .app import mcp_app
+
+__all__ = ["mcp_app"]

qbraid_cli/mcp/app.py

@@ -0,0 +1,126 @@
+# Copyright (c) 2025, qBraid Development Team
+# All rights reserved.
+
+"""
+CLI commands for qBraid MCP aggregator.
+
+"""
+import typer
+
+from .serve import serve_mcp
+
+mcp_app = typer.Typer(help="MCP (Model Context Protocol) aggregator commands")
+
+
+@mcp_app.command("serve", help="Start MCP aggregator server for Claude Desktop")
+def serve(
+    workspace: str = typer.Option(
+        "lab",
+        "--workspace",
+        "-w",
+        help="Workspace to connect to (lab, qbook, etc.)",
+    ),
+    include_staging: bool = typer.Option(
+        False,
+        "--staging",
+        "-s",
+        help="Include staging endpoints",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        "-d",
+        help="Enable debug logging",
+    ),
+):
+    """
+    Start the qBraid MCP aggregator server.
+
+    This command starts a unified MCP server that connects to multiple qBraid MCP backends
+    (Lab pod_mcp, devices, jobs, etc.) and exposes them through a single stdio interface
+    for Claude Desktop and other AI agents.
+
+    Usage:
+        # Start MCP server for Lab workspace
+        qbraid mcp serve
+
+        # Include staging endpoints for testing
+        qbraid mcp serve --staging
+
+        # Enable debug logging
+        qbraid mcp serve --debug
+
+    Claude Desktop Configuration:
+        {
+          "mcpServers": {
+            "qbraid": {
+              "command": "qbraid",
+              "args": ["mcp", "serve"]
+            }
+          }
+        }
+    """
+    serve_mcp(workspace=workspace, include_staging=include_staging, debug=debug)
+
+
+@mcp_app.command("status", help="Show status of MCP connections")
+def status():
+    """
+    Show the status of MCP backend connections.
+
+    Displays which backends are configured and their connection status.
+    """
+    typer.echo("MCP Status:")
+    typer.echo("  Implementation in progress...")
+    typer.echo("  This will show connection status for all configured MCP backends")
+
+
+@mcp_app.command("list", help="List available MCP servers")
+def list_servers(
+    workspace: str = typer.Option(
+        None,
+        "--workspace",
+        "-w",
+        help="Filter by workspace (lab, qbook, etc.)",
+    ),
+    include_staging: bool = typer.Option(
+        False,
+        "--staging",
+        "-s",
+        help="Include staging endpoints",
+    ),
+):
+    """
+    List available qBraid MCP servers.
+
+    Shows all discovered MCP endpoints that can be connected to.
+    """
+    try:
+        from qbraid_core.services.mcp import discover_mcp_servers
+
+        endpoints = discover_mcp_servers(
+            workspace=workspace or "lab", include_staging=include_staging
+        )
+
+        if not endpoints:
+            typer.echo("No MCP servers found")
+            return
+
+        typer.echo(f"Found {len(endpoints)} MCP server(s):\n")
+        for endpoint in endpoints:
+            typer.echo(f"  • {endpoint.name}")
+            typer.echo(f"    {endpoint.base_url}")
+            if endpoint.description:
+                typer.echo(f"    {endpoint.description}")
+            typer.echo()
+
+    except ImportError as exc:
+        typer.secho(
+            "Error: qbraid-core MCP module not found. "
+            "Please install qbraid-core with MCP support: pip install qbraid-core[mcp]",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1) from exc
+    except Exception as err:
+        typer.secho(f"Error listing MCP servers: {err}", fg=typer.colors.RED)
+        raise typer.Exit(1)