#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Quantum LIMIT-Graph v2.0 Setup Script Automated setup and configuration for quantum-enhanced AI research agent. """ import os import sys import subprocess import logging from pathlib import Path from typing import Dict, List, Optional # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) class QuantumSetup: """Setup manager for Quantum LIMIT-Graph v2.0.""" def __init__(self): self.project_root = Path(__file__).parent self.requirements_file = self.project_root / "requirements.txt" self.config_dir = self.project_root / "config" def check_python_version(self) -> bool: """Check if Python version is compatible.""" version = sys.version_info if version.major < 3 or (version.major == 3 and version.minor < 8): logger.error("Python 3.8+ is required for Quantum LIMIT-Graph v2.0") return False logger.info(f"✓ Python {version.major}.{version.minor}.{version.micro} is compatible") return True def install_quantum_dependencies(self) -> bool: """Install quantum computing dependencies.""" logger.info("Installing quantum computing dependencies...") try: # Install core quantum packages quantum_packages = [ "qiskit>=0.45.0", "qiskit-aer>=0.13.0", "qiskit-algorithms>=0.2.0", "pennylane>=0.32.0", "cirq-core>=1.2.0", "lambeq>=0.3.4" ] for package in quantum_packages: logger.info(f"Installing {package}...") result = subprocess.run([ sys.executable, "-m", "pip", "install", package ], capture_output=True, text=True) if result.returncode != 0: logger.error(f"Failed to install {package}: {result.stderr}") return False logger.info(f"✓ {package} installed successfully") return True except Exception as e: logger.error(f"Error installing quantum dependencies: {e}") return False def install_requirements(self) -> bool: """Install all requirements from requirements.txt.""" if not self.requirements_file.exists(): logger.error(f"Requirements file not found: {self.requirements_file}") return False logger.info("Installing all requirements...") try: result = subprocess.run([ sys.executable, "-m", "pip", "install", "-r", str(self.requirements_file) ], capture_output=True, text=True) if result.returncode != 0: logger.error(f"Failed to install requirements: {result.stderr}") return False logger.info("✓ All requirements installed successfully") return True except Exception as e: logger.error(f"Error installing requirements: {e}") return False def verify_quantum_installation(self) -> bool: """Verify quantum computing packages are working.""" logger.info("Verifying quantum installations...") # Test Qiskit try: import qiskit from qiskit import QuantumCircuit from qiskit_aer import AerSimulator # Create simple test circuit qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) qc.measure_all() # Test simulation simulator = AerSimulator() job = simulator.run(qc, shots=100) result = job.result() logger.info(f"✓ Qiskit {qiskit.__version__} working correctly") except Exception as e: logger.error(f"Qiskit verification failed: {e}") return False # Test PennyLane try: import pennylane as qml # Create simple test device dev = qml.device('default.qubit', wires=2) @qml.qnode(dev) def test_circuit(): qml.Hadamard(wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)) result = test_circuit() logger.info(f"✓ PennyLane {qml.__version__} working correctly") except Exception as e: logger.error(f"PennyLane verification failed: {e}") return False # Test Cirq try: import cirq # Create simple test circuit qubit = cirq.GridQubit(0, 0) circuit = cirq.Circuit(cirq.H(qubit)) logger.info(f"✓ Cirq {cirq.__version__} working correctly") except Exception as e: logger.error(f"Cirq verification failed: {e}") return False # Test Lambeq try: import lambeq from lambeq import AtomicType # Test basic functionality noun_type = AtomicType.NOUN logger.info(f"✓ Lambeq {lambeq.__version__} working correctly") except Exception as e: logger.error(f"Lambeq verification failed: {e}") return False logger.info("✅ All quantum packages verified successfully") return True def create_config_files(self) -> bool: """Create configuration files for quantum components.""" logger.info("Creating configuration files...") try: # Create config directory self.config_dir.mkdir(exist_ok=True) # Quantum configuration quantum_config = { "quantum_backend": "qiskit_aer", "max_qubits": 24, "default_languages": ["indonesian", "arabic", "spanish", "english"], "components": { "semantic_graph": { "enabled": True, "max_qubits": 20 }, "policy_optimizer": { "enabled": True, "num_qubits": 16, "num_layers": 3 }, "context_engine": { "enabled": True, "max_context_qubits": 20, "cultural_dimensions": 8 }, "benchmark_harness": { "enabled": True, "max_qubits": 24 }, "provenance_tracker": { "enabled": True, "max_qubits": 20, "hash_precision": 256 } } } config_file = self.config_dir / "quantum_config.json" with open(config_file, 'w') as f: import json json.dump(quantum_config, f, indent=2) logger.info(f"✓ Created quantum configuration: {config_file}") # Environment template env_template = """# Quantum LIMIT-Graph v2.0 Environment Variables # Quantum Computing Backend QUANTUM_BACKEND=qiskit_aer # Optional: IBM Quantum Access # IBMQ_TOKEN=your_ibm_quantum_token_here # Optional: Google Quantum AI # GOOGLE_QUANTUM_PROJECT=your_google_project_id # Optional: Rigetti Quantum Computing # RIGETTI_API_KEY=your_rigetti_api_key # Optional: Amazon Braket # AWS_ACCESS_KEY_ID=your_aws_access_key # AWS_SECRET_ACCESS_KEY=your_aws_secret_key # AWS_DEFAULT_REGION=us-east-1 # Logging Level LOG_LEVEL=INFO # Session Configuration MAX_QUBITS=24 DEFAULT_LANGUAGES=indonesian,arabic,spanish,english """ env_file = self.config_dir / ".env.template" with open(env_file, 'w') as f: f.write(env_template) logger.info(f"✓ Created environment template: {env_file}") return True except Exception as e: logger.error(f"Error creating config files: {e}") return False def run_quantum_tests(self) -> bool: """Run basic quantum functionality tests.""" logger.info("Running quantum functionality tests...") try: # Import quantum components from quantum_integration import QuantumLimitGraph # Initialize with minimal configuration quantum_agent = QuantumLimitGraph( languages=['english', 'spanish'], max_qubits=8, # Small for testing enable_quantum_walks=True, enable_quantum_rlhf=False, # Skip for quick test enable_quantum_context=True, enable_quantum_benchmarking=False, # Skip for quick test enable_quantum_provenance=True ) # Test basic quantum research test_query = "quantum semantic processing test" results = quantum_agent.quantum_research( test_query, languages=['english'], research_depth='quick' ) if results and 'synthesis' in results: logger.info("✓ Basic quantum research functionality working") else: logger.error("Quantum research test failed") return False # Test system status status = quantum_agent.get_quantum_system_status() if status and 'session_id' in status: logger.info("✓ Quantum system status working") else: logger.error("Quantum system status test failed") return False logger.info("✅ All quantum functionality tests passed") return True except Exception as e: logger.error(f"Quantum functionality tests failed: {e}") return False def setup_complete(self) -> bool: """Complete setup process.""" logger.info("🚀 Starting Quantum LIMIT-Graph v2.0 Setup...") # Step 1: Check Python version if not self.check_python_version(): return False # Step 2: Install requirements if not self.install_requirements(): return False # Step 3: Verify quantum installations if not self.verify_quantum_installation(): return False # Step 4: Create configuration files if not self.create_config_files(): return False # Step 5: Run basic tests if not self.run_quantum_tests(): return False logger.info("✅ Quantum LIMIT-Graph v2.0 setup completed successfully!") logger.info("") logger.info("Next steps:") logger.info("1. Review configuration files in ./config/") logger.info("2. Set up environment variables (copy .env.template to .env)") logger.info("3. Run: python -c 'from quantum_integration import QuantumLimitGraph; print(\"Ready!\")'") logger.info("4. See README.md for usage examples") return True def main(): """Main setup function.""" setup = QuantumSetup() success = setup.setup_complete() if not success: logger.error("❌ Setup failed. Please check the errors above.") sys.exit(1) sys.exit(0) if __name__ == "__main__": main()