Update app.py

app.py

@@ -2281,27 +2281,126 @@ def display_page(pathname):
     running=[[Output("output-response", "children"), "", None]],
     prevent_initial_call=True,
 )
-def display_status(num, current, n_clicks, pathname):
+def display_status(num_bcc, current, n_clicks, pathname):
     if not n_clicks:
         return no_update, []
     
     if not current:
         print(f"Erreur: Il n'y a pas de fichier dans le répertoire.")
         return no_update, []
-    if not num:
+    if not num_bcc:
         print(f"Erreur: Il n'y a pas de nombre de BCC à générer.")
         return no_update, []
 
     current_url = current
     
     print(f"Fichier Maquette sélectionné: {current_url}")
-    agent = init_agent_state(current_url, num, pathname)
+    #agent = init_agent_state(current_url, num, pathname)
+    #try:
+    #    df = agent[0]
+    #    result = agent[1]
+    #    return html.Div(children=[dbc.Table.from_dataframe(df[["diplome", "RNCP", "Année d'étude", "Semestre", "BCC", "UE", "ECUE","exemple_situation_apprentissage"]], striped=True, bordered=True, hover=True, index=False), dcc.Markdown(f"""{result}""", style={"color":"white","font-size":"0.75rem"})]), []
+    #except:
+    #    return html.Div(dcc.Markdown(f"""{agent}""", style={"color":"white","font-size":"0.75rem"})), []
+    
+    # Charger le fichier CSV
     try:
