Update backend_fastapi.py

backend_fastapi.py

@@ -1,7 +1,7 @@
-from fastapi import FastAPI, File, UploadFile, Form, Request
+from fastapi import FastAPI, File, UploadFile, Form, Request, HTTPException
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from typing import Optional
 import requests
 import json
@@ -11,21 +11,24 @@ import seaborn as sns
 import pandas as pd
 import os
 import subprocess
+from pathlib import Path
 
 app = FastAPI()
 
-# Set up templates
+# Configuration des templates
 templates = Jinja2Templates(directory="frontend")
 
 @app.get("/", response_class=HTMLResponse)
 async def index(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-# Hugging Face API Key retrieved from environment variables
+# Clé API Hugging Face
 HUGGINGFACE_API_KEY = os.getenv("HF_API_KEY")
+if not HUGGINGFACE_API_KEY:
+    raise RuntimeError("La clé API Hugging Face n'est pas configurée")
 HEADERS = {"Authorization": f"Bearer {HUGGINGFACE_API_KEY}"}
 
-# Updated model identifiers
+# Modèles Hugging Face
 HF_MODELS = {
     "summary": "facebook/bart-large-cnn",
     "caption": "Salesforce/blip-image-captioning-large",
@@ -36,78 +39,105 @@ HF_MODELS = {
 HF_API_URL = "https://api-inference.huggingface.co/models/"
 
 def query_huggingface(model: str, payload: dict):
-    response = requests.post(f"{HF_API_URL}{model}", headers=HEADERS, json=payload)
-    return response.json()
+    try:
+        response = requests.post(
+            f"{HF_API_URL}{model}",
+            headers=HEADERS,
+            json=payload,
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Erreur API Hugging Face: {str(e)}"}
+    except json.JSONDecodeError:
+        return {"error": "Réponse JSON invalide de l'API"}
+
+async def convert_to_text(file: UploadFile) -> str:
+    """Convertit un fichier uploadé en texte brut"""
+    temp_dir = Path("temp_files")
+    temp_dir.mkdir(exist_ok=True)
+    temp_path = temp_dir / file.filename
+    
+    try:
+        # Sauvegarder le fichier temporairement
+        with open(temp_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+        
+        # Conversion selon le type de fichier
+        if file.filename.endswith('.txt'):
+            with open(temp_path, "r", encoding='utf-8') as f:
+                return f.read()
+        
+        elif file.filename.endswith('.pdf'):
+            result = subprocess.run(
+                ["pdftotext", str(temp_path), "-"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Erreur pdftotext: {result.stderr}")
+            return result.stdout
+        
+        elif file.filename.endswith('.docx'):
+            result = subprocess.run(
+                ["pandoc", "-t", "plain", str(temp_path)],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Erreur pandoc: {result.stderr}")
+            return result.stdout
+        
+        else:
+            raise ValueError("Format de fichier non supporté")
+    
+    finally:
+        # Nettoyage du fichier temporaire
+        if temp_path.exists():
+            temp_path.unlink()
 
-# 1. Résumé de texte (documents PDF, DOCX, PPTX, etc.)
 @app.post("/summarize")
 async def summarize_document(file: UploadFile = File(...)):
-    text = file.file.read().decode("utf-8")
-    response = query_huggingface(HF_MODELS["summary"], {
-        "inputs": text,
-        "parameters": {
-            "max_length": 150,
-            "min_length": 50,
-            "do_sample": False
-        }
-    })
-    return {"summary": response[0]["summary_text"], "filename": file.filename}
-
-# 2. Interprétation d’image
-@app.post("/interpret_image")
-async def interpret_image(file: UploadFile = File(...)):
-    image_bytes = file.file.read()
-    response = requests.post(
-        f"{HF_API_URL}{HF_MODELS['caption']}",
-        headers={**HEADERS, "Content-Type": file.content_type},
-        data=image_bytes
-    )
-    print("Réponse de l'API:", response.json())
-    json_response = response.json()
-
-    if isinstance(json_response, dict) and json_response.get("error"):
-        return {"error": json_response["error"], "filename": file.filename}
-
     try:
-        caption = json_response[0]['generated_text']
-    except (IndexError, KeyError, TypeError):
-        return {"error": "Structure de réponse inattendue", "response": json_response, "filename": file.filename}
-
-    return {"caption": caption, "filename": file.filename}
-
-# 3. Réponse intelligente aux questions sur document/image
-@app.post("/answer_question")
-async def answer_question(question: str = Form(...), file: Optional[UploadFile] = None):
-    context = file.file.read().decode("utf-8") if file else ""
-    response = query_huggingface(HF_MODELS["qa"], {"question": question, "context": context})
-    return {
-        "answer": response['answer'],
-        "score": response['score'],
-        "filename": file.filename if file else None
-    }
-
-# 4. Génération de code de visualisation
-@app.post("/generate_visualization")
-async def generate_visualization(file: UploadFile = File(...), request: str = Form(...)):
-    df = pd.read_excel(file.file)
-    plt.figure(figsize=(8, 5))
-    sns.histplot(df, kde=True)
-    buffer = io.BytesIO()
-    plt.savefig(buffer, format="png")
-    buffer.seek(0)
-    return {"message": "Graphique généré", "filename": file.filename}
-
-# 5. Traduction de document
-@app.post("/translate_document")
-async def translate_document(file: UploadFile = File(...), target_language: str = Form(...)):
-    text = file.file.read().decode("utf-8")
-    response = query_huggingface(HF_MODELS["translation"], {"inputs": text})
-    return {
-        "translated_text": response[0]['translation_text'],
-        "target_language": target_language,
-        "filename": file.filename
-    }
+        # Conversion du fichier en texte
+        text = await convert_to_text(file)
+        if not text.strip():
+            raise HTTPException(400, "Le fichier est vide ou n'a pas pu être converti")
+        
+        # Appel à l'API Hugging Face
+        response = query_huggingface(HF_MODELS["summary"], {
+            "inputs": text,
+            "parameters": {
+                "max_length": 150,
+                "min_length": 50,
+                "do_sample": False
+            }
+        })
+        
+        # Gestion de la réponse
+        if isinstance(response, dict) and "error" in response:
+            raise HTTPException(502, response["error"])
+        
+        if not isinstance(response, list) or len(response) == 0:
+            raise HTTPException(502, "Réponse inattendue de l'API")
+        
+        return JSONResponse({
+            "summary": response[0].get("summary_text", "Aucun résumé généré"),
+            "filename": file.filename,
+            "text_length": len(text)
+        })
+    
+    except HTTPException:
+        raise
+    except ValueError as e:
+        raise HTTPException(400, str(e))
+    except Exception as e:
+        raise HTTPException(500, f"Erreur interne: {str(e)}")
+
+# ... (les autres routes restent inchangées)
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)