Spaces:

Docfile
/

Flasksite

Running

App Files Files Community

Docfile commited on Sep 24

Commit

e1b7241

verified ·

1 Parent(s): f1fd51e

Update app.py

Browse files

Files changed (1) hide show

app.py +35 -245

app.py CHANGED Viewed

@@ -11,12 +11,8 @@ from psycopg2.extras import RealDictCursor
 from google import genai
 from google.genai import types
 from utils import load_prompt
-# Nouveaux imports pour la génération PDF côté serveur
-import pdfkit
-from jinja2 import Template
-import tempfile
-import io
 # --- Configuration de l'application ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -34,16 +30,6 @@ DISSERTATIONS_FILE = os.path.join(DATA_DIR, "dissertations_log.json")
 # Créer le dossier data s'il n'existe pas
 os.makedirs(DATA_DIR, exist_ok=True)
-# Configuration wkhtmltopdf (ajustez le chemin selon votre système)
-# Sur Linux/Mac: wkhtmltopdf est généralement dans le PATH
-# Sur Windows: spécifiez le chemin complet vers wkhtmltopdf.exe
-WKHTML_PATH = os.environ.get('WKHTML_PATH', None)  # None = utilise le PATH
-if WKHTML_PATH:
-    config = pdfkit.configuration(wkhtmltopdf=WKHTML_PATH)
-else:
-    config = pdfkit.configuration()
 # --- Modèles de Données Pydantic (inchangés) ---
 class Argument(BaseModel):
     paragraphe_argumentatif: str = Field(description="Un unique paragraphe formant un argument complet. Il doit commencer par un connecteur logique (ex: 'Premièrement,'), suivi de son développement.")
@@ -60,7 +46,7 @@ class Dissertation(BaseModel):
     parties: List[Partie]
     conclusion: str = Field(description="La conclusion complète de la dissertation.")
-# --- Configuration Gemini ---
 try:
     if not GOOGLE_API_KEY:
         logging.warning("La variable d'environnement TOKEN (GOOGLE_API_KEY) n'est pas définie.")
@@ -78,124 +64,6 @@ SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
-# --- Template HTML pour le PDF ---
-PDF_TEMPLATE = """
-<!DOCTYPE html>
-<html lang="fr">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Dissertation Philosophique</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Kalam&display=swap" rel="stylesheet">
-    <style>
-        body {
-            margin: 0;
-            padding: 0;
-            font-family: 'Kalam', cursive;
-            font-size: 20px;
-            color: #1a2a4c;
-            background-color: #fdfaf4;
-            line-height: 2;
-        }
-        .dissertation-paper {
-            background-image: linear-gradient(transparent 97%, #d8e2ee 98%);
-            background-size: 100% 40px;
-            border-left: 3px solid #ffaaab;
-            padding-left: 4em;
-            padding-top: 30px;
-            padding-bottom: 40px;
-            padding-right: 30px;
-            min-height: 100vh;
-            -webkit-print-color-adjust: exact;
-            print-color-adjust: exact;
-        }
-        .dissertation-paper h2 {
-            font-size: 1.5em;
-            text-align: center;
-            margin-bottom: 1.5em;
-            color: #1a2a4c;
-        }
-        .dissertation-paper h3 {
-            font-size: 1.2em;
-            margin-top: 3em;
-            margin-bottom: 1.5em;
-            text-transform: uppercase;
-            text-decoration: underline;
-            color: #1a2a4c;
-        }
-        .dissertation-paper .development-block {
-            margin-top: 3em;
-        }
-        .dissertation-paper p {
-            text-align: justify;
-            margin: 0;
-            padding: 0;
-        }
-        .dissertation-paper .prof {
-            text-align: center;
-            font-style: italic;
-            margin-bottom: 2em;
-        }
-        .dissertation-paper .indented {
-            text-indent: 3em;
-        }
-        .dissertation-paper .transition {
-            margin-top: 2em;
-            margin-bottom: 2em;
-            font-style: italic;
-            color: #4a6a9c;
-        }
-        .avoid-page-break {
-            page-break-inside: avoid;
-            break-inside: avoid;
-        }
-        @page {
-            margin: 15mm;
-            size: A4;
-        }
-    </style>
-</head>
-<body>
-    <div class="dissertation-paper">
-        <h2>Sujet : {{ dissertation.sujet }}</h2>
-        <p class="prof">Prof : {{ dissertation.prof }}</p>
-        <h3>Introduction</h3>
-        <p class="indented">{{ dissertation.introduction }}</p>
-        {% for partie in dissertation.parties %}
-        <div class="avoid-page-break">
-            <div class="development-block">
-                <p class="indented">{{ partie.chapeau }}</p>
-                {% for arg in partie.arguments %}
-                <p class="indented">{{ arg.paragraphe_argumentatif }}</p>
-                {% endfor %}
-            </div>
-            {% if partie.transition %}
-            <p class="indented transition">{{ partie.transition }}</p>
-            {% endif %}
-        </div>
-        {% endfor %}
-        <h3>Conclusion</h3>
-        <p class="indented">{{ dissertation.conclusion }}</p>
-    </div>
-</body>
-</html>
-"""
 # --- Helpers de base de données (inchangés) ---
 def create_connection():
     """Crée et retourne une connexion à la base de données PostgreSQL."""
