renaming main file frontend to app.py

app.py

@@ -1,262 +1,7 @@
-# import gradio as gr
-# from youtube_transcript_api import YouTubeTranscriptApi
-
-
-from openai import OpenAI
-import os
-from dotenv import load_dotenv
-from youtube_transcript_api import YouTubeTranscriptApi
 import gradio as gr
+from fonctions import obtenir_transcription, processus_complet, creer_boite_leitner, ajouter_cartes_leitner, poser_question, valider_reponse
+from classes import LeitnerSystem
 
-# Load environment variables from .env file
-load_dotenv()
-
-
-OpenAI.api_key = os.getenv('OPENAI_API_KEY')
-client = OpenAI()
-
-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
-
-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 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."
-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
-
-client = OpenAI()
-
-class LeitnerSystem:
-    def __init__(self):
-        self.compartments = [[], [], [], []]  # Quatre compartiments pour cet exemple
-        
-    def add_card(self, question, answer):
-        self.compartments[0].append({'question': question, 'answer': answer})
-    def compare_semantic_similarity(self, correct_answer, user_answer):
-            """Utilise l'API d'OpenAI pour comparer la similarité sémantique des réponses."""
-            client = OpenAI()
-            try:
-                
-                response = client.chat.completions.create(
-                    model="gpt-4",  # Utilisez "gpt-4" si vous avez accès à GPT-4
-                    messages=[
-                        {"role": "system", "content": "Vous êtes un assistant hautement intelligent capable d'évaluer la similarité sémantique entre deux phrases en fournissant une valeur de 0 à 10. X est un entier."},
-                        {"role": "user", "content": f"""
-                         Évaluez la similarité sémantique entre ces deux phrases en fournissant une note sur 10. 
-                         Exemple : 7. Cette avaleur est un entier  
-                         Phrase 1: '{correct_answer}'. Phrase 2: '{user_answer}'."
-                         """}
-                    ],   
-                    temperature=0.5,
-                    max_tokens=600,
-                    # seed=10
-                )
-
-                score = response.choices[0].message.content
-                # print(score)
-                    # Utilisation d'une expression régulière pour extraire le score numérique
-                # score, analysis = self.extract_score_and_explanation(full_response)
-                
-                return score
-            except Exception as e:
-                print("Erreur lors de l'évaluation de la similarité :", e)
-                return "0", str(e)
-        
-    def compare_semantic_similarity_explanation(self, correct_answer, user_answer):
-            """Utilise l'API d'OpenAI pour comparer la similarité sémantique des réponses."""
-            client = OpenAI()
-            try:
-                response = client.chat.completions.create(
-                    model="gpt-4",  # Utilisez "gpt-4" si vous avez accès à GPT-4
-                    messages=[
-                        {"role": "system", "content": "Vous êtes un assistant hautement intelligent capable d'évaluer la similarité sémantique entre deux phrases"},
-                        {"role": "user", "content": f"Évaluez la similarité sémantique entre ces deux phrases en fournissant un explication en français. Les aspects positifs de la réponse, et les aspects négatifs. Phrase 1: '{correct_answer}'. Phrase 2: '{user_answer}'."}
-                    ],   
-                    temperature=0.5,
-                    max_tokens=600,
-                    # seed=10
-                )
-
-                explanation = response.choices[0].message.content
-                # print(explanation)
-                    # Utilisation d'une expression régulière pour extraire le score numérique
-                # score, analysis = self.extract_score_and_explanation(full_response)
-                
-                return explanation
-            except Exception as e:
-                print("Erreur lors de l'évaluation de la similarité :", e)
-                return "0", str(e)   
-    
-def creer_boite_leitner():
-    global leitner_system
-    leitner_system = LeitnerSystem()
-    return "Boîte de Leitner créée avec succès!"
-
-
-
-import random
-
-# Ajout d'un attribut pour stocker la dernière question posée
-LeitnerSystem.derniere_question = None
-
-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, ""
 
 with gr.Blocks() as demo:
     with gr.Row():
@@ -296,5 +41,6 @@ with gr.Blocks() as demo:
 
     # createLeitnerBox_btn.click(createLeitnerBox_btn)
 
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

frontend.py

@@ -1,46 +0,0 @@
-import gradio as gr
-from fonctions import obtenir_transcription, processus_complet, creer_boite_leitner, ajouter_cartes_leitner, poser_question, valider_reponse
-from classes import LeitnerSystem
-
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        id_youtube_input = gr.Textbox(label="ID YouTube", value="a6Sfpbjz68k&t=365s")
-    with gr.Row():
-        transcript_btn = gr.Button("Générer transcription")
-        generer_btn = gr.Button("Générer Q/R")
-    with gr.Row():
-        txtB_transcript = gr.Textbox(label= "transcription", lines = 4)
-        sortie = gr.Textbox(label="Questions/Réponses", lines=4)   
-    with gr.Row():    
-        createLeitnerBox_btn = gr.Button("Créer une boite de Leitner") 
-        ajouter_cartes_btn = gr.Button("Ajouter les cartes") 
-    with gr.Row():
-        leitner_box_status = gr.Textbox(label="Statut de la boîte de Leitner") 
-        ajout_cartes_status = gr.Textbox(label="Statut d'ajout des cartes")   
-    with gr.Row():     
-        # Ajout_des_cartes_btn = gr.Button("Ajout des cartes")
-        poser_question_btn = gr.Button("Poser une Question")
-        question_affichee = gr.Textbox(label="Question")
-    with gr.Row():
-        valider_reponse_btn = gr.Button("Valider la Réponse")
-        reponse_utilisateur = gr.Textbox(label="Votre Réponse")
-    with gr.Row():    
-        resultat_quiz = gr.Textbox(label="Résultat")
-
-# charger contenu    
-    transcript_btn.click(obtenir_transcription,inputs = id_youtube_input, outputs = txtB_transcript)
-    generer_btn.click(processus_complet, inputs=id_youtube_input, outputs=sortie)
-# charger box
-    createLeitnerBox_btn.click(creer_boite_leitner, inputs=None, outputs=leitner_box_status)
-# charger carte dans box
-    ajouter_cartes_btn.click(ajouter_cartes_leitner, inputs=sortie, outputs=ajout_cartes_status)
-# Quizz et evaluation + mise à jour de la box
-    poser_question_btn.click(poser_question, inputs=None, outputs=[question_affichee, reponse_utilisateur])
-    valider_reponse_btn.click(valider_reponse, inputs=reponse_utilisateur, outputs=resultat_quiz)
-
-    # createLeitnerBox_btn.click(createLeitnerBox_btn)
-
-
-if __name__ == "__main__":
-    demo.launch()