4NK_IA_back/services/host_api/app_simple.py

#!/usr/bin/env python3
"""
API simplifiée pour le système notarial
Version sans dépendances lourdes pour test rapide
"""

from fastapi import FastAPI, HTTPException, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import HTMLResponse
import uvicorn
import json
import os
from datetime import datetime
from typing import List, Dict, Any
import asyncio

# Configuration
app = FastAPI(
    title="API Notariale Simplifiée",
    description="API pour l'analyse de documents notariaux",
    version="1.0.0"
)

# CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Stockage en mémoire pour la démo
documents_db = {}
processing_queue = []

@app.get("/")
async def root():
    """Page d'accueil"""
    return {"message": "API Notariale Simplifiée - Version 1.0.0"}

@app.get("/api/health")
async def health_check():
    """Vérification de l'état de l'API"""
    return {
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "version": "1.0.0",
        "services": {
            "api": "OK",
            "llm": "Simulé",
            "external_apis": "Simulé"
        }
    }

@app.get("/api/notary/stats")
async def get_stats():
    """Statistiques des documents"""
    total_docs = len(documents_db)
    processed = len([d for d in documents_db.values() if d.get("status") == "completed"])
    processing = len([d for d in documents_db.values() if d.get("status") == "processing"])

    return {
        "total_documents": total_docs,
        "processed": processed,
        "processing": processing,
        "pending": total_docs - processed - processing
    }

@app.get("/api/notary/documents")
async def get_documents():
    """Liste des documents"""
    return {
        "documents": list(documents_db.values()),
        "total": len(documents_db)
    }

@app.post("/api/notary/upload")
async def upload_document(file: UploadFile = File(...)):
    """Upload d'un document"""
    if not file.filename:
        raise HTTPException(status_code=400, detail="Aucun fichier fourni")

    # Générer un ID unique
    doc_id = f"doc_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{len(documents_db)}"

    # Simuler le traitement
    document_data = {
        "id": doc_id,
        "filename": file.filename,
        "size": file.size if hasattr(file, 'size') else 0,
        "upload_time": datetime.now().isoformat(),
        "status": "uploaded",
        "progress": 0
    }

    documents_db[doc_id] = document_data
    processing_queue.append(doc_id)

    # Démarrer le traitement simulé
    asyncio.create_task(process_document_simulated(doc_id))

    return {
        "message": "Document uploadé avec succès",
        "document_id": doc_id,
        "status": "uploaded"
    }

async def process_document_simulated(doc_id: str):
    """Simulation du traitement d'un document"""
    if doc_id not in documents_db:
        return

    # Mise à jour du statut
    documents_db[doc_id]["status"] = "processing"
    documents_db[doc_id]["progress"] = 10

    # Simuler les étapes de traitement
    steps = [
        ("OCR", 30),
        ("Classification", 50),
        ("Extraction d'entités", 70),
        ("Vérification", 90),
        ("Finalisation", 100)
    ]

    for step_name, progress in steps:
        await asyncio.sleep(2)  # Simuler le temps de traitement
        documents_db[doc_id]["progress"] = progress
        documents_db[doc_id]["current_step"] = step_name

    # Résultats simulés
    documents_db[doc_id].update({
        "status": "completed",
        "progress": 100,
        "current_step": "Terminé",
        "results": {
            "ocr_text": "Texte extrait simulé du document...",
            "document_type": "Acte de vente",
            "entities": {
                "persons": ["Jean Dupont", "Marie Martin"],
                "addresses": ["123 Rue de la Paix, 75001 Paris"],
                "properties": ["Appartement T3, 75m²"]
            },
            "verification_score": 0.85,
            "external_checks": {
                "cadastre": "OK",
                "georisques": "OK",
                "bodacc": "OK"
            }
        },
        "completion_time": datetime.now().isoformat()
    })

@app.get("/api/notary/documents/{document_id}")
async def get_document(document_id: str):
    """Détails d'un document"""
    if document_id not in documents_db:
        raise HTTPException(status_code=404, detail="Document non trouvé")

    return documents_db[document_id]

@app.get("/api/notary/documents/{document_id}/download")
async def download_document(document_id: str):
    """Téléchargement d'un document (simulé)"""
    if document_id not in documents_db:
        raise HTTPException(status_code=404, detail="Document non trouvé")

    return {
        "message": "Téléchargement simulé",
        "document_id": document_id,
        "filename": documents_db[document_id]["filename"]
    }

@app.delete("/api/notary/documents/{document_id}")
async def delete_document(document_id: str):
    """Suppression d'un document"""
    if document_id not in documents_db:
        raise HTTPException(status_code=404, detail="Document non trouvé")

    del documents_db[document_id]
    return {"message": "Document supprimé avec succès"}

@app.get("/api/notary/search")
async def search_documents(query: str = ""):
    """Recherche dans les documents"""
    if not query:
        return {"documents": list(documents_db.values())}

    # Recherche simple simulée
    results = []
    for doc in documents_db.values():
        if query.lower() in doc.get("filename", "").lower():
            results.append(doc)

    return {"documents": results, "query": query}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)