-        df = agent[0]
-        result = agent[1]
-        return html.Div(children=[dbc.Table.from_dataframe(df[["diplome", "RNCP", "Année d'étude", "Semestre", "BCC", "UE", "ECUE","exemple_situation_apprentissage"]], striped=True, bordered=True, hover=True, index=False), dcc.Markdown(f"""{result}""", style={"color":"white","font-size":"0.75rem"})]), []
-    except:
-        return html.Div(dcc.Markdown(f"""{agent}""", style={"color":"white","font-size":"0.75rem"})), []
+        res = requests.get(current_url, headers=headers, params=params)
+        if res.status_code == 200:
+            #jsonData = json.loads(base64.b64decode(res.json()['content']))
+            #decoded_content = base64.b64decode(res.json()['content'])
+            decoded_content = res.text
+            df = pd.read_csv(io.StringIO(decoded_content), sep=',', encoding='utf-8')
+            #df["BCC"].fillna("BCC", inplace = True)
+            df = df.loc[:, 'diplome':'ECUE']
+            print(f"Colonnes disponibles: {df.columns.tolist()}")
+            df.fillna(value={"BCC": "BCC"})  # Remplacer les NaN par des chaînes vides
+            # Créer la colonne 'enseignements' selon les règles spécifiées
+            if 'UE' in df.columns and 'ECUE' in df.columns:
+                # Vérifier si la colonne ECUE a des valeurs non nulles
+                df['enseignements'] = np.where(
+                    df['ECUE'].notna() & (df['ECUE'] != ''),
+                    df['UE'] + ' - ' + df['ECUE'],
+                    df['BCC'] + ' - ' + df['UE'] if 'BCC' in df.columns else df['UE']
+                )
+            else:
+                # Fallback si les colonnes attendues n'existent pas
+                print("Attention: Colonnes UE/ECUE non trouvées. Vérifiez le format du fichier.")
+                raise ValueError("Format de fichier incorrect: colonnes UE/ECUE manquantes.")
+
+            print(f"Prétraitement réussi. {len(df)} lignes traitées.")
+
+    except Exception as e:
+        print(f"Erreur lors du chargement/prétraitement du fichier: {e}")
+        # Passer au fichier suivant en cas d'erreur
+    
+    unique_teachings = df['enseignements'].dropna().unique().tolist()
+
+    # Préparer le message pour le LLM
+    messages = [
+        SystemMessage(content=f"""Tu es un expert en sciences de l'éducation, spécialiste dans la catégorisation thématique de contenus pédagogiques, chargé de classifier des enseignements académiques, de créer des situations d'apprentissage puis de formuler de compétences académiques.
+        
+        Tu es en capacité de comprendre et de traiter des processus pédagogiques complexes, en passant OBLIGATOIREMENT par les 4 tâches suivantes:
+        
+        1. Dans ta première tâche, tu dois créer EXACTEMENT {num_bcc} catégories thématiques distinctes qui représentent au mieux les enseignements listés. Pour chaque catégorie, fournis un nom précis et représentatif de 20 mots minimum.
+        2. Ta deuxième tâche est de classer chaque enseignement dans l'une des {num_bcc} catégories créées dans la première tâche.
+        Chaque enseignement doit être classé dans UNE SEULE catégorie la plus pertinente.
+        Assure-toi que TOUS les enseignements sont classés et qu'aucun n'est oublié.
+        
+        3. Ta troisième tâche est de créer UNE situation d'apprentissage pour chaque catégorie, en intégrant les enseignements classés dans cette catégorie.
+        Pour chaque situation d'apprentissage :
+        - tu t'appuies sur la définition d'une situation d'apprentissage qui est un scénario pédagogique contextualisé qui place l'apprenant face à un défi concret nécessitant la mobilisation de savoirs, savoir-faire et savoir-être. Elle s'articule autour d'une problématique réelle, favorise l'interdisciplinarité et vise le développement de compétences transversales.
+        - tu appliques la méthode cohérente et détaillée qui : Intègre l'ensemble des enseignements de la catégorie fournie. Soit adaptée au niveau d'études supérieures. Comprenne un contexte, des objectifs, des activités et des modalités d'évaluation. Soit rédigée en 150-250 mots.
+        - Assure-toi qu'une situation d'apprentissage soit créée pour chaque catégorie et qu'aucune ne soit oubliée.
+        Tu Réponds en français avec un texte continu, bien structuré, sans titre ni puces.
+        
+        4. Ta quatrième tâche est de formuler UNE compétence académique pour chaque catégorie, en lien avec la situation d'apprentissage créée.
+        Pour chaque compétence académique :
+        - tu t'appuies sur la définition d'une compétence académique qui est une capacité avérée à mobiliser des ressources (savoirs, savoir-faire, savoir-être) dans une famille de situations complexes, pour résoudre des problèmes ou réaliser des tâches. Elle est formulée avec un verbe d'action, un objet, un contexte et un niveau de performance attendu. Elle s'inscrit dans une taxonomie (comme celle de Bloom) et peut être évaluée à travers des indicateurs observables.
+        - tu prends comme exemple les formulations suivantes : "Analyser des problèmes complexes en mobilisant des approches multidisciplinaires pour proposer des solutions innovantes", "Concevoir et mettre en œuvre des projets de recherche en respectant les normes éthiques et méthodologiques du domaine", "Interpréter des données scientifiques pour prendre des décisions éclairées dans un contexte d'incertitude".
+        - tu utilises les niveaux taxonomiques de Bloom appropriés au niveau d'étude : Licence 1-2 (se concentrer sur "se rappeler", "comprendre", "appliquer"), Licence 3/BUT (privilégier "appliquer", "analyser"), Master (privilégier "analyser", "évaluer", "créer").
+        - tu appliques la méthode cohérente et détaillée qui : Synthétise l'ensemble des enseignements de la catégorie fournie. S'articule avec la situation d'apprentissage associée. Soit précise, mesurable et pertinente pour le domaine d'études. Comporte entre 15 et 25 mots.
+        - tu réponds avec une seule phrase complète, sans préambule ni explications.
+        - Assure-toi qu'une compétence académique soit formulée pour chaque catégorie et qu'aucune ne soit oubliée.
+        
+        Réponds UNIQUEMENT au format JSON avec la structure suivante:
+        [
+            {{
+                "catégorie": "Nom de la catégorie 1",
+                "situation": "Texte de la situation d'apprentissage associée à la catégorie 1 (150-250 mots)",
+                "compétence": "Texte de la compétence académique associée à la catégorie 1 (15-25 mots)"
+            }},
+            ...
+        ]
+        """),
+        HumanMessage(content=f"Voici la liste des enseignements à catégoriser: {json.dumps(unique_teachings, ensure_ascii=False)}")
+    ]
+
+    try:
+        # Obtenir la réponse du LLM
+        response = llm.invoke(messages)
+
+        # Extraire le JSON de la réponse
+        content = response.content
+
+        # Nettoyer la réponse si nécessaire (enlever les ```json et ```)
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].split("```")[0].strip()
+
+        # Parser le JSON
+        categories = json.loads(content)
+        print(categories)
+        print("Catégories thématiques créées avec succès:")
+        for idx, cat in enumerate(categories, 1):
+            print(f"{idx}. {cat['nom']} - {cat['description'][:50]}...")
+
+        # Mettre à jour l'état avec les catégories générées
+        return html.Div(children=[dbc.Table.from_dataframe(df[["diplome", "RNCP", "Année d'étude", "Semestre", "BCC", "UE", "ECUE","exemple_situation_apprentissage"]], striped=True, bordered=True, hover=True, index=False), dcc.Markdown(f"""{content}""", style={"color":"white","font-size":"0.75rem"})]), []
+
+    except Exception as e:
+        print(f"Erreur lors de la création des catégories: {e}")
     
 @callback(
     Output("output-response-avid", "children"),