@@ -250,39 +118,7 @@ def load_dissertations_data():
         logging.error(f"Erreur lors du chargement des données: {e}")
         return []
-# --- NOUVELLE fonction pour générer le PDF côté serveur ---
-def generate_pdf_from_dissertation(dissertation_data):
-    """Génère un PDF à partir des données de dissertation."""
-    try:
-        # Créer le template Jinja2
-        template = Template(PDF_TEMPLATE)
-        # Rendre le HTML avec les données
-        html_content = template.render(dissertation=dissertation_data)
-        # Options pour wkhtmltopdf
-        options = {
-            'page-size': 'A4',
-            'margin-top': '15mm',
-            'margin-right': '15mm',
-            'margin-bottom': '15mm',
-            'margin-left': '15mm',
-            'encoding': "UTF-8",
-            'no-outline': None,
-            'enable-local-file-access': None,
-            'print-media-type': None
-        }
-        # Générer le PDF en mémoire
-        pdf_bytes = pdfkit.from_string(html_content, False, options=options, configuration=config)
-        return pdf_bytes
-    except Exception as e:
-        logging.error(f"Erreur lors de la génération PDF: {e}")
-        raise
-# --- Routes (inchangées sauf nouvelle route PDF) ---
 @app.route('/')
 def philosophie():
     return render_template("philosophie.html")
@@ -291,80 +127,44 @@ def philosophie():
 def gestion():
     return render_template("gestion.html")
 @app.route('/api/gestion/dissertations', methods=['GET'])
 def get_dissertations_data():
-    """Récupère toutes les données des dissertations générées."""
     try:
         data = load_dissertations_data()
-        return jsonify({
-            "success": True,
-            "data": data,
-            "total": len(data)
-        })
     except Exception as e:
         logging.error(f"Erreur lors de la récupération des données de gestion: {e}")
-        return jsonify({
-            "success": False,
-            "error": "Erreur lors de la récupération des données"
-        }), 500
 @app.route('/api/gestion/dissertations/<int:record_id>', methods=['DELETE'])
 def delete_dissertation_record(record_id):
-    """Supprime un enregistrement spécifique."""
     try:
         data = load_dissertations_data()
-        record_index = None
-        for i, record in enumerate(data):
-            if record.get('id') == record_id:
-                record_index = i
-                break
         if record_index is None:
-            return jsonify({
-                "success": False,
-                "error": "Enregistrement non trouvé"
-            }), 404
-        deleted_record = data.pop(record_index)
         with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
             json.dump(data, f, ensure_ascii=False, indent=2)
-        return jsonify({
-            "success": True,
-            "message": "Enregistrement supprimé avec succès"
-        })
     except Exception as e:
         logging.error(f"Erreur lors de la suppression: {e}")
-        return jsonify({
-            "success": False,
-            "error": "Erreur lors de la suppression"
-        }), 500
 @app.route('/api/gestion/dissertations/clear', methods=['DELETE'])
 def clear_all_dissertations():
-    """Vide toutes les données des dissertations."""
     try:
         with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
             json.dump([], f)
-        return jsonify({
-            "success": True,
-            "message": "Toutes les données ont été supprimées"
-        })
     except Exception as e:
         logging.error(f"Erreur lors de la suppression générale: {e}")
