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

superquantx/exceptions.py

@@ -5,15 +5,15 @@ to provide clear error messages and proper error handling for quantum-agentic
 AI research workflows.
 """
 
-from typing import Any, Optional
+from typing import Any
 
 
 class SuperQuantXError(Exception):
     """Base exception for all SuperQuantX errors."""
 
-    def __init__(self, message: str, error_code: Optional[str] = None) -> None:
+    def __init__(self, message: str, error_code: str | None = None) -> None:
         """Initialize SuperQuantX base exception.
-        
+
         Args:
             message: Human-readable error message
             error_code: Optional error code for programmatic handling
@@ -36,11 +36,11 @@ class BackendError(SuperQuantXError):
     def __init__(
         self,
         message: str,
-        backend_name: Optional[str] = None,
-        original_error: Optional[Exception] = None,
+        backend_name: str | None = None,
+        original_error: Exception | None = None,
     ) -> None:
         """Initialize backend error.
-        
+
         Args:
             message: Error description
             backend_name: Name of the backend that failed
@@ -60,9 +60,9 @@ class BackendError(SuperQuantXError):
 class BackendNotAvailableError(BackendError):
     """Raised when a required quantum backend is not available."""
 
-    def __init__(self, backend_name: str, missing_dependencies: Optional[list[str]] = None) -> None:
+    def __init__(self, backend_name: str, missing_dependencies: list[str] | None = None) -> None:
         """Initialize backend not available error.
-        
+
         Args:
             backend_name: Name of the unavailable backend
             missing_dependencies: List of missing dependency packages
@@ -84,11 +84,11 @@ class AlgorithmError(SuperQuantXError):
     def __init__(
         self,
         message: str,
-        algorithm_name: Optional[str] = None,
-        step: Optional[str] = None,
+        algorithm_name: str | None = None,
+        step: str | None = None,
     ) -> None:
         """Initialize algorithm error.
-        
+
         Args:
             message: Error description
             algorithm_name: Name of the algorithm that failed
@@ -112,7 +112,7 @@ class NotFittedError(AlgorithmError):
 
     def __init__(self, algorithm_name: str) -> None:
         """Initialize not fitted error.
-        
+
         Args:
             algorithm_name: Name of the algorithm that needs fitting
 
@@ -128,11 +128,11 @@ class InvalidParameterError(SuperQuantXError):
         self,
         parameter_name: str,
         parameter_value: Any,
-        expected_type: Optional[str] = None,
-        valid_values: Optional[list[Any]] = None,
+        expected_type: str | None = None,
+        valid_values: list[Any] | None = None,
     ) -> None:
         """Initialize invalid parameter error.
-        
+
         Args:
             parameter_name: Name of the invalid parameter
             parameter_value: The invalid value provided
@@ -161,10 +161,10 @@ class QuantumCircuitError(SuperQuantXError):
     def __init__(
         self,
         message: str,
-        circuit_info: Optional[dict[str, Any]] = None,
+        circuit_info: dict[str, Any] | None = None,
     ) -> None:
         """Initialize quantum circuit error.
-        
+
         Args:
             message: Error description
             circuit_info: Dictionary with circuit information (qubits, gates, etc.)
@@ -177,9 +177,9 @@ class QuantumCircuitError(SuperQuantXError):
 class ConfigurationError(SuperQuantXError):
     """Raised when configuration issues are detected."""
 
-    def __init__(self, message: str, config_key: Optional[str] = None) -> None:
+    def __init__(self, message: str, config_key: str | None = None) -> None:
         """Initialize configuration error.
-        
+
         Args:
             message: Error description
             config_key: The configuration key that caused the error
@@ -197,9 +197,9 @@ class ConfigurationError(SuperQuantXError):
 class ResearchModeError(SuperQuantXError):
     """Raised when research-only features are used incorrectly."""
 
-    def __init__(self, message: str, feature_name: Optional[str] = None) -> None:
+    def __init__(self, message: str, feature_name: str | None = None) -> None:
         """Initialize research mode error.
-        
+
         Args:
             message: Error description
             feature_name: Name of the research feature
