main.py

from fastapi import FastAPI, UploadFile, HTTPException
from fastapi.responses import JSONResponse
import PyPDF2
import io
import httpx
import json
from typing import Dict, Any
import asyncio
import logging
import time
import re

# Configuration des logs
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

app = FastAPI(title="Service d'Analyse PDF")

# URL d'Ollama en local
OLLAMA_URL = "http://localhost:11434"
MAX_RETRIES = 3
RETRY_DELAY = 2  # secondes

def format_json_response(data: Dict[str, Any]) -> Dict[str, Any]:
    """Formate la réponse JSON avec des valeurs cohérentes"""
    # Conversion des nombres en chaînes de caractères pour les dimensions
    if "dimensions" in data:
        for key in data["dimensions"]:
            if isinstance(data["dimensions"][key], (int, float)):
                data["dimensions"][key] = f"{data['dimensions'][key]}mm"
    
    # Conversion du poids en chaîne avec unité
    if "weight" in data and isinstance(data["weight"], (int, float)):
        data["weight"] = f"{data['weight']}kg"
    
    # Conversion de la consommation électrique en chaîne avec unité
    if "power_consumption" in data and isinstance(data["power_consumption"], (int, float)):
        data["power_consumption"] = f"{data['power_consumption']}W"
    
    return data

def extract_json_from_text(text: str) -> str:
    """Extrait le JSON de la réponse d'Ollama"""
    # Recherche du premier { et du dernier }
    start = text.find('{')
    end = text.rfind('}') + 1
    if start == -1 or end == 0:
        raise ValueError("Aucun JSON trouvé dans la réponse")
    return text[start:end]

async def check_ollama_availability() -> bool:
    """Vérifie si Ollama est disponible"""
    try:
        async with httpx.AsyncClient(timeout=5.0) as client:
            logger.info(f"Tentative de connexion à Ollama sur {OLLAMA_URL}")
            response = await client.get(f"{OLLAMA_URL}/api/tags")
            return response.status_code == 200
    except Exception as e:
        logger.error(f"Ollama n'est pas disponible sur {OLLAMA_URL}: {str(e)}")
        return False

async def wait_for_ollama():
    """Attend que Ollama soit disponible"""
    retries = 0
    while retries < MAX_RETRIES:
        if await check_ollama_availability():
            logger.info("Ollama est disponible")
            return True
        retries += 1
        logger.warning(f"Tentative {retries}/{MAX_RETRIES} de connexion à Ollama...")
        await asyncio.sleep(RETRY_DELAY)
    return False

async def extract_text_from_pdf(file_content: bytes) -> str:
    try:
        logger.info("Début de l'extraction du texte du PDF")
        pdf_file = io.BytesIO(file_content)
        pdf_reader = PyPDF2.PdfReader(pdf_file)
        text = ""
        for i, page in enumerate(pdf_reader.pages):
            page_text = page.extract_text()
            text += page_text
            logger.info(f"Page {i+1} extraite, longueur: {len(page_text)} caractères")
        logger.info(f"Extraction terminée, texte total: {len(text)} caractères")
        return text
    except Exception as e:
        logger.error(f"Erreur lors de l'extraction du PDF: {str(e)}", exc_info=True)
        raise HTTPException(status_code=400, detail=f"Erreur lors de l'extraction du PDF: {str(e)}")

