add

app.py

@@ -176,36 +176,37 @@ async def translate_document(file: UploadFile = File(...), target_lang: str = Fo
 
 
 
-        # Charger le modèle pour la génération de code
+      
+
+       
+         # Charger le modèle pour la génération de code
 codegen_model_name = "Salesforce/codegen-350M-mono"
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
 codegen_tokenizer = AutoTokenizer.from_pretrained(codegen_model_name)
 codegen_model = AutoModelForCausalLM.from_pretrained(codegen_model_name).to(device)
 
-VALID_PLOTS = {"histplot", "scatterplot", "barplot", "lineplot", "boxplot"}
 
+VALID_PLOTS = {"histplot", "scatterplot", "barplot", "lineplot", "boxplot"}
+print("hello")
 @app.post("/generate_viz/")
 async def generate_viz(file: UploadFile = File(...), query: str = Form(...)):
+    print("hello")
     try:
         if query not in VALID_PLOTS:
-            return {"error": f"Type de graphique invalide. Choisissez parmi : {', '.join(VALID_PLOTS)}"}
+            return JSONResponse(content={"error": f"Type de graphique invalide. Choisissez parmi : {', '.join(VALID_PLOTS)}"}, status_code=400)
 
         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."}
 
-        x_col, y_col = numeric_cols[:2]
+        if len(numeric_cols) < 1:
+            return JSONResponse(content={"error": "Le fichier doit contenir au moins une colonne numérique."}, status_code=400)
 
-        # Contraintes spécifiques pour éviter l'erreur avec histplot
-        if query == "histplot":
-            prompt_y = ""
-        else:
-            prompt_y = f', y="{y_col}"'
+        x_col = numeric_cols[0]
+        y_col = numeric_cols[1] if query != "histplot" and len(numeric_cols) > 1 else None
+        prompt_y = f', y="{y_col}"' if y_col else ""
 
-        # Générer l'invite pour le modèle
+        # Prompt d'entrée pour le modèle
         prompt = f"""
 ### Génère uniquement du code Python fonctionnel pour tracer un {query} avec Matplotlib et Seaborn ###
 # Contraintes :
@@ -213,8 +214,6 @@ async def generate_viz(file: UploadFile = File(...), query: str = Form(...)):
 # - 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))
@@ -223,49 +222,38 @@ plt.savefig("plot.png")
 plt.close()
 """
 
-        # Génération du code
         inputs = codegen_tokenizer(prompt, return_tensors="pt").to(device)
         outputs = codegen_model.generate(**inputs, max_new_tokens=120, pad_token_id=codegen_tokenizer.eos_token_id)
         generated_code = codegen_tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
-        # Nettoyage du code
+
+        # Nettoyage
         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
+            generated_code = generated_code.rsplit("\n", 1)[0]
 
         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}"}
-
-        # 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())
+            return JSONResponse(content={"error": f"Erreur de syntaxe détectée : {e}\nCode généré :\n{generated_code}"}, status_code=422)
 
-        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."}
-
-        # Exécution du code généré
         exec_env = {"df": df, "plt": plt, "sns": sns, "pd": pd}
         exec(generated_code, exec_env)
 
-        # 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é."}
+            return JSONResponse(content={"error": "Le fichier plot.png n'a pas été généré."}, status_code=500)
         if os.path.getsize(img_path) == 0:
-            return {"error": "Le fichier plot.png est vide."}
+            return JSONResponse(content={"error": "Le fichier plot.png est vide."}, status_code=500)
 
-        plt.close()
-        return FileResponse(img_path, media_type="image/png")
+        # Encoder l'image en base64
+        with open(img_path, "rb") as image_file:
+            encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+            return JSONResponse(content={"image_base64": encoded_string})
 
     except Exception as e:
-        print(e)
-        return {"error": f"Erreur lors de la génération du graphique : {str(e)}"}
-
+        return JSONResponse(content={"error": f"Erreur lors de la génération du graphique : {str(e)}"}, status_code=500)