superquantx 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

superquantx/cli/commands.py

@@ -7,7 +7,6 @@ including algorithm execution, benchmarking, configuration, and system informati
 import json
 import sys
 import time
-from typing import Optional
 
 import click
 import numpy as np
@@ -100,7 +99,7 @@ def list_algorithms(category: str, verbose: bool):
 
                     # Try to get algorithm class and show parameters
                     try:
-                        alg_class = getattr(sqx.algorithms, alg_name)
+                        getattr(sqx.algorithms, alg_name)
                         # This is a simplified approach - real implementation would
                         # need to inspect the class properly
                         click.echo(f"    Module: superquantx.algorithms.{alg_name}")
@@ -189,8 +188,8 @@ def run_algorithm(
     algorithm: str,
     data: str,
     backend: str,
-    output: Optional[str],
-    config_file: Optional[str],
+    output: str | None,
+    config_file: str | None,
     verbose: bool
 ):
     """Run a quantum algorithm on specified dataset."""
@@ -403,7 +402,7 @@ def benchmark(
     is_flag=True,
     help='Show current configuration'
 )
-def configure(backend: Optional[str], shots: Optional[int], seed: Optional[int], show: bool):
+def configure(backend: str | None, shots: int | None, seed: int | None, show: bool):
     """Configure SuperQuantX settings."""
     if show:
         click.echo("Current SuperQuantX Configuration:")
@@ -451,7 +450,7 @@ def configure(backend: Optional[str], shots: Optional[int], seed: Optional[int],
     type=click.Path(),
     help='Output file (NPZ format)'
 )
-def create_dataset(dataset_type: str, samples: int, features: int, output: Optional[str]):
+def create_dataset(dataset_type: str, samples: int, features: int, output: str | None):
     """Create synthetic datasets for testing."""
     if dataset_type == 'classification':
         X_train, X_test, y_train, y_test, metadata = sqx.datasets.generate_classification_data(
@@ -502,7 +501,7 @@ def create_dataset(dataset_type: str, samples: int, features: int, output: Optio
     type=click.Path(),
     help='Output file for plot'
 )
-def visualize(results_file: str, plot_type: str, output: Optional[str]):
+def visualize(results_file: str, plot_type: str, output: str | None):
     """Visualize algorithm results."""
     # Load results
     with open(results_file) as f:

superquantx/cli/main.py

@@ -6,7 +6,6 @@ with subcommands for various quantum machine learning operations.
 
 import sys
 from pathlib import Path
-from typing import Optional
 
 import click
 
@@ -38,12 +37,12 @@ from .commands import (
     help='Enable verbose output'
 )
 @click.pass_context
-def cli(ctx: click.Context, config: Optional[str], verbose: bool):
+def cli(ctx: click.Context, config: str | None, 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
@@ -109,12 +108,12 @@ def shell():
         banner = """
         SuperQuantX Interactive Shell
         =============================
-        
+
         Available imports:
         - superquantx as sqx
         - numpy as np
         - matplotlib.pyplot as plt
-        
+
         Try: sqx.algorithms.QuantumSVM()
         """
 

superquantx/client.py

@@ -2,7 +2,7 @@
 """
 
 import asyncio
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import httpx
 from pydantic import BaseModel, Field
@@ -24,23 +24,23 @@ class QuantumJob(BaseModel):
     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
+    circuit_id: str | None = None
+    backend: str | None = None
+    shots: int | None = None
+    results: dict[str, Any] | None = None
+    error: str | None = 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]]):
+    def __init__(self, config: SuperQuantXConfig | str | dict[str, Any]):
         """Initialize SuperQuantX client
-        
+
         Args:
             config: Configuration object, API key string, or config dictionary
 
@@ -83,20 +83,20 @@ class SuperQuantXClient:
         self,
         method: str,
         endpoint: str,
-        data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = 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
 
@@ -117,27 +117,27 @@ class SuperQuantXClient:
                     raise
                 await asyncio.sleep(2 ** attempt)  # Exponential backoff
 
-    async def health_check(self) -> Dict[str, Any]:
+    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]:
+    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]]:
+    async def list_backends(self) -> list[dict[str, Any]]:
         """List available quantum backends
-        
+
         Returns:
             List of available backends with their specifications
 
@@ -145,12 +145,12 @@ class SuperQuantXClient:
         response = await self._request("GET", "/backends")
         return response.get("backends", [])
 
-    async def get_backend_info(self, backend_name: str) -> Dict[str, Any]:
+    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
 
@@ -159,21 +159,21 @@ class SuperQuantXClient:
 
     async def submit_job(
         self,
-        circuit_data: Dict[str, Any],
+        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
 
@@ -191,10 +191,10 @@ class SuperQuantXClient:
 
     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
 
@@ -202,12 +202,12 @@ class SuperQuantXClient:
         response = await self._request("GET", f"/jobs/{job_id}")
         return QuantumJob(**response)
 
-    async def cancel_job(self, job_id: str) -> Dict[str, Any]:
+    async def cancel_job(self, job_id: str) -> dict[str, Any]:
         """Cancel a running job
