app.py

from flask import Flask,make_response,render_template, request, redirect, url_for, session, jsonify, flash
from datetime import datetime, timedelta
import sqlite3
from urllib.parse import urlparse
import requests
import yt_dlp
import functools
import time
import tempfile
import logging
import re
import psycopg2
from markupsafe import Markup
from gradio_client import Client,handle_file
from functools import wraps
import os
import google.generativeai as genai
import textwrap
import PIL.Image
from werkzeug.utils import secure_filename
from pytube import YouTube
from psycopg2.extras import RealDictCursor
import redis 



logging.basicConfig(level=logging.INFO)

DATABASE_URL= os.environ.get("DATABASE")

GOOGLE_API_KEY = os.environ.get("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"
  },
]


genai.configure(api_key=GOOGLE_API_KEY)


MAX_CONTENT_LENGTH = 760 * 1024 * 1024  # 16MB max file size

def create_connection():
    #le première c'est pour boma langue 
    conn = psycopg2.connect(DATABASE_URL)
    return conn

app = Flask(__name__)
app.secret_key = "uyyhhy77uu"
app.permanent_session_lifetime = timedelta(days=200)

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



# Route pour récupérer la liste des cours
@app.route('/api/philosophy/courses', methods=['GET'])
def get_philosophy_courses():
    try:
        conn = psycopg2.connect(DATABASE_URL)
        cur = conn.cursor(cursor_factory=RealDictCursor)
        cur.execute("""
            SELECT id, title, author, updated_at 
            FROM cours_philosophie 
            ORDER BY title
        """)
        courses = cur.fetchall()
        cur.close()
        conn.close()
        return jsonify(courses)
    except Exception as e:
        print(f"Erreur lors de la récupération des cours : {e}")
        return jsonify({"error": str(e)}), 500

# Route pour récupérer les détails d'un cours spécifique
@app.route('/api/philosophy/courses/<int:course_id>', methods=['GET'])
def get_philosophy_course(course_id):
    try:
        conn = psycopg2.connect(DATABASE_URL)
        cur = conn.cursor(cursor_factory=RealDictCursor)
        cur.execute("""
            SELECT id, title, content, author, created_at, updated_at 
            FROM cours_philosophie 
            WHERE id = %s
        """, (course_id,))
        course = cur.fetchone()
        cur.close()
        conn.close()
        
        if course:
            return jsonify(course)
        return jsonify({"error": "Cours non trouvé"}), 404
    except Exception as e:
        print(f"Erreur lors de la récupération du cours : {e}")
        return jsonify({"error": str(e)}), 500