@@ -218,11 +218,11 @@ class ResearchModeError(SuperQuantXError):
 # Utility functions for error handling
 def validate_backend_available(backend_name: str, backend_instance: Any) -> None:
     """Validate that a backend is available and properly initialized.
-    
+
     Args:
         backend_name: Name of the backend to validate
         backend_instance: The backend instance to check
-        
+
     Raises:
         BackendNotAvailableError: If backend is not available
         BackendError: If backend is improperly initialized
@@ -237,11 +237,11 @@ def validate_backend_available(backend_name: str, backend_instance: Any) -> None
 
 def validate_fitted(algorithm_instance: Any, algorithm_name: str) -> None:
     """Validate that an algorithm has been fitted.
-    
+
     Args:
         algorithm_instance: The algorithm instance to check
         algorithm_name: Name of the algorithm
-        
+
     Raises:
         NotFittedError: If algorithm is not fitted
 
@@ -253,19 +253,19 @@ def validate_fitted(algorithm_instance: Any, algorithm_name: str) -> None:
 def validate_parameter(
     parameter_name: str,
     parameter_value: Any,
-    expected_type: Optional[type] = None,
-    valid_values: Optional[list[Any]] = None,
+    expected_type: type | None = None,
+    valid_values: list[Any] | None = None,
     allow_none: bool = False,
 ) -> None:
     """Validate a parameter value.
-    
+
     Args:
         parameter_name: Name of the parameter
         parameter_value: Value to validate
         expected_type: Expected Python type
         valid_values: List of valid values
         allow_none: Whether None is an acceptable value
-        
+
     Raises:
         InvalidParameterError: If parameter is invalid
 

superquantx/gates.py

@@ -2,7 +2,7 @@
 """
 
 import math
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Union
 
 import numpy as np
 from scipy.linalg import expm
@@ -13,7 +13,7 @@ class GateMatrix:
     """
 
     # Pauli matrices
-    I = np.array([[1, 0], [0, 1]], dtype=complex)
+    identity = np.array([[1, 0], [0, 1]], dtype=complex)
     X = np.array([[0, 1], [1, 0]], dtype=complex)
     Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
     Z = np.array([[1, 0], [0, -1]], dtype=complex)
@@ -199,11 +199,11 @@ class ParametricGate:
         name: str,
         num_qubits: int,
         matrix_func: callable,
-        parameters: List[str],
-        description: Optional[str] = None
+        parameters: list[str],
+        description: str | None = None
     ):
         """Initialize parametric gate
-        
+
         Args:
             name: Gate name
             num_qubits: Number of qubits the gate acts on
@@ -238,12 +238,12 @@ class GateDecomposer:
     """
 
     @staticmethod
-    def decompose_arbitrary_single_qubit(matrix: np.ndarray) -> List[Tuple[str, List[float]]]:
+    def decompose_arbitrary_single_qubit(matrix: np.ndarray) -> list[tuple[str, list[float]]]:
         """Decompose arbitrary single-qubit unitary into U3 gates
-        
+
         Args:
             matrix: 2x2 unitary matrix
-            
+
         Returns:
             List of (gate_name, parameters) tuples
 
@@ -279,9 +279,9 @@ class GateDecomposer:
         return decomposition
 
     @staticmethod
-    def decompose_cnot_to_cz(control: int, target: int) -> List[Tuple[str, List[int], List[float]]]:
+    def decompose_cnot_to_cz(control: int, target: int) -> list[tuple[str, list[int], list[float]]]:
         """Decompose CNOT to CZ using Hadamard gates
-        
+
         Returns:
             List of (gate_name, qubits, parameters) tuples
 
@@ -293,9 +293,9 @@ class GateDecomposer:
         ]
 
     @staticmethod
-    def decompose_toffoli() -> List[Tuple[str, List[int], List[float]]]:
+    def decompose_toffoli() -> list[tuple[str, list[int], list[float]]]:
         """Decompose Toffoli gate into CNOT and single-qubit gates
-        
+
         Returns:
             List of (gate_name, qubits, parameters) for qubits [0, 1, 2]
 
@@ -319,9 +319,9 @@ class GateDecomposer:
         ]
 
     @staticmethod
-    def decompose_fredkin() -> List[Tuple[str, List[int], List[float]]]:
+    def decompose_fredkin() -> list[tuple[str, list[int], list[float]]]:
         """Decompose Fredkin gate into CNOT and Toffoli gates
-        
+
         Returns:
             List of (gate_name, qubits, parameters) for qubits [0, 1, 2]
 
@@ -339,7 +339,7 @@ class PauliString:
 
     def __init__(self, pauli_ops: str, coefficient: complex = 1.0):
         """Initialize Pauli string
