app.py

from flask import Flask, render_template, request, jsonify, Response, stream_with_context
from google import genai
import os
from PIL import Image
import io
import base64
import json
import requests
import threading
import uuid
import time

app = Flask(__name__)

# API Keys
GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88"
TELEGRAM_CHAT_ID = "-1002497861230"

# Initialize Gemini client
client = genai.Client(api_key=GOOGLE_API_KEY)




ppmqth = r"""

**PROMPT AMÉLIORÉ**

# RÔLE & OBJECTIF
Tu es un expert en mathématiques du supérieur, un tuteur pédagogue exceptionnel, et un maître utilisateur de LaTeX. Ton objectif est de générer une correction LaTeX complète, rigoureuse, pédagogique et visuellement impeccable pour l'exercice de mathématiques fourni. Le résultat doit être un fichier source `.tex` autonome, directement compilable via `pdflatex`, et d'une qualité de présentation professionnelle, similaire à l'exemple fourni précédemment.

# CONTEXTE
*   **Input:** L'énoncé de l'exercice de mathématiques sera fourni sous forme de texte (copié/collé par l'utilisateur) immédiatement après ce prompt.
*   **Niveau Cible:** Élève de Terminale (système français, filière scientifique ou équivalent).
*   **Output Attendu:** **Uniquement** le code source LaTeX (`.tex`) brut et complet. Aucune explication ou texte d'accompagnement en dehors du code lui-même. Pas de marqueurs de code (comme ```latex ... ```).

# TÂCHE PRINCIPALE
1.  **Analyse:** Lis et comprends parfaitement l'énoncé de l'exercice fourni.
2.  **Résolution:** Résous l'exercice de manière exhaustive, en détaillant chaque étape de raisonnement et de calcul.
3.  **Rédaction LaTeX:** Rédige la solution complète *directement* en code LaTeX, en respectant **scrupuleusement** toutes les spécifications techniques, de style et de contenu ci-dessous.

# SPÉCIFICATIONS TECHNIQUES DU CODE LATEX

1.  **Document de Base:**
    *   Classe: `\documentclass[12pt,a4paper]{article}`
    *   Encodage: `\usepackage[utf8]{inputenc}`, `\usepackage[T1]{fontenc}`
    *   Langue: `\usepackage[french]{babel}`
    *   Police: `\usepackage{lmodern}` (Latin Modern)
    *   Typographie Fine: `\usepackage{microtype}`

2.  **Packages Indispensables (Configurer si nécessaire):**
    *   Maths: `amsmath`, `amssymb`, `amsfonts`, `mathtools`, `bm` (pour gras maths), `siunitx` (unités SI).
    *   Mise en Page: `geometry` (marges `a4paper, margin=2.5cm`), `setspace` (utiliser `\onehalfspacing`), `fancyhdr` (pour en-têtes/pieds), `titlesec` & `titletoc` (personnalisation titres/TDM), `multicol` (si besoin).
    *   Visuel & Couleurs: `xcolor` (définir les couleurs ci-dessous), `tcolorbox` (avec `theorems`, `skins`, `breakable`, `hooks`), `fontawesome5` (pour icônes).
    *   Liens & PDF: `hyperref` (configuré pour liens colorés, métadonnées PDF), `bookmark`.
    *   Graphiques: `tikz` (avec `calc`, `shapes`, `arrows.meta`, `positioning`), `pgfplots` (avec `compat=1.18`, `fillbetween`).

3.  **Configuration Générale:**
    *   Paragraphes: Pas d'indentation (`\setlength{\parindent}{0pt}`), espacement entre paragraphes (`\setlength{\parskip}{1.2ex plus 0.5ex minus 0.2ex}`).
    *   Compilabilité: Code valide pour `pdflatex`.

# STYLE & PRÉSENTATION PROFESSIONNELLE (Inspiré de l'exemple)

1.  **Couleurs à Définir (`\definecolor`):**
    *   `maincolor`: Bleu (e.g., `{RGB}{0, 90, 160}`)
    *   `secondcolor`: Vert-bleu (e.g., `{RGB}{0, 150, 136}`)
    *   `thirdcolor`: Violet (e.g., `{RGB}{140, 0, 140}`)
    *   `accentcolor`: Orange (e.g., `{RGB}{255, 140, 0}`)
    *   `ubgcolor`: Fond clair (e.g., `{RGB}{245, 247, 250}`)
    *   `codebackground`: Fond code (e.g., `{RGB}{245, 245, 245}`)
    *   `gridcolor`: Grille PGFPlots (e.g., `{RGB}{220, 220, 220}`)
    *   `asymptotecolor`: Asymptotes (e.g., `{RGB}{200, 0, 0}`)

2.  **Page de Titre / Présentation Initiale:**
    *   Créer une page de titre distincte (`titlepage`) ou un bloc titre élégant après `\begin{document}` utilisant `\maketitle` (redéfini si nécessaire).
    *   Inclure titre clair, sous-titre (e.g., "Exercice X: Solution Détaillée"), auteur générique (e.g., "Solution Proposée"), date (`\today`).
    *   Optionnel : Page séparée pour l'énoncé encadré et un plan de résolution avant la table des matières.

3.  **Structure & Navigation:**
    *   Table des matières (`\tableofcontents`) après la présentation initiale.
    *   En-têtes/Pieds de page (`fancyhdr`): Infos discrètes (titre exo, page), règles fines colorées.
    *   Titres (`titlesec`): Sections/sous-sections numérotées avec style distinctif (e.g., numéro dans cercle/rectangle coloré, ligne de séparation).

4.  **Boîtes `tcolorbox` Personnalisées (avec icônes `fontawesome5`):**
    *   `enoncebox` (Grisâtre, `\faBook`): Pour l'énoncé principal.
    *   `definitionbox` (Couleur secondaire, `\faLightbulb`): Pour définitions, théorèmes clés.
    *   `resultbox` (Couleur accent, `\faCheckCircle`): Pour les résultats finaux importants.
    *   `notebox` (Couleur tertiaire, `\faInfoCircle`): Pour remarques, astuces, points de méthode.
    *   `examplebox` (Vert, `\faClipboard`): Pour exemples illustratifs ou rappels de méthode.
    *   Configurer ces boîtes pour être `breakable`, avec titre stylisé.

5.  **Commandes Mathématiques Personnalisées (`\newcommand`):**
    *   Ensembles: `\R`, `\C`, `\N`, `\Z`, `\Q`.
    *   Limites: `\limx{}`, `\limxp{}`, `\limxm{}`, `\limsinf`, `\liminf`.
    *   Dérivées: `\derivee{}{} `, `\ddx{}`, `\dfdx{}`.
    *   Divers: `\abs{}`, `\norm{}`, `\vect{}`, `\ds` (`\displaystyle`).
    *   Mise en valeur: `\highlight{}` (fond jaune?), `\finalresult{}` (fond couleur accent?).
    *   Environnements: `importanteq` (pour équations clés encadrées, via `empheq`).

6.  **Graphiques (`pgfplots`):**
    *   Si pertinent (étude de fonction, géométrie): Inclure un graphique propre.
    *   Configurer `pgfplotsset`: Axes centrés (`axis lines=middle`), flèches (`-Latex`), grille (`grid=both`), labels (`xlabel`, `ylabel`), légende (`legend pos=...`), couleurs définies plus haut.
    *   Tracer la courbe principale (trait plein, couleur principale), asymptotes (pointillés, couleurs dédiées), points remarquables.

# CONTENU PÉDAGOGIQUE DE LA SOLUTION

1.  **Clarté et Rigueur:**
    *   Rappeler l'énoncé initialement dans `enoncebox`.
    *   Structurer la solution logiquement (par question, par étape).
    *   Justifier *chaque* étape de calcul ou de raisonnement.
    *   Utiliser un langage mathématique précis et une rédaction claire en français.
    *   Aligner soigneusement les équations (`align*`, `cases`).

2.  **Pédagogie:**
    *   Expliquer les "pourquoi" derrière les méthodes utilisées.
    *   Utiliser les `notebox` pour des conseils, pièges à éviter, ou rappels de cours.
    *   Mettre en évidence les définitions/théorèmes clés dans `definitionbox`.
    *   Encapsuler les résultats finaux dans `resultbox` ou avec `\finalresult`.

3.  **Complétude:**
    *   Traiter toutes les questions de l'énoncé.
    *   Inclure les interprétations graphiques demandées ou pertinentes.
    *   Conclure si nécessaire en résumant les points essentiels.

# CONTRAINTES STRICTES
*   Le seul output doit être le code LaTeX brut.
*   Aucun texte avant `\documentclass` ou après `\end{document}` (sauf la mention spéciale).
*   Inclure la ligne `{LATEX_MENTION}` juste avant `\end{document}`.

rend  le très espacer. Ça doit être très aéré 

"""


