backend/api/schemas.py

from typing import List, Optional
from pydantic import BaseModel, Field


class AxiomCreate(BaseModel):
    """Schema for creating a new axiom."""
    universe_id: int
    statement: str = Field(..., min_length=3, description="Axiom statement (min 3 chars)")


class AxiomOut(BaseModel):
    """Schema for axiom output."""
    id: int
    universe_id: int
    statement: str
    is_active: int
    parent_axiom_id: Optional[int]
    version: int
    created_at: Optional[str]
    updated_at: Optional[str]


class UniverseCreate(BaseModel):
    """Schema for creating a new universe."""
    name: str = Field(..., min_length=1, description="Universe name")
    description: Optional[str] = ""
    universe_type: Optional[str] = "generic"
    axioms: Optional[List[str]] = []


class UniverseOut(BaseModel):
    """Schema for universe output."""
    id: int
    name: str
    description: Optional[str]
    universe_type: str
    version: int
    created_at: Optional[str]
    updated_at: Optional[str]


class TheoremCreate(BaseModel):
    """Schema for creating a theorem."""
    universe_id: int
    axiom_ids: List[int]
    statement: str = Field(..., min_length=3, description="Theorem statement")


class TheoremOut(BaseModel):
    """Schema for theorem output."""
    id: int
    universe_id: int
    statement: str
    proof: Optional[str]
    created_at: Optional[str]


class ProofCreate(BaseModel):
    """Schema for creating a proof."""
    axiom_id: int
    content: str = Field(..., min_length=1, description="Proof content")


class ProofOut(BaseModel):
    """Schema for proof output."""
    id: int
    axiom_id: int
    content: str
    created_at: Optional[str]


class AnalysisRequest(BaseModel):
    """Schema for requesting analysis on universes."""
    universe_ids: List[int]


class AnalysisResultOut(BaseModel):
    """Schema for analysis result output."""
    id: int
    universe_id: int
    result: str
    created_at: Optional[str]


# --- Vector store schemas ---
class VectorAddRequest(BaseModel):
    id: str
    text: str
    metadata: Optional[dict] = {}


class VectorQueryRequest(BaseModel):
    text: str
    k: Optional[int] = 5


class VectorResultItem(BaseModel):
    id: str
    distance: float
    metadata: Optional[dict]


class VectorQueryResponse(BaseModel):
    results: List[VectorResultItem]


# --- vector store related schemas (small convenience types) ---


class VectorAddRequest(BaseModel):
    ids: List[str]
    vectors: List[List[float]]
    metas: Optional[List[dict]] = None


class VectorSearchRequest(BaseModel):
    query: List[float]
    top_k: int = 5


class VectorSearchResult(BaseModel):
    id: str
    score: float
    meta: Optional[dict]


# Vector store schemas
class VectorUpsert(BaseModel):
    id: str
    vector: List[float]
    metadata: Optional[dict] = None


class VectorQuery(BaseModel):
    vector: List[float]
    k: Optional[int] = 5


class VectorOut(BaseModel):
    id: str
    score: Optional[float] = None
    metadata: Optional[dict] = None
    vector: Optional[List[float]] = None