-        
+
         Args:
             pauli_ops: String of Pauli operators (e.g., "IXZY")
             coefficient: Complex coefficient
@@ -357,7 +357,7 @@ class PauliString:
     def matrix(self) -> np.ndarray:
         """Get the matrix representation of the Pauli string"""
         matrices = {
-            'I': GateMatrix.I,
+            'I': GateMatrix.identity,
             'X': GateMatrix.X,
             'Y': GateMatrix.Y,
             'Z': GateMatrix.Z
@@ -377,7 +377,7 @@ class PauliString:
         anti_commuting_pairs = {('X', 'Y'), ('Y', 'X'), ('X', 'Z'), ('Z', 'X'), ('Y', 'Z'), ('Z', 'Y')}
         anti_commutations = 0
 
-        for op1, op2 in zip(self.pauli_ops, other.pauli_ops):
+        for op1, op2 in zip(self.pauli_ops, other.pauli_ops, strict=False):
             if (op1, op2) in anti_commuting_pairs:
                 anti_commutations += 1
 
@@ -385,7 +385,7 @@ class PauliString:
 
     def __mul__(self, other: Union[complex, "PauliString"]) -> "PauliString":
         """Multiply with scalar or another Pauli string"""
-        if isinstance(other, (int, float, complex)):
+        if isinstance(other, int | float | complex):
             return PauliString(self.pauli_ops, self.coefficient * other)
         elif isinstance(other, PauliString):
             if len(self.pauli_ops) != len(other.pauli_ops):
@@ -395,7 +395,7 @@ class PauliString:
             result_ops = []
             phase = 1
 
-            for op1, op2 in zip(self.pauli_ops, other.pauli_ops):
+            for op1, op2 in zip(self.pauli_ops, other.pauli_ops, strict=False):
                 if op1 == 'I':
                     result_ops.append(op2)
                 elif op2 == 'I':
@@ -441,9 +441,9 @@ class Hamiltonian:
     """Quantum Hamiltonian represented as sum of Pauli strings
     """
 
-    def __init__(self, pauli_strings: List[PauliString]):
+    def __init__(self, pauli_strings: list[PauliString]):
         """Initialize Hamiltonian
-        
+
         Args:
             pauli_strings: List of Pauli strings that sum to form the Hamiltonian
 
@@ -498,12 +498,12 @@ class Hamiltonian:
         return self * scalar
 
     @classmethod
-    def from_dict(cls, hamiltonian_dict: Dict[str, complex]) -> "Hamiltonian":
+    def from_dict(cls, hamiltonian_dict: dict[str, complex]) -> "Hamiltonian":
         """Create Hamiltonian from dictionary
-        
+
         Args:
             hamiltonian_dict: Dictionary mapping Pauli strings to coefficients
-            
+
         Example:
             {"IXZI": 0.5, "YZII": -0.3, "ZXYX": 1.2j}
 
@@ -522,7 +522,7 @@ class Hamiltonian:
         periodic: bool = False
     ) -> "Hamiltonian":
         """Create Heisenberg model Hamiltonian
-        
+
         H = Σᵢ (Jₓ XᵢXᵢ₊₁ + Jᵧ YᵢYᵢ₊₁ + Jᵤ ZᵢZᵢ₊₁)
         """
         pauli_strings = []
@@ -560,7 +560,7 @@ class Hamiltonian:
         periodic: bool = False
     ) -> "Hamiltonian":
         """Create transverse field Ising model Hamiltonian
-        
+
         H = -J Σᵢ ZᵢZᵢ₊₁ - h Σᵢ Xᵢ
         """
         pauli_strings = []

superquantx/logging_config.py

@@ -8,14 +8,14 @@ import logging
 import sys
 import warnings
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 from loguru import logger
 
 
 class SuperQuantXLogger:
     """Centralized logger for SuperQuantX with research-focused features.
-    
+
     This logger provides:
     - Structured logging for research experiments
     - Performance tracking and benchmarking
@@ -28,19 +28,19 @@ class SuperQuantXLogger:
         """Initialize SuperQuantX logger."""
         self._configured = False
         self._log_level = "INFO"
-        self._log_file: Optional[Path] = None
-        self._experiment_id: Optional[str] = None
+        self._log_file: Path | None = None
+        self._experiment_id: str | None = None
 
     def configure(
         self,
-        level: Union[str, int] = "INFO",
-        log_file: Optional[Union[str, Path]] = None,
-        experiment_id: Optional[str] = None,
+        level: str | int = "INFO",
+        log_file: str | Path | None = None,
+        experiment_id: str | None = None,
         enable_research_mode: bool = True,
         silence_warnings: bool = True,
     ) -> None:
         """Configure SuperQuantX logging.
