Update modules/text_analysis/semantic_analysis.py

modules/text_analysis/semantic_analysis.py

@@ -1,19 +1,27 @@
 # modules/text_analysis/semantic_analysis.py
-# [Mantener todas las importaciones y constantes existentes...]
 
+# 1. Importaciones estándar del sistema
+import logging
+import io
+import base64
+from collections import Counter, defaultdict
+
+# 2. Importaciones de terceros
 import streamlit as st
 import spacy
 import networkx as nx
 import matplotlib.pyplot as plt
-import io
-import base64
-from collections import Counter, defaultdict
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 
-import logging
+# 3. Configuración del logger
 logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 
+# 4. Importaciones locales
 from .stopwords import (
     process_text,
     get_custom_stopwords,
@@ -77,15 +85,21 @@ ENTITY_LABELS = {
     }
 }
 
+def fig_to_bytes(fig):
+    """Convierte una figura de matplotlib a bytes."""
+    try:
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+        buf.seek(0)
+        return buf.getvalue()
+    except Exception as e:
+        logger.error(f"Error en fig_to_bytes: {str(e)}")
+        return None
+        
+###########################################################
 def perform_semantic_analysis(text, nlp, lang_code):
     """
     Realiza el análisis semántico completo del texto.
-    Args:
-        text: Texto a analizar
-        nlp: Modelo de spaCy
-        lang_code: Código del idioma
-    Returns:
-        dict: Resultados del análisis
     """
     try:
         logger.info(f"Starting semantic analysis for language: {lang_code}")
@@ -95,28 +109,58 @@ def perform_semantic_analysis(text, nlp, lang_code):
         tokens = process_text(text, lang_code, nlp)
         
         # Identificar conceptos clave
-        key_concepts = identify_key_concepts(doc, stopwords=get_custom_stopwords(lang_code))
+        logger.info("Identificando conceptos clave...")
+        stopwords = get_custom_stopwords(lang_code)
+        key_concepts = identify_key_concepts(doc, stopwords=stopwords)
         
-        # Crear y visualizar grafo de conceptos
+        if not key_concepts:
+            logger.warning("No se identificaron conceptos clave")
+            return {
+                'success': False,
+                'error': 'No se pudieron identificar conceptos clave'
+            }
+        
+        # Crear grafo de conceptos
+        logger.info("Creando grafo de conceptos...")
         concept_graph = create_concept_graph(doc, key_concepts)
+        
+        # Visualizar grafo
+        logger.info("Visualizando grafo...")
+        plt.clf()  # Limpiar figura actual
         concept_graph_fig = visualize_concept_graph(concept_graph, lang_code)
-
-        # Convertir figura a bytes
-        concept_graph_bytes = fig_to_bytes(concept_graph_fig)
-
-        logger.info("Semantic analysis completed successfully")
+        
+        # Convertir a bytes
+        logger.info("Convirtiendo grafo a bytes...")
+        graph_bytes = fig_to_bytes(concept_graph_fig)
+        
+        if not graph_bytes:
+            logger.error("Error al convertir grafo a bytes")
+            return {
+                'success': False,
+                'error': 'Error al generar visualización'
+            }
+        
+        # Limpiar recursos
+        plt.close(concept_graph_fig)
+        plt.close('all')
+        
+        logger.info("Análisis semántico completado exitosamente")
         return {
             'success': True,
             'key_concepts': key_concepts,
-            'concept_graph': concept_graph_bytes,
+            'concept_graph': graph_bytes
         }
+        
     except Exception as e:
         logger.error(f"Error in perform_semantic_analysis: {str(e)}")
+        plt.close('all')  # Asegurarse de limpiar recursos
         return {
             'success': False,
             'error': str(e)
         }
 
+############################################################ 
+
 def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
     """
     Identifica conceptos clave en el texto.
@@ -144,20 +188,7 @@ def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
         logger.error(f"Error en identify_key_concepts: {str(e)}")
         return []
 
-def fig_to_bytes(fig):
-    buf = io.BytesIO()
-    fig.savefig(buf, format='png')
-    buf.seek(0)
-    return buf.getvalue()
-
-
-def fig_to_html(fig):
-    buf = io.BytesIO()
-    fig.savefig(buf, format='png')
-    buf.seek(0)
-    img_str = base64.b64encode(buf.getvalue()).decode()
-    return f'<img src="data:image/png;base64,{img_str}" />'
-
+########################################################################
 def create_concept_graph(doc, key_concepts):
     """
     Crea un grafo de relaciones entre conceptos.
@@ -203,26 +234,27 @@ def create_concept_graph(doc, key_concepts):
         # Retornar un grafo vacío en caso de error
         return nx.Graph()
 
+###############################################################################
 def visualize_concept_graph(G, lang_code):
     """
     Visualiza el grafo de conceptos.
-    Args:
-        G: Grafo de networkx
-        lang_code: Código del idioma
-    Returns:
-        matplotlib.figure.Figure: Figura con el grafo visualizado
     """
     try:
-        plt.figure(figsize=(12, 8))
+        # Crear nueva figura
+        fig = plt.figure(figsize=(12, 8))
         
-        # Calcular el layout del grafo
-        pos = nx.spring_layout(G)
+        if not G.nodes():
+            logger.warning("Grafo vacío, retornando figura vacía")
+            return fig
+            
+        # Calcular layout
+        pos = nx.spring_layout(G, k=1, iterations=50)
         
-        # Obtener pesos de nodos y aristas
+        # Obtener pesos
         node_weights = [G.nodes[node].get('weight', 1) * 500 for node in G.nodes()]
         edge_weights = [G[u][v].get('weight', 1) for u, v in G.edges()]
         
-        # Dibujar el grafo
+        # Dibujar grafo
         nx.draw_networkx_nodes(G, pos, 
                              node_size=node_weights,
                              node_color='lightblue',
@@ -240,13 +272,14 @@ def visualize_concept_graph(G, lang_code):
         plt.title("Red de conceptos relacionados")
         plt.axis('off')
         
-        return plt.gcf()
+        return fig
         
     except Exception as e:
         logger.error(f"Error en visualize_concept_graph: {str(e)}")
-        # Retornar una figura vacía en caso de error
-        return plt.figure()
+        return plt.figure()  # Retornar figura vacía en caso de error
 
+
+########################################################################
 def create_entity_graph(entities):
     G = nx.Graph()
     for entity_type, entity_list in entities.items():
@@ -257,6 +290,8 @@ def create_entity_graph(entities):
                 G.add_edge(entity1, entity2)
     return G
 
+
+#############################################################
 def visualize_entity_graph(G, lang_code):
     fig, ax = plt.subplots(figsize=(12, 8))
     pos = nx.spring_layout(G)
@@ -332,14 +367,7 @@ __all__ = [
     'identify_key_concepts',
     'create_concept_graph',
     'visualize_concept_graph',
-    'create_entity_graph',
-    'visualize_entity_graph',
-    'generate_summary',
-    'extract_entities',
-    'analyze_sentiment',
-    'create_topic_graph',
-    'visualize_topic_graph',
-    'extract_topics',
+    'fig_to_bytes'
     'ENTITY_LABELS',
     'POS_COLORS',
     'POS_TRANSLATIONS'