superquantx 0.1.0__py3-none-any.whl

superquantx/cli/main.py

@@ -0,0 +1,254 @@
+"""Main CLI entry point for SuperQuantX.
+
+This module provides the main CLI application using Click framework,
+with subcommands for various quantum machine learning operations.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+
+# Import version directly to avoid circular import
+from superquantx.version import __version__
+
+from .commands import (
+    benchmark,
+    configure,
+    create_dataset,
+    info,
+    list_algorithms,
+    list_backends,
+    run_algorithm,
+    visualize,
+)
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name='SuperQuantX')
+@click.option(
+    '--config', '-c',
+    type=click.Path(exists=True),
+    help='Path to configuration file'
+)
+@click.option(
+    '--verbose', '-v',
+    is_flag=True,
+    help='Enable verbose output'
+)
+@click.pass_context
+def cli(ctx: click.Context, config: Optional[str], verbose: bool):
+    """SuperQuantX: Building the Foundation for Quantum Agentic AI
+    
+    Deploy quantum-enhanced autonomous agents and AI systems in minutes.
+    From quantum circuits to intelligent agents across all quantum platforms.
+    
+    Examples:
+        sqx create-agent trading               # Deploy quantum trading agent
+        sqx run automl --data portfolio        # Quantum AutoML optimization
+        sqx run qsvm --data iris               # Traditional quantum algorithm
+        sqx benchmark quantum-vs-classical     # Performance comparison
+        sqx benchmark --backend all # Benchmark all backends
+
+    """
+    # Ensure context object exists
+    ctx.ensure_object(dict)
+
+    # Store global options
+    ctx.obj['config'] = config
+    ctx.obj['verbose'] = verbose
+
+    # Load configuration if specified
+    if config:
+        try:
+            sqx.configure(config_file=config)
+            if verbose:
+                click.echo(f"Loaded configuration from {config}")
+        except Exception as e:
+            click.echo(f"Error loading configuration: {e}", err=True)
+            sys.exit(1)
+
+
+# Add command groups
+cli.add_command(info)
+cli.add_command(list_algorithms)
+cli.add_command(list_backends)
+cli.add_command(run_algorithm)
+cli.add_command(benchmark)
+cli.add_command(configure)
+cli.add_command(create_dataset)
+cli.add_command(visualize)
+
+
+@cli.command()
+@click.pass_context
+def version(ctx: click.Context):
+    """Show detailed version information."""
+    click.echo(f"SuperQuantX version: {sqx.__version__}")
+    click.echo(f"Python version: {sys.version}")
+
+    if ctx.obj.get('verbose'):
+        click.echo("\nBackend versions:")
+        backend_info = sqx.get_backend_info()
+        for backend, version in backend_info.items():
+            status = version if version else "Not installed"
+            click.echo(f"  {backend}: {status}")
+
+
+@cli.command()
+def shell():
+    """Start interactive SuperQuantX shell."""
+    try:
+        import matplotlib.pyplot as plt
+
+        # Import common modules for convenience
+        import numpy as np
+        from IPython import embed
+
+        banner = """
+        SuperQuantX Interactive Shell
+        =============================
+        
+        Available imports:
+        - superquantx as sqx
+        - numpy as np
+        - matplotlib.pyplot as plt
+        
+        Try: sqx.algorithms.QuantumSVM()
+        """
+
+        embed(banner1=banner, exit_msg="Goodbye!")
+
+    except ImportError:
+        click.echo("IPython not available. Install with: pip install ipython")
+        sys.exit(1)
+
+
+@cli.command()
+@click.option(
+    '--output', '-o',
+    type=click.Path(),
+    default='superquantx_examples',
+    help='Output directory for examples'
+)
+def examples(output: str):
+    """Generate example scripts and notebooks."""
+    output_path = Path(output)
+    output_path.mkdir(exist_ok=True)
+
+    # Basic example
+    basic_example = '''#!/usr/bin/env python3
+"""
+Basic SuperQuantX Example: Quantum SVM Classification
+"""
+
+import numpy as np
+import superquantx as sqx
+
+# Load quantum-adapted Iris dataset
+X_train, X_test, y_train, y_test, metadata = sqx.datasets.load_iris_quantum(
+    n_features=4, encoding='amplitude'
+)
+
+print(f"Dataset: {metadata['dataset_name']}")
+print(f"Training samples: {len(X_train)}")
+print(f"Test samples: {len(X_test)}")
+print(f"Features: {metadata['n_features']}")
+print(f"Classes: {metadata['n_classes']}")
+
+# Create quantum SVM with automatic backend selection
+qsvm = sqx.QuantumSVM(
+    backend='auto',
+    feature_map='ZZFeatureMap',
+    quantum_kernel=True
+)
+
+# Train the model
+print("\\nTraining Quantum SVM...")
+qsvm.fit(X_train, y_train)
+
+# Make predictions
+y_pred = qsvm.predict(X_test)
+
+# Calculate accuracy
+accuracy = np.mean(y_pred == y_test)
+print(f"Test Accuracy: {accuracy:.4f}")
+
+# Visualize results
+sqx.visualize_results({
+    'y_true': y_test,
+    'y_pred': y_pred,
+    'algorithm': 'QuantumSVM'
+}, plot_type='classification')
+'''
+
+    # VQE example
+    vqe_example = '''#!/usr/bin/env python3
+"""
+SuperQuantX VQE Example: H2 Molecule Ground State
+"""
+
+import superquantx as sqx
+
+# Load H2 molecule
+molecule, metadata = sqx.datasets.load_h2_molecule(bond_length=0.735)
+
+print(f"Molecule: {molecule.name}")
+print(f"Bond length: {metadata['bond_length']} Å")
+print(f"Expected ground state energy: {metadata['ground_state_energy']} Ha")
+
+# Create VQE algorithm
+vqe = sqx.VQE(
+    backend='auto',
+    ansatz='UCCSD',
+    optimizer='Adam'
+)
+
+# Run VQE optimization
+print("\\nRunning VQE optimization...")
+result = vqe.compute_minimum_eigenvalue(molecule)
+
+print(f"VQE ground state energy: {result['eigenvalue']:.6f} Ha")
+print(f"Number of iterations: {result['n_iterations']}")
+print(f"Optimization time: {result['optimization_time']:.2f} s")
+
+# Plot optimization history
+sqx.plot_optimization_history(result)
+'''
+
+    # Write examples
+    examples_to_create = [
+        ('basic_qsvm.py', basic_example),
+        ('vqe_h2.py', vqe_example)
+    ]
+
+    for filename, content in examples_to_create:
+        example_path = output_path / filename
+        with open(example_path, 'w') as f:
+            f.write(content)
+        click.echo(f"Created: {example_path}")
+
+    click.echo(f"\\nExamples created in: {output_path}")
+    click.echo("Run with: python basic_qsvm.py")
+
+
+def create_app():
+    """Create and return the CLI application."""
+    return cli
+
+
+def main():
+    """Main entry point for the CLI."""
+    try:
+        cli()
+    except KeyboardInterrupt:
+        click.echo("\\nInterrupted by user")
+        sys.exit(130)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

superquantx/client.py

@@ -0,0 +1,298 @@
+"""SuperQuantX Client - Main interface for the SuperQuantX platform
+"""
+
+import asyncio
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+from pydantic import BaseModel, Field
+
+
+class SuperQuantXConfig(BaseModel):
+    """Configuration for SuperQuantX client"""
+
+    api_key: str = Field(..., description="API key for authentication")
+    base_url: str = Field(default="https://api.superquantx.ai", description="Base API URL")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    max_retries: int = Field(default=3, description="Maximum number of retries")
+    verify_ssl: bool = Field(default=True, description="Verify SSL certificates")
+
+
+class QuantumJob(BaseModel):
+    """Represents a quantum computation job"""
+
+    job_id: str
+    status: str
+    created_at: str
+    circuit_id: Optional[str] = None
+    backend: Optional[str] = None
+    shots: Optional[int] = None
+    results: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class SuperQuantXClient:
+    """Main client for interacting with the SuperQuantX platform
+    
+    This client provides access to quantum computing resources, quantum algorithms,
+    and quantum machine learning capabilities through the SuperQuantX API.
+    """
+
+    def __init__(self, config: Union[SuperQuantXConfig, str, Dict[str, Any]]):
+        """Initialize SuperQuantX client
+        
+        Args:
+            config: Configuration object, API key string, or config dictionary
+
+        """
+        if isinstance(config, str):
+            self.config = SuperQuantXConfig(api_key=config)
+        elif isinstance(config, dict):
+            self.config = SuperQuantXConfig(**config)
+        else:
+            self.config = config
+
+        self._client = httpx.AsyncClient(
+            base_url=self.config.base_url,
+            timeout=self.config.timeout,
+            verify=self.config.verify_ssl,
+            headers={
+                "Authorization": f"Bearer {self.config.api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "SuperQuantX-Python-SDK/0.1.0"
+            }
+        )
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self._client.aclose()
+
+    def __enter__(self):
+        """Sync context manager entry"""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Sync context manager exit"""
+        asyncio.run(self._client.aclose())
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make an authenticated request to the SuperQuantX API
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint
+            data: Request body data
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            httpx.HTTPError: If request fails
+
+        """
+        for attempt in range(self.config.max_retries):
+            try:
+                response = await self._client.request(
+                    method=method,
+                    url=endpoint,
+                    json=data,
+                    params=params
+                )
+                response.raise_for_status()
+                return response.json()
+
+            except httpx.HTTPError:
+                if attempt == self.config.max_retries - 1:
+                    raise
+                await asyncio.sleep(2 ** attempt)  # Exponential backoff
+
+    async def health_check(self) -> Dict[str, Any]:
+        """Check API health and connectivity
+        
+        Returns:
+            Health status information
+
+        """
+        return await self._request("GET", "/health")
+
+    async def get_account_info(self) -> Dict[str, Any]:
+        """Get account information and usage statistics
+        
+        Returns:
+            Account information including quotas and usage
+
+        """
+        return await self._request("GET", "/account")
+
+    async def list_backends(self) -> List[Dict[str, Any]]:
+        """List available quantum backends
+        
+        Returns:
+            List of available backends with their specifications
+
+        """
+        response = await self._request("GET", "/backends")
+        return response.get("backends", [])
+
+    async def get_backend_info(self, backend_name: str) -> Dict[str, Any]:
+        """Get detailed information about a specific backend
+        
+        Args:
+            backend_name: Name of the backend
+            
+        Returns:
+            Backend information including capabilities and status
+
+        """
+        return await self._request("GET", f"/backends/{backend_name}")
+
+    async def submit_job(
+        self,
+        circuit_data: Dict[str, Any],
+        backend: str = "simulator",
+        shots: int = 1024,
+        optimization_level: int = 1,
+        **kwargs
+    ) -> QuantumJob:
+        """Submit a quantum circuit for execution
+        
+        Args:
+            circuit_data: Quantum circuit representation
+            backend: Target backend for execution
+            shots: Number of measurement shots
+            optimization_level: Circuit optimization level (0-3)
+            **kwargs: Additional execution parameters
+            
+        Returns:
+            QuantumJob object representing the submitted job
+
+        """
+        job_data = {
+            "circuit": circuit_data,
+            "backend": backend,
+            "shots": shots,
+            "optimization_level": optimization_level,
+            **kwargs
+        }
+
+        response = await self._request("POST", "/jobs", data=job_data)
+        return QuantumJob(**response)
+
+    async def get_job(self, job_id: str) -> QuantumJob:
+        """Get job information and results
+        
+        Args:
+            job_id: Job identifier
+            
+        Returns:
+            QuantumJob object with current status and results
+
+        """
+        response = await self._request("GET", f"/jobs/{job_id}")
+        return QuantumJob(**response)
+
+    async def cancel_job(self, job_id: str) -> Dict[str, Any]:
+        """Cancel a running job
+        
+        Args:
+            job_id: Job identifier
+            
+        Returns:
+            Cancellation confirmation
+
+        """
+        return await self._request("DELETE", f"/jobs/{job_id}")
+
+    async def list_jobs(
+        self,
+        limit: int = 100,
+        status: Optional[str] = None,
+        backend: Optional[str] = None
+    ) -> List[QuantumJob]:
+        """List user's jobs with optional filtering
+        
+        Args:
+            limit: Maximum number of jobs to return
+            status: Filter by job status
+            backend: Filter by backend
+            
+        Returns:
+            List of QuantumJob objects
+
+        """
+        params = {"limit": limit}
+        if status:
+            params["status"] = status
+        if backend:
+            params["backend"] = backend
+
+        response = await self._request("GET", "/jobs", params=params)
+        return [QuantumJob(**job) for job in response.get("jobs", [])]
+
+    async def wait_for_job(
+        self,
+        job_id: str,
+        timeout: int = 300,
+        poll_interval: int = 5
+    ) -> QuantumJob:
+        """Wait for job completion with polling
+        
+        Args:
+            job_id: Job identifier
+            timeout: Maximum wait time in seconds
+            poll_interval: Polling interval in seconds
+            
+        Returns:
+            Completed QuantumJob object
+            
+        Raises:
+            TimeoutError: If job doesn't complete within timeout
+
+        """
+        start_time = asyncio.get_event_loop().time()
+
+        while True:
+            job = await self.get_job(job_id)
+
+            if job.status in ["completed", "failed", "cancelled"]:
+                return job
+
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed > timeout:
+                raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+
+            await asyncio.sleep(poll_interval)
+
+    # Synchronous wrappers for common operations
+    def health_check_sync(self) -> Dict[str, Any]:
+        """Synchronous version of health_check"""
+        return asyncio.run(self.health_check())
+
+    def submit_job_sync(
+        self,
+        circuit_data: Dict[str, Any],
+        backend: str = "simulator",
+        shots: int = 1024,
+        **kwargs
+    ) -> QuantumJob:
+        """Synchronous version of submit_job"""
+        return asyncio.run(self.submit_job(circuit_data, backend, shots, **kwargs))
+
+    def get_job_sync(self, job_id: str) -> QuantumJob:
+        """Synchronous version of get_job"""
+        return asyncio.run(self.get_job(job_id))
+
+    def wait_for_job_sync(self, job_id: str, timeout: int = 300) -> QuantumJob:
+        """Synchronous version of wait_for_job"""
+        return asyncio.run(self.wait_for_job(job_id, timeout))