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

api/routes/pipeline_routes.py

@@ -0,0 +1,578 @@
+"""
+Pipeline API Routes.
+
+REST endpoints for managing data pipelines:
+- Create/start/stop pipelines
+- Checkpoint management
+- Rollback operations
+- Anomaly tracking
+
+Endpoints:
+    POST /v1/pipelines/create        - Create new pipeline
+    POST /v1/pipelines/{id}/start    - Start pipeline execution
+    POST /v1/pipelines/{id}/pause    - Pause pipeline
+    POST /v1/pipelines/{id}/resume   - Resume pipeline
+    POST /v1/pipelines/{id}/stop     - Stop pipeline
+    GET  /v1/pipelines/{id}          - Get pipeline status
+    GET  /v1/pipelines               - List user pipelines
+    GET  /v1/pipelines/{id}/checkpoints     - List checkpoints
+    POST /v1/pipelines/{id}/rollback/{cp}   - Rollback to checkpoint
+    GET  /v1/pipelines/{id}/anomalies       - List anomalies
+"""
+
+from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks
+from pydantic import BaseModel, Field
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/v1/pipelines", tags=["pipelines"])
+
+# In-memory pipeline storage (replace with DB in production)
+_active_pipelines: Dict[str, Any] = {}
+
+
+# ============================================================
+# Request/Response Models
+# ============================================================
+
+
+class PipelineConfigRequest(BaseModel):
+    """Pipeline configuration."""
+
+    checkpoint_interval_steps: int = Field(default=10, ge=1)
+    checkpoint_interval_seconds: int = Field(default=300, ge=60)
+    max_checkpoints: int = Field(default=5, ge=1)
+    enable_quantum_compression: bool = False
+    enable_anomaly_detection: bool = True
+    auto_rollback_on_critical: bool = True
+    backend: str = "simulator"
+
+
+class CreateProteinPipelineRequest(BaseModel):
+    """Request to create protein folding pipeline."""
+
+    name: str = Field(..., min_length=1, max_length=255)
+    pipeline_type: str = "protein_folding"
+    sequence: str = Field(..., min_length=1, description="Amino acid sequence")
+    reference_structure: Optional[List[List[float]]] = None
+    config: Optional[PipelineConfigRequest] = None
+
+    # VQE settings
+    n_qubits: int = Field(default=8, ge=2, le=20)
+    ansatz_depth: int = Field(default=2, ge=1, le=10)
+    max_rmsd: float = Field(default=10.0, gt=0)
+
+
+class CreatePortfolioPipelineRequest(BaseModel):
+    """Request to create portfolio optimization pipeline."""
+
+    name: str = Field(..., min_length=1, max_length=255)
+    pipeline_type: str = "portfolio_optimization"
+    assets: List[str] = Field(..., min_items=2)
+    expected_returns: List[float] = Field(..., min_items=2)
+    covariance_matrix: Optional[List[List[float]]] = None
+    initial_capital: float = Field(default=100000.0, gt=0)
+    config: Optional[PipelineConfigRequest] = None
+
+    # QAOA settings
+    n_qubits: int = Field(default=8, ge=2, le=20)
+    qaoa_depth: int = Field(default=2, ge=1, le=10)
+
+    # Risk settings
+    max_var: float = Field(default=0.05, gt=0, le=1)
+    max_drawdown: float = Field(default=0.20, gt=0, le=1)
+    target_return: float = Field(default=0.10)
+
+
+class StartPipelineRequest(BaseModel):
+    """Request to start pipeline execution."""
+
+    total_steps: int = Field(..., ge=1, le=10000)
+    resume_from_checkpoint: Optional[int] = None
+
+
+class RollbackRequest(BaseModel):
+    """Request to rollback to checkpoint."""
+
+    checkpoint_step: Optional[int] = None  # None = latest valid
+
+
+class PipelineResponse(BaseModel):
+    """Pipeline information response."""
+
+    id: str
+    name: str
+    pipeline_type: str
+    status: str
+    current_step: int
+    total_steps: Optional[int]
+    created_at: str
+    started_at: Optional[str]
+    completed_at: Optional[str]
+    metrics: Dict[str, Any]
+    checkpoints_count: int
+    anomalies_count: int
+    rollbacks_count: int
+
+
+class CheckpointResponse(BaseModel):
+    """Checkpoint information."""
+
+    id: str
+    step_number: int
+    checkpoint_name: Optional[str]
+    created_at: str
+    is_valid: bool
+    state_size_bytes: Optional[int]
+    compression_ratio: Optional[float]
+    metrics: Dict[str, Any]
+
+
+class AnomalyResponse(BaseModel):
+    """Anomaly event information."""
+
+    id: str
+    anomaly_type: str
+    severity: str
+    message: str
+    step_number: int
+    detector_name: Optional[str]
+    threshold: Optional[float]
+    actual_value: Optional[float]
+    was_auto_resolved: bool
+    created_at: str
+
+
+# ============================================================
+# Helper Functions
+# ============================================================
+
+
+def _get_pipeline(pipeline_id: str):
+    """Get pipeline by ID."""
+    if pipeline_id not in _active_pipelines:
+        raise HTTPException(status_code=404, detail="Pipeline not found")
+    return _active_pipelines[pipeline_id]
+
+
+def _run_pipeline_async(pipeline_id: str, total_steps: int):
+    """Run pipeline in background."""
+    pipeline_info = _active_pipelines.get(pipeline_id)
+    if not pipeline_info:
+        return
+
+    pipeline = pipeline_info["pipeline"]
+
+    try:
+        pipeline_info["status"] = "running"
+        pipeline_info["started_at"] = datetime.utcnow().isoformat()
+
+        result = pipeline.run(total_steps=total_steps)
+
+        pipeline_info["status"] = result.status
+        pipeline_info["completed_at"] = datetime.utcnow().isoformat()
+        pipeline_info["result"] = result.to_dict()
+        pipeline_info["current_step"] = result.total_steps
+        pipeline_info["metrics"] = result.final_state.metrics
+        pipeline_info["checkpoints_count"] = result.checkpoints_created
+        pipeline_info["anomalies_count"] = result.anomalies_detected
+        pipeline_info["rollbacks_count"] = result.rollbacks_performed
+
+    except Exception as e:
+        logger.error(f"Pipeline {pipeline_id} failed: {e}")
+        pipeline_info["status"] = "failed"
+        pipeline_info["error"] = str(e)
+
+
+# ============================================================
+# Endpoints
+# ============================================================
+
+
+@router.post("/create/protein", response_model=PipelineResponse)
+async def create_protein_pipeline(request: CreateProteinPipelineRequest):
+    """Create a new protein folding pipeline."""
+    from quantumflow.pipeline.healthcare.protein_folding import (
+        ProteinFoldingPipeline,
+        ProteinConfig,
+    )
+    from quantumflow.pipeline.checkpoint_manager import CheckpointManager
+    from quantumflow.pipeline.temporal_memory import TemporalMemoryStore
+
+    pipeline_id = str(uuid.uuid4())
+
+    # Create config
+    config = ProteinConfig(
+        sequence=request.sequence,
+        reference_structure=request.reference_structure,
+        n_qubits=request.n_qubits,
+        ansatz_depth=request.ansatz_depth,
+        max_rmsd=request.max_rmsd,
+        backend=request.config.backend if request.config else "simulator",
+        checkpoint_interval_steps=request.config.checkpoint_interval_steps if request.config else 10,
+        checkpoint_interval_seconds=request.config.checkpoint_interval_seconds if request.config else 300,
+        max_checkpoints=request.config.max_checkpoints if request.config else 5,
+        enable_quantum_compression=request.config.enable_quantum_compression if request.config else False,
+        enable_anomaly_detection=request.config.enable_anomaly_detection if request.config else True,
+        auto_rollback_on_critical=request.config.auto_rollback_on_critical if request.config else True,
+    )
+
+    # Create pipeline
+    pipeline = ProteinFoldingPipeline(
+        name=request.name,
+        sequence=request.sequence,
+        reference_structure=request.reference_structure,
+        config=config,
+        pipeline_id=pipeline_id,
+    )
+
+    # Setup checkpoint manager and temporal memory
+    checkpoint_manager = CheckpointManager(backend=config.backend, use_database=False)
+    temporal_memory = TemporalMemoryStore(use_database=False)
+
+    pipeline.set_checkpoint_manager(checkpoint_manager)
+    pipeline.set_temporal_memory(temporal_memory)
+
+    # Store pipeline
+    created_at = datetime.utcnow().isoformat()
+    _active_pipelines[pipeline_id] = {
+        "pipeline": pipeline,
+        "checkpoint_manager": checkpoint_manager,
+        "temporal_memory": temporal_memory,
+        "name": request.name,
+        "pipeline_type": "protein_folding",
+        "status": "created",
+        "current_step": 0,
+        "total_steps": None,
+        "created_at": created_at,
+        "started_at": None,
+        "completed_at": None,
+        "metrics": {},
+        "checkpoints_count": 0,
+        "anomalies_count": 0,
+        "rollbacks_count": 0,
+    }
+
+    return PipelineResponse(
+        id=pipeline_id,
+        name=request.name,
+        pipeline_type="protein_folding",
+        status="created",
+        current_step=0,
+        total_steps=None,
+        created_at=created_at,
+        started_at=None,
+        completed_at=None,
+        metrics={},
+        checkpoints_count=0,
+        anomalies_count=0,
+        rollbacks_count=0,
+    )
+
+
+@router.post("/create/portfolio", response_model=PipelineResponse)
+async def create_portfolio_pipeline(request: CreatePortfolioPipelineRequest):
+    """Create a new portfolio optimization pipeline."""
+    from quantumflow.pipeline.finance.portfolio_optimization import (
+        PortfolioOptimizationPipeline,
+        PortfolioConfig,
+    )
+    from quantumflow.pipeline.checkpoint_manager import CheckpointManager
+    from quantumflow.pipeline.temporal_memory import TemporalMemoryStore
+
+    pipeline_id = str(uuid.uuid4())
+
+    # Create config
+    config = PortfolioConfig(
+        assets=request.assets,
+        expected_returns=request.expected_returns,
+        covariance_matrix=request.covariance_matrix or [],
+        initial_capital=request.initial_capital,
+        n_qubits=request.n_qubits,
+        qaoa_depth=request.qaoa_depth,
+        max_var=request.max_var,
+        max_drawdown=request.max_drawdown,
+        target_return=request.target_return,
+        backend=request.config.backend if request.config else "simulator",
+        checkpoint_interval_steps=request.config.checkpoint_interval_steps if request.config else 10,
+        checkpoint_interval_seconds=request.config.checkpoint_interval_seconds if request.config else 300,
+        max_checkpoints=request.config.max_checkpoints if request.config else 5,
+        enable_quantum_compression=request.config.enable_quantum_compression if request.config else False,
+        enable_anomaly_detection=request.config.enable_anomaly_detection if request.config else True,
+        auto_rollback_on_critical=request.config.auto_rollback_on_critical if request.config else True,
+    )
+
+    # Create pipeline
+    pipeline = PortfolioOptimizationPipeline(
+        name=request.name,
+        assets=request.assets,
+        expected_returns=request.expected_returns,
+        covariance_matrix=request.covariance_matrix,
+        initial_capital=request.initial_capital,
+        config=config,
+        pipeline_id=pipeline_id,
+    )
+
+    # Setup managers
+    checkpoint_manager = CheckpointManager(backend=config.backend, use_database=False)
+    temporal_memory = TemporalMemoryStore(use_database=False)
+
+    pipeline.set_checkpoint_manager(checkpoint_manager)
+    pipeline.set_temporal_memory(temporal_memory)
+
+    # Store pipeline
+    created_at = datetime.utcnow().isoformat()
+    _active_pipelines[pipeline_id] = {
+        "pipeline": pipeline,
+        "checkpoint_manager": checkpoint_manager,
+        "temporal_memory": temporal_memory,
+        "name": request.name,
+        "pipeline_type": "portfolio_optimization",
+        "status": "created",
+        "current_step": 0,
+        "total_steps": None,
+        "created_at": created_at,
+        "started_at": None,
+        "completed_at": None,
+        "metrics": {},
+        "checkpoints_count": 0,
+        "anomalies_count": 0,
+        "rollbacks_count": 0,
+    }
+
+    return PipelineResponse(
+        id=pipeline_id,
+        name=request.name,
+        pipeline_type="portfolio_optimization",
+        status="created",
+        current_step=0,
+        total_steps=None,
+        created_at=created_at,
+        started_at=None,
+        completed_at=None,
+        metrics={},
+        checkpoints_count=0,
+        anomalies_count=0,
+        rollbacks_count=0,
+    )
+
+
+@router.post("/{pipeline_id}/start", response_model=PipelineResponse)
+async def start_pipeline(
+    pipeline_id: str,
+    request: StartPipelineRequest,
+    background_tasks: BackgroundTasks,
+):
+    """Start pipeline execution."""
+    info = _get_pipeline(pipeline_id)
+
+    if info["status"] == "running":
+        raise HTTPException(status_code=400, detail="Pipeline is already running")
+
+    info["total_steps"] = request.total_steps
+    info["status"] = "starting"
+
+    # Run in background
+    background_tasks.add_task(_run_pipeline_async, pipeline_id, request.total_steps)
+
+    return PipelineResponse(
+        id=pipeline_id,
+        name=info["name"],
+        pipeline_type=info["pipeline_type"],
+        status="starting",
+        current_step=info["current_step"],
+        total_steps=request.total_steps,
+        created_at=info["created_at"],
+        started_at=info["started_at"],
+        completed_at=info["completed_at"],
+        metrics=info["metrics"],
+        checkpoints_count=info["checkpoints_count"],
+        anomalies_count=info["anomalies_count"],
+        rollbacks_count=info["rollbacks_count"],
+    )
+
+
+@router.post("/{pipeline_id}/pause")
+async def pause_pipeline(pipeline_id: str):
+    """Pause pipeline execution."""
+    info = _get_pipeline(pipeline_id)
+    pipeline = info["pipeline"]
+
+    if info["status"] != "running":
+        raise HTTPException(status_code=400, detail="Pipeline is not running")
+
+    pipeline.pause()
+    info["status"] = "paused"
+
+    return {"status": "paused", "pipeline_id": pipeline_id}
+
+
+@router.post("/{pipeline_id}/resume")
+async def resume_pipeline(pipeline_id: str):
+    """Resume paused pipeline."""
+    info = _get_pipeline(pipeline_id)
+    pipeline = info["pipeline"]
+
+    if info["status"] != "paused":
+        raise HTTPException(status_code=400, detail="Pipeline is not paused")
+
+    pipeline.resume()
+    info["status"] = "running"
+
+    return {"status": "running", "pipeline_id": pipeline_id}
+
+
+@router.post("/{pipeline_id}/stop")
+async def stop_pipeline(pipeline_id: str):
+    """Stop pipeline execution."""
+    info = _get_pipeline(pipeline_id)
+    pipeline = info["pipeline"]
+
+    pipeline.stop()
+    info["status"] = "stopped"
+
+    return {"status": "stopped", "pipeline_id": pipeline_id}
+
+
+@router.get("/{pipeline_id}", response_model=PipelineResponse)
+async def get_pipeline(pipeline_id: str):
+    """Get pipeline status and information."""
+    info = _get_pipeline(pipeline_id)
+    pipeline = info["pipeline"]
+
+    return PipelineResponse(
+        id=pipeline_id,
+        name=info["name"],
+        pipeline_type=info["pipeline_type"],
+        status=info["status"],
+        current_step=pipeline.state.step if pipeline.state else info["current_step"],
+        total_steps=info["total_steps"],
+        created_at=info["created_at"],
+        started_at=info["started_at"],
+        completed_at=info["completed_at"],
+        metrics=pipeline.state.metrics if pipeline.state else info["metrics"],
+        checkpoints_count=info["checkpoints_count"],
+        anomalies_count=info["anomalies_count"],
+        rollbacks_count=info["rollbacks_count"],
+    )
+
+
+@router.get("", response_model=List[PipelineResponse])
+async def list_pipelines():
+    """List all pipelines."""
+    return [
+        PipelineResponse(
+            id=pid,
+            name=info["name"],
+            pipeline_type=info["pipeline_type"],
+            status=info["status"],
+            current_step=info["current_step"],
+            total_steps=info["total_steps"],
+            created_at=info["created_at"],
+            started_at=info["started_at"],
+            completed_at=info["completed_at"],
+            metrics=info["metrics"],
+            checkpoints_count=info["checkpoints_count"],
+            anomalies_count=info["anomalies_count"],
+            rollbacks_count=info["rollbacks_count"],
+        )
+        for pid, info in _active_pipelines.items()
+    ]
+
+
+@router.get("/{pipeline_id}/checkpoints", response_model=List[CheckpointResponse])
+async def list_checkpoints(pipeline_id: str, limit: int = 10):
+    """List checkpoints for a pipeline."""
+    info = _get_pipeline(pipeline_id)
+    checkpoint_manager = info["checkpoint_manager"]
+
+    checkpoints = checkpoint_manager.list_checkpoints(pipeline_id, limit=limit)
+
+    return [
+        CheckpointResponse(
+            id=cp["id"],
+            step_number=cp["step_number"],
+            checkpoint_name=cp.get("checkpoint_name"),
+            created_at=cp["created_at"],
+            is_valid=cp["is_valid"],
+            state_size_bytes=cp.get("state_size_bytes"),
+            compression_ratio=cp.get("compression_ratio"),
+            metrics=cp.get("metrics", {}),
+        )
+        for cp in checkpoints
+    ]
+
+
+@router.post("/{pipeline_id}/rollback/{checkpoint_step}")
+async def rollback_to_checkpoint(pipeline_id: str, checkpoint_step: int):
+    """Rollback pipeline to a specific checkpoint."""
+    info = _get_pipeline(pipeline_id)
+    pipeline = info["pipeline"]
+    checkpoint_manager = info["checkpoint_manager"]
+
+    # Load checkpoint
+    checkpoint = checkpoint_manager.load(pipeline_id, checkpoint_step)
+    if not checkpoint:
+        raise HTTPException(status_code=404, detail="Checkpoint not found")
+
+    if not checkpoint["is_valid"]:
+        raise HTTPException(status_code=400, detail="Checkpoint is invalid")
+
+    # Restore state
+    restored_state = pipeline.restore_state_from_checkpoint(checkpoint["state_data"])
+    pipeline._state = restored_state
+    info["current_step"] = checkpoint_step
+
+    return {
+        "status": "rolled_back",
+        "pipeline_id": pipeline_id,
+        "rolled_back_to_step": checkpoint_step,
+    }
+
+
+@router.get("/{pipeline_id}/anomalies", response_model=List[AnomalyResponse])
+async def list_anomalies(pipeline_id: str, limit: int = 50):
+    """List anomaly events for a pipeline."""
+    info = _get_pipeline(pipeline_id)
+
+    # Get anomalies from pipeline's anomaly detector history
+    # Note: In production, this would come from the database
+    anomalies = info.get("anomalies", [])
+
+    return [
+        AnomalyResponse(
+            id=str(uuid.uuid4()),
+            anomaly_type=a.get("anomaly_type", "unknown"),
+            severity=a.get("severity", "warning"),
+            message=a.get("message", ""),
+            step_number=a.get("step", 0),
+            detector_name=a.get("detector_name"),
+            threshold=a.get("threshold"),
+            actual_value=a.get("actual_value"),
+            was_auto_resolved=a.get("was_auto_resolved", False),
+            created_at=a.get("created_at", datetime.utcnow().isoformat()),
+        )
+        for a in anomalies[-limit:]
+    ]
+
+
+@router.delete("/{pipeline_id}")
+async def delete_pipeline(pipeline_id: str):
+    """Delete a pipeline."""
+    if pipeline_id not in _active_pipelines:
+        raise HTTPException(status_code=404, detail="Pipeline not found")
+
+    info = _active_pipelines[pipeline_id]
+    pipeline = info["pipeline"]
+
+    # Stop if running
+    if info["status"] == "running":
+        pipeline.stop()
+
+    del _active_pipelines[pipeline_id]
+
+    return {"status": "deleted", "pipeline_id": pipeline_id}