add

app.py

@@ -1,225 +1,116 @@
-from fastapi import FastAPI, File, UploadFile, Form
-from fastapi.responses import JSONResponse, RedirectResponse
+
 from fastapi.staticfiles import StaticFiles
-from transformers import pipeline, M2M100ForConditionalGeneration, M2M100Tokenizer
-import shutil
+import re
+import torch
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.responses import FileResponse
 import os
-import logging
 from fastapi.middleware.cors import CORSMiddleware
-from PyPDF2 import PdfReader
-import docx
-from PIL import Image  # Pour ouvrir les images avant analyse
-from transformers import MarianMTModel, MarianTokenizer
-import os
-import fitz 
-from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
-
-import logging
-import openpyxl
-import io
-from docx import Document
-from pptx import Presentation
-from fastapi.responses import JSONResponse
-
-
-# Configuration du logging
-logging.basicConfig(level=logging.INFO)
-
 app = FastAPI()
-
-# Configuration CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # Autorise toutes les origines (à sécuriser en prod)
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=["*"],  # Autorise toutes les méthodes (GET, POST, etc.)
+    allow_headers=["*"],  # Autorise tous les headers
 )
 
-UPLOAD_DIR = "uploads"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-
-# 🔹 Charger les modèles avec gestion des erreurs
-try:
-    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
-    logging.info("✅ Modèle de résumé chargé avec succès !")
-except Exception as e:
-    summarizer = None
-    logging.error(f"❌ Erreur chargement modèle résumé : {e}")
-
-try:
-    image_captioning = pipeline("image-to-text", model="nlpconnect/vit-gpt2-image-captioning")
-    logging.info("✅ Modèle d'image chargé avec succès !")
-except Exception as e:
-    image_captioning = None
-    logging.error(f"❌ Erreur chargement modèle image : {e}")
-
-# 🔹 Chargement du modèle de traduction
-
-# ✅ Déclare les routes AVANT le montage des fichiers statiques
-@app.post("/summarize/")
-async def summarize_document(file: UploadFile = File(...)):
-    logging.info(f"📂 Requête reçue - Fichier : {file.filename}")
-
-    file_path = os.path.join(UPLOAD_DIR, file.filename)
-    with open(file_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
-    
-    text = ""
-    if file.filename.endswith(".txt"):
-        with open(file_path, "r", encoding="utf-8") as f:
-            text = f.read()
-    elif file.filename.endswith(".pdf"):
-        try:
-            reader = PdfReader(file_path)
-            text = "\n".join([page.extract_text() or "" for page in reader.pages]).strip()
-        except Exception as e:
-            logging.error(f"❌ Erreur lecture PDF : {e}")
-            return JSONResponse(content={"error": "Impossible de lire le PDF"}, status_code=400)
-    elif file.filename.endswith(".docx"):
-        try:
-            doc = docx.Document(file_path)
-            text = "\n".join([para.text for para in doc.paragraphs]).strip()
-        except Exception as e:
-            logging.error(f"❌ Erreur lecture DOCX : {e}")
-            return JSONResponse(content={"error": "Impossible de lire le fichier DOCX"}, status_code=400)
-    else:
-        return JSONResponse(content={"error": "Format de fichier non supporté"}, status_code=400)
-
-    if not text:
-        logging.error("❌ Le fichier ne contient pas de texte lisible")
-        return JSONResponse(content={"error": "Le fichier est vide ou non lisible"}, status_code=400)
-
-    # Tronquer le texte pour éviter l'erreur "IndexError: index out of range"
-    max_input_length = 1024  # Limite du modèle
-    text = text[:max_input_length]  # Tronquer le texte s'il est trop long
-
-    try:
-        summary = summarizer(text, max_length=150, min_length=50, do_sample=False)[0]["summary_text"]
-        return JSONResponse(content={"summary": summary})
-    except Exception as e:
-        logging.error(f"❌ Erreur lors du résumé : {e}")
-        return JSONResponse(content={"error": "Échec du résumé. Texte trop long ou format invalide."}, status_code=500)
+# Charger le modèle Hugging Face
+model_name = "Salesforce/codegen-350M-mono"
+device = "cuda" if torch.cuda.is_available() else "cpu"
 
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
 
-@app.post("/interpret/")
-async def interpret_image(file: UploadFile = File(...)):
-    logging.info(f"📂 Requête reçue - Image : {file.filename}")
-
-    file_path = os.path.join(UPLOAD_DIR, file.filename)
-    with open(file_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
+VALID_PLOTS = {"histplot", "scatterplot", "barplot", "lineplot", "boxplot"}
 
+@app.post("/generate_viz/")
+async def generate_viz(file: UploadFile = File(...), query: str = Form(...)):
     try:
-        with Image.open(file_path) as img:  # Charger l'image correctement
-            caption = image_captioning(img)[0]["generated_text"]
-        return JSONResponse(content={"caption": caption})
-    except Exception as e:
-        logging.error(f"❌ Erreur interprétation image : {e}")
-        return JSONResponse(content={"error": "Échec de l'analyse de l'image"}, status_code=400)
-    
+        if query not in VALID_PLOTS:
+            return {"error": f"Type de graphique invalide. Choisissez parmi : {', '.join(VALID_PLOTS)}"}
 
+        df = pd.read_excel(file.file)
 
+        numeric_cols = df.select_dtypes(include=["number"]).columns
+        if len(numeric_cols) < 2:
+            return {"error": "Le fichier doit contenir au moins deux colonnes numériques."}
 
-# 🔹 Chargement du modèle de traduction
-try:
-    model_name = "facebook/m2m100_418M"
-    tokenizer = M2M100Tokenizer.from_pretrained(model_name)
-    model = M2M100ForConditionalGeneration.from_pretrained(model_name)
-    logging.info("✅ Modèle de traduction chargé avec succès !")
-except Exception as e:
-    logging.error(f"❌ Erreur chargement modèle de traduction : {e}")
-    model, tokenizer = None, None
+        x_col, y_col = numeric_cols[:2]
 
-
-def extract_text_from_pdf(file):
-    """Extrait le texte d'un fichier PDF."""
-    doc = fitz.open(stream=file.file.read(), filetype="pdf")
-    text = "\n".join([page.get_text() for page in doc])
-    return text.strip()
-
-
-def extract_text_from_docx(file):
-    """Extrait le texte d'un fichier DOCX."""
-    doc = Document(io.BytesIO(file.file.read()))
-    text = "\n".join([para.text for para in doc.paragraphs])
-    return text.strip()
-
-
-def extract_text_from_pptx(file):
-    """Extrait le texte d'un fichier PPTX."""
-    prs = Presentation(io.BytesIO(file.file.read()))
-    text = []
-    for slide in prs.slides:
-        for shape in slide.shapes:
-            if hasattr(shape, "text"):
-                text.append(shape.text)
-    return "\n".join(text).strip()
-
-
-def extract_text_from_excel(file):
-    """Extrait le texte d'un fichier Excel (XLSX)."""
-    try:
-        print("📥 Début extraction texte depuis Excel...")
-        wb = openpyxl.load_workbook(io.BytesIO(file.file.read()), data_only=True)
-        print("✅ Fichier Excel chargé avec succès !")
-
-        text = []
-        for sheet in wb.worksheets:
-            print(f"📄 Feuille trouvée : {sheet.title}")
-            for row in sheet.iter_rows(values_only=True):
-                text.extend([str(cell) for cell in row if cell])
-
-        extracted_text = "\n".join(text).strip()
-        print(f"✅ Texte extrait (début) : {extracted_text[:100]}...")
-        return extracted_text
-    except Exception as e:
-        print(f"❌ Erreur lors de l'extraction du fichier Excel : {e}")
-        return None
-
-
-
-@app.post("/translate/")
-async def translate_document(file: UploadFile = File(...), target_lang: str = Form(...)):
-    """API pour traduocire un dument."""
-    try:
-        logging.info(f"📥 Fichier reçu : {file.filename}")
-        logging.info(f"🌍 Langue cible reçue : {target_lang}")
-
-        if model is None or tokenizer is None:
-            return JSONResponse(status_code=500, content={"error": "Modèle de traduction non chargé"})
-
-        # Extraction du texte en fonction du type de fichier
-        if file.filename.endswith(".pdf"):
-            text = extract_text_from_pdf(file)
-        elif file.filename.endswith(".docx"):
-            text = extract_text_from_docx(file)
-        elif file.filename.endswith(".pptx"):
-            text = extract_text_from_pptx(file)
-        elif file.filename.endswith(".xlsx"):
-            text = extract_text_from_excel(file)
+        # Contraintes spécifiques pour éviter l'erreur avec histplot
+        if query == "histplot":
+            prompt_y = ""
         else:
-            return JSONResponse(status_code=400, content={"error": "Format non supporté"})
-
-        logging.info(f"📜 Texte extrait : {text[:50]}...")  # Affiche un extrait du texte
+            prompt_y = f', y="{y_col}"'
+
+        # Générer l'invite pour le modèle
+        prompt = f"""
+### Génère uniquement du code Python fonctionnel pour tracer un {query} avec Matplotlib et Seaborn ###
+# Contraintes :
+# - Utilise 'df' sans recréer de nouvelles données
+# - Axe X : '{x_col}'
+# - Enregistre le graphique sous 'plot.png'
+# - Ne génère que du code Python valide, sans texte explicatif
+# Contraintes spécifiques pour sns.histplot :
+# - N'inclut pas "y=" car histplot ne supporte qu'un axe
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+plt.figure(figsize=(8,6))
+sns.{query}(data=df, x="{x_col}"{prompt_y})
+
+plt.savefig("plot.png")
+plt.close()
+"""
+
+        # Génération du code
+        inputs = tokenizer(prompt, return_tensors="pt").to(device)
+        outputs = model.generate(**inputs, max_new_tokens=120, pad_token_id=tokenizer.eos_token_id)
+        generated_code = tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
+
+        # Nettoyage du code
+        generated_code = re.sub(r"(import matplotlib.pyplot as plt\nimport seaborn as sns\n)+", "import matplotlib.pyplot as plt\nimport seaborn as sns\n", generated_code)
+        if generated_code.strip().endswith("sns."):
+            generated_code = generated_code.rsplit("\n", 1)[0]  # Supprime la dernière ligne incomplète
+
+        print("🔹 Code généré par l'IA :\n", generated_code)
+
+        # Vérification syntaxique avant exécution
+        try:
+            compile(generated_code, "<string>", "exec")
+        except SyntaxError as e:
+            return {"error": f"Erreur de syntaxe détectée : {e}\nCode généré :\n{generated_code}"}
 
-        if not text:
-            return JSONResponse(status_code=400, content={"error": "Aucun texte trouvé dans le document"})
+        # Vérification des données
+        print(df.head())  # Affiche les premières lignes du dataframe
+        print(df.dtypes)  # Vérifie les types de colonnes
+        print(f"Colonne '{x_col}' - Valeurs uniques:", df[x_col].unique())
 
-        # Traduire le texte
-        tokenizer.src_lang = "fr"
-        encoded_text = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+        if df.empty or x_col not in df.columns or df[x_col].isnull().all():
+            return {"error": f"La colonne '{x_col}' est absente ou ne contient pas de données valides."}
 
-        generated_tokens = model.generate(**encoded_text, forced_bos_token_id=tokenizer.get_lang_id(target_lang))
-        translated_text = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+        # Exécution du code généré
+        exec_env = {"df": df, "plt": plt, "sns": sns, "pd": pd}
+        exec(generated_code, exec_env)
 
-        logging.info(f"✅ Traduction réussie : {translated_text[:50]}...")  # Affiche un extrait de la traduction
+        # Vérification de l'image générée
+        img_path = "plot.png"
+        if not os.path.exists(img_path):
+            return {"error": "Le fichier plot.png n'a pas été généré."}
+        if os.path.getsize(img_path) == 0:
+            return {"error": "Le fichier plot.png est vide."}
 
-        return {"translated_text": translated_text}
+        plt.close()
+        return FileResponse(img_path, media_type="image/png")
 
     except Exception as e:
-        logging.error(f"❌ Erreur lors de la traduction : {e}")
-        return JSONResponse(status_code=500, content={"error": "Échec de la traduction"})
+        return {"error": f"Erreur lors de la génération du graphique : {str(e)}"}
 
 
         # ✅ Déplace ici le montage des fichiers statiques