quantumflow-sdk 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

db/models.py

@@ -31,6 +31,44 @@ class JobStatus(str, enum.Enum):
     CANCELLED = "cancelled"
 
 
+class PipelineStatus(str, enum.Enum):
+    """Pipeline execution status."""
+    CREATED = "created"
+    RUNNING = "running"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    ROLLED_BACK = "rolled_back"
+
+
+class PipelineType(str, enum.Enum):
+    """Type of data pipeline."""
+    PROTEIN_FOLDING = "protein_folding"
+    PORTFOLIO_OPTIMIZATION = "portfolio_optimization"
+    CUSTOM = "custom"
+
+
+class AnomalyType(str, enum.Enum):
+    """Types of detected anomalies."""
+    GRADIENT_EXPLOSION = "gradient_explosion"
+    GRADIENT_VANISHING = "gradient_vanishing"
+    NAN_DETECTED = "nan_detected"
+    INF_DETECTED = "inf_detected"
+    ENERGY_SPIKE = "energy_spike"
+    RMSD_DIVERGENCE = "rmsd_divergence"
+    VAR_BREACH = "var_breach"
+    DRAWDOWN_BREACH = "drawdown_breach"
+    STATISTICAL_DEVIATION = "statistical_deviation"
+    CUSTOM = "custom"
+
+
+class AnomalySeverity(str, enum.Enum):
+    """Severity level of anomaly."""
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+
+
 class JobType(str, enum.Enum):
     """Type of quantum job."""
     COMPRESS = "compress"
@@ -79,6 +117,7 @@ class User(Base):
     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")
+    pipelines = relationship("Pipeline", back_populates="user", cascade="all, delete-orphan")
 
     def __repr__(self):
         return f"<User {self.email}>"
@@ -189,9 +228,327 @@ class UsageRecord(Base):
         return f"<UsageRecord {self.endpoint} {self.created_at}>"
 
 