async def analyze_with_ollama(text: str) -> Dict[str, Any]:
    prompt = """Analyse le texte suivant et extrait les informations du produit. Retourne UNIQUEMENT un objet JSON valide, sans aucun texte avant ou après. Le JSON doit avoir cette structure exacte, en laissant les champs vides si l'information n'est pas trouvée:
{
    "product_name": "",
    "brand": "",
    "model_number": "",
    "category": "",
    "technical_specs": {
        "volume": "",
        "classe_energetique": ""
    },
    "dimensions": {
        "longueur": "",
        "largeur": "",
        "hauteur": ""
    },
    "weight": "",
    "power_consumption": "",
    "features": [],
    "warranty": "",
    "price_range": "",
    "description": ""
}

Texte à analyser:
""" + text

    retries = 0
    while retries < MAX_RETRIES:
        try:
            logger.info(f"Tentative {retries + 1}/{MAX_RETRIES} d'analyse avec Ollama")
            async with httpx.AsyncClient(timeout=30.0) as client:
                logger.info("Envoi de la requête à Ollama")
                response = await client.post(
                    f"{OLLAMA_URL}/api/generate",
                    json={
                        "model": "llama3",
                        "prompt": prompt,
                        "stream": False
                    }
                )
                response.raise_for_status()
                result = response.json()
                logger.info("Réponse reçue d'Ollama")
                
                try:
                    json_str = result["response"]
                    logger.info(f"Réponse brute d'Ollama: {json_str[:200]}...")
                    
                    # Extraction du JSON
                    json_str = extract_json_from_text(json_str)
                    logger.info(f"JSON extrait: {json_str[:200]}...")
                    
                    parsed_json = json.loads(json_str)
                    logger.info("JSON parsé avec succès")
                    return parsed_json
                except (json.JSONDecodeError, ValueError) as e:
                    logger.error(f"Erreur de parsing JSON: {str(e)}", exc_info=True)
                    logger.error(f"Contenu reçu: {json_str}")
                    raise HTTPException(status_code=500, detail="Erreur lors du parsing de la réponse d'Ollama")
        except httpx.ConnectError as e:
            retries += 1
            if retries == MAX_RETRIES:
                logger.error("Impossible de se connecter à Ollama après plusieurs tentatives")
                raise HTTPException(
                    status_code=503,
                    detail="Service Ollama indisponible. Veuillez vérifier qu'Ollama est en cours d'exécution sur http://localhost:11434"
                )
            logger.warning(f"Échec de la connexion à Ollama, nouvelle tentative dans {RETRY_DELAY} secondes...")
            await asyncio.sleep(RETRY_DELAY)
        except httpx.TimeoutException:
            logger.error("Timeout lors de l'appel à Ollama")
            raise HTTPException(status_code=504, detail="Timeout lors de l'appel à Ollama")
        except Exception as e:
            logger.error(f"Erreur lors de l'analyse: {str(e)}", exc_info=True)
            raise HTTPException(status_code=500, detail=f"Erreur lors de l'analyse: {str(e)}")

@app.post("/analyze-pdf")
async def analyze_pdf(file: UploadFile):
    logger.info(f"Reçu fichier: {file.filename}")
    if not file.filename.lower().endswith('.pdf'):
        logger.error(f"Type de fichier invalide: {file.filename}")
        raise HTTPException(status_code=400, detail="Le fichier doit être un PDF")
    
    try:
        content = await file.read()
        logger.info(f"Taille du fichier: {len(content)} bytes")
        text = await extract_text_from_pdf(content)
        result = await analyze_with_ollama(text)
        
        # Formatage de la réponse
        formatted_result = format_json_response(result)
        
        logger.info("Analyse terminée avec succès")
        return JSONResponse(
            content=formatted_result,
            media_type="application/json"
        )
    except Exception as e:
        logger.error(f"Erreur générale: {str(e)}", exc_info=True)
        raise HTTPException(status_code=500, detail=str(e))

@app.on_event("startup")
async def startup_event():
    """Vérifie la disponibilité d'Ollama au démarrage"""
    if not await wait_for_ollama():
        logger.error("Impossible de se connecter à Ollama au démarrage")
        raise Exception("Ollama n'est pas disponible. Veuillez démarrer Ollama avant de lancer le service.")

if __name__ == "__main__":
    import uvicorn
    logger.info("Démarrage du serveur FastAPI")
    uvicorn.run(app, host="0.0.0.0", port=8000)