vent_ai_platform/app/schemas/document.py

from __future__ import annotations

from datetime import datetime

from pydantic import BaseModel, Field

from app.schemas.common import ORMModel


class BusinessDocumentCreate(BaseModel):
    mine_id: str
    code: str | None = None
    title: str = Field(max_length=255)
    category: str = Field(max_length=32)
    subcategory: str = ""
    document_type: str = ""
    file_name: str
    file_path: str
    file_ext: str = ""
    file_size: int = 0
    page_count: int | None = None
    row_count: int | None = None
    owner_name: str = ""
    department: str = ""
    version: str = "V1.0"
    status: str = "active"
    parse_status: str = "pending"
    effective_date: datetime | None = None
    expire_date: datetime | None = None
    is_confidential: bool = False
    tags: list[str] = Field(default_factory=list)
    summary: str = ""
    metadata: dict = Field(default_factory=dict)


class BusinessDocumentUpdate(BaseModel):
    code: str | None = None
    title: str | None = None
    category: str | None = None
    subcategory: str | None = None
    file_name: str | None = None
    file_path: str | None = None
    owner_name: str | None = None
    department: str | None = None
    version: str | None = None
    status: str | None = None
    parse_status: str | None = None
    parse_progress: int | None = None
    parse_error: str | None = None
    effective_date: datetime | None = None
    expire_date: datetime | None = None
    is_confidential: bool | None = None
    tags: list[str] | None = None
    summary: str | None = None
    metadata: dict | None = None


class BusinessDocumentRead(ORMModel):
    id: str
    mine_id: str
    code: str | None
    title: str
    category: str
    subcategory: str
    document_type: str
    file_name: str
    file_path: str
    file_ext: str
    file_size: int
    page_count: int | None
    row_count: int | None
    owner_name: str
    department: str
    version: str
    status: str
    parse_status: str
    parse_progress: int
    parse_error: str
    effective_date: datetime | None
    expire_date: datetime | None
    is_confidential: bool
    tags: list
    summary: str
    metadata: dict = Field(validation_alias="metadata_json")
    created_at: datetime
    updated_at: datetime


class DocumentExtractionCreate(BaseModel):
    document_id: str
    field_key: str
    field_name: str
    field_value: str = ""
    normalized_value: str = ""
    value_type: str = "text"
    unit: str = ""
    confidence: float | None = None
    page_no: int | None = None
    evidence_text: str = ""
    metadata: dict = Field(default_factory=dict)


class DocumentExtractionRead(ORMModel):
    id: str
    document_id: str
    field_key: str
    field_name: str
    field_value: str
    normalized_value: str
    original_value: str
    value_type: str
    unit: str
    confidence: float | None
    page_no: int | None
    evidence_text: str
    edited: bool
    edit_count: int
    extraction_correct: bool
    edit_reason: str
    edit_judgement_source: str
    edit_judgement_confidence: float | None
    edit_judgement_status: str
    edit_judged_at: datetime | None
    verified: bool
    verified_by: str
    metadata: dict = Field(validation_alias="metadata_json")


class DocumentExtractionUpdate(BaseModel):
    field_value: str | None = None
    normalized_value: str | None = None
    verified: bool | None = None
    verified_by: str | None = None


class DocumentCategorySummary(BaseModel):
    category: str
    count: int


class BusinessDocumentStatistics(BaseModel):
    total_documents: int
    documents_added_this_month: int
    extracted_fields: int
    field_completeness: float
    extraction_accuracy: float
    accuracy_change: float
    pending_tasks: int
    estimated_minutes: int
    verified_fields: int
    edited_fields: int
    incorrect_fields: int
    expected_fields: int
    valid_fields: int
    invalid_fields: int
    missing_fields: int
    pending_judgements: int
    accuracy_fields: int
    storage_used_bytes: int
    storage_capacity_bytes: int
    storage_usage_percent: float
    updated_at: datetime


class BusinessDocumentDetail(BusinessDocumentRead):
    extractions: list[DocumentExtractionRead] = Field(default_factory=list)


class DocumentPreviewRead(BaseModel):
    id: str
    title: str
    file_name: str
    file_ext: str
    file_size: int
    preview_type: str
    source_available: bool
    text_available: bool
    can_download: bool
    file_url: str
    download_url: str
    text: str = ""


class DocumentSearchSnippet(BaseModel):
    source: str
    label: str
    text: str


class DocumentSearchHit(BaseModel):
    document: BusinessDocumentRead
    score: float
    snippets: list[DocumentSearchSnippet] = Field(default_factory=list)


class DocumentSearchResponse(BaseModel):
    query: str
    total: int
    page: int
    page_size: int
    items: list[DocumentSearchHit] = Field(default_factory=list)


class DocumentExtractionTemplateRead(ORMModel):
    id: str
    code: str
    name: str
    document_type: str
    description: str
    version: str
    fields: dict = Field(
        validation_alias="extraction_schema",
        serialization_alias="fields",
    )
    enabled: bool
    created_at: datetime
    updated_at: datetime


class DocumentProcessingRunRead(ORMModel):
    id: str
    document_id: str
    template_id: str | None
    status: str
    stage: str
    progress: int
    document_type: str
    parser_engine: str
    parsed_markdown_path: str
    model_output: dict
    error: str
    started_at: datetime | None
    finished_at: datetime | None
    metadata: dict = Field(validation_alias="metadata_json")
    created_at: datetime
    updated_at: datetime


class DocumentProcessingTaskRead(BaseModel):
    id: str
    document_id: str
    title: str
    file_name: str
    file_ext: str
    status: str
    stage: str
    progress: int
    document_type: str
    parser_engine: str
    page_count: int | None
    row_count: int | None
    field_count: int
    processing_seconds: float | None
    started_at: datetime | None
    error: str
    created_at: datetime
    updated_at: datetime


class DocumentProcessingStart(BaseModel):
    force: bool = False
    parse_mode: str = "lightweight"
    template_id: str | None = None