Update modules/text_analysis/semantic_analysis.py

modules/text_analysis/semantic_analysis.py

@@ -82,6 +82,7 @@ ENTITY_LABELS = {
     }
 }
 
+###########################################################
 def fig_to_bytes(fig):
     """Convierte una figura de matplotlib a bytes."""
     try:
@@ -284,65 +285,63 @@ def create_concept_graph(doc, key_concepts):
 ###############################################################################
 
 def visualize_concept_graph(G, lang_code):
-    """
-    Visualiza el grafo de conceptos con layout consistente.
-    Args:
-        G: networkx.Graph - Grafo de conceptos
-        lang_code: str - Código del idioma
-    Returns:
-        matplotlib.figure.Figure - Figura del grafo
-    """
     try:
-        # Crear nueva figura con mayor tamaño y definir los ejes explícitamente
+        # 1. Diccionario de traducciones
+        GRAPH_LABELS = {
+            'es': {
+                'concept_network': 'Relaciones entre conceptos clave',
+                'concept_centrality': 'Centralidad de conceptos clave'
+            },
+            'en': {
+                'concept_network': 'Relationships between key concepts',
+                'concept_centrality': 'Concept centrality'
+            },
+            'fr': {
+                'concept_network': 'Relations entre concepts clés',
+                'concept_centrality': 'Centralité des concepts'
+            },
+            'pt': {
+                'concept_network': 'Relações entre conceitos-chave',
+                'concept_centrality': 'Centralidade dos conceitos'
+            }
+        }
+
+        # 2. Obtener traducciones (inglés por defecto)
+        translations = GRAPH_LABELS.get(lang_code, GRAPH_LABELS['en'])
+        
+        # Configuración de la figura
         fig, ax = plt.subplots(figsize=(15, 10))
         
         if not G.nodes():
             logger.warning("Grafo vacío, retornando figura vacía")
             return fig
             
-        # Convertir grafo no dirigido a dirigido para mostrar flechas
+        # Convertir a grafo dirigido para flechas
         DG = nx.DiGraph(G)
-        
-        # Calcular centralidad de los nodos para el color
         centrality = nx.degree_centrality(G)
         
-        # Establecer semilla para reproducibilidad
-        seed = 42
-        
-        # Calcular layout con parámetros fijos
-        pos = nx.spring_layout(
-            DG,
-            k=2,          # Distancia ideal entre nodos
-            iterations=50, # Número de iteraciones
-            seed=seed     # Semilla fija para reproducibilidad
-        )
+        # Layout consistente
+        pos = nx.spring_layout(DG, k=2, iterations=50, seed=42)
         
-        # Calcular factor de escala basado en número de nodos
+        # Escalado de elementos visuales
         num_nodes = len(DG.nodes())
         scale_factor = 1000 if num_nodes < 10 else 500 if num_nodes < 20 else 200
-        
-        # Obtener pesos ajustados
-        node_weights = [DG.nodes[node].get('weight', 1) * scale_factor for node in DG.nodes()]
-        edge_weights = [DG[u][v].get('weight', 1) for u, v in DG.edges()]
-        
-        # Crear mapa de colores basado en centralidad
+        node_sizes = [DG.nodes[node].get('weight', 1) * scale_factor for node in DG.nodes()]
+        edge_widths = [DG[u][v].get('weight', 1) for u, v in DG.edges()]
         node_colors = [plt.cm.viridis(centrality[node]) for node in DG.nodes()]
         
-        # Dibujar nodos
-        nodes = nx.draw_networkx_nodes(
-            DG, 
-            pos, 
-            node_size=node_weights,
+        # Dibujar elementos del grafo
+        nx.draw_networkx_nodes(
+            DG, pos, 
+            node_size=node_sizes,
             node_color=node_colors,
             alpha=0.7,
             ax=ax
         )
         
-        # Dibujar aristas con flechas
-        edges = nx.draw_networkx_edges(
-            DG, 
-            pos,
-            width=edge_weights,
+        nx.draw_networkx_edges(
+            DG, pos,
+            width=edge_widths,
             alpha=0.6,
             edge_color='gray',
             arrows=True,
@@ -352,42 +351,34 @@ def visualize_concept_graph(G, lang_code):
             ax=ax
         )
         
-        # Ajustar tamaño de fuente según número de nodos
+        # Etiquetas de nodos
         font_size = 12 if num_nodes < 10 else 10 if num_nodes < 20 else 8
-        
-        # Dibujar etiquetas con fondo blanco para mejor legibilidad
-        labels = nx.draw_networkx_labels(
-            DG, 
-            pos,
+        nx.draw_networkx_labels(
+            DG, pos,
             font_size=font_size,
             font_weight='bold',
-            bbox=dict(
-                facecolor='white', 
-                edgecolor='none', 
-                alpha=0.7
-            ),
+            bbox=dict(facecolor='white', edgecolor='none', alpha=0.7),
             ax=ax
         )
         
-        # Añadir leyenda de centralidad
+        # Barra de color (centralidad)
         sm = plt.cm.ScalarMappable(
             cmap=plt.cm.viridis, 
             norm=plt.Normalize(vmin=0, vmax=1)
         )
         sm.set_array([])
-        plt.colorbar(sm, ax=ax, label='Centralidad del concepto')
+        plt.colorbar(sm, ax=ax, label=translations['concept_centrality'])
         
-        plt.title("Red de conceptos relacionados", pad=20, fontsize=14)
+        # Título del gráfico
+        plt.title(translations['concept_network'], pad=20, fontsize=14)
         ax.set_axis_off()
-        
-        # Ajustar el layout para que la barra de color no se superponga
         plt.tight_layout()
         
         return fig
         
     except Exception as e:
         logger.error(f"Error en visualize_concept_graph: {str(e)}")
-        return plt.figure()  # Retornar figura vacía en caso de error
+        return plt.figure()
 
 ########################################################################
 def create_entity_graph(entities):