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 :

        Phase 1 : La Rédaction de l'Introduction (en un seul paragraphe)

Rôle : Accrocher le lecteur, présenter et délimiter précisément le sujet, poser la problématique et annoncer la structure de votre réflexion (le plan).

Structure :

Amorce : Introduire le thème général de manière pertinente.

Position du Sujet : Présenter l'auteur/œuvre (si pertinent), citer le sujet exact, et impérativement le reformuler.

Problématique : Énoncer clairement la question centrale à laquelle vous allez répondre.

Annonce du Plan : Indiquer les grandes étapes (axes) de votre développement.

bonne pratique pour l'intro : Concision : L'introduction doit être dense mais pas démesurément longue (environ 10-15 lignes pour une copie standard). Allez à l'essentiel.

Pertinence : Restez centré sur le sujet. Ne divaguez pas. L'amorce doit réellement introduire votre sujet.

Élégance (si possible) : Une fois la structure solide, soignez la formulation pour rendre l'introduction agréable à lire.

Un seul paragraphe : Répétons-le, tout doit tenir en un seul bloc, sans alinéas intermédiaires ou sauts de ligne.



Phase 2 : La Rédaction du Développement (Le Cœur Argumentatif)

Rôle : Développer de manière organisée et justifiée la réponse à la problématique, en suivant le plan annoncé.

Structure :

Divisé en Grandes Parties : Autant de parties que d'axes annoncés dans le plan (généralement 2). Chaque partie développe une idée directrice majeure.

Transitions entre les Parties : Assurer le lien logique entre les grandes parties par une phrase de transition claire (faisant le bilan de ce qui précède et annonçant ce qui suit). Séparez les parties en sautant une ligne.

À l'intérieur de chaque Partie : Plusieurs paragraphes (toujours 3).

Chaque Paragraphe = 1 Argument : Chaque paragraphe développe une seule idée/argument précis venant soutenir l'idée directrice de la partie.

Structure du Paragraphe Argumentatif (A.I.E) :

Affirmation (Idée) : Phrase claire énonçant l'argument.

Illustration (Exemple) : Preuve littéraire concrète et précise (œuvre, auteur, citation, personnage, scène...).

Explication (Analyse) : Analyse de l'exemple, montrant comment il prouve l'argument et comment cet argument répond à la problématique. C'est l'étape la plus importante.

Transitions entre les Paragraphes : Utiliser des connecteurs logiques pour assurer la fluidité au sein d'une même partie.

Phase 3 : La Synthèse**
    * Objectif :Dépasser l'opposition** entre la Thèse et l'Antithèse. Ce n'est PAS un simple résumé ni un compromis faible. C'est une **nouvelle perspective**, plus riche et nuancée, qui intègre les éléments valides des deux premières parties tout en les transcendant.
    * Contenu :
        *   Reconnaître la complexité du problème.
        *   Proposer une idée nouvelle qui réconcilie les aspects contradictoires, ou montre que la vérité réside dans la tension elle-même, ou redéfinit le problème, ou introduit une condition/contexte.
        *   Développer 2 ou 3 arguments (chacun dans un paragraphe A.I.E) soutenant cette nouvelle perspective de dépassement, illustrés par des exemples littéraires précis et analysés.
    *   **Transition :** Une phrase liant l'Antithèse à la Synthèse est importante (Ex : "Face à cette opposition, il convient de proposer une perspective qui...", "Pour dépasser cette contradiction, on peut considérer que...").

Phase 4 : La Conclusion (en un seul paragraphe)**

1. Bilan Synthétique :Résumer très brièvement les étapes clés de votre parcours dialectique (les conclusions principales de la Thèse, de l'Antithèse, et **surtout de la Synthèse**).
2. Réponse Claire à la Problématique :** Fournir une réponse finale, nuancée (souvent issue de votre synthèse), à la question posée en introduction.
3.  Ouverture :Élargir la réflexion en reliant le sujet à un contexte plus large (autre art, autre époque, question philosophique, actualité pertinente) sans relancer un nouveau débat.





Principes Transversaux :

Cohérence : L'introduction, le développement et la conclusion doivent être parfaitement alignés. Le plan annoncé doit être suivi.

Argumentation et Preuves : La dissertation est une démonstration. Chaque affirmation doit être soutenue par des arguments logiques et des exemples littéraires précis et analysés.

Clarté et Précision : Utilisez un langage clair, un vocabulaire littéraire approprié. Soyez précis dans vos références.

Focus sur la Problématique : Gardez toujours à l'esprit la question centrale et assurez-vous que chaque partie de votre devoir y contribue.



        
        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)