qbraid-cli 0.10.7__py3-none-any.whl → 0.10.9a0__py3-none-any.whl

qbraid_cli/account/app.py

@@ -11,6 +11,7 @@ from typing import Any
 import rich
 import typer
 
+from qbraid_cli.configure.actions import QBRAID_ORG_MODEL_ENABLED
 from qbraid_cli.handlers import run_progress_task
 
 account_app = typer.Typer(help="Manage qBraid account.", no_args_is_help=True)
@@ -51,9 +52,10 @@ def account_info():
             "email": user.get("email"),
             "joinedDate": user.get("createdAt", "Unknown"),
             "activePlan": user.get("activePlan", "") or "Free",
-            "organization": personal_info.get("organization", "") or "qbraid",
             "role": personal_info.get("role", "") or "guest",
         }
+        if QBRAID_ORG_MODEL_ENABLED:
+            metadata["organization"] = personal_info.get("organization", "") or "qbraid"
 
         return metadata
 

qbraid_cli/configure/actions.py

@@ -25,6 +25,8 @@ from rich.console import Console
 
 from qbraid_cli.handlers import handle_filesystem_operation
 
+QBRAID_ORG_MODEL_ENABLED = False  # Set to True if organization/workspace model is enabled
+
 
 def validate_input(key: str, value: str) -> str:
     """Validate the user input based on the key.
@@ -96,16 +98,21 @@ def default_action(section: str = DEFAULT_CONFIG_SECTION):
 
     default_values = {
         "url": DEFAULT_ENDPOINT_URL,
-        "organization": DEFAULT_ORGANIZATION,
-        "workspace": DEFAULT_WORKSPACE,
     }
+    if QBRAID_ORG_MODEL_ENABLED:
+        default_values["organization"] = DEFAULT_ORGANIZATION
+        default_values["workspace"] = DEFAULT_WORKSPACE
 
     config[section]["url"] = prompt_for_config(config, section, "url", default_values)
     config[section]["api-key"] = prompt_for_config(config, section, "api-key", default_values)
-    config[section]["organization"] = prompt_for_config(
-        config, section, "organization", default_values
-    )
-    config[section]["workspace"] = prompt_for_config(config, section, "workspace", default_values)
+
+    if QBRAID_ORG_MODEL_ENABLED:
+        config[section]["organization"] = prompt_for_config(
+            config, section, "organization", default_values
+        )
+        config[section]["workspace"] = prompt_for_config(
+            config, section, "workspace", default_values
+        )
 
     for key in list(config[section]):
         if not config[section][key]:

qbraid_cli/main.py

@@ -17,6 +17,7 @@ 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
@@ -35,6 +36,7 @@ app.add_typer(account_app, name="account")
 app.add_typer(devices_app, name="devices")
 app.add_typer(files_app, name="files")
 app.add_typer(jobs_app, name="jobs")
+app.add_typer(mcp_app, name="mcp")
 
 if ENVS_COMMANDS is True:
     app.add_typer(envs_app, name="envs")

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)

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-0.10.7.dist-info → qbraid_cli-0.10.9a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.10.7
+Version: 0.10.9a0
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License: Proprietary
@@ -30,16 +30,19 @@ License-File: LICENSE
 Requires-Dist: typer>=0.12.1
 Requires-Dist: rich>=10.11.0
 Requires-Dist: click<=8.1.8
-Requires-Dist: qbraid-core<0.2,>=0.1.41
+Requires-Dist: qbraid-core<0.2,>=0.1.45
 Provides-Extra: jobs
 Requires-Dist: amazon-braket-sdk>=1.48.1; extra == "jobs"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]<0.2,>=0.1.41; extra == "envs"
+Requires-Dist: qbraid-core[environments]<0.2,>=0.1.42; extra == "envs"
+Provides-Extra: mcp
+Requires-Dist: qbraid-core[mcp]<0.2,>=0.1.45; extra == "mcp"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
+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">
@@ -165,6 +168,7 @@ Commands
   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.
 ```
 

{qbraid_cli-0.10.7.dist-info → qbraid_cli-0.10.9a0.dist-info}/RECORD

@@ -1,11 +1,10 @@
 qbraid_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qbraid_cli/_version.py,sha256=MZArT0XdOyz4PClOVaSsIkigIviF4cY9W9HHSg6r2c8,513
 qbraid_cli/exceptions.py,sha256=KjlhYJhSHMVazaNiBjD_Ur06w4sekP8zRsFzBdyIpno,672
 qbraid_cli/handlers.py,sha256=qRxrB37-n9WBYIAf63KLEAPSQ7Hfhb1qRaHgsA2TVH8,8069
-qbraid_cli/main.py,sha256=aSOQyoRRvKBJBcx8VtU4zKZ2WHvGKHhw8I-WiRwPxcE,3926
+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=1UogauwgX0Hnr7H6cBV2Qv-lT6aRpRLAimCyLi0afGI,1843
+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
@@ -13,7 +12,7 @@ qbraid_cli/admin/validation.py,sha256=fhpttxupCGBk56ExQPuuQm8nMnptLLy_8sj-EjpM8g
 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=VZ7uP4bFE5ks9yH5xZYzllAm4rM0grV70CP2GbXiwrY,3589
+qbraid_cli/configure/actions.py,sha256=Zv-y7iGgj1fwYceMSXrurpK2PyFCIitKXPqCb4H9AZo,3818
 qbraid_cli/configure/app.py,sha256=7UN8Bje0n_s2nDE-cHid8VwOp7gl0jjw9gldyCcZNhI,4164
 qbraid_cli/devices/__init__.py,sha256=hiScO-px6jCL5cJj5Hbty55EUfNejTO4bmqUZuS3aqc,181
 qbraid_cli/devices/app.py,sha256=B-cRdV092C6ACeu3C-5l2P_izpPDxvCzzAKfxO1WkaM,3224
@@ -31,12 +30,15 @@ qbraid_cli/jobs/toggle_braket.py,sha256=3AEu-Z5q4avduB-fJMyMTVTuyZXuA8m-hnvi325w
 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.10.7.dist-info/licenses/LICENSE,sha256=3KvWfsaXBCqbZ4qwk5jN9CQXE53tQeaZTySN5a-CCgQ,2753
-qbraid_cli-0.10.7.dist-info/METADATA,sha256=LYzmNjBfp7iCYoq5Wl6vF5_kp_sG0kqu6PGyaiWlxH4,7628
-qbraid_cli-0.10.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-qbraid_cli-0.10.7.dist-info/entry_points.txt,sha256=c5ZJ7NjbxhDqMpou9q5F03_b_KG34HzFDijIDmEIwgQ,47
-qbraid_cli-0.10.7.dist-info/top_level.txt,sha256=LTYJgeYSCHo9Il8vZu0yIPuGdGyNaIw6iRy6BeoZo8o,11
-qbraid_cli-0.10.7.dist-info/RECORD,,
+qbraid_cli-0.10.9a0.dist-info/licenses/LICENSE,sha256=3KvWfsaXBCqbZ4qwk5jN9CQXE53tQeaZTySN5a-CCgQ,2753
+qbraid_cli-0.10.9a0.dist-info/METADATA,sha256=3qv0HRybpysRiHUy37YiksN97Q4Jg-MeAzwZH9LU8l8,7839
+qbraid_cli-0.10.9a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qbraid_cli-0.10.9a0.dist-info/entry_points.txt,sha256=c5ZJ7NjbxhDqMpou9q5F03_b_KG34HzFDijIDmEIwgQ,47
+qbraid_cli-0.10.9a0.dist-info/top_level.txt,sha256=LTYJgeYSCHo9Il8vZu0yIPuGdGyNaIw6iRy6BeoZo8o,11
+qbraid_cli-0.10.9a0.dist-info/RECORD,,

qbraid_cli/_version.py

@@ -1,21 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-else:
-    VERSION_TUPLE = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-
-__version__ = version = '0.10.7'
-__version_tuple__ = version_tuple = (0, 10, 7)