Create api/routers/document.py

api/routers/document.py

@@ -0,0 +1,123 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from typing import Dict, Any, Optional, List
+from pydantic import BaseModel
+from datetime import datetime
+from ...core.document.processor import DocumentProcessor, ProcessedDocument, DocumentConfig
+import json
+
+router = APIRouter()
+
+class ProcessingResponse(BaseModel):
+    """Document processing response"""
+    status: str
+    document: ProcessedDocument
+    processing_time: float
+
+@router.post("/process", response_model=ProcessingResponse)
+async def process_document(
+    file: UploadFile = File(...),
+    config: Optional[str] = Form(None)
+):
+    """Process document"""
+    try:
+        start_time = datetime.now()
+        
+        # Parse configuration
+        proc_config = {}
+        if config:
+            proc_config = json.loads(config)
+        
+        # Initialize processor
+        processor = DocumentProcessor(proc_config)
+        await processor.initialize()
+        
+        # Process document
+        result = await processor.process_document(file.file)
+        
+        # Calculate processing time
+        processing_time = (datetime.now() - start_time).total_seconds()
+        
+        return ProcessingResponse(
+            status="success",
+            document=result,
+            processing_time=processing_time
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Document processing failed: {str(e)}"
+        )
+
+@router.post("/batch", response_model=Dict[str, ProcessingResponse])
+async def batch_process(files: List[UploadFile] = File(...)):
+    """Batch process documents"""
+    try:
+        # Initialize processor
+        processor = DocumentProcessor()
+        await processor.initialize()
+        
+        # Process documents
+        results = {}
+        for file in files:
+            start_time = datetime.now()
+            result = await processor.process_document(file.file)
+            processing_time = (datetime.now() - start_time).total_seconds()
+            
+            results[file.filename] = ProcessingResponse(
+                status="success",
+                document=result,
+                processing_time=processing_time
+            )
+        
+        return results
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Batch processing failed: {str(e)}"
+        )
+
+@router.get("/supported-types")
+async def get_supported_types():
+    """Get supported document types"""
+    processor = DocumentProcessor()
+    return {
+        "supported_types": processor.SUPPORTED_TYPES
+    }
+
+@router.get("/config/validate")
+async def validate_config(config: Dict[str, Any]):
+    """Validate document processing configuration"""
+    try:
+        processor = DocumentProcessor(config)
+        is_valid = await processor.validate_config()
+        
+        return {
+            "valid": is_valid,
+            "config": config
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid configuration: {str(e)}"
+        )
+
+@router.get("/health")
+async def health_check():
+    """Check document processor health"""
+    try:
+        processor = DocumentProcessor()
+        await processor.initialize()
+        
+        return {
+            "status": "healthy",
+            "timestamp": datetime.now()
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Health check failed: {str(e)}"
+        )