+class Pipeline(Base):
+    """Long-running data pipeline with checkpointing support."""
+
+    __tablename__ = "pipelines"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+
+    # Pipeline info
+    name = Column(String(255), nullable=False)
+    pipeline_type = Column(SQLEnum(PipelineType), nullable=False)
+    status = Column(SQLEnum(PipelineStatus), default=PipelineStatus.CREATED)
+    description = Column(Text, nullable=True)
+
+    # Configuration
+    config = Column(JSON, default=dict)  # Pipeline-specific config
+    backend = Column(String(50), default="simulator")
+
+    # Checkpointing settings
+    checkpoint_interval_steps = Column(Integer, default=10)
+    checkpoint_interval_seconds = Column(Integer, default=300)  # 5 minutes
+    max_checkpoints = Column(Integer, default=5)  # Keep N most recent
+
+    # Execution state
+    current_step = Column(Integer, default=0)
+    total_steps = Column(Integer, nullable=True)
+    current_checkpoint_id = Column(UUID(as_uuid=True), nullable=True)
+
+    # Metrics
+    total_execution_time_ms = Column(Float, default=0)
+    rollback_count = Column(Integer, default=0)
+    anomaly_count = Column(Integer, default=0)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+    last_checkpoint_at = Column(DateTime, nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="pipelines")
+    checkpoints = relationship("Checkpoint", back_populates="pipeline", cascade="all, delete-orphan")
+    anomaly_events = relationship("AnomalyEvent", back_populates="pipeline", cascade="all, delete-orphan")
+    memory_states = relationship("TemporalMemoryState", back_populates="pipeline", cascade="all, delete-orphan")
+
+    def __repr__(self):
+        return f"<Pipeline {self.name} {self.pipeline_type} {self.status}>"
+
+
+class Checkpoint(Base):
+    """State persistence checkpoint for pipeline recovery."""
+
+    __tablename__ = "checkpoints"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    pipeline_id = Column(UUID(as_uuid=True), ForeignKey("pipelines.id"), nullable=False)
+
+    # Checkpoint info
+    step_number = Column(Integer, nullable=False)
+    checkpoint_name = Column(String(255), nullable=True)
+
+    # State data
+    state_data = Column(JSON, nullable=False)  # Serialized algorithm state
+    state_hash = Column(String(64), nullable=False)  # SHA-256 for integrity verification
+
+    # Quantum state (optional, for quantum compression)
+    compressed_state = Column(JSON, nullable=True)  # Quantum-compressed state vector
+    compression_ratio = Column(Float, nullable=True)
+
+    # Metrics at checkpoint
+    metrics = Column(JSON, default=dict)  # Energy, loss, gradients, etc.
+
+    # Validity
+    is_valid = Column(Boolean, default=True)
+    validation_error = Column(Text, nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Size tracking
+    state_size_bytes = Column(Integer, nullable=True)
+
+    # Relationships
+    pipeline = relationship("Pipeline", back_populates="checkpoints")
+
+    def __repr__(self):
+        return f"<Checkpoint {self.id} step={self.step_number}>"
+
+
+class AnomalyEvent(Base):
+    """Detected divergence or anomaly event during pipeline execution."""
+
+    __tablename__ = "anomaly_events"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    pipeline_id = Column(UUID(as_uuid=True), ForeignKey("pipelines.id"), nullable=False)
+
+    # Anomaly info
+    anomaly_type = Column(SQLEnum(AnomalyType), nullable=False)
+    severity = Column(SQLEnum(AnomalySeverity), default=AnomalySeverity.WARNING)
+    message = Column(Text, nullable=False)
+
+    # Context
+    step_number = Column(Integer, nullable=False)
+    detector_name = Column(String(255), nullable=True)  # Which detector caught it
+
+    # Data at anomaly
+    anomaly_data = Column(JSON, default=dict)  # Values that triggered detection
+    threshold = Column(Float, nullable=True)  # Threshold that was breached
+    actual_value = Column(Float, nullable=True)  # Actual value observed
+
+    # Resolution
+    was_auto_resolved = Column(Boolean, default=False)
+    resolution_action = Column(String(50), nullable=True)  # rollback, skip, retry
+    resolved_checkpoint_id = Column(UUID(as_uuid=True), nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    resolved_at = Column(DateTime, nullable=True)
+
+    # Relationships
+    pipeline = relationship("Pipeline", back_populates="anomaly_events")
+
+    def __repr__(self):
+        return f"<AnomalyEvent {self.anomaly_type} {self.severity}>"
+
+
+class TemporalMemoryState(Base):
+    """LSTM-like sequential state storage for pattern matching."""
+
+    __tablename__ = "temporal_memory_states"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    pipeline_id = Column(UUID(as_uuid=True), ForeignKey("pipelines.id"), nullable=False)
+
+    # Sequence info
+    sequence_number = Column(Integer, nullable=False)  # Order in the sequence
+    run_id = Column(UUID(as_uuid=True), nullable=False)  # Groups states by run
+
+    # State data
+    state_vector = Column(JSON, nullable=False)  # The actual state embedding
+    state_dimension = Column(Integer, nullable=False)  # Vector dimension
+
+    # Quantum compression (optional)
+    is_compressed = Column(Boolean, default=False)
+    compressed_vector = Column(JSON, nullable=True)
+    compression_n_qubits = Column(Integer, nullable=True)
+
+    # Additional context
+    extra_data = Column(JSON, default=dict)  # Additional context (labels, tags, etc.)
+
+    # Pattern matching helpers
+    state_norm = Column(Float, nullable=True)  # For fast similarity lookup
+    cluster_id = Column(Integer, nullable=True)  # Optional clustering
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Relationships
+    pipeline = relationship("Pipeline", back_populates="memory_states")
+
+    def __repr__(self):
+        return f"<TemporalMemoryState seq={self.sequence_number} run={self.run_id}>"
+
+
 # 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())
+
+# Pipeline indexes
+Index("ix_pipelines_user_status", Pipeline.user_id, Pipeline.status)
+Index("ix_pipelines_type", Pipeline.pipeline_type)
+Index("ix_checkpoints_pipeline_step", Checkpoint.pipeline_id, Checkpoint.step_number.desc())
+Index("ix_anomalies_pipeline_created", AnomalyEvent.pipeline_id, AnomalyEvent.created_at.desc())
+Index("ix_anomalies_type_severity", AnomalyEvent.anomaly_type, AnomalyEvent.severity)
+Index("ix_memory_pipeline_run_seq", TemporalMemoryState.pipeline_id, TemporalMemoryState.run_id, TemporalMemoryState.sequence_number)
+
+
+# ==================== QChat Messaging Models ====================
+
+class MessageStatus(str, enum.Enum):
+    """Message delivery status."""
+    PENDING = "pending"
+    SENT = "sent"
+    DELIVERED = "delivered"
+    READ = "read"
+    FAILED = "failed"
+
+
+class ChannelStatus(str, enum.Enum):
+    """Quantum channel status."""
+    PENDING = "pending"
+    ESTABLISHING = "establishing"
+    READY = "ready"
+    COMPROMISED = "compromised"
+    EXPIRED = "expired"
+
+
+class ChatUser(Base):
+    """QChat user linked by phone number."""
+
+    __tablename__ = "chat_users"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    phone_number = Column(String(20), unique=True, nullable=False, index=True)
+    display_name = Column(String(100), nullable=True)
+
+    # Firebase UID for auth verification
+    firebase_uid = Column(String(128), unique=True, nullable=True)
+
+    # Public key for quantum key exchange
+    public_key = Column(Text, nullable=True)
+
+    # Device info for push notifications
+    device_token = Column(String(255), nullable=True)
+    platform = Column(String(20), nullable=True)  # ios, android
+
+    # Status
+    is_online = Column(Boolean, default=False)
+    last_seen = Column(DateTime, nullable=True)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def __repr__(self):
+        return f"<ChatUser {self.phone_number}>"
+
+
+class QuantumChannel(Base):
+    """Quantum-secure channel between two users."""
+
+    __tablename__ = "quantum_channels"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+    # Participants
+    user_a_id = Column(UUID(as_uuid=True), ForeignKey("chat_users.id"), nullable=False)
+    user_b_id = Column(UUID(as_uuid=True), ForeignKey("chat_users.id"), nullable=False)
+
+    # Channel status
+    status = Column(SQLEnum(ChannelStatus), default=ChannelStatus.PENDING)
+
+    # Quantum key distribution
+    qkd_key_id = Column(String(64), nullable=True)  # Reference to QKD session
+    bell_pairs_remaining = Column(Integer, default=1000)
+    key_generated_at = Column(DateTime, nullable=True)
+    key_expires_at = Column(DateTime, nullable=True)
+
+    # Security metrics
+    eavesdrop_detected_count = Column(Integer, default=0)
+    last_eavesdrop_at = Column(DateTime, nullable=True)
+    error_rate = Column(Float, default=0.0)  # QBER - Quantum Bit Error Rate
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    established_at = Column(DateTime, nullable=True)
+    last_message_at = Column(DateTime, nullable=True)
+
+    # Relationships
+    user_a = relationship("ChatUser", foreign_keys=[user_a_id])
+    user_b = relationship("ChatUser", foreign_keys=[user_b_id])
+    messages = relationship("ChatMessage", back_populates="channel", cascade="all, delete-orphan")
+
+    def __repr__(self):
+        return f"<QuantumChannel {self.id} {self.status}>"
+
+
+class ChatMessage(Base):
+    """Encrypted message in a quantum channel."""
+
+    __tablename__ = "chat_messages"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    channel_id = Column(UUID(as_uuid=True), ForeignKey("quantum_channels.id"), nullable=False)
+    sender_id = Column(UUID(as_uuid=True), ForeignKey("chat_users.id"), nullable=False)
+
+    # Encrypted content (backend never sees plaintext)
+    encrypted_content = Column(Text, nullable=False)
+    content_hash = Column(String(64), nullable=False)  # SHA-256 for integrity
+
+    # Encryption metadata
+    encryption_method = Column(String(50), default="qkd_aes256")
+    compression_ratio = Column(Float, nullable=True)
+
+    # Quantum teleportation metadata
+    bell_pair_id = Column(String(64), nullable=True)
+    teleport_fidelity = Column(Float, nullable=True)
+
+    # Security
+    eavesdrop_detected = Column(Boolean, default=False)
+
+    # Status
+    status = Column(SQLEnum(MessageStatus), default=MessageStatus.PENDING)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow)
+    sent_at = Column(DateTime, nullable=True)
+    delivered_at = Column(DateTime, nullable=True)
+    read_at = Column(DateTime, nullable=True)
+
+    # Auto-delete after delivery (ephemeral mode)
+    auto_delete = Column(Boolean, default=True)
+    delete_after_seconds = Column(Integer, default=86400)  # 24 hours
+
+    # Relationships
+    channel = relationship("QuantumChannel", back_populates="messages")
+    sender = relationship("ChatUser", foreign_keys=[sender_id])
+
+    def __repr__(self):
+        return f"<ChatMessage {self.id} {self.status}>"
+
+
+# QChat indexes
+Index("ix_chat_users_phone", ChatUser.phone_number)
+Index("ix_chat_users_firebase", ChatUser.firebase_uid)
+Index("ix_channels_users", QuantumChannel.user_a_id, QuantumChannel.user_b_id)
+Index("ix_channels_status", QuantumChannel.status)
+Index("ix_messages_channel_created", ChatMessage.channel_id, ChatMessage.created_at.desc())
+Index("ix_messages_sender", ChatMessage.sender_id)
+Index("ix_messages_status", ChatMessage.status)

quantumflow/algorithms/machine_learning/__init__.py

@@ -1,7 +1,19 @@
 """Machine Learning Algorithms."""
 
-from quantumflow.algorithms.machine_learning.vqe import VQE
+from quantumflow.algorithms.machine_learning.vqe import (
+    VQE,
+    VQEResult,
+    run_ses_vqe,
+    calculate_volumetric_cost,
+)
 from quantumflow.algorithms.machine_learning.qsvm import QSVM
 from quantumflow.algorithms.machine_learning.qnn import QNN
 
-__all__ = ["VQE", "QSVM", "QNN"]
+__all__ = [
+    "VQE",
+    "VQEResult",
+    "run_ses_vqe",
+    "calculate_volumetric_cost",
+    "QSVM",
+    "QNN",
+]