app.py

from flask import Flask, render_template, request, jsonify
import google.generativeai as genai
from google.generativeai import types
import os
from PIL import Image
import io
import logging

# Configuration du logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

app = Flask(__name__)

# Configuration de l'API Gemini
token = os.environ.get("TOKEN")
genai.configure(api_key=token)

generation_config = {
    "temperature": 1,
    "max_output_tokens": 8192,
}

safety_settings = [
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
]

# Define model names
STANDARD_MODEL_NAME = "gemini-2.0-flash" # Using latest flash
# MODIFICATION: Utilisation du nom de modèle Pro spécifié (attention: peut être expérimental/non disponible)
DEEPTHINK_MODEL_NAME = "gemini-2.5-pro-exp-03-25" # Using stable latest Pro model is generally safer
# DEEPTHINK_MODEL_NAME = "models/gemini-1.5-pro-exp-0325" # Si vous voulez absolument tester ce modèle expérimental spécifique
# Note: Les noms de modèles expérimentaux peuvent nécessiter un préfixe "models/"

# Default model instance (used for etude-texte)
default_model = genai.GenerativeModel(
    model_name=STANDARD_MODEL_NAME,
    generation_config=generation_config,
    safety_settings=safety_settings
)

@app.route('/')
def index():
    logging.info("Rendering index.html")
    return render_template('index.html')

@app.route('/api/francais', methods=['POST'])
def gpt_francais():
    """Handles French questions with optional DeepThink model."""
    logging.info("Received request at /api/francais")
    french_prompt = request.form.get('sujet', '').strip()
    choix = request.form.get('choix', '').strip()
    style = request.form.get('style', '').strip()
    # MODIFICATION: Lire le nouveau paramètre 'use_deepthink'
    use_deepthink_str = request.form.get('use_deepthink', 'false')
    use_deepthink = use_deepthink_str.lower() == 'true'

    logging.info(f"Received data: french_prompt='{french_prompt}', choix='{choix}', style='{style}', use_deepthink='{use_deepthink}'")

    if not french_prompt:
        logging.warning("French prompt is empty.")
        return jsonify({"output": "Veuillez saisir un thème."}), 400

    # MODIFICATION: Sélectionner le nom du modèle basé sur use_deepthink
    model_to_use_name = DEEPTHINK_MODEL_NAME if use_deepthink else STANDARD_MODEL_NAME
    logging.info(f"Using model: {model_to_use_name}") # Log for debugging

    # Le reste de la logique de construction du prompt reste identique...
    if choix == "discuter":
        prompt = f""" Je veux faire mon travail de français de niveau lycée sous la forme d'un travail argumentatif.
        La question du travail est la suivante : "{french_prompt}". Tu devras discuter ce thème.
        tu utiliseras la méthodologie suivante :

        # INTRODUCTION:
            - Approche par constat
            - Problématique
            - Annonce du plan

            # DÉVELOPPEMENT:
            ## Partie 1 : Thèse
            - Introduction partielle (énonce la thèse)
            - Argument 1:
                * Explications
                * Illustration (exemple + explication)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication)
           - Argument 3:
                * Explications
                * Illustration (exemple + explication)

            # phrase de Transiton vers la deuxieme partie :

            ## Partie 2 : Antithèse
            - Introduction partielle (énonce l'antithèse)
            - Argument 1:
                * Explications
                * Illustration (exemple + explication)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication)
           - Argument 3:
                * Explications
                * Illustration (exemple + explication)

            #Conclusion
                * Bilan (Synthèse des arguments pour et contre)
                * Ouverture du sujet (sous forme de phrase interrogative )

        Je veux que tu utilises un style d'écriture {style}."""

    elif choix == "dissertation":
        prompt = f""" Je veux faire mon travail de français de niveau lycée sous la forme d'une dissertation.
        La question du travail est la suivante : "{french_prompt}". Tu devras traiter ce sujet de manière approfondie.
        tu utiliseras la méthodologie suivante :

        # INTRODUCTION:
            - Accroche (ou amorce) pertinente
            - Présentation du sujet et reformulation de la question
            - Problématique claire
            - Annonce du plan (généralement en deux ou trois parties)

        # DÉVELOPPEMENT:
        ## Partie 1: Thèse (ou première grande idée)
            - Introduction partielle (énonce l'idée directrice de la partie)
            - Argument 1:
                * Explications
                * Illustration (exemple + explication détaillée)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication détaillée)
            - (Optionnel: Argument 3)
            - Transition vers la partie suivante

        ## Partie 2: Antithèse (ou deuxième grande idée / nuance / contrepoint)
            - Introduction partielle (énonce l'idée directrice de la partie)
            - Argument 1:
                * Explications
                * Illustration (exemple + explication détaillée)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication détaillée)
            - (Optionnel: Argument 3)
            - Transition vers la partie suivante (si applicable) ou la conclusion

        ## (Optionnel: Partie 3: Synthèse / Dépassement)
            - Introduction partielle
            - Arguments développés (synthèse ou dépassement des points précédents)

        # CONCLUSION
            * Bilan synthétique des idées principales du développement (réponse claire à la problématique)
            * Ouverture du sujet (perspective plus large, nouvelle question, lien avec l'actualité ou une autre œuvre...)

        Je veux que tu utilises un style d'écriture {style}."""

    else: # Cas pour "Etaye" et "refute"
        prompt = f"""Je veux faire mon travail de français de niveau lycée sous la forme d'un travail argumentatif.
        La question du travail est la suivante : "{french_prompt}". Tu devras {choix} ce thème.
        tu utiliseras la méthodologie suivante :

        # INTRODUCTION:
            - Approche par constat
            - Problématique
            - Annonce du plan

            # DÉVELOPPEMENT:
            - Phrase chapeau (énonce la thèse principale : pour étayer ou contre pour réfuter)
            - Argument 1:
                * Explications
                * Illustration (exemple + explication)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication)
           - Argument 3:
                * Explications
                * Illustration (exemple + explication)

            #Conclusion
                * Bilan (rappel de la thèse + arguments principaux)
                * Ouverture du sujet ( sous forme de phrase interrogative )

        Je veux que tu utilises un style d'écriture {style}."""

    try:
        # MODIFICATION: Instancier le modèle spécifique pour cette requête
        # Utiliser les mêmes configurations que le modèle par défaut
        logging.info(f"Creating GenerativeModel instance with model name: {model_to_use_name}")
        selected_model = genai.GenerativeModel(
            model_name=model_to_use_name,
            generation_config=generation_config,
            safety_settings=safety_settings
        )
        logging.info("Generating content...")
        response = selected_model.generate_content(prompt)
        logging.info("Content generated successfully.")
        return jsonify({"output": response.text}), 200
    except Exception as e:
        # Log l'erreur pour le débogage côté serveur
        logging.exception(f"Error generating content with model {model_to_use_name}: {e}")
        # Retourne un message d'erreur générique à l'utilisateur
        # Vérifier si l'erreur est due à un modèle invalide/non disponible
        if "model" in str(e).lower() and "not found" in str(e).lower():
             logging.error(f"Model '{model_to_use_name}' not found.")
             return jsonify({"output": f"Erreur: Le modèle '{model_to_use_name}' n'est pas accessible ou n'existe pas. Essayez sans l'option DeepThink."}), 500
        logging.error(f"Internal error occurred: {e}")
        return jsonify({"output":"Une erreur interne est survenue lors de la génération du contenu. Veuillez réessayer."}), 500