# Dictionnaire pour stocker les résultats des tâches en cours
task_results = {}

def send_to_telegram(image_data, caption="Nouvelle image uploadée"):
    """Envoie l'image à un chat Telegram spécifié"""
    try:
        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto"
        files = {'photo': ('image.png', image_data)}
        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
        response = requests.post(url, files=files, data=data)
        
        if response.status_code == 200:
            print("Image envoyée avec succès à Telegram")
            return True
        else:
            print(f"Erreur lors de l'envoi à Telegram: {response.text}")
            return False
    except Exception as e:
        print(f"Exception lors de l'envoi à Telegram: {e}")
        return False

def send_document_to_telegram(text_content, filename="reponse.txt", caption="Réponse"):
    """Envoie un fichier texte à un chat Telegram spécifié"""
    try:
        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
        files = {'document': (filename, text_content.encode('utf-8'), 'text/plain')}
        data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption}
        response = requests.post(url, files=files, data=data)
        
        if response.status_code == 200:
            print("Document envoyé avec succès à Telegram")
            return True
        else:
            print(f"Erreur lors de l'envoi du document à Telegram: {response.text}")
            return False
    except Exception as e:
        print(f"Exception lors de l'envoi du document à Telegram: {e}")
        return False

def process_image_background(task_id, image_data):
    """Traite l'image en arrière-plan et met à jour le statut de la tâche"""
    try:
        # Mettre à jour le statut
        task_results[task_id]['status'] = 'processing'
        
        # Ouvrir l'image pour la traiter
        img = Image.open(io.BytesIO(image_data))
        
        # Traitement pour Gemini
        buffered = io.BytesIO()
        img.save(buffered, format="PNG")
        img_str = base64.b64encode(buffered.getvalue()).decode()
        
        # Générer une réponse complète
        full_response = ""
        
        try:
            response = client.models.generate_content(
                model="gemini-2.5-pro-exp-03-25",
                contents=[
                    {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
                    ppmqth
                ])
            
            # Extraire le texte complet
            for part in response.candidates[0].content.parts:
                full_response += part.text
            
            # Envoyer la réponse par Telegram
            send_document_to_telegram(
                full_response, 
                filename=f"reponse_{task_id}.txt", 
                caption=f"Réponse pour la tâche {task_id}"
            )
            
            # Mettre à jour le résultat
            task_results[task_id]['status'] = 'completed'
            task_results[task_id]['response'] = full_response
            
        except Exception as e:
            print(f"Error during generation: {e}")
            task_results[task_id]['status'] = 'error'
            task_results[task_id]['error'] = str(e)
    
    except Exception as e:
        print(f"Exception in background task: {e}")
        task_results[task_id]['status'] = 'error'
        task_results[task_id]['error'] = str(e)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/solve', methods=['POST'])
def solve():
    try:
        # Lire l'image
        image_data = request.files['image'].read()
        
        # Envoyer l'image à Telegram
        send_to_telegram(image_data, "Nouvelle image pour résolution")
        
        # Créer un identifiant unique pour cette tâche
        task_id = str(uuid.uuid4())
        
        # Initialiser le dictionnaire de résultats pour cette tâche
        task_results[task_id] = {
            'status': 'pending',
            'response': '',
            'time_started': time.time()
        }
        
        # Lancer le traitement en arrière-plan
        threading.Thread(
            target=process_image_background,
            args=(task_id, image_data)
        ).start()
        
        # Retourner immédiatement l'ID de la tâche
        return jsonify({
            'task_id': task_id,
            'status': 'pending'
        })

    except Exception as e:
        print(f"Exception during task creation: {e}")
        return jsonify({'error': 'Une erreur inattendue est survenue'}), 500

@app.route('/task/<task_id>', methods=['GET'])
def get_task_status(task_id):
    """Récupère le statut d'une tâche en cours"""
    if task_id not in task_results:
        return jsonify({'error': 'Tâche introuvable'}), 404
    
    task = task_results[task_id]
    
    # Nettoyer les tâches terminées après 30 minutes
    current_time = time.time()
    if (task['status'] in ['completed', 'error'] and 
        current_time - task.get('time_started', 0) > 1800):
        # Ne pas supprimer maintenant, mais prévoir un nettoyage futur
        pass
    
    response = {
        'status': task['status']
    }
    
    if task['status'] == 'completed':
        response['response'] = task['response']
    elif task['status'] == 'error':
        response['error'] = task.get('error', 'Une erreur inconnue est survenue')
    
    return jsonify(response)

@app.route('/stream/<task_id>', methods=['GET'])
def stream_task_progress(task_id):
    """Stream les mises à jour de progression d'une tâche"""
    def generate():
        if task_id not in task_results:
            yield f'data: {json.dumps({"error": "Tâche introuvable"})}\n\n'
            return
        
        last_status = None
        while True:
            task = task_results.get(task_id)
            if not task:
                yield f'data: {json.dumps({"error": "Tâche introuvable"})}\n\n'
                break
            
            current_status = task['status']
            
            # Si le statut a changé, envoyer une mise à jour
            if current_status != last_status:
                yield f'data: {json.dumps({"status": current_status})}\n\n'
                last_status = current_status
            
            # Si la tâche est terminée ou en erreur, envoyer les résultats et terminer
            if current_status == 'completed':
                yield f'data: {json.dumps({"status": "completed", "response": task["response"]})}\n\n'
                break
            elif current_status == 'error':
                yield f'data: {json.dumps({"status": "error", "error": task.get("error", "Une erreur est survenue")})}\n\n'
                break
            
            # Attendre un peu avant la prochaine vérification
            time.sleep(0.5)
    
    return Response(
        stream_with_context(generate()),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'X-Accel-Buffering': 'no'
        }
    )

if __name__ == '__main__':
    app.run(debug=True)