Delete modules/text_analysis/semantic_analysis.py

modules/text_analysis/semantic_analysis.py

@@ -1,486 +0,0 @@
-# modules/text_analysis/semantic_analysis.py
-
-# 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
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-
-# Solo configurar si no hay handlers ya configurados
-logger = logging.getLogger(__name__)
-    
-# 4. Importaciones locales
-from .stopwords import (
-    process_text,
-    clean_text,
-    get_custom_stopwords,
-    get_stopwords_for_spacy
-)
-
-
-# Define colors for grammatical categories
-POS_COLORS = {
-    'ADJ': '#FFA07A', 'ADP': '#98FB98', 'ADV': '#87CEFA', 'AUX': '#DDA0DD',
-    'CCONJ': '#F0E68C', 'DET': '#FFB6C1', 'INTJ': '#FF6347', 'NOUN': '#90EE90',
-    'NUM': '#FAFAD2', 'PART': '#D3D3D3', 'PRON': '#FFA500', 'PROPN': '#20B2AA',
-    'SCONJ': '#DEB887', 'SYM': '#7B68EE', 'VERB': '#FF69B4', 'X': '#A9A9A9',
-}
-
-POS_TRANSLATIONS = {
-    'es': {
-        'ADJ': 'Adjetivo', 'ADP': 'Preposición', 'ADV': 'Adverbio', 'AUX': 'Auxiliar',
-        'CCONJ': 'Conjunción Coordinante', 'DET': 'Determinante', 'INTJ': 'Interjección',
-        'NOUN': 'Sustantivo', 'NUM': 'Número', 'PART': 'Partícula', 'PRON': 'Pronombre',
-        'PROPN': 'Nombre Propio', 'SCONJ': 'Conjunción Subordinante', 'SYM': 'Símbolo',
-        'VERB': 'Verbo', 'X': 'Otro',
-    },
-    'en': {
-        'ADJ': 'Adjective', 'ADP': 'Preposition', 'ADV': 'Adverb', 'AUX': 'Auxiliary',
-        'CCONJ': 'Coordinating Conjunction', 'DET': 'Determiner', 'INTJ': 'Interjection',
-        'NOUN': 'Noun', 'NUM': 'Number', 'PART': 'Particle', 'PRON': 'Pronoun',
-        'PROPN': 'Proper Noun', 'SCONJ': 'Subordinating Conjunction', 'SYM': 'Symbol',
-        'VERB': 'Verb', 'X': 'Other',
-    },
-    'fr': {
-        'ADJ': 'Adjectif', 'ADP': 'Préposition', 'ADV': 'Adverbe', 'AUX': 'Auxiliaire',
-        'CCONJ': 'Conjonction de Coordination', 'DET': 'Déterminant', 'INTJ': 'Interjection',
-        'NOUN': 'Nom', 'NUM': 'Nombre', 'PART': 'Particule', 'PRON': 'Pronom',
-        'PROPN': 'Nom Propre', 'SCONJ': 'Conjonction de Subordination', 'SYM': 'Symbole',
-        'VERB': 'Verbe', 'X': 'Autre',
-    }
-}
-
-ENTITY_LABELS = {
-    'es': {
-        "Personas": "lightblue",
-        "Lugares": "lightcoral",
-        "Inventos": "lightgreen",
-        "Fechas": "lightyellow",
-        "Conceptos": "lightpink"
-    },
-    'en': {
-        "People": "lightblue",
-        "Places": "lightcoral",
-        "Inventions": "lightgreen",
-        "Dates": "lightyellow",
-        "Concepts": "lightpink"
-    },
-    'fr': {
-        "Personnes": "lightblue",
-        "Lieux": "lightcoral",
-        "Inventions": "lightgreen",
-        "Dates": "lightyellow",
-        "Concepts": "lightpink"
-    }
-}
-
-#################################################################################
-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, semantic_t):
-    """
-    Realiza el análisis semántico completo del texto.
-    """
-    if not text or not nlp or not lang_code:
-        logger.error("Parámetros inválidos para el análisis semántico")
-        return {
-            'success': False,
-            'error': 'Parámetros inválidos'
-        }
-        
-    try:
-        logger.info(f"Starting semantic analysis for language: {lang_code}")
-        
-        # Procesar texto y remover stopwords
-        doc = nlp(text)
-        if not doc:
-            logger.error("Error al procesar el texto con spaCy")
-            return {
-                'success': False,
-                'error': 'Error al procesar el texto'
-            }
-        
-        # Identificar conceptos clave
-        logger.info("Identificando conceptos clave...")
-        stopwords = get_custom_stopwords(lang_code)
-        key_concepts = identify_key_concepts(doc, stopwords=stopwords)
-        
-        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(f"Creando grafo de conceptos con {len(key_concepts)} conceptos...")
-        concept_graph = create_concept_graph(doc, key_concepts)
-        
-        if not concept_graph.nodes():
-            logger.warning("Se creó un grafo vacío")
-            return {
-                'success': False,
-                'error': 'No se pudo crear el grafo de conceptos'
-            }
-        
-        # Visualizar grafo
-        logger.info("Visualizando grafo...")
-        plt.clf()  # Limpiar figura actual
-        
-        concept_graph_fig = visualize_concept_graph(concept_graph, lang_code, semantic_t)
-        
-        # 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')
-        
-        result = {
-            'success': True,
-            'key_concepts': key_concepts,
-            'concept_graph': graph_bytes
-        }
-        
-        logger.info("Análisis semántico completado exitosamente")
-        return result
-        
-    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)
-        }
-    finally:
-        plt.close('all')  # Asegurar limpieza incluso si hay error
-
-############################################################ 
-
-def identify_key_concepts(doc, stopwords, min_freq=2, min_length=3):
-    """
-    Identifica conceptos clave en el texto, excluyendo entidades nombradas.
-    Args:
-        doc: Documento procesado por spaCy
-        stopwords: Lista de stopwords
-        min_freq: Frecuencia mínima para considerar un concepto
-        min_length: Longitud mínima del concepto
-    Returns:
-        List[Tuple[str, int]]: Lista de tuplas (concepto, frecuencia)
-    """
-    try:
-        word_freq = Counter()
-        
-        # Crear conjunto de tokens que son parte de entidades
-        entity_tokens = set()
-        for ent in doc.ents:
-            entity_tokens.update(token.i for token in ent)
-        
-        # Procesar tokens
-        for token in doc:
-            # Verificar si el token no es parte de una entidad nombrada
-            if (token.i not in entity_tokens and  # No es parte de una entidad
-                token.lemma_.lower() not in stopwords and  # No es stopword
-                len(token.lemma_) >= min_length and  # Longitud mínima
-                token.is_alpha and  # Es alfabético
-                not token.is_punct and  # No es puntuación
-                not token.like_num and  # No es número
-                not token.is_space and  # No es espacio
-                not token.is_stop and  # No es stopword de spaCy
-                not token.pos_ == 'PROPN' and  # No es nombre propio
-                not token.pos_ == 'SYM' and  # No es símbolo
-                not token.pos_ == 'NUM' and  # No es número
-                not token.pos_ == 'X'):  # No es otro
-                
-                # Convertir a minúsculas y añadir al contador
-                word_freq[token.lemma_.lower()] += 1
-        
-        # Filtrar conceptos por frecuencia mínima y ordenar por frecuencia
-        concepts = [(word, freq) for word, freq in word_freq.items() 
-                   if freq >= min_freq]
-        concepts.sort(key=lambda x: x[1], reverse=True)
-        
-        logger.info(f"Identified {len(concepts)} key concepts after excluding entities")
-        return concepts[:10]
-        
-    except Exception as e:
-        logger.error(f"Error en identify_key_concepts: {str(e)}")
-        return []
-
-########################################################################
-
-def create_concept_graph(doc, key_concepts):
-    """
-    Crea un grafo de relaciones entre conceptos, ignorando entidades.
-    Args:
-        doc: Documento procesado por spaCy
-        key_concepts: Lista de tuplas (concepto, frecuencia)
-    Returns:
-        nx.Graph: Grafo de conceptos
-    """
-    try:
-        G = nx.Graph()
-        
-        # Crear un conjunto de conceptos clave para búsqueda rápida
-        concept_words = {concept[0].lower() for concept in key_concepts}
-        
-        # Crear conjunto de tokens que son parte de entidades
-        entity_tokens = set()
-        for ent in doc.ents:
-            entity_tokens.update(token.i for token in ent)
-        
-        # Añadir nodos al grafo
-        for concept, freq in key_concepts:
-            G.add_node(concept.lower(), weight=freq)
-        
-        # Analizar cada oración
-        for sent in doc.sents:
-            # Obtener conceptos en la oración actual, excluyendo entidades
-            current_concepts = []
-            for token in sent:
-                if (token.i not in entity_tokens and 
-                    token.lemma_.lower() in concept_words):
-                    current_concepts.append(token.lemma_.lower())
-            
-            # Crear conexiones entre conceptos en la misma oración
-            for i, concept1 in enumerate(current_concepts):
-                for concept2 in current_concepts[i+1:]:
-                    if concept1 != concept2:
-                        if G.has_edge(concept1, concept2):
-                            G[concept1][concept2]['weight'] += 1
-                        else:
-                            G.add_edge(concept1, concept2, weight=1)
-        
-        return G
-        
-    except Exception as e:
-        logger.error(f"Error en create_concept_graph: {str(e)}")
-        return nx.Graph()
-
-###############################################################################
-
-def visualize_concept_graph(G, lang_code, semantic_t):
-    """
-    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
-        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
-        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
-        )
-        
-        # Calcular factor de escala basado en número de nodos
-        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_colors = [plt.cm.viridis(centrality[node]) for node in DG.nodes()]
-        
-        # Dibujar nodos
-        nodes = nx.draw_networkx_nodes(
-            DG, 
-            pos, 
-            node_size=node_weights,
-            node_color=node_colors,
-            alpha=0.7,
-            ax=ax
-        )
-        
-        # Dibujar aristas con flechas
-        edges = nx.draw_networkx_edges(
-            DG, 
-            pos,
-            width=edge_weights,
-            alpha=0.6,
-            edge_color='gray',
-            arrows=True,
-            arrowsize=20,
-            arrowstyle='->',
-            connectionstyle='arc3,rad=0.2',
-            ax=ax
-        )
-        
-        # Ajustar tamaño de fuente según número 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,
-            font_size=font_size,
-            font_weight='bold',
-            bbox=dict(
-                facecolor='white', 
-                edgecolor='none', 
-                alpha=0.7
-            ),
-            ax=ax
-        )
-        
-        # Añadir leyenda de 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=semantic_t.get('concept_centrality', 'Centralidad de los conceptos clave'))
-        
-        plt.title(semantic_t.get('concept_network', 'Relaciones entre los conceptos clave'), 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
-
-########################################################################
-def create_entity_graph(entities):
-    G = nx.Graph()
-    for entity_type, entity_list in entities.items():
-        for entity in entity_list:
-            G.add_node(entity, type=entity_type)
-        for i, entity1 in enumerate(entity_list):
-            for entity2 in entity_list[i+1:]:
-                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)
-    for entity_type, color in ENTITY_LABELS[lang_code].items():
-        node_list = [node for node, data in G.nodes(data=True) if data['type'] == entity_type]
-        nx.draw_networkx_nodes(G, pos, nodelist=node_list, node_color=color, node_size=500, alpha=0.8, ax=ax)
-    nx.draw_networkx_edges(G, pos, width=1, alpha=0.5, ax=ax)
-    nx.draw_networkx_labels(G, pos, font_size=8, font_weight="bold", ax=ax)
-    ax.set_title(f"Relaciones entre Entidades ({lang_code})", fontsize=16)
-    ax.axis('off')
-    plt.tight_layout()
-    return fig
-
-
-#################################################################################
-def create_topic_graph(topics, doc):
-    G = nx.Graph()
-    for topic in topics:
-        G.add_node(topic, weight=doc.text.count(topic))
-    for i, topic1 in enumerate(topics):
-        for topic2 in topics[i+1:]:
-            weight = sum(1 for sent in doc.sents if topic1 in sent.text and topic2 in sent.text)
-            if weight > 0:
-                G.add_edge(topic1, topic2, weight=weight)
-    return G
-
-def visualize_topic_graph(G, lang_code):
-    fig, ax = plt.subplots(figsize=(12, 8))
-    pos = nx.spring_layout(G)
-    node_sizes = [G.nodes[node]['weight'] * 100 for node in G.nodes()]
-    nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='lightgreen', alpha=0.8, ax=ax)
-    nx.draw_networkx_labels(G, pos, font_size=10, font_weight="bold", ax=ax)
-    edge_weights = [G[u][v]['weight'] for u, v in G.edges()]
-    nx.draw_networkx_edges(G, pos, width=edge_weights, alpha=0.5, ax=ax)
-    ax.set_title(f"Relaciones entre Temas ({lang_code})", fontsize=16)
-    ax.axis('off')
-    plt.tight_layout()
-    return fig
-
-###########################################################################################
-def generate_summary(doc, lang_code):
-    sentences = list(doc.sents)
-    summary = sentences[:3]  # Toma las primeras 3 oraciones como resumen
-    return " ".join([sent.text for sent in summary])
-
-def extract_entities(doc, lang_code):
-    entities = defaultdict(list)
-    for ent in doc.ents:
-        if ent.label_ in ENTITY_LABELS[lang_code]:
-            entities[ent.label_].append(ent.text)
-    return dict(entities)
-
-def analyze_sentiment(doc, lang_code):
-    positive_words = sum(1 for token in doc if token.sentiment > 0)
-    negative_words = sum(1 for token in doc if token.sentiment < 0)
-    total_words = len(doc)
-    if positive_words > negative_words:
-        return "Positivo"
-    elif negative_words > positive_words:
-        return "Negativo"
-    else:
-        return "Neutral"
-
-def extract_topics(doc, lang_code):
-    vectorizer = TfidfVectorizer(stop_words='english', max_features=5)
-    tfidf_matrix = vectorizer.fit_transform([doc.text])
-    feature_names = vectorizer.get_feature_names_out()
-    return list(feature_names)
-
-# Asegúrate de que todas las funciones necesarias estén exportadas
-__all__ = [
-    'perform_semantic_analysis',
-    'identify_key_concepts',
-    'create_concept_graph',
-    'visualize_concept_graph',
-    'fig_to_bytes',  # Faltaba esta coma
-    'ENTITY_LABELS',
-    'POS_COLORS',
-    'POS_TRANSLATIONS'
-]