@app.route('/api/etude-texte', methods=['POST'])
def gpt_francais_cc():
    """Handles text analysis for French with multiple images (uses default model)."""
    logging.info("Received request at /api/etude-texte")
    if 'images' not in request.files:
        logging.warning("No images were uploaded.")
        return jsonify({"output": "Aucune image n'a été téléchargée."}), 400

    images = request.files.getlist('images')
    if not images or all(not image.filename for image in images):
        logging.warning("No images selected or files are empty.")
        return jsonify({"output": "Aucune image sélectionnée ou les fichiers sont vides."}), 400

    pre_prompt = "Analyse de manière exhaustive et structurée le contenu du devoir présenté dans les images suivantes. Identifie les questions, extrais le texte si présent, et réponds aux questions de manière détaillée en te basant uniquement sur les informations fournies dans les images."

    contents = [pre_prompt]
    valid_images_found = False
    for image in images:
        if image and image.filename:
            logging.info(f"Processing image: {image.filename}")
            try:
                img_bytes = image.read()
                if not img_bytes:
                    logging.warning(f"Skipping empty file: {image.filename}")
                    continue

                img = Image.open(io.BytesIO(img_bytes))
                img.verify()
                img = Image.open(io.BytesIO(img_bytes))

                contents.append(img)
                valid_images_found = True

            except (IOError, SyntaxError) as e:
                logging.error(f"Error processing image {image.filename}: {e}. It might be corrupted or not a valid image format.")
            except Exception as e:
                logging.exception(f"Unexpected error processing image {image.filename}: {e}")

    if not valid_images_found:
        logging.warning("No valid images were found among the uploaded files.")
        return jsonify({"output": "Aucune image valide n'a été trouvée parmi les fichiers téléchargés."}), 400

    try:
        # Utilisation du modèle par défaut (non-DeepThink) pour l'analyse d'images
        logging.info("Generating content with default model for image analysis...")
        response = default_model.generate_content(contents)
        logging.info("Content generated successfully for image analysis.")
        return jsonify({"output": response.text}), 200
    except types.generation_types.BlockedPromptException as e:
        logging.warning(f"Content generation blocked: {e}")
        return jsonify({"output": "La génération de contenu a été bloquée car la requête ou les images contenaient potentiellement du contenu non autorisé."}), 400
    except Exception as e:
        logging.exception(f"Error during  generation (etude-texte): {e}")
        return jsonify({"output":"Une erreur interne est survenue lors de l'analyse des images.Veuillez réessayer."}), 500


if __name__ == '__main__':
    # Désactiver le reloader Flask si vous avez des problèmes avec les instances multiples de modèle ou la mémoire
    # app.run(debug=True, use_reloader=False)
    logging.info("Starting the Flask app...")
    app.run(debug=True)