quantumflow-sdk 0.1.0__py3-none-any.whl

db/crud.py

@@ -0,0 +1,319 @@
+"""
+CRUD Operations for QuantumFlow.
+
+Provides clean interface for database operations.
+"""
+
+import secrets
+from datetime import datetime, timedelta
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy.orm import Session
+from sqlalchemy import select, and_
+import bcrypt
+
+from db.models import User, APIKey, Job, UsageRecord, JobStatus, JobType
+
+
+# ============== User CRUD ==============
+
+def get_user(db: Session, user_id: UUID) -> Optional[User]:
+    """Get user by ID."""
+    return db.query(User).filter(User.id == user_id).first()
+
+
+def get_user_by_email(db: Session, email: str) -> Optional[User]:
+    """Get user by email."""
+    return db.query(User).filter(User.email == email).first()
+
+
+def create_user(
+    db: Session,
+    email: str,
+    password: str,
+    name: Optional[str] = None,
+) -> User:
+    """Create a new user."""
+    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+    user = User(
+        email=email,
+        hashed_password=hashed_password,
+        name=name,
+    )
+
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+
+    return user
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against hash."""
+    return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
+
+
+def authenticate_user(db: Session, email: str, password: str) -> Optional[User]:
+    """Authenticate user by email and password."""
+    user = get_user_by_email(db, email)
+    if not user:
+        return None
+    if not verify_password(password, user.hashed_password):
+        return None
+    return user
+
+
+def update_user_login(db: Session, user: User) -> User:
+    """Update user's last login timestamp."""
+    user.last_login = datetime.utcnow()
+    db.commit()
+    db.refresh(user)
+    return user
+
+
+# ============== API Key CRUD ==============
+
+def create_api_key(
+    db: Session,
+    user_id: UUID,
+    name: str,
+    scopes: Optional[list[str]] = None,
+    expires_in_days: Optional[int] = None,
+) -> tuple[APIKey, str]:
+    """
+    Create a new API key.
+
+    Returns:
+        Tuple of (APIKey object, raw key string)
+        The raw key is only returned once and should be shown to user.
+    """
+    # Generate secure random key
+    raw_key = f"qf_{secrets.token_hex(24)}"
+    prefix = raw_key[:7]
+
+    expires_at = None
+    if expires_in_days:
+        expires_at = datetime.utcnow() + timedelta(days=expires_in_days)
+
+    api_key = APIKey(
+        user_id=user_id,
+        key=raw_key,
+        name=name,
+        prefix=prefix,
+        scopes=scopes or ["all"],
+        expires_at=expires_at,
+    )
+
+    db.add(api_key)
+    db.commit()
+    db.refresh(api_key)
+
+    return api_key, raw_key
+
+
+def get_api_key(db: Session, key: str) -> Optional[APIKey]:
+    """Get API key by key string."""
+    api_key = db.query(APIKey).filter(
+        and_(
+            APIKey.key == key,
+            APIKey.is_active == True,
+        )
+    ).first()
+
+    # Check expiration
+    if api_key and api_key.expires_at and api_key.expires_at < datetime.utcnow():
+        return None
+
+    return api_key
+
+
+def get_user_api_keys(db: Session, user_id: UUID) -> list[APIKey]:
+    """Get all API keys for a user."""
+    return db.query(APIKey).filter(APIKey.user_id == user_id).all()
+
+
+def revoke_api_key(db: Session, key_id: UUID) -> bool:
+    """Revoke an API key."""
+    api_key = db.query(APIKey).filter(APIKey.id == key_id).first()
+    if api_key:
+        api_key.is_active = False
+        db.commit()
+        return True
+    return False
+
+
+def update_api_key_usage(db: Session, api_key: APIKey) -> APIKey:
+    """Update API key's last used timestamp."""
+    api_key.last_used = datetime.utcnow()
+    db.commit()
+    return api_key
+
+
+# ============== Job CRUD ==============
+
+def create_job(
+    db: Session,
+    user_id: UUID,
+    job_type: JobType,
+    backend: str = "simulator",
+    input_data: Optional[dict] = None,
+    n_qubits: Optional[int] = None,
+    shots: int = 1024,
+) -> Job:
+    """Create a new quantum job."""
+    job = Job(
+        user_id=user_id,
+        job_type=job_type,
+        backend=backend,
+        input_data=input_data,
+        n_qubits=n_qubits,
+        shots=shots,
+        status=JobStatus.PENDING,
+    )
+
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+
+    return job
+
+
+def get_job(db: Session, job_id: UUID) -> Optional[Job]:
+    """Get job by ID."""
+    return db.query(Job).filter(Job.id == job_id).first()
+
+
+def get_user_jobs(
+    db: Session,
+    user_id: UUID,
+    limit: int = 100,
+    offset: int = 0,
+    status: Optional[JobStatus] = None,
+) -> list[Job]:
+    """Get jobs for a user."""
+    query = db.query(Job).filter(Job.user_id == user_id)
+
+    if status:
+        query = query.filter(Job.status == status)
+
+    return query.order_by(Job.created_at.desc()).offset(offset).limit(limit).all()
+
+
+def update_job_status(
+    db: Session,
+    job: Job,
+    status: JobStatus,
+    output_data: Optional[dict] = None,
+    error_message: Optional[str] = None,
+    execution_time_ms: Optional[float] = None,
+    fidelity: Optional[float] = None,
+    compression_ratio: Optional[float] = None,
+) -> Job:
+    """Update job status and results."""
+    job.status = status
+
+    if status == JobStatus.RUNNING:
+        job.started_at = datetime.utcnow()
+    elif status in [JobStatus.COMPLETED, JobStatus.FAILED]:
+        job.completed_at = datetime.utcnow()
+
+    if output_data is not None:
+        job.output_data = output_data
+    if error_message is not None:
+        job.error_message = error_message
+    if execution_time_ms is not None:
+        job.execution_time_ms = execution_time_ms
+    if fidelity is not None:
+        job.fidelity = fidelity
+    if compression_ratio is not None:
+        job.compression_ratio = compression_ratio
+
+    db.commit()
+    db.refresh(job)
+
+    return job
+
+
+# ============== Usage CRUD ==============
+
+def create_usage_record(
+    db: Session,
+    user_id: UUID,
+    endpoint: str,
+    method: str,
+    tokens_input: int = 0,
+    tokens_output: int = 0,
+    qubits_used: int = 0,
+    execution_time_ms: float = 0,
+    credits_used: float = 0,
+    ip_address: Optional[str] = None,
+    user_agent: Optional[str] = None,
+) -> UsageRecord:
+    """Create a usage record."""
+    record = UsageRecord(
+        user_id=user_id,
+        endpoint=endpoint,
+        method=method,
+        tokens_input=tokens_input,
+        tokens_output=tokens_output,
+        qubits_used=qubits_used,
+        execution_time_ms=execution_time_ms,
+        credits_used=credits_used,
+        ip_address=ip_address,
+        user_agent=user_agent,
+    )
+
+    db.add(record)
+    db.commit()
+    db.refresh(record)
+
+    return record
+
+
+def get_user_usage(
+    db: Session,
+    user_id: UUID,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+) -> dict:
+    """Get usage summary for a user."""
+    query = db.query(UsageRecord).filter(UsageRecord.user_id == user_id)
+
+    if start_date:
+        query = query.filter(UsageRecord.created_at >= start_date)
+    if end_date:
+        query = query.filter(UsageRecord.created_at <= end_date)
+
+    records = query.all()
+
+    return {
+        "total_requests": len(records),
+        "total_tokens_input": sum(r.tokens_input for r in records),
+        "total_tokens_output": sum(r.tokens_output for r in records),
+        "total_qubits_used": sum(r.qubits_used for r in records),
+        "total_execution_time_ms": sum(r.execution_time_ms for r in records),
+        "total_credits_used": sum(r.credits_used for r in records),
+    }
+
+
+def get_monthly_usage(db: Session, user_id: UUID) -> int:
+    """Get current month's API call count."""
+    now = datetime.utcnow()
+    start_of_month = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+
+    count = db.query(UsageRecord).filter(
+        and_(
+            UsageRecord.user_id == user_id,
+            UsageRecord.created_at >= start_of_month,
+        )
+    ).count()
+
+    return count
+
+
+def check_quota(db: Session, user: User) -> bool:
+    """Check if user is within their monthly quota."""
+    usage = get_monthly_usage(db, user.id)
+    return usage < user.monthly_quota

