Update app.py

app.py

@@ -1,63 +1,154 @@
+
+
 import streamlit as st
-import google.generativeai as genai
+from google import genai
+from PIL import Image
+import io
 import os
-import time
+import google.auth
+import subprocess
+import tempfile
+import shutil
+
+# Authenticate using the application default credentials
+#credentials, project = google.auth.default()
+gen = api_key=os.environ['GOOGLE_API_KEY']
+# Initialize the Gemini client
+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:
+        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
 
-# Setup page config
-st.set_page_config(
-    page_title="Gemini Streaming Demo",
-    page_icon="🤖",
-    layout="wide"
-)
+def generate_latex_response(image, question):
+    """Génère une réponse en format LaTeX depuis le modèle Gemini."""
+    try:
+        response = client.models.generate_content(
+            model="gemini-2.0-flash-thinking-exp",
+            contents=[image, 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
 
-# Create a title
-st.title("🤖 Gemini API Streaming Demo")
+        # Formate en LaTeX
+        latex_output = f"""\\documentclass{{article}}
+\\usepackage{{amsmath}}
+\\usepackage{{amssymb}}
+\\usepackage[utf8]{{inputenc}}
+\\usepackage[T1]{{fontenc}}
+\\usepackage{{lmodern}}
+\\usepackage[french]{{babel}}
+\\begin{{document}}
 
-# Configure the Gemini API with environment variable
-genai.configure(api_key=os.environ['GOOGLE_API_KEY'])
+\\section*{{Analyse de l'image}}
 
-# Initialize the model
-model = genai.GenerativeModel('gemini-1.5-flash')
+\\subsection*{{Réflexions:}}
+{thoughts}
 
-# Create input text area
-user_input = st.text_area("Enter your prompt:", height=100)
+\\subsection*{{Réponse:}}
+{answer}
 
-# Create a button to generate content
-if st.button("Generate", type="primary"):
-    if user_input:
-        # Create a placeholder for the streaming text
-        response_placeholder = st.empty()
+\\end{{document}}
+
+"""
+        print(answer)
+        return answer
+
+    except Exception as e:
+        return f"Une erreur s'est produite: {e}"
+
+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
+        tex_file = os.path.join(temp_dir, "output.tex")
         
-        # Initialize full_response
-        full_response = ""
+        # Écrit le contenu LaTeX dans le fichier
+        with open(tex_file, "w", encoding="utf-8") as f:
+            f.write(latex_content)
         
-        # Generate streaming response
         try:
-            response = model.generate_content(user_input, stream=True)
+            # 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
+                )
             
-            # Stream the response
-            for chunk in response:
-                if chunk.text:
-                    full_response += chunk.text
-                    # Update the placeholder with the full response so far
-                    response_placeholder.markdown(full_response + "▌")
-                    time.sleep(0.05)  # Add a small delay for better visualization
+            # 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()
             
-            # Final update without the cursor
-            response_placeholder.markdown(full_response)
+            return pdf_data
             
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-    else:
-        st.warning("Please enter a prompt first.")
-
-# Add instructions in the sidebar
-with st.sidebar:
-    st.markdown("""
-    ### Instructions
-    1. Type your prompt in the text area
-    2. Click 'Generate' to see the streaming response
+        except subprocess.CalledProcessError as e:
+            st.error(f"Erreur lors de la génération du PDF: {e}")
+            st.code(e.output.decode())
+            return None
+
+# Application Streamlit
+def main():
+    st.title("Application Gemini 2.0 avec Export PDF")
     
-    ### About
-    This demo shows how to use Gemini's streaming capabilities to generate text responses in real-time.
-    """)
+    # Vérifie si LaTeX est installé
+    if not ensure_latex_packages():
+        st.stop()
+    
+    uploaded_file = st.file_uploader("Choisissez une image...", type=["png", "jpg", "jpeg"])
+
+    if uploaded_file is not None:
+        # Affiche l'image téléchargée
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Image téléchargée", use_column_width=True)
+
+        # Obtient la question de l'utilisateur
+        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
+                    bytes_data = io.BytesIO()
+                    image.save(bytes_data, format='PNG')
+                    image_bytes = bytes_data.getvalue()
+
+                    # Génère la réponse LaTeX
+                    latex_response = generate_latex_response(image_bytes, 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)
+                        
+                        if pdf_data:
+                            # Crée un bouton de téléchargement
+                            st.download_button(
+                                label="Télécharger le PDF",
+                                data=pdf_data,
+                                file_name="reponse_gemini.pdf",
+                                mime="application/pdf"
+                            )
+            else:
+                st.warning("Veuillez entrer une question.")
+
+if __name__ == "__main__":
+    main()