Update app.py

app.py

@@ -1,136 +1,133 @@
-
-
 import streamlit as st
 from google import genai
 from PIL import Image
-import io
 import os
-import google.auth
-import subprocess
 import tempfile
-import shutil
+import subprocess
 
-# Authenticate using the application default credentials
-#credentials, project = google.auth.default()
-gen = api_key=os.environ['GOOGLE_API_KEY']
-# Initialize the Gemini client
+# Configuration de l'API Gemini
+gen = os.environ['GOOGLE_API_KEY']
 client = genai.Client(api_key=gen)
 
 def ensure_latex_packages():
     """Vérifie si les packages LaTeX nécessaires sont installés."""
-    required_packages = ['amsmath', 'amssymb']
-    
     try:
-        # Vérifie si pdflatex est installé
         subprocess.run(['pdflatex', '--version'], capture_output=True, check=True)
         return True
-    except subprocess.CalledProcessError:
+    except (subprocess.CalledProcessError, FileNotFoundError):
         st.error("pdflatex n'est pas installé. Veuillez installer TeX Live ou MiKTeX.")
         return False
-    except FileNotFoundError:
-        st.error("pdflatex n'est pas trouvé. Veuillez installer TeX Live ou MiKTeX.")
-        return False
 
-def generate_latex_response(image, question):
+def generate_latex_response(image_path, question):
     """Génère une réponse en format LaTeX depuis le modèle Gemini."""
     try:
-        images = Image.open(image)
+        # Charge l'image pour l'API
+        with open(image_path, 'rb') as img_file:
+            image_data = img_file.read()
+            
+        # Prépare le template LaTeX
+        latex_template = r"""\documentclass{article}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\begin{document}
+%s
+\end{document}
+"""
+        
+        # Génère la réponse avec Gemini
         response = client.models.generate_content(
             model="gemini-2.0-flash-thinking-exp",
-            contents=[images, question],
+            contents=[{"mime_type": "image/jpeg", "data": image_data}, question]
         )
-        # Extrait les pensées et la réponse
-        thoughts = response.candidates[0].content.parts[0].text
-        answer = response.candidates[0].content.parts[1].text
-
-        # Formate en LaTeX
-        latex_output = answer
-        print(answer)
-        return answer
-
+        
+        # Extrait la réponse
+        answer = response.text
+        
+        # Formate la réponse en LaTeX complet
+        return latex_template % answer
+        
     except Exception as e:
-        return f"Une erreur s'est produite: {e}"
+        st.error(f"Erreur lors de la génération de la réponse: {str(e)}")
+        return None
 
 def latex_to_pdf(latex_content):
     """Convertit le contenu LaTeX en PDF."""
-    # Crée un dossier temporaire pour les fichiers LaTeX
     with tempfile.TemporaryDirectory() as temp_dir:
-        # Chemin du fichier tex
+        # Crée le fichier tex
         tex_file = os.path.join(temp_dir, "output.tex")
-        
-        # Écrit le contenu LaTeX dans le fichier
         with open(tex_file, "w", encoding="utf-8") as f:
             f.write(latex_content)
         
         try:
-            # Exécute pdflatex deux fois pour assurer la bonne génération des références
-            for _ in range(2):
-                subprocess.run(
-                    ["pdflatex", "-interaction=nonstopmode", "output.tex"],
-                    cwd=temp_dir,
-                    capture_output=True,
-                    check=True
-                )
-            
-            # Lit le fichier PDF généré
-            pdf_file = os.path.join(temp_dir, "output.pdf")
-            with open(pdf_file, "rb") as f:
-                pdf_data = f.read()
-            
-            return pdf_data
+            # Exécute pdflatex
+            process = subprocess.run(
+                ["pdflatex", "-interaction=nonstopmode", tex_file],
+                cwd=temp_dir,
+                capture_output=True,
+                text=True,
+                check=True
+            )
             
+            # Vérifie si le PDF a été généré
+            pdf_path = os.path.join(temp_dir, "output.pdf")
+            if os.path.exists(pdf_path):
+                with open(pdf_path, "rb") as f:
+                    return f.read()
+            else:
+                st.error("Le fichier PDF n'a pas été généré")
+                st.code(process.stdout)
+                return None
+                
         except subprocess.CalledProcessError as e:
-            st.error(f"Erreur lors de la génération du PDF: {e}")
-            st.code(e.output.decode())
+            st.error(f"Erreur lors de la compilation LaTeX: {str(e)}")
+            st.code(e.stdout)
             return None
 
-# Application Streamlit
 def main():
     st.title("Application Gemini 2.0 avec Export PDF")
     
-    # Vérifie si LaTeX est installé
     if not ensure_latex_packages():
-        st.stop()
+        return
     
     uploaded_file = st.file_uploader("Choisissez une image...", type=["png", "jpg", "jpeg"])
-
-    if uploaded_file is not None:
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_file:
-            tmp_file.write(uploaded_file.getvalue())
-            temp_image_path = tmp_file.name
-        # Affiche l'image téléchargée
-        image = Image.open(temp_image_path)
-        st.image(image, caption="Image téléchargée", use_container_width=True)
-
-        # Obtient la question de l'utilisateur
+    
+    if uploaded_file:
+        # Sauvegarde temporaire de l'image
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
+            temp_file.write(uploaded_file.getvalue())
+            temp_path = temp_file.name
+            
+        st.image(uploaded_file, caption="Image téléchargée")
+        
         question = st.text_input("Entrez votre question:")
-
-        if st.button("Générer la réponse"):
-            if question:
-                with st.spinner("Génération de la réponse en cours..."):
-                    # Convertit l'image PIL en bytes pour l'API Gemini
+        
+        if st.button("Générer la réponse") and question:
+            with st.spinner("Génération de la réponse..."):
+                # Génère la réponse LaTeX
+                latex_content = generate_latex_response(temp_path, question)
+                
+                if latex_content:
+                    st.markdown("### Réponse LaTeX générée:")
+                    st.text(latex_content)
                     
-                    # Génère la réponse LaTeX
-                    latex_response = generate_latex_response(temp_image_path, question)
-
-                    # Affiche la réponse LaTeX
-                    st.markdown("### Code LaTeX généré:")
-                    st.text(latex_response)
-
                     # Convertit en PDF
                     with st.spinner("Conversion en PDF..."):
-                        pdf_data = latex_to_pdf(latex_response)
+                        pdf_data = latex_to_pdf(latex_content)
                         
                         if pdf_data:
-                            # Crée un bouton de téléchargement
+                            st.success("PDF généré avec succès!")
                             st.download_button(
-                                label="Télécharger le PDF",
-                                data=pdf_data,
-                                file_name="reponse_gemini.pdf",
+                                "Télécharger le PDF",
+                                pdf_data,
+                                file_name="reponse.pdf",
                                 mime="application/pdf"
                             )
-            else:
-                st.warning("Veuillez entrer une question.")
+        
+        # Nettoie le fichier temporaire
+        os.unlink(temp_path)
 
 if __name__ == "__main__":
     main()