db/database.py

@@ -0,0 +1,93 @@
+"""
+Database Connection and Session Management.
+
+Supports both sync and async operations with PostgreSQL.
+"""
+
+import os
+from typing import Generator
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+
+# Database URL from environment
+DATABASE_URL = os.getenv(
+    "DATABASE_URL",
+    "postgresql://localhost:5432/quantumflow"
+)
+
+# Convert to async URL if needed
+ASYNC_DATABASE_URL = DATABASE_URL.replace("postgresql://", "postgresql+asyncpg://")
+
+# Sync engine (for migrations and simple operations)
+engine = create_engine(
+    DATABASE_URL,
+    pool_pre_ping=True,
+    pool_size=5,
+    max_overflow=10,
+)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine,
+)
+
+# Async engine (for FastAPI endpoints)
+async_engine = create_async_engine(
+    ASYNC_DATABASE_URL,
+    pool_pre_ping=True,
+    pool_size=5,
+    max_overflow=10,
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    async_engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+def get_db() -> Generator[Session, None, None]:
+    """
+    Sync database session dependency.
+
+    Usage:
+        @app.get("/")
+        def endpoint(db: Session = Depends(get_db)):
+            ...
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+async def get_async_db() -> AsyncSession:
+    """
+    Async database session dependency.
+
+    Usage:
+        @app.get("/")
+        async def endpoint(db: AsyncSession = Depends(get_async_db)):
+            ...
+    """
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+
+def init_db():
+    """Initialize database tables."""
+    from db.models import Base
+    Base.metadata.create_all(bind=engine)
+
+
+async def init_async_db():
+    """Initialize database tables (async)."""
+    from db.models import Base
+    async with async_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)

db/models.py

@@ -0,0 +1,197 @@
+"""
+Database Models for QuantumFlow.
+
+Tables:
+- users: User accounts
+- api_keys: API authentication keys
+- jobs: Quantum job execution history
+- usage_records: Usage tracking and billing
+"""
+
+import uuid
+from datetime import datetime
+from typing import Optional
+from sqlalchemy import (
+    Column, String, Integer, Float, Boolean, DateTime,
+    ForeignKey, Text, JSON, Enum as SQLEnum
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import declarative_base, relationship
+import enum
+
+Base = declarative_base()
+
+
+class JobStatus(str, enum.Enum):
+    """Job execution status."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class JobType(str, enum.Enum):
+    """Type of quantum job."""
+    COMPRESS = "compress"
+    GRADIENT = "gradient"
+    ENTANGLE = "entangle"
+    GROVER = "grover"
+    QAOA = "qaoa"
+    VQE = "vqe"
+    QNN = "qnn"
+    QSVM = "qsvm"
+    QKD = "qkd"
+    QRNG = "qrng"
+    CUSTOM = "custom"
+
+
+class User(Base):
+    """User account model."""
+
+    __tablename__ = "users"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    email = Column(String(255), unique=True, nullable=False, index=True)
+    hashed_password = Column(String(255), nullable=False)
+    name = Column(String(255), nullable=True)
+
+    # Account status
+    is_active = Column(Boolean, default=True)
+    is_verified = Column(Boolean, default=False)
+    is_admin = Column(Boolean, default=False)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    last_login = Column(DateTime, nullable=True)
+
+    # Usage limits
+    tier = Column(String(50), default="free")  # free, pro, enterprise
+    monthly_quota = Column(Integer, default=1000)  # API calls per month
+
+    # Stripe billing
+    stripe_customer_id = Column(String(255), nullable=True, unique=True)
+    stripe_subscription_id = Column(String(255), nullable=True)
+    stripe_subscription_item_id = Column(String(255), nullable=True)
+
+    # Relationships
+    api_keys = relationship("APIKey", back_populates="user", cascade="all, delete-orphan")
+    jobs = relationship("Job", back_populates="user", cascade="all, delete-orphan")
+    usage_records = relationship("UsageRecord", back_populates="user", cascade="all, delete-orphan")
+
+    def __repr__(self):
+        return f"<User {self.email}>"
+
+
+class APIKey(Base):
+    """API key for authentication."""
+
+    __tablename__ = "api_keys"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+
+    # Key info
+    key = Column(String(64), unique=True, nullable=False, index=True)
+    name = Column(String(255), nullable=False)  # User-friendly name
+    prefix = Column(String(10), nullable=False)  # e.g., "qf_" for display
+
+    # Permissions
+    scopes = Column(JSON, default=list)  # ["compress", "gradient", "all"]
+
+    # Status
+    is_active = Column(Boolean, default=True)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    last_used = Column(DateTime, nullable=True)
+    expires_at = Column(DateTime, nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="api_keys")
+
+    def __repr__(self):
+        return f"<APIKey {self.prefix}***>"
+
+
+class Job(Base):
+    """Quantum job execution record."""
+
+    __tablename__ = "jobs"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+
+    # Job info
+    job_type = Column(SQLEnum(JobType), nullable=False)
+    status = Column(SQLEnum(JobStatus), default=JobStatus.PENDING)
+
+    # Backend info
+    backend = Column(String(50), default="simulator")  # simulator, ibm, google
+    n_qubits = Column(Integer, nullable=True)
+    shots = Column(Integer, default=1024)
+
+    # Input/Output
+    input_data = Column(JSON, nullable=True)
+    output_data = Column(JSON, nullable=True)
+    error_message = Column(Text, nullable=True)
+
+    # Metrics
+    execution_time_ms = Column(Float, nullable=True)
+    fidelity = Column(Float, nullable=True)
+    compression_ratio = Column(Float, nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="jobs")
+
+    def __repr__(self):
+        return f"<Job {self.id} {self.job_type} {self.status}>"
+
+
+class UsageRecord(Base):
+    """Usage tracking for billing and analytics."""
+
+    __tablename__ = "usage_records"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+
+    # Usage info
+    endpoint = Column(String(255), nullable=False)  # /v1/compress
+    method = Column(String(10), nullable=False)  # POST
+
+    # Metrics
+    tokens_input = Column(Integer, default=0)
+    tokens_output = Column(Integer, default=0)
+    qubits_used = Column(Integer, default=0)
+    execution_time_ms = Column(Float, default=0)
+
+    # Cost (for paid tiers)
+    credits_used = Column(Float, default=0)
+
+    # Timestamp
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Request metadata
+    ip_address = Column(String(45), nullable=True)
+    user_agent = Column(String(255), nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="usage_records")
+
+    def __repr__(self):
+        return f"<UsageRecord {self.endpoint} {self.created_at}>"
+
+
+# Indexes for common queries
+from sqlalchemy import Index
+
+Index("ix_jobs_user_created", Job.user_id, Job.created_at.desc())
+Index("ix_jobs_status", Job.status)
+Index("ix_usage_user_created", UsageRecord.user_id, UsageRecord.created_at.desc())

quantumflow/__init__.py

@@ -0,0 +1,47 @@
+"""
+QuantumFlow - Quantum-optimized AI agent workflow platform.
+
+Core Features:
+- 53% token compression via quantum superposition
+- O(log n) memory through quantum entanglement
+- Quantum teleportation for secure messaging
+- BB84 QKD for unconditionally secure key exchange
+- Multi-backend support (IBM, AWS Braket, Simulator)
+
+Installation:
+    pip install quantumflow
+
+Quick Start:
+    from quantumflow import QuantumCompressor
+
+    compressor = QuantumCompressor(backend="simulator")
+    result = compressor.compress([100, 200, 150, 175])
+    print(f"Compression: {result.compression_percentage}%")
+"""
+
+from quantumflow.core.quantum_compressor import QuantumCompressor, CompressedResult
+from quantumflow.core.quantum_backprop import QuantumBackprop
+from quantumflow.core.entanglement import Entangler
+from quantumflow.core.memory import QuantumMemory
+from quantumflow.core.teleportation import (
+    QuantumTeleporter,
+    QKDExchange,
+    SecureMessenger,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    # Core compression
+    "QuantumCompressor",
+    "CompressedResult",
+    # Backpropagation
+    "QuantumBackprop",
+    # Entanglement
+    "Entangler",
+    # Memory
+    "QuantumMemory",
+    # Teleportation & Security
+    "QuantumTeleporter",
+    "QKDExchange",
+    "SecureMessenger",
+]

quantumflow/algorithms/__init__.py

@@ -0,0 +1,48 @@
+"""
+QuantumFlow Algorithm Library.
+
+Categories:
+- compression: Token compression, QFT, amplitude amplification
+- optimization: QAOA, Grover, quantum annealing
+- machine_learning: VQE, QSVM, QNN
+- cryptography: QKD, QRNG
+- utility: Error correction, circuit optimization
+"""
+
+from quantumflow.algorithms.compression import (
+    TokenCompression,
+    QFTCompression,
+    AmplitudeAmplification,
+)
+from quantumflow.algorithms.optimization import (
+    QAOA,
+    GroverSearch,
+    QuantumAnnealing,
+)
+from quantumflow.algorithms.machine_learning import (
+    VQE,
+    QSVM,
+    QNN,
+)
+from quantumflow.algorithms.cryptography import (
+    QKD,
+    QRNG,
+)
+
+__all__ = [
+    # Compression
+    "TokenCompression",
+    "QFTCompression",
+    "AmplitudeAmplification",
+    # Optimization
+    "QAOA",
+    "GroverSearch",
+    "QuantumAnnealing",
+    # ML
+    "VQE",
+    "QSVM",
+    "QNN",
+    # Crypto
+    "QKD",
+    "QRNG",
+]

quantumflow/algorithms/compression/__init__.py

@@ -0,0 +1,7 @@
+"""Compression Algorithms."""
+
+from quantumflow.algorithms.compression.token_compression import TokenCompression
+from quantumflow.algorithms.compression.qft_compression import QFTCompression
+from quantumflow.algorithms.compression.amplitude_amplification import AmplitudeAmplification
+
+__all__ = ["TokenCompression", "QFTCompression", "AmplitudeAmplification"]