fonctions.py

from openai import OpenAI
import os
from dotenv import load_dotenv
from youtube_transcript_api import YouTubeTranscriptApi
import random
from classes import LeitnerSystem
# Load environment variables from .env file
load_dotenv()


OpenAI.api_key = os.getenv('OPENAI_API_KEY')
client = OpenAI()

# Extraction et pré-traitement de l'information

def extraire_qr_de_chatgpt(reponse_chat_gpt):
    """
    Extrait les paires de questions et réponses du texte de réponse ChatGPT.

    :param reponse_chat_gpt: Le texte de réponse de ChatGPT contenant des Q/R.
    :return: Liste de tuples contenant les paires (question, réponse).
    """
    # Séparer le texte en lignes
    lignes = reponse_chat_gpt.split('\n\n')  # Deux sauts de ligne séparent chaque Q/R
    paires_qr = []

    for ligne in lignes:
        if ligne.startswith("Q:") and "\nR:" in ligne:
            question, reponse = ligne.split("\nR:")
            paires_qr.append((question[3:], reponse))  # Supprime 'Q: ' de la question

    return paires_qr
def obtenir_transcription(id_youtube):
    """
    Obtient la transcription d'une vidéo YouTube à partir de son ID.
    """
    try:
        result = YouTubeTranscriptApi.get_transcript(id_youtube, languages=["fr"])
        texte_continu = ' '.join([segment['text'] for segment in result])
        # qr = extraire_qr_de_chatgpt(texte_continu)
        return texte_continu
    except Exception as e:
        return str(e)
def decouper_texte_en_segments(texte, longueur_max=2000):
    """
    Découpe un texte en segments de taille spécifiée sans couper les mots en deux.

    :param texte: Le texte à découper.
    :param longueur_max: La longueur maximale de chaque segment.
    :return: Une liste de segments de texte.
    """
    # Vérifie si le texte est plus court que la longueur maximale
    if len(texte) <= longueur_max:
        return [texte]
    
    segments = []
    mots = texte.split()
    segment_actuel = []

    for mot in mots:
        # Vérifie si l'ajout du mot courant dépasse la longueur maximale
        if len(' '.join(segment_actuel + [mot])) > longueur_max:
            # Si oui, ajoute le segment actuel à la liste des segments et commence un nouveau segment
            segments.append(' '.join(segment_actuel))
            segment_actuel = [mot]
        else:
            # Si non, ajoute le mot au segment actuel
            segment_actuel.append(mot)
    
    # Ajoute le dernier segment s'il y a des mots restants
    if segment_actuel:
        segments.append(' '.join(segment_actuel))
    
    return segments

# Création de question/réponse

def generer_questions_reponses(texte):
    """
    Génère des questions et réponses à partir d'un texte donné en utilisant l'API d'OpenAI.

    :param texte: Le texte à partir duquel générer les Q/R.
    :return: Texte contenant les questions et réponses.
    """
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-4",
            messages=[
            {
                "role": "system",
                "content": 
                    """
                            Vous êtes un assistant perspicace capable de générer du contenu éducatif sous forme de question/réponse adapté 
                            à un système de cartes de Leitner. Pour un text donné, tu es capable de générer des questions et des réponses. 
                            Tu es attentif au nombre de question demandée par l'utilisateur
                            Utilisez un style formel en évitant les textes inutiles. 
                            Les questions commencent par Q: et les réponses sur la ligne suivante par R: 
                            Veuillez garder les réponses sous 10 mots maximum.
                    """
            },
            {
                "role": "user",
                "content": f"""Pour un texte donné ci-après, extrait une information éducative pertinente et 
                résume là sous forme d'une question et d'une réponse très courte pour alimenter 
                une boîte de Leitner; La réponse ne doit pas dépasser 10 mots; Format de la réponse 
                : Première ligne Q: ... et deuxième ligne R: ...; Texte à traiter : '{texte}';"""
                  
            }
        ],
        temperature=0.5 # Ajustez ce paramètre selon vos besoins
    )
    # print(response.choices[0].message.content)
    # paires_qr = extraire_qr_de_chatgpt(response.choices[0].message.content)
    # print(paires_qr)
    return response.choices[0].message.content
def processus_complet(id_youtube):
    """
    Combine l'obtention de la transcription YouTube et la génération de Q/R dans un seul processus.
    """
    transcription = obtenir_transcription(id_youtube)
    segments = decouper_texte_en_segments(transcription, longueur_max=1000)
    qr = generer_questions_reponses(segments[8])
    print(segments[8])
    # paires_qr = extraire_qr_de_chatgpt(qr)
    # leitner_system_test = LeitnerSystem()
    # result  = YouTubeTranscriptApi.get_transcript('d2lJUOv0hLA&t=65s', languages = ["fr"])
    # texte_continu = ' '.join([segment['text'] for segment in result]) # Concaténation de tous les segments de texte en une seule chaîne
    # segments = decouper_texte_en_segments(texte_continu, longueur_max=1000)
    # paires_qr = extraire_qr_de_chatgpt(generer_questions_reponses(segments[8]))
    # for question, reponse in paires_qr:
    #     leitner_system_test.add_card(question, reponse)
    return qr

# Creation/edition/Configuration de la boite de Leitner

def creer_boite_leitner():
    global leitner_system
    leitner_system = LeitnerSystem()
    return "Boîte de Leitner créée avec succès!"
def ajouter_cartes_leitner(texte_qr):
    """
    Extrait les paires de questions-réponses du texte et les ajoute à la boîte de Leitner.
    
    :param texte_qr: Le texte contenant les questions et réponses générées.
    :return: Un message confirmant l'ajout des cartes.
    """
    if leitner_system is None:
        return "Veuillez d'abord créer une boîte de Leitner."
    
    paires_qr = extraire_qr_de_chatgpt(texte_qr)
    if not paires_qr:
        return "Aucune paire Q/R n'a été trouvée dans le texte."
    
    for question, reponse in paires_qr:
        leitner_system.add_card(question, reponse)
    
    return f"{len(paires_qr)} cartes ajoutées à la boîte de Leitner."

# Utilisation et mise à jour de la boite de Leitner

def poser_question():
    global leitner_system
    if leitner_system is None or not leitner_system.compartments[0]:
        return "Aucune carte disponible pour le quiz.", ""
    
    carte = random.choice(leitner_system.compartments[0])
    leitner_system.derniere_question = carte
    return carte['question'], ""
def valider_reponse(user_answer):
    global leitner_system
    
    if leitner_system.derniere_question is None:
        return "Veuillez d'abord poser une question.", ""

    correct_answer = leitner_system.derniere_question['answer']
    
    # Utilise l'API d'OpenAI pour évaluer la similarité sémantique des réponses
    score = leitner_system.compare_semantic_similarity(correct_answer, user_answer)
    explanation = leitner_system.compare_semantic_similarity_explanation(correct_answer, user_answer)

    # Logique pour déplacer la carte en fonction de la réponse
    if float(score) > 5.0:
        result = f"Correct! Votre score de similarité : {score}\n{explanation}"
        # Déplacer la carte au prochain compartiment ou marquer comme maîtrisée
        # Cette partie dépend de la manière dont vous souhaitez gérer la progression dans les compartiments
    else:
        result = f"Incorrect. Votre score de similarité : {score}\n{explanation}"
        # Optionnellement, remettre la carte dans le premier compartiment ou gérer la répétition

    return result, ""