Update utils_gdmk.py

utils_gdmk.py

@@ -1,71 +1,162 @@
 import networkx as nx
 import matplotlib.pyplot as plt
 import json
-import textwrap
 import requests
 import pandas as pd
 import os
+import gradio as gr
+import openai
+import scipy as sp
 
-api_key = os.getenv("AIRT_KEY")
-AIRT_DBASEx = os.getenv("AIRT_DBASE")
-AIRT_TABLEx = os.getenv("AIRT_TABLE")
+# Load OpenAI API Key
+API_KEY = os.getenv("OAIK")
+client = openai.OpenAI(api_key=API_KEY)
 
-G = nx.DiGraph()
+api_key_airt = os.getenv("AIRT_KEY")
+AIRT_DBASE = 'appUuBVTJR5ju0y6J'
+AIRT_TABLE = 'foros_postdoc'
 
-url = f"https://api.airtable.com/v0/{AIRT_DBASEx}/{AIRT_TABLEx}"
+url = f"https://api.airtable.com/v0/{AIRT_DBASE}/{AIRT_TABLE}"
 headers = {
-    "Authorization": f"Bearer {api_key}",
+    "Authorization": f"Bearer {api_key_airt}",
     "Content-Type": "application/json"
 }
 
+# Sample vocabulary for concept extraction
+VOCABULARY = ["algoritmos", "inteligencia artificial", "políticas públicas", 
+              "educación a distancia", "gobernanza", "educación superior"]
+
+def cargar_nombres(archivo):
+    with open('nombres_postdoc.txt', "r", encoding="utf-8") as f:
+        students = [line.strip() for line in f if line.strip()]  # Eliminar espacios y líneas vacías
+    return students
+
+students = cargar_nombres("nombres.txt")
+
+G = nx.DiGraph()
+
+def extract_concepts(text):
+
+    instrucciones = "Eres un experto en educación superior a distancia con conocimiento de políticas públicas, \
+                    tanto para educación superior como la adopción de inteligencia artificial"
+    prompt = f"""Dado el siguiente mensaje: '{text}', utilizando como base esta lista,  {VOCABULARY}, genera una lista corta de los términos \
+                coincidentes con la lista larga separados por comas."""
+
+    version_model = 'gpt-3.5-turbo-0125'
+    response = client.chat.completions.create(
+        model=version_model,
+        messages=[{"role": "system", "content": instrucciones},
+                  {"role": "user", "content": prompt}],
+        temperature=0.8,
+        max_tokens=300,
+    )
+    extract_concepts = response.choices[0].message.content.split(',')
+    return extract_concepts
+
 def cargar_desde_airtable():
-    response = requests.get(url, headers=headers)
-    
+    response = requests.get(url, headers=headers)    
     if response.status_code != 200:
         print(f"Error: {response.status_code} - {response.text}")
         return pd.DataFrame(columns=["Nombre", "Conceptos"])
+    
     records = response.json().get("records", [])
-    aportes = [
-        [record["fields"].get("Nombre", ""), 
-         record["fields"].get("Conceptos", "")] for record in records
-    ]
-    return pd.DataFrame(aportes, columns=["Nombre", "Conceptos"])
+    aportes = []
+    
+    for record in records:
+        nombre = record["fields"].get("Nombre", "").strip()
+        conceptos = record["fields"].get("Conceptos", "").strip()
+        aportes.append([nombre, conceptos])
+
+    df = pd.DataFrame(aportes, columns=["Nombre", "Conceptos"])
+    
+    print("Loaded Airtable Data:")
+    print(df)  # 🔍 Debugging: Print the loaded data
+    return df
 
 def inicializar_grafo():
     df = cargar_desde_airtable()
+    
     for _, row in df.iterrows():
-        nombre, conceptos = row["Nombre"], row["Conceptos"]
-        for termino in conceptos:
-            if not G.has_node(termino):
-                G.add_node(termino, color='gray')
-            if not G.has_edge(nombre, termino):
-                G.add_edge(norma, enfoque)
-
-def guardar_en_airtable(nombre, conceptos): 
-    data = {"fields": {"Nombre": nombre, "Conceptos": conceptos}}
-    requests.post(url, headers=headers, json=data)
-
-def agregar_aporte(nombre, enfoque, norma, texto):
-    textox = wrap_text(f"{nombre}: {texto}")
+        nombre = row["Nombre"].strip()
+        conceptos = row["Conceptos"].strip()
     
