quantumflow-sdk 0.1.0__py3-none-any.whl

api/models.py

@@ -0,0 +1,137 @@
+"""
+API Request/Response Models for QuantumFlow.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+# === Compression Models ===
+
+class CompressRequest(BaseModel):
+    """Request to compress tokens."""
+
+    tokens: list[int] = Field(..., description="List of integer tokens to compress")
+    compression_level: float = Field(default=1.0, ge=0.0, le=1.0)
+    backend: str = Field(default="auto", description="Backend: auto, simulator, ibm")
+    execute: bool = Field(default=False, description="Execute on quantum backend")
+    shots: int = Field(default=1024, ge=1, le=10000)
+
+
+class CompressResponse(BaseModel):
+    """Response from token compression."""
+
+    input_tokens: int
+    output_qubits: int
+    tokens_saved: int
+    compression_ratio: float
+    compression_percent: float
+    fidelity: Optional[float] = None
+    execution_time_ms: Optional[float] = None
+    backend_used: str
+
+
+# === Gradient Models ===
+
+class GradientRequest(BaseModel):
+    """Request to compute quantum gradient."""
+
+    input_state: list[float] = Field(..., description="Input state amplitudes")
+    target_state: list[float] = Field(..., description="Target state amplitudes")
+    weights: list[float] = Field(..., description="Current weight parameters")
+    backend: str = Field(default="auto")
+    shots: int = Field(default=1024, ge=1, le=10000)
+
+
+class GradientResponse(BaseModel):
+    """Response from quantum gradient computation."""
+
+    gradients: list[float]
+    bit_x: int
+    bit_z: int
+    gradient_direction: int
+    gradient_magnitude: float
+    classical_similarity: float
+    execution_time_ms: float
+
+
+# === Backend Models ===
+
+class BackendStatus(BaseModel):
+    """Status of a quantum backend."""
+
+    name: str
+    status: str
+    is_simulator: bool
+    max_qubits: int
+    queue_position: Optional[int] = None
+
+
+class BackendsResponse(BaseModel):
+    """List of available backends."""
+
+    backends: list[BackendStatus]
+
+
+# === Memory Models ===
+
+class MemoryStoreRequest(BaseModel):
+    """Request to store data in quantum memory."""
+
+    key: str = Field(..., min_length=1, max_length=256)
+    values: list[int]
+    compress: bool = Field(default=True)
+
+
+class MemoryStoreResponse(BaseModel):
+    """Response from memory store operation."""
+
+    key: str
+    stored_count: int
+    qubits_used: Optional[int] = None
+    compression_ratio: Optional[float] = None
+
+
+class MemoryRetrieveResponse(BaseModel):
+    """Response from memory retrieve operation."""
+
+    key: str
+    values: list[int]
+
+
+class MemoryStatsResponse(BaseModel):
+    """Quantum memory statistics."""
+
+    total_items: int
+    classical_size: int
+    quantum_size: int
+    compression_ratio: float
+    memory_saved_percent: float
+
+
+# === Entanglement Models ===
+
+class EntangleRequest(BaseModel):
+    """Request to create entangled state."""
+
+    contexts: list[list[float]] = Field(..., min_length=2)
+    backend: str = Field(default="auto")
+
+
+class EntangleResponse(BaseModel):
+    """Response from entanglement creation."""
+
+    n_qubits: int
+    n_parties: int
+    entropy: float
+    is_maximally_entangled: bool
+
+
+# === Health Models ===
+
+class HealthResponse(BaseModel):
+    """API health status."""
+
+    status: str
+    version: str
+    quantum_ready: bool

api/routes/__init__.py

@@ -0,0 +1 @@
+"""API Routes Package."""

api/routes/auth_routes.py

@@ -0,0 +1,234 @@
+"""
+Authentication Routes.
+
+Endpoints for user registration, login, and API key management.
+"""
+
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, EmailStr
+from sqlalchemy.orm import Session
+
+from api.auth import (
+    get_db_session,
+    get_current_user,
+    get_current_active_user,
+    create_access_token,
+    authenticate_user,
+    create_user,
+    create_api_key_for_user,
+    TokenResponse,
+    UserResponse,
+    APIKeyResponse,
+    ACCESS_TOKEN_EXPIRE_MINUTES,
+)
+from db import crud
+from db.models import User
+
+router = APIRouter(prefix="/auth", tags=["Authentication"])
+
+
+# ============== Request Models ==============
+
+class RegisterRequest(BaseModel):
+    """User registration request."""
+    email: EmailStr
+    password: str
+    name: Optional[str] = None
+
+
+class LoginRequest(BaseModel):
+    """User login request."""
+    email: EmailStr
+    password: str
+
+
+class CreateAPIKeyRequest(BaseModel):
+    """Create API key request."""
+    name: str
+    scopes: Optional[list[str]] = None
+
+
+class APIKeyCreatedResponse(BaseModel):
+    """Response when API key is created (includes full key)."""
+    id: str
+    name: str
+    key: str  # Only returned once!
+    prefix: str
+    message: str = "Save this key securely - it won't be shown again"
+
+
+# ============== Routes ==============
+
+@router.post("/register", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
+async def register(
+    request: RegisterRequest,
+    db: Session = Depends(get_db_session),
+):
+    """
+    Register a new user account.
+    """
+    # Check if email exists
+    existing = crud.get_user_by_email(db, request.email)
+    if existing:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered",
+        )
+
+    # Create user
+    user = create_user(db, request.email, request.password, request.name)
+
+    return UserResponse(
+        id=str(user.id),
+        email=user.email,
+        name=user.name,
+        tier=user.tier,
+        is_active=user.is_active,
+    )
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(
+    request: LoginRequest,
+    db: Session = Depends(get_db_session),
+):
+    """
+    Login and get JWT access token.
+    """
+    user = authenticate_user(db, request.email, request.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid email or password",
+        )
+
+    if not user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Account is disabled",
+        )
+
+    # Update last login
+    crud.update_user_login(db, user)
+
+    # Create token
+    token = create_access_token(str(user.id))
+
+    return TokenResponse(
+        access_token=token,
+        expires_in=ACCESS_TOKEN_EXPIRE_MINUTES * 60,
+    )
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_me(
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    Get current user profile.
+    """
+    return UserResponse(
+        id=str(current_user.id),
+        email=current_user.email,
+        name=current_user.name,
+        tier=current_user.tier,
+        is_active=current_user.is_active,
+    )
+
+
+@router.get("/usage")
+async def get_usage(
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db_session),
+):
+    """
+    Get current user's usage statistics.
+    """
+    usage = crud.get_user_usage(db, current_user.id)
+    monthly = crud.get_monthly_usage(db, current_user.id)
+
+    return {
+        "user_id": str(current_user.id),
+        "tier": current_user.tier,
+        "monthly_quota": current_user.monthly_quota,
+        "monthly_used": monthly,
+        "monthly_remaining": max(0, current_user.monthly_quota - monthly),
+        "all_time": usage,
+    }
+
+
+# ============== API Key Management ==============
+
+@router.post("/keys", response_model=APIKeyCreatedResponse, status_code=status.HTTP_201_CREATED)
+async def create_api_key(
+    request: CreateAPIKeyRequest,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db_session),
+):
+    """
+    Create a new API key.
+
+    The full key is only returned once - save it securely!
+    """
+    key_record, raw_key = create_api_key_for_user(
+        db, current_user.id, request.name, request.scopes
+    )
+
+    return APIKeyCreatedResponse(
+        id=str(key_record.id),
+        name=key_record.name,
+        key=raw_key,
+        prefix=key_record.prefix,
+    )
+
+
+@router.get("/keys", response_model=list[APIKeyResponse])
+async def list_api_keys(
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db_session),
+):
+    """
+    List all API keys for current user.
+    """
+    keys = crud.get_user_api_keys(db, current_user.id)
+
+    return [
+        APIKeyResponse(
+            id=str(k.id),
+            name=k.name,
+            prefix=k.prefix,
+            created_at=k.created_at,
+            last_used=k.last_used,
+            is_active=k.is_active,
+        )
+        for k in keys
+    ]
+
+
+@router.delete("/keys/{key_id}")
+async def revoke_api_key(
+    key_id: str,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db_session),
+):
+    """
+    Revoke an API key.
+    """
+    from uuid import UUID
+
+    try:
+        uuid_key_id = UUID(key_id)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid key ID")
+
+    # Verify key belongs to user
+    keys = crud.get_user_api_keys(db, current_user.id)
+    if not any(k.id == uuid_key_id for k in keys):
+        raise HTTPException(status_code=404, detail="API key not found")
+
+    success = crud.revoke_api_key(db, uuid_key_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="API key not found")
+
+    return {"message": "API key revoked", "key_id": key_id}