|
|
| |
| from flask import Flask, render_template, request, jsonify, Response, stream_with_context |
| from google import genai |
| import os |
| from google.genai import types |
| from PIL import Image |
| import io |
| import base64 |
| import json |
| import requests |
| import threading |
| import uuid |
| import time |
| import tempfile |
| import subprocess |
| import shutil |
| import re |
|
|
| |
| app = Flask(__name__) |
|
|
| |
| |
| GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") |
| |
| TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88" |
| TELEGRAM_CHAT_ID = "-4983537657" |
|
|
| |
| if GOOGLE_API_KEY: |
| try: |
| client = genai.Client(api_key=GOOGLE_API_KEY) |
| except Exception as e: |
| print(f"Erreur lors de l'initialisation du client Gemini: {e}") |
| client = None |
| else: |
| print("GEMINI_API_KEY non trouvé. Le client Gemini ne sera pas initialisé.") |
| client = None |
|
|
| |
| task_results = {} |
|
|
| |
| |
|
|
| def get_prompt_extract_problem(): |
| """Prompt pour extraire l'énoncé mathématique à partir des fichiers.""" |
| return """ |
| From the provided image(s) and/or PDF document, your task is to identify and extract the complete mathematical problem statement. |
| |
| - Focus solely on the problem itself, including all conditions, variables, and the question being asked. |
| - Exclude any surrounding text like page numbers, author names, or irrelevant context. |
| - Format all mathematical expressions using TeX (e.g., $f(x) = x^2 - 1$, for all $x \in \mathbb{R}$). |
| - Your output must be ONLY the clean, extracted problem statement. Do not add any conversational text like "Here is the problem statement:". |
| """ |
|
|
| def get_prompt_light(): |
| """Prompt pour une solution simple et directe (style 'light').""" |
| return """ |
| Vous êtes un expert en mathématiques. Votre tâche est de fournir une solution claire et concise au problème soumis. |
| La sortie doit être un code LaTeX complet, propre et directement compilable. |
| La solution doit être bien expliquée, mais sans fioritures visuelles. |
| Structurez la solution avec des sections logiques. |
| Produisez UNIQUEMENT le code LaTeX. |
| """ |
|
|
| def get_prompt_colorful(): |
| """Prompt pour une solution pédagogique et colorée (style 'colorful').""" |
| |
| return r""" |
| # 📝 GÉNÉRATEUR DE CORRECTION MATHÉMATIQUE PROFESSIONNELLE |
| |
| ## 🎓 VOTRE RÔLE |
| Vous êtes **Mariam-MATHEX-PRO**, un système d'intelligence artificielle ultra-spécialisé dans la création de documents mathématiques parfaits. Vous combinez l'expertise d'un: |
| * 🧠 Professeur agrégé de mathématiques avec 25 ans d'expérience |
| * 🖋️ Expert LaTeX de niveau international |
| * 👨🏫 Pédagogue reconnu pour votre clarté exceptionnelle |
| |
| Votre mission: transformer un simple énoncé mathématique en une correction LaTeX impeccable, aérée et pédagogiquement parfaite. |
| |
| ## 📊 FORMAT D'ENTRÉE ET SORTIE |
| |
| **ENTRÉE:** L'énoncé d'un exercice mathématique (niveau Terminale/Supérieur) |
| |
| **SORTIE:** UNIQUEMENT le code source LaTeX complet (.tex) sans annotations externes, directement compilable avec pdfLaTeX pour produire un document PDF de qualité professionnelle. |
| |
| ## 🌟 PRINCIPES FONDAMENTAUX |
| |
| 1. **DESIGN AÉRÉ ET ÉLÉGANT** |
| * Utilisez généreusement l'espace vertical entre tous les éléments |
| * Créez un document visuellement reposant avec beaucoup d'espaces blancs |
| * Évitez absolument la densité visuelle et le texte compact |
| |
| 2. **EXCELLENCE PÉDAGOGIQUE** |
| * Une seule étape de raisonnement par paragraphe |
| * Développement méticuleux de chaque calcul sans sauts logiques |
| * Mise en évidence claire des points clés et des résultats |
| |
| 3. **ESTHÉTIQUE PROFESSIONNELLE** |
| * Utilisation experte de la couleur pour guider l'attention |
| * Boîtes thématiques élégantes pour structurer l'information |
| * Typographie mathématique irréprochable |
| |
| ## 🛠️ SPÉCIFICATIONS TECHNIQUES DÉTAILLÉES |
| |
| ### 📑 STRUCTURE DE BASE |
| |
| ```latex |
| \documentclass[12pt,a4paper]{article} |
| |
| % --- PACKAGES FONDAMENTAUX --- |
| \usepackage[utf8]{inputenc} |
| \usepackage[T1]{fontenc} |
| \usepackage[french]{babel} |
| \usepackage{lmodern} |
| \usepackage{microtype} |
| |
| % --- PACKAGES MATHÉMATIQUES --- |
| \usepackage{amsmath,amssymb,amsfonts,mathtools} |
| \usepackage{bm} % Gras en mode mathématique |
| \usepackage{siunitx} % Unités SI |
| |
| % --- MISE EN PAGE --- |
| \usepackage[a4paper,margin=2.5cm]{geometry} |
| \usepackage{setspace} |
| \usepackage{fancyhdr} |
| \usepackage{titlesec,titletoc} |
| \usepackage{multicol} |
| \usepackage{enumitem} % Listes personnalisées |
| |
| % --- ÉLÉMENTS VISUELS --- |
| \usepackage{xcolor} |
| \usepackage[most]{tcolorbox} |
| \usepackage{fontawesome5} |
| \usepackage{graphicx} |
| |
| % --- GRAPHIQUES --- |
| \usepackage{tikz} |
| \usetikzlibrary{calc,shapes,arrows.meta,positioning} |
| \usepackage{pgfplots} |
| \pgfplotsset{compat=1.18} |
| \usepgfplotslibrary{fillbetween} |
| |
| % --- HYPERLIENS ET MÉTADONNÉES --- |
| \usepackage{hyperref} |
| \usepackage{bookmark} |
| |
| % --- ESPACEMENT EXTRA-AÉRÉ --- |
| \setlength{\parindent}{0pt} |
| \setlength{\parskip}{2.5ex plus 0.8ex minus 0.4ex} % Espacement paragraphes généreux |
| \onehalfspacing % Interligne 1.5 |
| ``` |
| |
| ### 🎨 PALETTE DE COULEURS ET STYLES VISUELS |
| |
| ```latex |
| % --- DÉFINITION DES COULEURS --- |
| \definecolor{maincolor}{RGB}{30, 100, 180} % Bleu principal |
| \definecolor{secondcolor}{RGB}{0, 150, 136} % Vert-bleu |
| \definecolor{thirdcolor}{RGB}{140, 0, 140} % Violet |
| \definecolor{accentcolor}{RGB}{255, 140, 0} % Orange |
| \definecolor{ubgcolor}{RGB}{245, 250, 255} % Fond bleuté très clair |
| \definecolor{lightgray}{RGB}{248, 248, 248} % Gris très clair |
| \definecolor{gridcolor}{RGB}{220, 220, 220} % Gris pour grilles |
| \definecolor{highlightcolor}{RGB}{255, 255, 200} % Jaune clair pour surlignage |
| \definecolor{asymptotecolor}{RGB}{220, 0, 0} % Rouge pour asymptotes |
| |
| % --- CONFIGURATION DE PAGE --- |
| \pagestyle{fancy} |
| \fancyhf{} |
| \fancyhead[L]{\textcolor{maincolor}{\small\textit{Correction Mathématiques}}} |
| \fancyhead[R]{\textcolor{maincolor}{\small\thepage}} |
| \renewcommand{\headrulewidth}{0.2pt} |
| \renewcommand{\headrule}{\hbox to\headwidth{\color{maincolor}\leaders\hrule height \headrulewidth\hfill}} |
| \setlength{\headheight}{15pt} |
| \setlength{\headsep}{25pt} % Plus d'espace sous l'en-tête |
| |
| % --- CONFIGURATION DES TITRES DE SECTION --- |
| \titleformat{\section} |
| {\normalfont\Large\bfseries\color{maincolor}} |
| {\colorbox{maincolor}{\color{white}\thesection}} |
| {1em}{}[\vspace{0.2cm}\titlerule[0.8pt]\vspace{0.8cm}] |
| |
| \titleformat{\subsection} |
| {\normalfont\large\bfseries\color{secondcolor}} |
| {\thesubsection} |
| {1em}{}[\vspace{0.5cm}] |
| |
| \titlespacing*{\section}{0pt}{3.5ex plus 1ex minus .2ex}{2.3ex plus .2ex} |
| \titlespacing*{\subsection}{0pt}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex} |
| ``` |
| |
| ### 📦 BOÎTES THÉMATIQUES AÉRÉES |
| |
| ```latex |
| % --- DÉFINITION DES BOÎTES THÉMATIQUES --- |
| \newtcolorbox{enoncebox}{ |
| enhanced, |
| breakable, |
| colback=lightgray!50, |
| colframe=gray!70, |
| fonttitle=\bfseries, |
| top=12pt, bottom=12pt, left=12pt, right=12pt, |
| boxrule=0.5pt, |
| arc=3mm, |
| title={\faBook\ Énoncé}, |
| attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2}, |
| boxed title style={colback=gray!70, colframe=gray!70}, |
| before={\vspace{15pt}}, |
| after={\vspace{15pt}} |
| } |
| |
| \newtcolorbox{definitionbox}{ |
| enhanced, |
| breakable, |
| colback=secondcolor!10, |
| colframe=secondcolor, |
| fonttitle=\bfseries, |
| top=12pt, bottom=12pt, left=12pt, right=12pt, |
| boxrule=0.5pt, |
| arc=3mm, |
| title={\faLightbulb\ Définition/Théorème}, |
| attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2}, |
| boxed title style={colback=secondcolor, colframe=secondcolor, color=white}, |
| before={\vspace{15pt}}, |
| after={\vspace{15pt}} |
| } |
| |
| \newtcolorbox{resultbox}{ |
| enhanced, |
| breakable, |
| colback=accentcolor!10, |
| colframe=accentcolor, |
| fonttitle=\bfseries, |
| top=12pt, bottom=12pt, left=12pt, right=12pt, |
| boxrule=0.5pt, |
| arc=3mm, |
| title={\faCheckCircle\ Résultat}, |
| attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2}, |
| boxed title style={colback=accentcolor, colframe=accentcolor, color=white}, |
| before={\vspace{15pt}}, |
| after={\vspace{15pt}} |
| } |
| |
| \newtcolorbox{notebox}{ |
| enhanced, |
| breakable, |
| colback=thirdcolor!10, |
| colframe=thirdcolor, |
| fonttitle=\bfseries, |
| top=12pt, bottom=12pt, left=12pt, right=12pt, |
| boxrule=0.5pt, |
| arc=3mm, |
| title={\faInfoCircle\ Remarque/Astuce}, |
| attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2}, |
| boxed title style={colback=thirdcolor, colframe=thirdcolor, color=white}, |
| before={\vspace{15pt}}, |
| after={\vspace{15pt}} |
| } |
| |
| \newtcolorbox{examplebox}{ |
| enhanced, |
| breakable, |
| colback=green!10, |
| colframe=green!70!black, |
| fonttitle=\bfseries, |
| top=12pt, bottom=12pt, left=12pt, right=12pt, |
| boxrule=0.5pt, |
| arc=3mm, |
| title={\faClipboard\ Exemple/Méthode}, |
| attach boxed title to top left={xshift=0.5cm,yshift=-\tcboxedtitleheight/2}, |
| boxed title style={colback=green!70!black, colframe=green!70!black, color=white}, |
| before={\vspace{15pt}}, |
| after={\vspace{15pt}} |
| } |
| ``` |
| |
| ### 🧮 COMMANDES MATHÉMATIQUES PERSONNALISÉES |
| |
| ```latex |
| % --- COMMANDES MATHÉMATIQUES --- |
| \newcommand{\R}{\mathbb{R}} |
| \newcommand{\C}{\mathbb{C}} |
| \newcommand{\N}{\mathbb{N}} |
| \newcommand{\Z}{\mathbb{Z}} |
| \newcommand{\Q}{\mathbb{Q}} |
| |
| \newcommand{\limx}[1]{\lim_{x \to #1}} |
| \newcommand{\limxp}[1]{\lim_{x \to #1^+}} |
| \newcommand{\limxm}[1]{\lim_{x \to #1^-}} |
| \newcommand{\limsinf}{\lim_{n \to +\infty}} |
| \newcommand{\liminf}{\lim_{x \to +\infty}} |
| |
| \newcommand{\derivee}[2]{\frac{d#1}{d#2}} |
| \newcommand{\ddx}[1]{\frac{d}{dx}\left(#1\right)} |
| \newcommand{\dfdx}[1]{\frac{df}{dx}\left(#1\right)} |
| |
| \newcommand{\abs}[1]{\left|#1\right|} |
| \newcommand{\norm}[1]{\left\|#1\right\|} |
| \newcommand{\vect}[1]{\overrightarrow{#1}} |
| \newcommand{\ds}{\displaystyle} |
| |
| \newcommand{\highlight}[1]{\colorbox{highlightcolor}{$#1$}} |
| \newcommand{\finalresult}[1]{\colorbox{accentcolor!20}{$\displaystyle #1$}} |
| |
| % Environnement pour équations importantes |
| \newcommand{\boxedeq}[1]{% |
| \begin{center} |
| \begin{tcolorbox}[ |
| enhanced, |
| colback=ubgcolor, |
| colframe=maincolor, |
| arc=3mm, |
| boxrule=0.5pt, |
| left=10pt,right=10pt,top=6pt,bottom=6pt |
| ] |
| $\displaystyle #1$ |
| \end{tcolorbox} |
| \end{center} |
| } |
| |
| % Configuration pour espacement des listes |
| \setlist{itemsep=8pt, parsep=4pt} |
| |
| % Configuration des environnements mathématiques pour plus d'espacement |
| \setlength{\abovedisplayskip}{12pt plus 3pt minus 7pt} |
| \setlength{\belowdisplayskip}{12pt plus 3pt minus 7pt} |
| \setlength{\abovedisplayshortskip}{7pt plus 2pt minus 4pt} |
| \setlength{\belowdisplayshortskip}{7pt plus 2pt minus 4pt} |
| ``` |
| |
| ### 📊 CONFIGURATION DE GRAPHIQUES |
| |
| ```latex |
| % --- CONFIGURATION DE PGFPLOTS POUR GRAPHIQUES --- |
| \pgfplotsset{ |
| every axis/.append style={ |
| axis lines=middle, |
| xlabel={$x$}, |
| ylabel={$y$}, |
| xlabel style={at={(ticklabel* cs:1.05)}, anchor=west}, |
| ylabel style={at={(ticklabel* cs:1.05)}, anchor=south}, |
| legend pos=outer north east, |
| grid=both, |
| grid style={gridcolor, line width=0.1pt}, |
| tick align=outside, |
| minor tick num=4, |
| enlargelimits={abs=0.2}, |
| axis line style={-Latex, line width=0.6pt}, |
| xmajorgrids=true, |
| ymajorgrids=true, |
| ticklabel style={font=\footnotesize} |
| } |
| } |
| ``` |
| |
| ### 🖌️ MODÈLE DE PAGE DE TITRE |
| |
| ```latex |
| % --- PAGE DE TITRE ÉLÉGANTE --- |
| \newcommand{\maketitlepage}[2]{% |
| \begin{titlepage} |
| \centering |
| \vspace*{2cm} |
| {\Huge\bfseries\color{maincolor} Correction Mathématiques\par} |
| \vspace{1.5cm} |
| {\huge\bfseries #1\par} |
| \vspace{1cm} |
| {\Large\textit{#2}\par} |
| \vspace{2cm} |
| |
| \begin{tikzpicture} |
| \draw[line width=0.5pt, maincolor] (0,0) -- (12,0); |
| \foreach \x in {0,1,...,12} { |
| \draw[line width=1pt, maincolor] (\x,0) -- (\x,-0.2); |
| } |
| \draw[line width=0.5pt, secondcolor] (0,-0.6) -- (12,-0.6); |
| \end{tikzpicture} |
| |
| \vspace{1.5cm} |
| |
| {\Large\today\par} |
| |
| \vfill |
| |
| \begin{tcolorbox}[ |
| enhanced, |
| colback=ubgcolor, |
| colframe=maincolor, |
| arc=5mm, |
| boxrule=0.5pt, |
| width=0.8\textwidth |
| ] |
| \centering |
| \large\textit{Document généré avec soin pour une clarté et une pédagogie optimales} |
| \end{tcolorbox} |
| |
| \vspace{1cm} |
| \end{titlepage} |
| } |
| |
| % Configuration hyperref pour liens colorés |
| \hypersetup{ |
| colorlinks=true, |
| linkcolor=maincolor, |
| filecolor=secondcolor, |
| urlcolor=thirdcolor, |
| pdfauthor={}, |
| pdftitle={Correction Mathématiques}, |
| pdfsubject={}, |
| pdfkeywords={} |
| } |
| ``` |
| |
| ## 🔄 STRUCTURE DU DOCUMENT COMPLET |
| |
| ```latex |
| \begin{document} |
| |
| % Page de titre élégante |
| \maketitlepage{Titre de l'Exercice}{Solution Détaillée et Commentée} |
| |
| % Espacement après la page de titre |
| \newpage |
| \vspace*{1cm} |
| |
| % Table des matières distincte et aérée |
| \begingroup |
| \setlength{\parskip}{8pt} |
| \tableofcontents |
| \endgroup |
| |
| \vspace{2cm} |
| \begin{enoncebox} |
| [TEXTE COMPLET DE L'ÉNONCÉ] |
| \end{enoncebox} |
| |
| \vspace{1.5cm} |
| |
| \section{Première partie de la résolution} |
| \vspace{0.8cm} |
| |
| [SOLUTION DÉTAILLÉE] |
| |
| \vspace{1.2cm} |
| \section{Deuxième partie de la résolution} |
| \vspace{0.8cm} |
| |
| [SUITE DE LA SOLUTION] |
| |
| % Et ainsi de suite... |
| |
| {Mariam AI} |
| \end{document} |
| ``` |
| |
| ## 💡 INSTRUCTIONS POUR UNE PRÉSENTATION ULTRA-AÉRÉE |
| |
| 1. **ESPACES VERTICAUX GÉNÉREUX** |
| * Utilisez `\vspace{1cm}` fréquemment entre les sections logiques |
| * Minimum 0.8cm d'espace après chaque titre de section |
| * Au moins 0.5cm d'espace avant/après chaque environnement mathématique |
| * Ne lésinez JAMAIS sur les espacements verticaux |
| |
| 2. **FORMULATION DE LA SOLUTION** |
| * Une seule idée par paragraphe, jamais plus |
| * Espacez généreusement les étapes des raisonnements |
| * Insérez une ligne vide avant ET après chaque équation ou bloc d'équations |
| * Utilisez abondamment les environnements thématiques avec leurs espacements inclus |
| |
| 3. **MISE EN VALEUR VISUELLE** |
| * Encadrez chaque résultat principal dans une `resultbox` |
| * Isolez les définitions et rappels théoriques dans des `definitionbox` |
| * Utilisez `\boxedeq{}` pour les formules clés qui méritent attention |
| * Alternez paragraphes textuels courts et expressions mathématiques pour créer du rythme visuel |
| |
| ## ⭐ RÉSULTAT FINAL ATTENDU |
| |
| Le document final doit: |
| * Être EXTRÊMEMENT aéré, avec beaucoup plus d'espace blanc que de contenu |
| * Présenter un équilibre parfait entre texte explicatif et développements mathématiques |
| * Guider visuellement l'attention grâce aux couleurs et aux encadrements |
| * Faciliter la compréhension par la décomposition méthodique et l'espacement généreux |
| |
| ✅ PRODUISEZ UNIQUEMENT LE CODE LATEX COMPLET, rien d'autre. |
| """ |
|
|
| def get_prompt_for_style(style): |
| """Retourne le prompt approprié selon le style.""" |
| if style == 'light': |
| return get_prompt_light() |
| else: |
| return get_prompt_colorful() |
|
|
| |
| |
|
|
| |
| SOLVER_MODEL_NAME = "gemini-2.5-pro" |
| SOLVER_MAX_ITERATIONS = 5 |
| SOLVER_PASSES_NEEDED = 2 |
| SOLVER_TEMPERATURE = 0.1 |
|
|
| def _get_solver_prompt_initial(problem_statement): |
| return f"### Core Instructions ###\n* **Rigor is Paramount:** Your primary goal is to produce a complete and rigorously justified solution. Every step must be logically sound.\n* **Honesty About Completeness:** If you cannot find a complete solution, present only significant partial results you can rigorously prove.\n* **Use TeX for All Mathematics:** All mathematical elements must be in TeX (e.g., $n \in \mathbb{{Z}}$).\n\n### Output Format ###\nYour response MUST be structured into these sections:\n**1. Summary**\n* **a. Verdict:** State if the solution is complete or partial.\n* **b. Method Sketch:** A high-level outline of your argument.\n**2. Detailed Solution**\nThe full, step-by-step mathematical proof.\n\n### Self-Correction Instruction ###\nReview your work to ensure it is clean, rigorous, and adheres to all instructions.\n\n### Problem ###\n{problem_statement}" |
|
|
| def _get_solver_prompt_improve(solution_attempt): |
| return f"You are a world-class mathematician. Review the following draft solution for flaws, gaps, or clarity issues.\nThen, produce a new, improved, and more rigorous version. Do not comment on the changes, just provide the final, clean proof.\n\n### Draft Solution ###\n{solution_attempt}\n\n### Improved Solution ###" |
|
|
| def _get_solver_prompt_verifier(problem_statement, solution_to_verify): |
| return f"You are an expert IMO grader. Your task is to rigorously verify the provided solution. A solution is correct ONLY if every step is justified. Do NOT correct errors, only report them.\n\n### Instructions ###\n1. **Core Instructions:** Find and report all issues.\n2. **Issue Classification:**\n * **a. Critical Error:** An error that breaks the proof's logic. Stop verifying dependant steps.\n * **b. Justification Gap:** A correct but insufficiently justified step. Assume it's true and continue verifying.\n3. **Output Format:**\n * **a. Summary:**\n * **Final Verdict:** A single sentence (e.g., \"The solution is correct.\").\n * **List of Findings:** A bulleted list of every issue found.\n * **b. Detailed Verification Log:** A step-by-step analysis.\n\n---\n### Problem ###\n{problem_statement}\n\n---\n### Solution ###\n{solution_to_verify}\n---\n### Verification Task Reminder ###\nGenerate the summary and the step-by-step verification log." |
|
|
| def _get_solver_prompt_correction(solution_attempt, verification_report): |
| return f"You are a brilliant mathematician. Your previous solution has been reviewed.\nYour task is to write a new, corrected version of your solution that meticulously addresses all issues raised in the verifier's report.\n\n### Verification Report on Your Last Attempt ###\n{verification_report}\n\n### Your Previous Flawed Solution ###\n{solution_attempt}\n\n### Your Task ###\nProvide a new, complete, and rigorously correct solution that fixes all identified issues. Follow the original structured output format (Summary and Detailed Solution)." |
|
|
| def _call_solver_llm(prompt, task_id, step_name): |
| """Fonction d'appel LLM spécifique pour le pipeline de résolution.""" |
| print(f"Task {task_id}: [Math Solver] - {step_name}...") |
| try: |
| response = client.models.generate_content( |
| model=SOLVER_MODEL_NAME, |
| contents=[prompt], |
| generation_config={"temperature": SOLVER_TEMPERATURE} |
| ) |
| time.sleep(2) |
| return response.text |
| except Exception as e: |
| print(f"Task {task_id}: An error occurred with the LLM API during '{step_name}': {e}") |
| return None |
|
|
| def _parse_verifier_verdict(report): |
| if not report: return "ERROR" |
| report_lower = report.lower() |
| if "the solution is correct" in report_lower: return "CORRECT" |
| if "critical error" in report_lower: return "CRITICAL_ERROR" |
| if "justification gap" in report_lower: return "GAPS" |
| return "UNKNOWN" |
|
|
| def run_solver_pipeline(problem_statement, task_id, task_results): |
| """Orchestrateur du pipeline de résolution mathématique.""" |
| |
| task_results[task_id]['status'] = 'solving_generating' |
| initial_prompt = _get_solver_prompt_initial(problem_statement) |
| current_solution = _call_solver_llm(initial_prompt, task_id, "Initial Generation") |
| if not current_solution: return "Failed at initial generation." |
|
|
| |
| task_results[task_id]['status'] = 'solving_improving' |
| improve_prompt = _get_solver_prompt_improve(current_solution) |
| current_solution = _call_solver_llm(improve_prompt, task_id, "Self-Improvement") |
| if not current_solution: return "Failed at self-improvement." |
|
|
| |
| iteration = 0 |
| consecutive_passes = 0 |
| while iteration < SOLVER_MAX_ITERATIONS: |
| iteration += 1 |
| task_results[task_id]['status'] = f'solving_verifying_iter_{iteration}' |
| verifier_prompt = _get_solver_prompt_verifier(problem_statement, current_solution) |
| verification_report = _call_solver_llm(verifier_prompt, task_id, f"Verification (Iter {iteration})") |
| if not verification_report: break |
| |
| verdict = _parse_verifier_verdict(verification_report) |
| if verdict == "CORRECT": |
| consecutive_passes += 1 |
| print(f"Task {task_id}: [Math Solver] - PASS! Consecutive: {consecutive_passes}/{SOLVER_PASSES_NEEDED}") |
| if consecutive_passes >= SOLVER_PASSES_NEEDED: |
| print(f"Task {task_id}: [Math Solver] - Solution verified. Exiting loop.") |
| return current_solution |
| else: |
| consecutive_passes = 0 |
| task_results[task_id]['status'] = f'solving_correcting_iter_{iteration}' |
| correction_prompt = _get_solver_prompt_correction(current_solution, verification_report) |
| new_solution = _call_solver_llm(correction_prompt, task_id, f"Correction (Iter {iteration})") |
| if not new_solution: break |
| current_solution = new_solution |
| |
| print(f"Task {task_id}: [Math Solver] - Solver finished. Returning last valid solution.") |
| return current_solution |
|
|
|
|
| |
| def check_latex_installation(): |
| """Vérifie si pdflatex est installé sur le système.""" |
| try: |
| subprocess.run(["pdflatex", "-version"], capture_output=True, check=True, timeout=10) |
| print("INFO: pdflatex est installé et accessible.") |
| return True |
| except (FileNotFoundError, subprocess.TimeoutExpired, subprocess.CalledProcessError) as e: |
| print(f"AVERTISSEMENT: pdflatex non installé ou non fonctionnel: {e}") |
| return False |
|
|
| IS_LATEX_INSTALLED = check_latex_installation() |
|
|
| def clean_latex_code(latex_code): |
| """Removes markdown code block fences (```latex ... ``` or ``` ... ```) if present.""" |
| match_latex = re.search(r"```(?:latex|tex)\s*(.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE) |
| if match_latex: return match_latex.group(1).strip() |
| match_generic = re.search(r"```\s*(\\documentclass.*?)\s*```", latex_code, re.DOTALL | re.IGNORECASE) |
| if match_generic: return match_generic.group(1).strip() |
| return latex_code.strip() |
|
|
| def latex_to_pdf(latex_code, output_filename_base="document"): |
| """Converts LaTeX code to PDF.""" |
| if not IS_LATEX_INSTALLED: |
| return None, "pdflatex n'est pas disponible sur le système." |
| with tempfile.TemporaryDirectory() as temp_dir_compile: |
| tex_path = os.path.join(temp_dir_compile, f"{output_filename_base}.tex") |
| pdf_path_in_compile_dir = os.path.join(temp_dir_compile, f"{output_filename_base}.pdf") |
| try: |
| with open(tex_path, "w", encoding="utf-8") as tex_file: tex_file.write(latex_code) |
| my_env = os.environ.copy() |
| my_env["LC_ALL"] = "C.UTF-8" |
| last_result = None |
| for _ in range(2): |
| process = subprocess.run( |
| ["pdflatex", "-interaction=nonstopmode", "-output-directory", temp_dir_compile, tex_path], |
| capture_output=True, text=True, check=False, encoding="utf-8", errors="replace", env=my_env |
| ) |
| last_result = process |
| if not os.path.exists(pdf_path_in_compile_dir) and process.returncode != 0: break |
| if os.path.exists(pdf_path_in_compile_dir): |
| temp_pdf_out_file = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) |
| shutil.copy(pdf_path_in_compile_dir, temp_pdf_out_file.name) |
| return temp_pdf_out_file.name, "PDF généré avec succès." |
| else: |
| error_log = last_result.stdout if last_result else "Aucun résultat de compilation." |
| print(f"Erreur de compilation PDF pour {output_filename_base}:\n{error_log}") |
| match_error = re.search(r"! LaTeX Error: (.*?)\n", error_log) |
| if match_error: return None, f"Erreur de compilation PDF: {match_error.group(1).strip()}" |
| return None, f"Erreur lors de la compilation du PDF. Détails dans les logs du serveur." |
| except Exception as e: |
| print(f"Exception inattendue lors de la génération du PDF ({output_filename_base}): {e}") |
| return None, f"Exception inattendue lors de la génération du PDF: {str(e)}" |
|
|
| def send_to_telegram(file_data, filename, caption="Nouveau fichier"): |
| """Envoie un fichier (image ou PDF) à un chat Telegram.""" |
| try: |
| if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')): |
| url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendPhoto" |
| files = {'photo': (filename, file_data)} |
| else: |
| url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument" |
| files = {'document': (filename, file_data)} |
| data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption} |
| response = requests.post(url, files=files, data=data, timeout=30) |
| if response.status_code == 200: |
| print(f"Fichier '{filename}' envoyé avec succès à Telegram") |
| return True |
| else: |
| print(f"Erreur envoi Telegram: {response.status_code} - {response.text}") |
| return False |
| except Exception as e: |
| print(f"Exception envoi Telegram: {e}") |
| return False |
|
|
| def send_document_to_telegram(content_or_path, filename="reponse.txt", caption="Réponse", is_pdf=False): |
| """Envoie un document texte ou PDF à Telegram.""" |
| try: |
| url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument" |
| data = {'chat_id': TELEGRAM_CHAT_ID, 'caption': caption} |
| if is_pdf: |
| with open(content_or_path, 'rb') as f: |
| files = {'document': (filename, f.read(), 'application/pdf')} |
| response = requests.post(url, files=files, data=data, timeout=60) |
| else: |
| files = {'document': (filename, content_or_path.encode('utf-8'), 'text/plain')} |
| response = requests.post(url, files=files, data=data, timeout=60) |
| |
| if response.status_code == 200: |
| print(f"Document '{filename}' envoyé avec succès à Telegram.") |
| return True |
| else: |
| print(f"Erreur envoi document Telegram: {response.status_code} - {response.text}") |
| return False |
| except Exception as e: |
| print(f"Exception envoi document Telegram: {e}") |
| return False |
|
|
| |
| def process_files_background(task_id, files_data, resolution_style='colorful'): |
| """Traite les fichiers, applique le pipeline de résolution et génère le PDF final.""" |
| pdf_file_to_clean = None |
| uploaded_file_refs = [] |
| |
| try: |
| task_results[task_id]['status'] = 'processing' |
| if not client: raise ConnectionError("Client Gemini non initialisé.") |
|
|
| |
| initial_contents = [] |
| for file_info in files_data: |
| file_type = file_info['type'] |
| file_data = file_info['data'] |
| if file_type.startswith('image/'): |
| img = Image.open(io.BytesIO(file_data)) |
| buffered = io.BytesIO() |
| img.save(buffered, format="PNG") |
| img_base64_str = base64.b64encode(buffered.getvalue()).decode() |
| initial_contents.append({'inline_data': {'mime_type': 'image/png', 'data': img_base64_str}}) |
| elif file_type == 'application/pdf': |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_pdf: |
| temp_pdf.write(file_data) |
| file_ref = client.files.upload(file=temp_pdf.name) |
| uploaded_file_refs.append(file_ref) |
| initial_contents.append(file_ref) |
| os.unlink(temp_pdf.name) |
| |
| if not initial_contents: raise ValueError("Aucun contenu valide trouvé.") |
| |
| full_latex_response = "" |
| if resolution_style == 'colorful': |
| |
| task_results[task_id]['status'] = 'extracting_problem' |
| print(f"Task {task_id}: Étape 1 - Extraction de l'énoncé...") |
| extraction_response = client.models.generate_content( |
| model=SOLVER_MODEL_NAME, contents=[*initial_contents, get_prompt_extract_problem()]) |
| problem_statement_text = extraction_response.text |
| print(f"Task {task_id}: Énoncé extrait: {problem_statement_text[:200]}...") |
|
|
| print(f"Task {task_id}: Étape 2 - Lancement du pipeline de résolution mathématique...") |
| rigorous_solution_text = run_solver_pipeline(problem_statement_text, task_id, task_results) |
| if not rigorous_solution_text: raise ValueError("Le pipeline de résolution n'a pas retourné de solution.") |
|
|
| task_results[task_id]['status'] = 'designing_pdf' |
| print(f"Task {task_id}: Étape 3 - Génération du document LaTeX final...") |
| colorful_prompt_template = get_prompt_for_style('colorful') |
| final_design_prompt = f"{colorful_prompt_template}\n\n---\n## CONTENU À METTRE EN FORME\n\n### ÉNONCÉ DE L'EXERCICE\n```\n{problem_statement_text}\n```\n\n### SOLUTION RIGIOUREUSE À METTRE EN PAGE\n```\n{rigorous_solution_text}\n```\n\nMaintenant, produis le code source LaTeX complet et uniquement le code." |
| gemini_response = client.models.generate_content(model=SOLVER_MODEL_NAME, contents=[final_design_prompt]) |
| full_latex_response = gemini_response.text |
| else: |
| |
| task_results[task_id]['status'] = 'generating_latex' |
| print(f"Task {task_id}: Génération LaTeX simple (style: {resolution_style})...") |
| prompt_to_use = get_prompt_for_style(resolution_style) |
| gemini_response = client.models.generate_content(model=SOLVER_MODEL_NAME, contents=[*initial_contents, prompt_to_use]) |
| full_latex_response = gemini_response.text |
|
|
| |
| if not full_latex_response.strip(): raise ValueError("Gemini a retourné une réponse vide.") |
| |
| task_results[task_id]['status'] = 'cleaning_latex' |
| cleaned_latex = clean_latex_code(full_latex_response) |
| |
| if not IS_LATEX_INSTALLED: |
| print(f"Task {task_id}: pdflatex non disponible. Envoi du .tex uniquement.") |
| send_document_to_telegram(cleaned_latex, f"solution_{task_id}.tex", f"Code LaTeX pour tâche {task_id}") |
| task_results[task_id]['status'] = 'completed_tex_only' |
| task_results[task_id]['response'] = cleaned_latex |
| return |
|
|
| task_results[task_id]['status'] = 'generating_pdf' |
| pdf_filename_base = f"solution_{task_id}" |
| pdf_file_to_clean, pdf_message = latex_to_pdf(cleaned_latex, output_filename_base=pdf_filename_base) |
|
|
| if pdf_file_to_clean: |
| send_document_to_telegram(pdf_file_to_clean, f"{pdf_filename_base}.pdf", f"Solution PDF pour tâche {task_id}", is_pdf=True) |
| task_results[task_id]['status'] = 'completed' |
| task_results[task_id]['response'] = cleaned_latex |
| else: |
| task_results[task_id]['status'] = 'pdf_error' |
| task_results[task_id]['error_detail'] = f"Erreur PDF: {pdf_message}" |
| send_document_to_telegram(cleaned_latex, f"solution_{task_id}.tex", f"Code LaTeX (Erreur PDF: {pdf_message[:150]})") |
| task_results[task_id]['response'] = cleaned_latex |
|
|
| except Exception as e_outer: |
| print(f"Task {task_id}: Exception majeure dans la tâche de fond: {e_outer}") |
| task_results[task_id]['status'] = 'error' |
| task_results[task_id]['error'] = f"Erreur système: {str(e_outer)}" |
| finally: |
| if pdf_file_to_clean and os.path.exists(pdf_file_to_clean): |
| try: |
| os.remove(pdf_file_to_clean) |
| except Exception as e_clean: |
| print(f"Task {task_id}: Erreur suppression PDF temp: {e_clean}") |
| |
|
|
| |
| @app.route('/') |
| def index(): |
| return render_template('index.html') |
|
|
| @app.route('/free') |
| def free(): |
| return render_template('index.html') |
|
|
| @app.route('/solve', methods=['POST']) |
| def solve(): |
| try: |
| if 'user_files' not in request.files: return jsonify({'error': 'Aucun fichier fourni'}), 400 |
| uploaded_files = request.files.getlist('user_files') |
| if not uploaded_files or all(f.filename == '' for f in uploaded_files): return jsonify({'error': 'Aucun fichier sélectionné'}), 400 |
|
|
| resolution_style = request.form.get('style', 'colorful') |
| files_data = [] |
| for file in uploaded_files: |
| if file.filename != '': |
| file_data = file.read() |
| file_type = file.content_type or 'application/octet-stream' |
| if file_type.startswith('image/') or file_type == 'application/pdf': |
| files_data.append({'filename': file.filename, 'data': file_data, 'type': file_type}) |
| send_to_telegram(file_data, file.filename, f"Mariam(Pro) - Style: {resolution_style}") |
| |
| if not files_data: return jsonify({'error': 'Aucun fichier valide (images/PDF acceptés)'}), 400 |
| |
| task_id = str(uuid.uuid4()) |
| task_results[task_id] = {'status': 'pending', 'response': ''} |
| |
| threading.Thread(target=process_files_background, args=(task_id, files_data, resolution_style)).start() |
| |
| return jsonify({'task_id': task_id, 'status': 'pending'}) |
|
|
| except Exception as e: |
| print(f"Exception lors de la création de la tâche: {e}") |
| return jsonify({'error': f'Erreur serveur: {e}'}), 500 |
|
|
| @app.route('/task/<task_id>', methods=['GET']) |
| def get_task_status(task_id): |
| if task_id not in task_results: return jsonify({'error': 'Tâche introuvable'}), 404 |
| task = task_results[task_id] |
| return jsonify({ |
| 'status': task.get('status'), |
| 'response': task.get('response'), |
| 'error': task.get('error'), |
| 'error_detail': task.get('error_detail') |
| }) |
|
|
| @app.route('/stream/<task_id>', methods=['GET']) |
| def stream_task_progress(task_id): |
| def generate(): |
| if task_id not in task_results: |
| yield f'data: {json.dumps({"error": "Tâche introuvable", "status": "error"})}\n\n' |
| return |
| |
| last_status_sent = None |
| while True: |
| task = task_results.get(task_id) |
| if not task: |
| yield f'data: {json.dumps({"error": "Tâche disparue", "status": "error"})}\n\n' |
| break |
| |
| current_status = task['status'] |
| if current_status != last_status_sent: |
| data_to_send = {"status": current_status} |
| if current_status in ['completed', 'completed_tex_only', 'pdf_error']: |
| data_to_send["response"] = task.get("response", "") |
| if current_status in ['error', 'pdf_error']: |
| data_to_send["error"] = task.get("error", "Erreur") |
| if task.get("error_detail"): data_to_send["error_detail"] = task.get("error_detail") |
| |
| yield f'data: {json.dumps(data_to_send)}\n\n' |
| last_status_sent = current_status |
| |
| if current_status in ['completed', 'error', 'pdf_error', 'completed_tex_only']: |
| break |
| |
| time.sleep(1) |
| |
| return Response(stream_with_context(generate()), mimetype='text/event-stream') |
|
|
| |
| if __name__ == '__main__': |
| if not GOOGLE_API_KEY: |
| print("CRITICAL: GOOGLE_API_KEY non définie.") |
| if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID: |
| print("CRITICAL: Variables Telegram non définies.") |
| |
| app.run(debug=True, host='0.0.0.0', port=5000) |
|
|
|
|
