app.py

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

# 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

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

        # 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}}

\\section*{{Analyse de l'image}}

\\subsection*{{Réflexions:}}
{thoughts}

\\subsection*{{Réponse:}}
{answer}

\\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")
        
        # É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
            
        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")
    
    # 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()