-        
+
         Args:
             level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
             log_file: Optional file path for log output
@@ -103,7 +103,7 @@ class SuperQuantXLogger:
         self._configured = True
         logger.info("SuperQuantX logging configured", extra={"component": "logging"})
 
-    def _get_log_format(self, enable_research_mode: bool, experiment_id: Optional[str]) -> str:
+    def _get_log_format(self, enable_research_mode: bool, experiment_id: str | None) -> str:
         """Get logging format string based on configuration."""
         base_format = "{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{line} | {message}"
 
@@ -114,7 +114,7 @@ class SuperQuantXLogger:
 
         return base_format
 
-    def _configure_stdlib_logging(self, level: Union[str, int]) -> None:
+    def _configure_stdlib_logging(self, level: str | int) -> None:
         """Configure standard library logging to work with loguru."""
         class InterceptHandler(logging.Handler):
             def emit(self, record: logging.LogRecord) -> None:
@@ -162,10 +162,10 @@ class SuperQuantXLogger:
 
     def get_experiment_logger(self, experiment_name: str) -> "loguru.Logger":
         """Get a logger for a specific research experiment.
-        
+
         Args:
             experiment_name: Name of the experiment
-            
+
         Returns:
             Configured logger instance with experiment context
 
@@ -174,10 +174,10 @@ class SuperQuantXLogger:
 
     def get_algorithm_logger(self, algorithm_name: str) -> "loguru.Logger":
         """Get a logger for a specific quantum algorithm.
-        
+
         Args:
             algorithm_name: Name of the algorithm
-            
+
         Returns:
             Configured logger instance with algorithm context
 
@@ -186,10 +186,10 @@ class SuperQuantXLogger:
 
     def get_backend_logger(self, backend_name: str) -> "loguru.Logger":
         """Get a logger for a specific quantum backend.
-        
+
         Args:
             backend_name: Name of the backend
-            
+
         Returns:
             Configured logger instance with backend context
 
@@ -200,10 +200,10 @@ class SuperQuantXLogger:
         self,
         operation: str,
         duration: float,
-        metadata: Optional[Dict[str, Any]] = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Log performance metrics for research analysis.
-        
+
         Args:
             operation: Name of the operation being measured
             duration: Duration in seconds
@@ -224,11 +224,11 @@ class SuperQuantXLogger:
     def log_experiment_result(
         self,
         experiment_name: str,
-        results: Dict[str, Any],
-        metadata: Optional[Dict[str, Any]] = None,
+        results: dict[str, Any],
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Log experiment results for research tracking.
-        
+
         Args:
             experiment_name: Name of the experiment
             results: Experiment results dictionary
@@ -252,23 +252,23 @@ class SuperQuantXLogger:
         return self._configured
 
     @property
-    def log_file(self) -> Optional[Path]:
+    def log_file(self) -> Path | None:
         """Get the current log file path."""
         return self._log_file
 
     @property
-    def experiment_id(self) -> Optional[str]:
+    def experiment_id(self) -> str | None:
         """Get the current experiment ID."""
         return self._experiment_id
 
 
 # Global logger instance
-_logger_instance: Optional[SuperQuantXLogger] = None
+_logger_instance: SuperQuantXLogger | None = None
 
 
 def get_logger() -> SuperQuantXLogger:
     """Get the global SuperQuantX logger instance.
-    
+
     Returns:
         Global logger instance
 
@@ -280,14 +280,14 @@ def get_logger() -> SuperQuantXLogger:
 
 
 def configure_logging(
-    level: Union[str, int] = "INFO",
-    log_file: Optional[Union[str, Path]] = None,
-    experiment_id: Optional[str] = None,
+    level: str | int = "INFO",
+    log_file: str | Path | None = None,
+    experiment_id: str | None = None,
     enable_research_mode: bool = True,
     silence_warnings: bool = True,
 ) -> None:
     """Configure SuperQuantX logging (convenience function).
-    
+
     Args:
         level: Logging level
         log_file: Optional log file path