-        return jsonify({
-            "success": False,
-            "error": "Erreur lors de la suppression"
-        }), 500
 @app.route('/api/philosophy/courses', methods=['GET'])
 def get_philosophy_courses():
-    """Récupère la liste de tous les cours de philosophie pour le menu déroulant."""
     conn = create_connection()
     if not conn:
         return jsonify({"error": "Connexion à la base de données échouée."}), 503
@@ -380,6 +180,7 @@ def get_philosophy_courses():
         if conn:
             conn.close()
 @app.route('/api/generate_dissertation', methods=['POST'])
 def generate_dissertation_api():
     if not client:
@@ -402,7 +203,6 @@ def generate_dissertation_api():
         save_dissertation_data(data, None, False, error_msg)
         return jsonify({"error": error_msg}), 400
-    # Récupérer le contenu du cours si un ID est fourni
     context_str = ""
     if course_id:
         conn = create_connection()
@@ -433,13 +233,11 @@ def generate_dissertation_api():
             return jsonify({"error": error_msg}), 500
         final_prompt = prompt_template.format(phi_prompt=sujet, context=context_str)
         config = types.GenerateContentConfig(
             safety_settings=SAFETY_SETTINGS,
             response_mime_type="application/json",
             response_schema=Dissertation,
         )
         response = client.models.generate_content(
             model="gemini-2.5-flash",
             contents=final_prompt,
@@ -462,42 +260,34 @@ def generate_dissertation_api():
         save_dissertation_data(data, None, False, error_msg)
         return jsonify({"error": error_msg}), 500
-# --- NOUVELLE Route pour générer et télécharger le PDF ---
 @app.route('/api/generate_pdf', methods=['POST'])
 def generate_pdf_api():
-    """Génère et retourne un PDF de dissertation côté serveur."""
     try:
-        data = request.json
-        if not data:
-            return jsonify({"error": "Aucune donnée de dissertation fournie."}), 400
-        # Vérifier que les données contiennent les champs nécessaires
-        required_fields = ['sujet', 'prof', 'introduction', 'parties', 'conclusion']
-        for field in required_fields:
-            if field not in data:
-                return jsonify({"error": f"Champ manquant: {field}"}), 400
-        # Générer le PDF
-        pdf_bytes = generate_pdf_from_dissertation(data)
-        # Créer un nom de fichier basé sur le sujet (limité et sécurisé)
-        safe_filename = "".join(c for c in data['sujet'][:50] if c.isalnum() or c in (' ', '-', '_')).strip()
-        if not safe_filename:
-            safe_filename = "dissertation"
-        filename = f"{safe_filename}.pdf"
-        # Retourner le PDF
         return send_file(
             io.BytesIO(pdf_bytes),
             mimetype='application/pdf',
             as_attachment=True,
-            download_name=filename
         )
     except Exception as e:
-        logging.error(f"Erreur lors de la génération du PDF: {e}")
-        return jsonify({"error": "Erreur lors de la génération du PDF."}), 500
 if __name__ == '__main__':
     app.run(debug=True, port=5001)

 from google import genai
 from google.genai import types
 from utils import load_prompt
+from weasyprint import HTML # <-- NOUVEL IMPORT
+import io # <-- NOUVEL IMPORT
 # --- Configuration de l'application ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 # Créer le dossier data s'il n'existe pas
 os.makedirs(DATA_DIR, exist_ok=True)
 # --- Modèles de Données Pydantic (inchangés) ---
 class Argument(BaseModel):
     paragraphe_argumentatif: str = Field(description="Un unique paragraphe formant un argument complet. Il doit commencer par un connecteur logique (ex: 'Premièrement,'), suivi de son développement.")
     parties: List[Partie]
     conclusion: str = Field(description="La conclusion complète de la dissertation.")
+# --- Configuration Gemini (inchangée) ---
 try:
     if not GOOGLE_API_KEY:
         logging.warning("La variable d'environnement TOKEN (GOOGLE_API_KEY) n'est pas définie.")
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 # --- Helpers de base de données (inchangés) ---
 def create_connection():
     """Crée et retourne une connexion à la base de données PostgreSQL."""
         logging.error(f"Erreur lors du chargement des données: {e}")
         return []
+# --- Routes (inchangées) ---
 @app.route('/')
 def philosophie():
     return render_template("philosophie.html")
 def gestion():
     return render_template("gestion.html")
+# --- API de gestion (inchangées) ---
 @app.route('/api/gestion/dissertations', methods=['GET'])
 def get_dissertations_data():
     try:
         data = load_dissertations_data()
+        return jsonify({"success": True, "data": data, "total": len(data)})
     except Exception as e:
         logging.error(f"Erreur lors de la récupération des données de gestion: {e}")
+        return jsonify({"success": False, "error": "Erreur lors de la récupération des données"}), 500
 @app.route('/api/gestion/dissertations/<int:record_id>', methods=['DELETE'])
 def delete_dissertation_record(record_id):
     try:
         data = load_dissertations_data()
+        record_index = next((i for i, record in enumerate(data) if record.get('id') == record_id), None)
         if record_index is None:
+            return jsonify({"success": False, "error": "Enregistrement non trouvé"}), 404
+        data.pop(record_index)
         with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
             json.dump(data, f, ensure_ascii=False, indent=2)
+        return jsonify({"success": True, "message": "Enregistrement supprimé avec succès"})
     except Exception as e:
         logging.error(f"Erreur lors de la suppression: {e}")
+        return jsonify({"success": False, "error": "Erreur lors de la suppression"}), 500
 @app.route('/api/gestion/dissertations/clear', methods=['DELETE'])
 def clear_all_dissertations():
     try:
         with open(DISSERTATIONS_FILE, 'w', encoding='utf-8') as f:
             json.dump([], f)
+        return jsonify({"success": True, "message": "Toutes les données ont été supprimées"})
     except Exception as e:
         logging.error(f"Erreur lors de la suppression générale: {e}")
+        return jsonify({"success": False, "error": "Erreur lors de la suppression"}), 500
+# --- API pour lister les cours (inchangée) ---
 @app.route('/api/philosophy/courses', methods=['GET'])
 def get_philosophy_courses():
     conn = create_connection()
     if not conn:
         return jsonify({"error": "Connexion à la base de données échouée."}), 503
         if conn:
             conn.close()
+# --- API pour la génération de dissertation (inchangée) ---
 @app.route('/api/generate_dissertation', methods=['POST'])
 def generate_dissertation_api():
     if not client:
         save_dissertation_data(data, None, False, error_msg)
         return jsonify({"error": error_msg}), 400
     context_str = ""
     if course_id:
         conn = create_connection()
             return jsonify({"error": error_msg}), 500
         final_prompt = prompt_template.format(phi_prompt=sujet, context=context_str)
         config = types.GenerateContentConfig(
             safety_settings=SAFETY_SETTINGS,
             response_mime_type="application/json",
             response_schema=Dissertation,
         )
         response = client.models.generate_content(
             model="gemini-2.5-flash",
             contents=final_prompt,
         save_dissertation_data(data, None, False, error_msg)
         return jsonify({"error": error_msg}), 500
+# --- NOUVELLE ROUTE API POUR LA GÉNÉRATION DE PDF ---
 @app.route('/api/generate_pdf', methods=['POST'])
 def generate_pdf_api():
+    """Génère un PDF à partir des données JSON de la dissertation."""
+    dissertation_data = request.json
+    if not dissertation_data:
+        return jsonify({"error": "Aucune donnée de dissertation fournie."}), 400
     try:
+        # 1. Rendre le template HTML avec les données de la dissertation
+        html_string = render_template('dissertation_pdf.html', dissertation=dissertation_data)
+        # 2. Utiliser WeasyPrint pour convertir le HTML en PDF
+        html = HTML(string=html_string)
+        pdf_bytes = html.write_pdf()
+        # 3. Envoyer le PDF en tant que fichier à télécharger
         return send_file(
             io.BytesIO(pdf_bytes),
             mimetype='application/pdf',
             as_attachment=True,
+            download_name='dissertation-philosophie.pdf'
         )
     except Exception as e:
+        logging.error(f"Erreur lors de la génération du PDF : {e}")
+        return jsonify({"error": "Une erreur est survenue lors de la création du PDF."}), 500
 if __name__ == '__main__':
     app.run(debug=True, port=5001)