-        
+
         Args:
             job_id: Job identifier
-            
+
         Returns:
             Cancellation confirmation
 
@@ -217,16 +217,16 @@ class SuperQuantXClient:
     async def list_jobs(
         self,
         limit: int = 100,
-        status: Optional[str] = None,
-        backend: Optional[str] = None
-    ) -> List[QuantumJob]:
+        status: str | None = None,
+        backend: str | None = 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
 
@@ -247,15 +247,15 @@ class SuperQuantXClient:
         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
 
@@ -275,13 +275,13 @@ class SuperQuantXClient:
             await asyncio.sleep(poll_interval)
 
     # Synchronous wrappers for common operations
-    def health_check_sync(self) -> Dict[str, Any]:
+    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],
+        circuit_data: dict[str, Any],
         backend: str = "simulator",
         shots: int = 1024,
         **kwargs

superquantx/config.py

@@ -8,7 +8,7 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 import yaml
 
@@ -20,7 +20,7 @@ class Config:
 
     def __init__(self) -> None:
         """Initialize configuration with defaults."""
-        self._config: Dict[str, Any] = {
+        self._config: dict[str, Any] = {
             # Backend configuration
             "backends": {
                 "default": "auto",
@@ -160,9 +160,9 @@ class Config:
             if value is not None:
                 self._set_nested_value(config_path, value)
 
-    def _merge_config(self, new_config: Dict[str, Any]) -> None:
+    def _merge_config(self, new_config: dict[str, Any]) -> None:
         """Merge new configuration with existing configuration."""
-        def merge_dicts(base: Dict, update: Dict) -> Dict:
+        def merge_dicts(base: dict, update: dict) -> dict:
             for key, value in update.items():
                 if key in base and isinstance(base[key], dict) and isinstance(value, dict):
                     base[key] = merge_dicts(base[key], value)
@@ -215,11 +215,11 @@ class Config:
 
         current[keys[-1]] = value
 
-    def update(self, updates: Dict[str, Any]) -> None:
+    def update(self, updates: dict[str, Any]) -> None:
         """Update configuration with a dictionary of values."""
         self._merge_config(updates)
 
-    def save(self, path: Optional[Union[str, Path]] = None) -> None:
+    def save(self, path: str | Path | None = None) -> None:
         """Save current configuration to file."""
         if path is None:
             path = Path.home() / ".superquantx" / "config.yaml"
@@ -240,7 +240,7 @@ class Config:
         """Reset configuration to defaults."""
         self.__init__()
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Get configuration as dictionary."""
         return self._config.copy()
 
@@ -258,13 +258,13 @@ class Config:
 config = Config()
 
 def configure(
-    backend: Optional[str] = None,
-    shots: Optional[int] = None,
-    debug: Optional[bool] = None,
+    backend: str | None = None,
+    shots: int | None = None,
+    debug: bool | None = None,
     **kwargs
 ) -> None:
     """Configure SuperQuantX settings.
-    
+
     Args:
         backend: Default backend to use
         shots: Default number of shots for quantum circuits
@@ -310,12 +310,12 @@ def setup_logging() -> None:
         force=True,
     )
 
-def get_platform_config(platform: str) -> Dict[str, Any]:
+def get_platform_config(platform: str) -> dict[str, Any]:
     """Get configuration for a specific platform.
-    
+
     Args:
         platform: Platform name (e.g., 'ibm', 'braket', 'azure')
-        
+
     Returns:
         Platform configuration dictionary
 

superquantx/datasets/__init__.py

@@ -0,0 +1,58 @@
+"""SuperQuantX Datasets Module.
+
+This module provides datasets and data loading utilities for quantum machine learning.
+It includes quantum-specific datasets, classical datasets adapted for quantum computing,
+and synthetic data generators for testing quantum algorithms.
+"""
+
+from .molecular import (
+    load_beh2_molecule,
+    load_h2_molecule,
+    load_lih_molecule,
+    load_molecule,
+)
+from .preprocessing import (
+    AmplitudeEncoder,
+    AngleEncoder,
+    QuantumFeatureEncoder,
+    normalize_quantum_data,
+)
+from .quantum_datasets import (
+    load_breast_cancer_quantum,
+    load_digits_quantum,
+    load_iris_quantum,
+    load_wine_quantum,
+)
+from .synthetic import (
+    generate_classification_data,
+    generate_clustering_data,
+    generate_portfolio_data,
+    generate_regression_data,
+)
+
+
+__all__ = [
+    # Quantum datasets
+    "load_iris_quantum",
+    "load_wine_quantum",
+    "load_digits_quantum",
+    "load_breast_cancer_quantum",
+
+    # Synthetic data generators
+    "generate_classification_data",
+    "generate_regression_data",
+    "generate_clustering_data",
+    "generate_portfolio_data",
+
+    # Molecular datasets
+    "load_molecule",
+    "load_h2_molecule",
+    "load_lih_molecule",
+    "load_beh2_molecule",
+
+    # Preprocessing utilities
+    "QuantumFeatureEncoder",
+    "AmplitudeEncoder",
+    "AngleEncoder",
+    "normalize_quantum_data",
+]