# Route Flask mise à jour
@app.route('/submit_philo', methods=['POST'])
def submit_philo():
    data = request.json
    phi_prompt = data.get('question', '').strip()
    phi_type = data.get('type', '1')  # Type 1 par défaut
    course_id = data.get('courseId')

    logging.info(f"Le sujet est: {phi_prompt}")
    logging.info(f"Le type est: {phi_type}")
    
    if not phi_prompt:
        return jsonify({"error": "Veuillez saisir un sujet."}), 400

    try:
        # Récupération du contenu du cours si un cours est sélectionné
        course_content = ""
        course_info = ""
        if course_id:
            conn = psycopg2.connect(DATABASE_URL)
            cur = conn.cursor(cursor_factory=RealDictCursor)
            cur.execute("""
                SELECT content, author, title 
                FROM cours_philosophie 
                WHERE id = %s
            """, (course_id,))
            result = cur.fetchone()
            if result:
                course_content = result['content']
                course_info = f"\nBasé sur le cours '{result['title']}' de {result['author']}"
            cur.close()
            conn.close()

        # Sélection de la méthodologie selon le type
        if phi_type == '1':
            methodologie = f"""
    

    Traite ce sujet de philosophie "{phi_prompt}" selon le plan suivant:

            # INTRODUCTION: ( l'introduction se fait en un paragraphe )
            - Approche par constat
            - - Amorcer le sujet avec moins de deux phrases
            - Poser le problème 
            - Formuler la problématique autour de deux questions essentielles:
            - Question-thèse 
           - Question-antithèse

            # DÉVELOPPEMENT:
            ## Première partie (Thèse)
            - Introduction partielle (thèse + arguments1 + arguments2)
            - Argument 1:
                * Explications
                * Illustration (citation + reformulation)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication)
            - Transition:
                * Bilan (thèse + arguments1 + arguments2)
                * Annonce de l'idée critique

            ## Deuxième partie (Antithèse)
            - Introduction partielle (antithèse + arguments3 + arguments4)
            - Argument 3:
                * Explications
                * Illustration (citation + reformulation)
            - Argument 4:
                * Explications
                * Illustration (exemple + reformulation)

            # CONCLUSION:
            - Bilan global de l'analyse (rappel du problème + thèse + antithèse)
            - Prise de position (réponse à la question critique de l'introduction)

            Je veux un travail bien détaillé et complet avec un français raffiné et soutenu.
          """
        else:  # Type 2
            methodologie = f"""
            Traite ce sujet de philosophie "{phi_prompt}" selon le plan suivant:

            # INTRODUCTION: ( l'introduction se fait en un paragraphe)
            - Approche par constat
            - Posez la citation
            - Reformulation de la citation
            - Nuancez la thèse (antithèse)
            - De cette opposition naît le problème
            - En quoi
            - Idée de la citation

            # DÉVELOPPEMENT:
            ## Première partie (Thèse)
            - Introduction partielle (thèse + arguments1 + arguments2)
            - Argument 1:
                * Explications
                * Illustration (citation + reformulation)
            - Argument 2:
                * Explications
                * Illustration (exemple + explication)
            - Transition:
                * Bilan (thèse + arguments1 + arguments2)
                * Annonce de l'idée critique

            ## Deuxième partie (Antithèse)
            - Introduction partielle (antithèse + arguments3 + arguments4)
            - Argument 3:
                * Explications
                * Illustration (citation + reformulation)
            - Argument 4:
                * Explications
                * Illustration (exemple + reformulation)

            # CONCLUSION:
            - Bilan global de l'analyse (rappel du problème + thèse + antithèse)
            - Prise de position (réponse à la question critique de l'introduction)

            Je veux un travail bien détaillé et complet avec un français raffiné et soutenu.
            """

        # Ajout du contenu du cours à la prompt si disponible
        if course_content:
            methodologie += f"\nEn te basant sur le cours suivant:\n{course_content}"

        prompt = methodologie

        try:
            model = genai.GenerativeModel(model_name="models/gemini-1.5-flash", safety_settings=safety_settings)
            response = model.generate_content(prompt, request_options={"timeout": 1100})
            
            dissertation = response.text
            return jsonify({"response": dissertation}), 200
        except Exception as e:
            print(f"Erreur dans la génération de contenu : {e}")
            return jsonify({"error": str(e)}), 500

    except Exception as e:
        print(f"Erreur dans submit_philo : {e}")
        return jsonify({"error": str(e)}), 500

@app.route('/admin/philosophy/courses', methods=['GET', 'POST', 'DELETE'])
def manage_philosophy_courses():
    if request.method == 'GET':
        try:
            conn = psycopg2.connect(DATABASE_URL)
            cur = conn.cursor(cursor_factory=RealDictCursor)
            cur.execute("SELECT * FROM cours_philosophie")
            courses = cur.fetchall()
            cur.close()
            conn.close()
            return render_template('philosophy_courses.html', courses=courses)
        except Exception as e:
            flash(f'Erreur lors de la récupération des cours : {e}', 'danger')
            return redirect(url_for('manage_philosophy_courses'))

    elif request.method == 'POST':
        if 'title' in request.form: #  Vérification pour savoir si le formulaire soumis est celui d'ajout
            try:
                title = request.form.get('title')
                content = request.form.get('content')
                author = request.form.get('author')
                conn = psycopg2.connect(DATABASE_URL)
                cur = conn.cursor()
                cur.execute("""
                    INSERT INTO cours_philosophie (title, content, author)
                    VALUES (%s, %s, %s)
                """, (title, content, author))
                conn.commit()
                cur.close()
                conn.close()
                flash('Cours ajouté avec succès !', 'success')
                return redirect(url_for('manage_philosophy_courses'))
            except Exception as e:
                flash(f'Erreur lors de l\'ajout du cours : {e}', 'danger')
                return redirect(url_for('manage_philosophy_courses'))
        else:
            try:
                course_id = request.form.get('id')
                conn = psycopg2.connect(DATABASE_URL)
                cur = conn.cursor()
                cur.execute("DELETE FROM cours_philosophie WHERE id = %s", (course_id,))
                conn.commit()
                cur.close()
                conn.close()
                flash('Cours supprimé avec succès !', 'success')
                return redirect(url_for('manage_philosophy_courses'))
            except Exception as e:
                flash(f'Erreur lors de la suppression du cours : {e}', 'danger')
                return redirect(url_for('manage_philosophy_courses'))