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

qbraid_cli/mcp/serve.py

@@ -0,0 +1,321 @@
+# Copyright (c) 2025, qBraid Development Team
+# All rights reserved.
+
+"""
+MCP aggregator server implementation.
+
+Provides stdio-based MCP server that aggregates multiple qBraid MCP backends.
+"""
+import asyncio
+import json
+import logging
+import signal
+import sys
+from typing import Optional
+
+import typer
+from qbraid_core.services.mcp import MCPRouter, MCPWebSocketClient, discover_mcp_servers
+from qbraid_core.sessions import QbraidSession
+
+
+def setup_logging(debug: bool = False) -> None:
+    """
+    Configure logging for MCP server.
+
+    Args:
+        debug: Enable debug logging
+    """
+    level = logging.DEBUG if debug else logging.INFO
+
+    # Log to stderr so stdout remains clean for MCP protocol
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        stream=sys.stderr,
+    )
+
+
+class MCPAggregatorServer:
+    """
+    MCP aggregator server that bridges stdio to multiple WebSocket backends.
+
+    Architecture:
+        Claude Desktop (stdio) <-> THIS SERVER <-> Multiple MCP WebSocket Servers
+    """
+
+    def __init__(
+        self,
+        session: QbraidSession,
+        workspace: str = "lab",
+        include_staging: bool = False,
+        debug: bool = False,
+    ):
+        """
+        Initialize MCP aggregator server.
+
+        Args:
+            session: Authenticated qBraid session
+            workspace: Workspace to connect to
+            include_staging: Include staging endpoints
+            debug: Enable debug logging
+        """
+        self.session = session
+        self.workspace = workspace
+        self.include_staging = include_staging
+        self.debug = debug
+        self.router: Optional[MCPRouter] = None
+        self.logger = logging.getLogger(__name__)
+        self._shutdown_event = asyncio.Event()
+
+    async def initialize_backends(self) -> None:
+        """
+        Discover and connect to MCP backend servers.
+        """
+        # Get user info for building WebSocket URLs
+        try:
+            user_info = self.session.get_user()
+            username = user_info.get("email")
+            if not username:
+                raise ValueError("User email not found in session")
+        except Exception as err:
+            self.logger.error("Failed to get user info: %s", err)
+            typer.secho(
+                "Error: Could not authenticate. Please run 'qbraid configure' first.",
+                fg=typer.colors.RED,
+                err=True,
+            )
+            raise typer.Exit(1)
+
+        # Discover available MCP endpoints
+        endpoints = discover_mcp_servers(
+            workspace=self.workspace,
+            include_staging=self.include_staging,
+        )
+
+        if not endpoints:
+            typer.secho(
+                f"Warning: No MCP endpoints found for workspace '{self.workspace}'",
+                fg=typer.colors.YELLOW,
+                err=True,
+            )
+            raise typer.Exit(1)
+
+        self.logger.info("Discovered %d MCP endpoint(s)", len(endpoints))
+
+        # Create router
+        self.router = MCPRouter(on_message=self._handle_backend_message)
+
+        # Create WebSocket clients for each endpoint
+        for endpoint in endpoints:
+            # Use JupyterHub token for lab endpoints, API key for other endpoints
+            try:
+                if endpoint.name.startswith("lab"):
+                    try:
+                        token_data = self.session.get_jupyter_token_data()
+                        token = token_data.get("token")
+                        if not token:
+                            raise ValueError("Token not found in response data")
+                    except Exception as err:
+                        self.logger.error(
+                            "Failed to get Jupyter token for endpoint '%s': %s",
+                            endpoint.name,
+                            err,
+                        )
+                        typer.secho(
+                            f"Error: Could not retrieve Jupyter token for '{endpoint.name}'. "
+                            "Please ensure you are authenticated with qBraid Lab.",
+                            fg=typer.colors.RED,
+                            err=True,
+                        )
+                        raise typer.Exit(1)
+                else:
+                    token = self.session.api_key
+                    if not token:
+                        self.logger.error("No API key available for endpoint '%s'", endpoint.name)
+                        typer.secho(
+                            f"Error: No API key available for '{endpoint.name}'. "
+                            "Please run 'qbraid configure' to set up your credentials.",
+                            fg=typer.colors.RED,
+                            err=True,
+                        )
+                        raise typer.Exit(1)
+
+                ws_url = endpoint.build_url(username, token)
+                self.logger.info("Configuring backend: %s", endpoint.name)
+
+                client = MCPWebSocketClient(
+                    websocket_url=ws_url,
+                    on_message=self._handle_backend_message,
+                    name=endpoint.name,
+                )
+                self.router.add_backend(endpoint.name, client)
+            except typer.Exit:
+                raise  # Re-raise typer.Exit to propagate clean exits
+            except Exception as err:  # pylint: disable=broad-exception-caught
+                self.logger.error("Failed to configure backend '%s': %s", endpoint.name, err)
+                typer.secho(
+                    f"Error: Failed to configure backend '{endpoint.name}': {err}",
+                    fg=typer.colors.RED,
+                    err=True,
+                )
+                raise typer.Exit(1)
+
+        # Connect to all backends
+        self.logger.info("Connecting to backends...")
+        await self.router.connect_all()
+
+        # Check connection status
+        connected = self.router.get_connected_backends()
+        if not connected:
+            typer.secho(
+                "Error: Failed to connect to any MCP backends",
+                fg=typer.colors.RED,
+                err=True,
+            )
+            raise typer.Exit(1)
+
+        self.logger.info("Connected to %d backend(s): %s", len(connected), ", ".join(connected))
+        typer.secho(
+            f"MCP aggregator ready ({len(connected)} backend(s) connected)",
+            fg=typer.colors.GREEN,
+            err=True,
+        )
+
+    def _handle_backend_message(self, message: dict) -> None:
+        """
+        Handle messages from backend MCP servers.
+
+        Forwards messages to stdout for Claude Desktop.
+
+        Args:
+            message: Message dictionary from backend
+        """
+        try:
+            self.logger.info(
+                "📥 _handle_backend_message called with message: %s", str(message)[:100]
+            )
+            # Write message to stdout as JSON
+            json_str = json.dumps(message)
+            self.logger.info("📤 Writing to stdout: %s", json_str[:100])
+            sys.stdout.write(json_str + "\n")
+            sys.stdout.flush()
+            self.logger.info("✅ Successfully sent to client")
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            self.logger.error("❌ Error forwarding message: %s", err, exc_info=True)
+
+    async def _stdin_loop(self) -> None:
+        """
+        Read messages from stdin (Claude Desktop) and route to backends.
+        """
+        loop = asyncio.get_event_loop()
+
+        self.logger.info("Starting stdin loop...")
+
+        try:
+            while not self._shutdown_event.is_set():
+                # Read line from stdin (non-blocking)
+                try:
+                    line = await loop.run_in_executor(None, sys.stdin.readline)
+                    if not line:
+                        # EOF reached (stdin closed)
+                        self.logger.info("stdin closed, shutting down...")
+                        break
+
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    self.logger.debug("Received from client: %s...", line[:100])
+
+                    # Parse JSON message
+                    message = json.loads(line)
+
+                    # Route to appropriate backend
+                    if self.router:
+                        await self.router.handle_message(message)
+
+                except json.JSONDecodeError as err:
+                    self.logger.error("Invalid JSON from client: %s", err)
+                except Exception as err:  # pylint: disable=broad-exception-caught
+                    self.logger.error("Error processing message: %s", err)
+
+        except asyncio.CancelledError:
+            self.logger.info("stdin loop cancelled")
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            self.logger.error("Fatal error in stdin loop: %s", err)
+        finally:
+            self._shutdown_event.set()
+
+    async def run(self) -> None:
+        """
+        Run the MCP aggregator server.
+        """
+
+        # Setup signal handlers for graceful shutdown
+        def signal_handler(signum, _frame):  # pylint: disable=unused-argument
+            self.logger.info("Received signal %d, shutting down...", signum)
+            self._shutdown_event.set()
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        # Start backend initialization and stdin loop concurrently
+        # This allows the server to respond to Claude's initialize request
+        # while backends are still connecting in the background
+        try:
+            await asyncio.gather(
+                self.initialize_backends(),
+                self._stdin_loop(),
+            )
+        finally:
+            # Cleanup
+            self.logger.info("Shutting down backends...")
+            if self.router:
+                await self.router.shutdown_all()
+            self.logger.info("Shutdown complete")
+
+
+def serve_mcp(workspace: str, include_staging: bool, debug: bool) -> None:
+    """
+    Start the qBraid MCP aggregator server.
+
+    Args:
+        workspace: Workspace name (lab, qbook, etc.)
+        include_staging: Include staging endpoints
+        debug: Enable debug logging
+    """
+    # Setup logging
+    setup_logging(debug=debug)
+    logger = logging.getLogger(__name__)
+
+    logger.info("Starting qBraid MCP aggregator...")
+    logger.info("Workspace: %s, Staging: %s, Debug: %s", workspace, include_staging, debug)
+
+    # Create qBraid session
+    try:
+        session = QbraidSession()
+    except Exception as err:
+        typer.secho(
+            f"Error creating qBraid session: {err}\n"
+            "Please run 'qbraid configure' to set up your credentials.",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    # Create and run server
+    server = MCPAggregatorServer(
+        session=session,
+        workspace=workspace,
+        include_staging=include_staging,
+        debug=debug,
+    )
+
+    try:
+        asyncio.run(server.run())
+    except KeyboardInterrupt:
+        logger.info("Interrupted by user")
+    except Exception as err:
+        logger.error("Fatal error: %s", err, exc_info=debug)
+        typer.secho(f"Error: {err}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)

qbraid_cli/pip/app.py

@@ -5,6 +5,7 @@
 Module defining commands in the 'qbraid pip' namespace.
 
 """
+
 import subprocess
 import sys
 
@@ -15,8 +16,7 @@ from qbraid_core.system.executables import get_active_python_path
 from qbraid_cli.handlers import handle_error
 from qbraid_cli.pip.hooks import get_env_cfg_path, safe_set_include_sys_packages
 
-# disable pretty_exceptions_show_locals to avoid printing sensative information in the traceback
-pip_app = typer.Typer(help="Run pip command in active qBraid environment.")
+pip_app = typer.Typer(help="Run pip command in active qBraid environment.", no_args_is_help=True)
 
 
 @pip_app.command(

qbraid_cli/pip/hooks.py

@@ -5,6 +5,7 @@
 Module defining pre- and post-command hooks for the 'qbraid pip' namespace.
 
 """
+
 import sys
 from pathlib import Path
 from typing import Optional, Union

{qbraid_cli-0.8.5a1.dist-info → qbraid_cli-0.12.0a0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.8.5a1
+Version: 0.12.0a0
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
-License: Proprietary
+License-Expression: LicenseRef-Proprietary
 Project-URL: Homepage, https://docs.qbraid.com/cli/user-guide/overview
 Project-URL: Documentation, https://docs.qbraid.com/cli/api-reference/qbraid
 Project-URL: Bug Tracker, https://github.com/qBraid/community/issues
@@ -12,7 +12,6 @@ Keywords: qbraid,cli,quantum,cloud
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
-Classifier: License :: Other/Proprietary License
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
@@ -23,20 +22,28 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer>=0.12.1
 Requires-Dist: rich>=10.11.0
-Requires-Dist: qbraid-core[environments]>=0.1.17
+Requires-Dist: click<=8.1.8
+Requires-Dist: qbraid-core[environments]>=0.2.0a0
+Provides-Extra: jobs
+Requires-Dist: amazon-braket-sdk>=1.48.1; extra == "jobs"
+Provides-Extra: envs
+Requires-Dist: qbraid-core[environments]==0.2.0a0; extra == "envs"
+Provides-Extra: mcp
+Requires-Dist: qbraid-core[mcp]==0.2.0a0; extra == "mcp"
 Provides-Extra: dev
-Requires-Dist: ruff; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Provides-Extra: jobs
-Requires-Dist: amazon-braket-sdk>=1.48.1; extra == "jobs"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
 
 <img width="full" alt="qbraid_cli" src="https://qbraid-static.s3.amazonaws.com/logos/qbraid-cli-banner.png">
 
@@ -49,7 +56,11 @@ Requires-Dist: amazon-braket-sdk>=1.48.1; extra == "jobs"
 
 Command Line Interface for interacting with all parts of the qBraid platform.
 
-The **qBraid CLI** is a versatile command-line interface tool designed for seamless interaction with qBraid cloud services and quantum software management tools. Initially exclusive to the [qBraid Lab](https://docs.qbraid.com/lab/user-guide/overview) platform, the CLI now supports local installations as well. This enhancement broadens access to features like [qBraid Quantum Jobs](https://docs.qbraid.com/cli/user-guide/quantum-jobs), enabling direct acess to QPU devices from leading providers like IonQ, Oxford Quantum Circuits, QuEra, Rigetti, and IQM, as well as on-demand simulators from qBraid and AWS, all using qBraid [credits](https://docs.qbraid.com/home/pricing), with no additional access keys required.
+The **qBraid CLI** is a versatile command-line interface tool designed for seamless interaction with qBraid cloud services and quantum software management tools. Initially exclusive to the [qBraid Lab](https://docs.qbraid.com/lab/user-guide/overview) platform, the CLI now supports local installations as well. This enhancement broadens access to features like [qBraid Quantum Jobs](https://docs.qbraid.com/cli/user-guide/quantum-jobs), enabling direct, pre-configured access to QPUs from IonQ, Oxford Quantum Circuits, QuEra, Rigetti, and IQM, as well as on-demand simulators from qBraid, AWS, IonQ, QuEra, and NEC. See [pricing](https://docs.qbraid.com/home/pricing) for more.
+
+*Resources*:
+- [User Guide](https://docs.qbraid.com/cli/user-guide/overview)
+- [API Reference](https://docs.qbraid.com/cli/api-reference/qbraid)
 
 ## Getting Started
 
@@ -66,6 +77,12 @@ You can also install the qBraid-CLI from PyPI with:
 pip install qbraid-cli
 ```
 
+To manage qBraid [environments](https://docs.qbraid.com/lab/user-guide/environments) using the CLI, you must also install the `envs` extra:
+
+```bash
+pip install 'qbraid-cli[envs]'
+```
+
 ## Local configuration
 
 After installation, you must configure your account credentials to use the CLI locally:
@@ -74,12 +91,14 @@ After installation, you must configure your account credentials to use the CLI l
    [account.qbraid.com](https://account.qbraid.com/)
 2. Copy your API Key token from the left side of
     your [account page](https://account.qbraid.com/):
-3. Save your API key from step 2 in local configuration file `~/.qbraid/qbraidrc` using:
+3. Save your API key from step 2 in local [configuration file](https://docs.qbraid.com/cli/user-guide/config-files) `~/.qbraid/qbraidrc` using:
 
 ```bash
 $ qbraid configure
 ```
 
+For more on API keys, see [documentation](https://docs.qbraid.com/home/account#api-keys).
+
 ## Basic Commands
 
 ```bash
@@ -139,12 +158,18 @@ Options
   --help                        Show this message and exit.
 
 Commands
+  account                       Manage qBraid account
+  admin                         CI/CD commands for qBraid maintainers.
   configure                     Configure qBraid CLI options.
-  credits                       Manage qBraid credits.
+  account                       Manage qBraid account.
+  chat                          Interact with qBraid AI chat service.
   devices                       Manage qBraid quantum devices.
   envs                          Manage qBraid environments.
+  files                         Manage qBraid cloud storage files.
   jobs                          Manage qBraid quantum jobs.
   kernels                       Manage qBraid kernels.
+  mcp                           MCP (Model Context Protocol) aggregator commands.
+  pip                           Run pip command in active qBraid environment.
 ```
 
 To get the version of the qBraid CLI:
@@ -170,7 +195,5 @@ In [1]: %load_ext qbraid_magic
 Now you can continue to use the qBraid-CLI as normal from within your Jupyter notebook using the magic ``%`` operator, e.g.
 
 ```python
-In [2]: %qbraid jobs state
-
-In [3]: %qbraid jobs enable braket -y
+In [2]: %qbraid chat -f code -p "Write a Qiskit bell circuit"
 ```

qbraid_cli-0.12.0a0.dist-info/RECORD

@@ -0,0 +1,46 @@
+qbraid_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qbraid_cli/_version.py,sha256=3XwaThsiOWydODTKqEaylQmodo5qZxp3-tSzxEJq1sw,456
+qbraid_cli/exceptions.py,sha256=KjlhYJhSHMVazaNiBjD_Ur06w4sekP8zRsFzBdyIpno,672
+qbraid_cli/handlers.py,sha256=qRxrB37-n9WBYIAf63KLEAPSQ7Hfhb1qRaHgsA2TVH8,8069
+qbraid_cli/main.py,sha256=s0PA-jlebLxrFiI_mPDhioQ8JHTvMOjprFa7vbsmLII,3996
+qbraid_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qbraid_cli/account/__init__.py,sha256=smlpUcVkM3QEbJG0norGM7i71XBJlUGQYByswTfPnmg,181
+qbraid_cli/account/app.py,sha256=_On93HBaBmyizcxnArpdN6zeoA1lFMNPhya0DvBDTJ4,1956
+qbraid_cli/admin/__init__.py,sha256=qcWD5mQEUCtr49mrUpZmk7eGDe0L_Gtc8RwZmzIXSwo,175
+qbraid_cli/admin/app.py,sha256=i_JeyJYHT6qoJrsTuf_eippp7AG6ZJ_N6-Dsrpv2XHQ,1476
+qbraid_cli/admin/headers.py,sha256=QWAEuOu3rqumngLlOaGTI2R2wqyqmC0gUNpRt_74pd0,10610
+qbraid_cli/admin/validation.py,sha256=fhpttxupCGBk56ExQPuuQm8nMnptLLy_8sj-EjpM8g0,729
+qbraid_cli/chat/__init__.py,sha256=NO41vndEdfr0vDynNcmHFh-nhzWjnWqGm4M9parikck,258
+qbraid_cli/chat/app.py,sha256=-YqCLGDh4ezF149xB3dfuUAQotKAklZwYp0BL3HhA90,2256
+qbraid_cli/configure/__init__.py,sha256=YaJ74Ztz2vl3eYp8_jVBucWkXscxz7EZEIzr70OfuOM,187
+qbraid_cli/configure/actions.py,sha256=Zv-y7iGgj1fwYceMSXrurpK2PyFCIitKXPqCb4H9AZo,3818
+qbraid_cli/configure/app.py,sha256=CxzQmWDpCwpNe4HO7sOxJzbFwJ4dayzD8sjzefQvNNE,7260
+qbraid_cli/configure/claude_config.py,sha256=OJqdEA0wr19F4BnZMAxRBf7rA9FehX12VzC6TQ-rr6c,6457
+qbraid_cli/devices/__init__.py,sha256=hiScO-px6jCL5cJj5Hbty55EUfNejTO4bmqUZuS3aqc,181
+qbraid_cli/devices/app.py,sha256=B-cRdV092C6ACeu3C-5l2P_izpPDxvCzzAKfxO1WkaM,3224
+qbraid_cli/devices/validation.py,sha256=YhShyUufgrKnx2XjXOXF-PqFJYklJT9CgeqIwKcNam4,809
+qbraid_cli/envs/__init__.py,sha256=1-cMvrATsddYxcetPJWxq6bEOqJWMktGdhoZ4qm8euA,172
+qbraid_cli/envs/activate.py,sha256=pYugi2MmEjHKQlky7fVHvB_BpBu7xgOwa1Vrh50DXEo,3251
+qbraid_cli/envs/app.py,sha256=VVLNz_AvlH66RuV1JMB4mDPxXB7VhVg8jEmRKoZz2Ko,33035
+qbraid_cli/envs/create.py,sha256=2isv1eLFKxVutbrkHawMQK67Cz939eLwfhMBtVHiOas,1060
+qbraid_cli/envs/data_handling.py,sha256=Ibnp2yJoUDpivb_sNqi0suYgJZNat_LmM6Ya0Ovez5s,1288
+qbraid_cli/files/__init__.py,sha256=3_yhgFoNcviEtS6B75uJBrfFFUjsrMcccCNEntJ54xU,175
+qbraid_cli/files/app.py,sha256=gNa88cfAmpzYd9VOK7Q-OWJ1LyyHxq88PKhg8Q9w9Mk,3771
+qbraid_cli/jobs/__init__.py,sha256=qVLRHYIzP4XHpx_QWP_vCzd3LsCscCORaEx-Vcbx29U,172
+qbraid_cli/jobs/app.py,sha256=NchePouZkoHWxqV1lwiYuXwrLeP99zITKz5Ezc1pm2I,5383
+qbraid_cli/jobs/toggle_braket.py,sha256=3AEu-Z5q4avduB-fJMyMTVTuyZXuA8m-hnvi325wIv4,7444
+qbraid_cli/jobs/validation.py,sha256=KlkqVH1-vlNCHSayEpxzyXU86_TMN5prGfMFEoyBsFs,2971
+qbraid_cli/kernels/__init__.py,sha256=jORS9vV17s5laQyq8gSVB18EPBImgEIbMZ1wKC094DA,181
+qbraid_cli/kernels/app.py,sha256=n-iyWJHy7_ML6qk4pp-v_rQkGA7WfnZMG8gyiCFGO1c,2948
+qbraid_cli/mcp/__init__.py,sha256=GwW67sQpUViWhTpd6yq-kG8HH87QmCjKO0v2Ys_8Qpw,195
+qbraid_cli/mcp/app.py,sha256=TQnM9LI9OsgbGV6Pkp_Ri7d62dJs5voPKmG1FeweSy0,3463
+qbraid_cli/mcp/serve.py,sha256=4LFXjuv6CQPIuskPxcFXS0qE2igv1vYmLup-u1xhIZ0,11384
+qbraid_cli/pip/__init__.py,sha256=tJtU0rxn-ODogNh5Y4pp_BgDQXMN-3JY1QGj0OZHwjQ,169
+qbraid_cli/pip/app.py,sha256=jkk-djductrDOJIRYfHK_7WDJ12f0zOT3MMkiZp97oM,1365
+qbraid_cli/pip/hooks.py,sha256=jkIeev3cOd-cmaoJSdSqbmhTYCs6z1we84FMqa3ZoZw,2124
+qbraid_cli-0.12.0a0.dist-info/licenses/LICENSE,sha256=3KvWfsaXBCqbZ4qwk5jN9CQXE53tQeaZTySN5a-CCgQ,2753
+qbraid_cli-0.12.0a0.dist-info/METADATA,sha256=9RRo480Itl5YHFjHso2qR_ecYtJThGQTO5OZ9bUbT5Q,7865
+qbraid_cli-0.12.0a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qbraid_cli-0.12.0a0.dist-info/entry_points.txt,sha256=c5ZJ7NjbxhDqMpou9q5F03_b_KG34HzFDijIDmEIwgQ,47
+qbraid_cli-0.12.0a0.dist-info/top_level.txt,sha256=LTYJgeYSCHo9Il8vZu0yIPuGdGyNaIw6iRy6BeoZo8o,11
+qbraid_cli-0.12.0a0.dist-info/RECORD,,

{qbraid_cli-0.8.5a1.dist-info → qbraid_cli-0.12.0a0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{qbraid_cli-0.8.5a1.dist-info → qbraid_cli-0.12.0a0.dist-info/licenses}/LICENSE

@@ -1,10 +1,10 @@
-qBraid Closed-Source Software License
+qBraid Commercial Software License
 
-Copyright (c) 2024, qBraid Development Team
+Copyright (c) 2025, qBraid Development Team
 
 All rights reserved.
 
-This license agreement ("License") is between the qBraid Development Team ("Author") and you, the Licensee. By using or distributing the qBraid ("Software"), you agree to the following terms:
+This license agreement ("License") is between the qBraid Development Team ("Author") and you, the Licensee. This software and associated documentation files (the "Software") may only be used by authorized qBraid customers who have agreed to qBraid's Terms of Service and have a valid subscription or license agreement with qBraid. By using or distributing this Software, you agree to the following terms:
 
 1. Grant of License.
 
@@ -24,7 +24,7 @@ This license agreement ("License") is between the qBraid Development Team ("Auth
 
 5. Attribution
 
-   If the Software is used in a non-private setting, including but not limited to academic work, commercial settings, or published literature, attribution must be given to the "qBraid Jupyter Environment Manager authored by the qBraid Development Team."
+   If the Software is used in a non-private setting, including but not limited to academic work, commercial settings, or published literature, attribution must be given to the "qBraid CLI authored by the qBraid Development Team."
 
 6. Disclaimer of Warranty.
 
@@ -39,3 +39,5 @@ This license agreement ("License") is between the qBraid Development Team ("Auth
    This License is effective until terminated. Your rights under this License will terminate automatically without notice from the Author if you fail to comply with any term(s) of this License.
 
 By using the Software, you agree to be bound by the terms of this License. Redistribution of the Software or use of the Software other than as specifically authorized under this License is prohibited and may result in severe civil and criminal penalties.
+
+For licensing inquiries, please contact: contact@qbraid.com

qbraid_cli/admin/buildlogs.py

@@ -1,114 +0,0 @@
-# Copyright (c) 2024, qBraid Development Team
-# All rights reserved.
-
-"""
-Module defining commands in the 'qbraid admin buildlogs' namespace.
-
-This module uses the Typer library to create CLI commands for managing Docker builds and logs
-in an administrative context.
-"""
-
-import json
-
-import typer
-from qbraid_core.exceptions import RequestsApiError
-from qbraid_core.services.admin.client import AdminClient
-from rich.console import Console
-
-from qbraid_cli.handlers import handle_error
-
-buildlogs_app = typer.Typer(
-    help="Manage qBraid containerized services logs.", pretty_exceptions_show_locals=False
-)
-console = Console()
-
-
-@buildlogs_app.command(name="get")
-def get_docker_build_logs(
-    build_id: str = typer.Option(None, "--build_id", "-b", help="Name of the build ID")
-) -> None:
-    """
-    Fetches and displays Docker build logs for a specified build ID.
-
-    Args:
-        build_id (str, optional): The unique identifier for the Docker build.
-
-    This function queries the administrative backend to retrieve and display build logs.
-    If a build ID is provided, it will retrieve and display logs specific to that build ID.
-    If build ID not provided, fetches all logs.
-    """
-    client = AdminClient()
-
-    build_log = client.get_docker_build_logs(build_id)
-    if build_id and "buildLogs" in build_log and build_log["buildLogs"]:
-        log_entry = build_log["buildLogs"][0]
-        console.print(log_entry)
-    else:
-        console.print(build_log)
-
-
-@buildlogs_app.command(name="post")
-def post_docker_build_log(
-    data: str = typer.Option(..., "--data", "-d", help="Data to post to Docker logs")
-) -> None:
-    """
-    Posts a new Docker build log entry.
-
-    Args:
-        data (str): JSON string containing the data to be logged.
-
-    This command converts a JSON string into a dictionary and sends it to the backend service
-    to create a new Docker build log.
-    """
-    client = AdminClient()
-
-    try:
-        data_dict = json.loads(data)
-        console.print(client.post_docker_build_logs(data_dict))
-    except RequestsApiError:
-        handle_error(message="Couldn't post a build_log.")
-
-
-@buildlogs_app.command(name="put")
-def put_docker_build_log(
-    build_id: str = typer.Option(..., "--build_id", "-b", help="Name of the build ID"),
-    data: str = typer.Option(..., "--data", "-d", help="Data to post to Docker logs"),
-) -> None:
-    """
-    Updates an existing Docker build log entry by a given build ID.
-
-    Args:
-        build_id (str): The unique identifier of the Docker build to update.
-        data (str): JSON string containing the updated data for the log.
-
-    This command updates a Docker build log entry, identified by the provided build ID,
-    with the new data provided in JSON format.
-    """
-    client = AdminClient()
-
-    try:
-        data_dict = json.loads(data)
-        console.print(client.put_docker_build_logs(build_id, data_dict))
-    except RequestsApiError:
-        handle_error(message="Couldn't post a build_log.")
-
-
-@buildlogs_app.command(name="delete")
-def delete_docker_build_log(
-    build_id: str = typer.Option(..., "--build_id", "-b", help="ID of the build log to delete")
-) -> None:
-    """
-    Deletes a Docker build log entry by a specified build ID.
-
-    Args:
-        build_id (str): The unique identifier of the Docker build log to delete.
-
-    This command sends a request to delete a Docker build log identified by the provided build ID.
-    """
-    client = AdminClient()
-
-    console.print(client.delete_docker_build_logs(build_id))
-
-
-if __name__ == "__main__":
-    buildlogs_app()