-    if not G.has_node(norma):
-        G.add_node(norma, color='gray')
-    if not G.has_edge(norma, enfoque):
-        G.add_edge(norma, enfoque, label=textox)
-
-    guardar_en_airtable(nombre, enfoque, norma, texto)  
-    return visualizar_grafo()
+        if not nombre or not conceptos:
+            continue  # Skip empty rows
+    
+        # ✅ Ensure name is added as a node first
+        if not G.has_node(nombre):
+            G.add_node(nombre, color='lightblue')
+    
+        for termino in conceptos.split(','):
+            termino = termino.strip()
+            if termino:  # ✅ Fix empty terms issue
+                if not G.has_node(termino):
+                    G.add_node(termino, color='lightgreen')
+                if not G.has_edge(nombre, termino):
+                    G.add_edge(nombre, termino)
+    
+    # print("✅ Graph Nodes:", list(G.nodes))
+    # print("✅ Graph Edges:", list(G.edges))
 
 def visualizar_grafo():
     plt.figure(figsize=(10, 6))
-    pos = nx.spring_layout(G)
 
-    edge_labels = nx.get_edge_attributes(G, 'label')
+    if len(G.nodes) == 0:
+        print("⚠️ Warning: The graph is empty! Check if data was loaded correctly.")
+        plt.text(0.5, 0.5, "No data available", fontsize=12, ha='center')
+        plt.savefig("graph.png")
+        plt.close()
+        return "graph.png"
+
+    centrality = nx.betweenness_centrality(G)
+    pos = nx.kamada_kawai_layout(G)
+    node_colors = []
+    node_sizes = []
     
-    nx.draw(G, pos, with_labels=True, node_color='lightblue', edge_color='gray', node_size=2000, font_size=10)
+    for node in G.nodes():
+        if node in students:  # Si es un estudiante
+            node_colors.append('lightblue')  # 🔵 Color para nombres
+        else:
+            node_colors.append('lightgreen')  # 🟢 Color para conceptos
+        
+        node_sizes.append(2000 + 8000 * centrality.get(node, 0)) 
+    nx.draw(
+        G, pos, with_labels=True, node_color=node_colors, edge_color='gray',
+        node_size=node_sizes, font_size=10
+    )
+    edge_labels = nx.get_edge_attributes(G, 'label')
     nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
-
-    plt.title("Red de Aportes")
+    plt.title("Red de Aportes - Optimizada por Betweenness")
     plt.savefig("graph.png")
     plt.close()
     return "graph.png"
+
+def guardar_en_airtable(nombre, conceptos, texto): 
+    if isinstance(conceptos, str):
+        conceptos = [c.strip() for c in conceptos.split(',') if c.strip()]  # Ensure it's a list
+    data = {"fields": {"Nombre": nombre, "Conceptos": ", ".join(conceptos), "Texto_Aporte": texto}}
+    response = requests.post(url, headers=headers, json=data)
+    if response.status_code != 200:
+        print(f"Error saving to Airtable: {response.status_code} - {response.text}")
+
+def agregar_aporte(nombre, texto):
+    conceptos = extract_concepts(texto)  # ✅ Extract concepts dynamically
+    print(f"Extracted Concepts: {conceptos}")  # 🔍 Debugging
+
+    if not G.has_node(nombre):
+        G.add_node(nombre, color='gray')
+    
+    for termino in conceptos:
+        termino = termino.strip()
+        if not G.has_node(termino):
+            G.add_node(termino, color='gray')
+        if not G.has_edge(nombre, termino):
+            G.add_edge(nombre, termino)
+
+    guardar_en_airtable(nombre, conceptos, texto)  
+    return visualizar_grafo()
+
+def reload_data():
+    """Reloads data from Airtable and updates the graph."""
+    inicializar_grafo()  # Fetch fresh data and rebuild the graph
+    return visualizar_grafo()  # Return updated image