Update app.py

app.py

@@ -1,128 +1,102 @@
-from flask import Flask, request, render_template, send_from_directory
+from flask import Flask, render_template, request, send_file
 import google.generativeai as genai
 import os
-from PIL import Image
-import subprocess
-import uuid
 import re
+from rdkit.Chem import MolFromSmiles, MolToImage
+from rdkit.Chem.Draw import rdMolDraw2D
 import tempfile
-from pathlib import Path
-
-app = Flask(__name__)
-
-# Configuration constants
-UPLOAD_FOLDER = Path('uploads')
-ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
-
-# Create uploads directory if it doesn't exist
-UPLOAD_FOLDER.mkdir(exist_ok=True)
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-
-# Gemini API configuration
-def configure_gemini():
-    token = os.environ.get("TOKEN")
-    if not token:
-        raise ValueError("Environment variable TOKEN must be set.")
-    
-    genai.configure(api_key=token)
-    
-    generation_config = {
-        "temperature": 1,
-        "top_p": 0.95,
-        "top_k": 64,
-        "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"},
-    ]
-    
-    return genai.GenerativeModel(
-        model_name="gemini-1.5-pro",
-        generation_config=generation_config,
-        safety_settings=safety_settings,
-    )
-
-PROMPT_TEMPLATE = """
-Résous cet exercice. Tu répondras en détaillant au maximum ton procédé de calcul. 
-Réponse attendue uniquement en LaTeX
-"""
-
-def allowed_file(filename):
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
-
-def generate_svg_from_chemfig(chemfig_code, tmpdirname):
-    unique_id = str(uuid.uuid4())
-    tex_filename = Path(tmpdirname) / f"chem_{unique_id}.tex"
-    pdf_filename = Path(tmpdirname) / f"chem_{unique_id}.pdf"
-    svg_filename = f"chem_{unique_id}.svg"
-
-    tex_content = f"""\\documentclass[margin=10pt]{{standalone}}
-\\usepackage{{chemfig}}
-\\begin{{document}}
-\\chemfig{{{chemfig_code}}}
-\\end{{document}}"""
+import uuid
 
-    tex_filename.write_text(tex_content)
+# Configuration de l'API Gemini
+token = os.environ.get("TOKEN")
+genai.configure(api_key=token)
+generation_config = {
+    "temperature": 1,
+    "top_p": 0.95,
+    "top_k": 64,
+    "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"},
+]
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-pro",
+    generation_config=generation_config,
+    safety_settings=safety_settings,
+)
 
-    try:
-        subprocess.run(["pdflatex", "-interaction=nonstopmode", str(tex_filename)], 
-                      check=True, cwd=tmpdirname)
-        subprocess.run(["pdf2svg", str(pdf_filename), 
-                      str(UPLOAD_FOLDER / svg_filename)], check=True)
-        return svg_filename
-    except subprocess.CalledProcessError as e:
-        raise Exception(f"LaTeX compilation or SVG conversion error: {e}")
+app = Flask(__name__)
 
-@app.route("/", methods=["GET", "POST"])
+# Dossier pour les images temporaires
+app.config['UPLOAD_FOLDER'] = 'static/temp_images'
+if not os.path.exists(app.config['UPLOAD_FOLDER']):
+    os.makedirs(app.config['UPLOAD_FOLDER'])
+
+# Fonction pour extraire et traiter les structures chimiques
+def process_chemfig(text):
+    chemfig_pattern = r"\\chemfig{(.*?)}"
+    matches = re.findall(chemfig_pattern, text)
+    image_paths = []
+
+    for match in matches:
+        # Supposons que la syntaxe est du SMILES simplifié ou une représentation compatible RDKit
+        try:
+          #  mol = MolFromSmiles(match)
+           mol=MolFromSmiles(match)
+
+           if mol:
+                d = rdMolDraw2D.MolDraw2DCairo(500,500)
+                d.DrawMolecule(mol)
+                d.FinishDrawing()
+                image_filename = str(uuid.uuid4()) + '.png'
+                image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_filename)
+                d.WriteDrawingText(image_path)
+                image_paths.append(image_path)
+                text = text.replace(f"\\chemfig{{{match}}}", f'<img src="/temp_images/{image_filename}" style="width:100%; height:auto;" alt="Structure Chimique">')
+           else:
+                text = text.replace(f"\\chemfig{{{match}}}", f'Structure Chimique non valide : {match}')
+        except Exception as e:
+            text = text.replace(f"\\chemfig{{{match}}}", f'Erreur lors du rendu de la structure : {e}')
+
+    return text, image_paths
+
+# Route principale
+@app.route('/', methods=['GET', 'POST'])
 def index():
-    if request.method != "POST":
-        return render_template("index.html", e="")
-
-    if "image" not in request.files:
-        return render_template("index.html", e="No image selected.")
-
-    image_file = request.files["image"]
-    if not image_file or not allowed_file(image_file.filename):
-        return render_template("index.html", e="Invalid file type. Please upload PNG or JPG.")
-
-    try:
-        model = configure_gemini()
-        
-        with tempfile.NamedTemporaryFile(delete=False) as temp_img:
-            image_file.save(temp_img.name)
-            image = Image.open(temp_img.name)
-
-            response = model.generate_content([PROMPT_TEMPLATE, image])
-            latex_code = response.text
-            os.unlink(temp_img.name)
-
-            # Handle chemfig diagrams
-            match = re.search(r"\\chemfig\{(.*?)\}", latex_code, re.DOTALL)
-            if match:
-                chemfig_code = match.group(1)
-                with tempfile.TemporaryDirectory() as tmpdirname:
-                    svg_filename = generate_svg_from_chemfig(chemfig_code, tmpdirname)
-                    return render_template("index.html", 
-                                        e=f'<img src="/uploads/{svg_filename}" alt="Chemical structure">')
+    generated_content = ""
+    image_paths = []
+    if request.method == 'POST':
+        image_file = request.files.get('image')
+        mm = """ resous cet exercice. tu répondras en détaillant au maximum ton procédé de calcul. réponse attendue uniquement en Latex 
 
-            # Block potentially unsafe content
-            if any(keyword in latex_code.lower() for keyword in 
-                  ['.pdf', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.svg']):
-                return render_template("index.html", 
-                                    e="Sorry, images and PDFs are not yet supported in the response.")
-
-            return render_template("index.html", e=latex_code)
-
-    except Exception as error:
-        return render_template("index.html", e=f"Error processing request: {str(error)}")
-
-@app.route('/uploads/<filename>')
-def uploaded_file(filename):
-    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
-
-if __name__ == "__main__":
+"""
+        if image_file :
+            image_bytes = image_file.read()
+            parts=[
+                 {
+                        "mime_type":"image/jpeg",
+                        "data": image_bytes
+                        },
+                mm
+            ]
+            response = model.generate_content(parts)
+            generated_content = response.text
+        else:
+            text_input= request.form.get('text_input')
+            response = model.generate_content(mm+text_input)
+            generated_content = response.text
+
+        generated_content, image_paths = process_chemfig(generated_content)
+
+    return render_template('index.html', generated_content=generated_content, image_paths=image_paths)
+
+# Route pour servir les images temporaires
+@app.route('/temp_images/<filename>')
+def temp_image(filename):
+    return send_file(os.path.join(app.config['UPLOAD_FOLDER'], filename), mimetype='image/png')
+
+if __name__ == '__main__':
     app.run(debug=True)