modules/text_analysis/semantic_analysis.py

# 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,
    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):
    """
    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)
        
        # 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.
    """
    try:
        word_freq = Counter()
        
        for token in doc:
            if (token.lemma_.lower() not in stopwords and
                len(token.lemma_) >= min_length and
                token.is_alpha and
                not token.is_punct and
                not token.like_num):
                
                word_freq[token.lemma_.lower()] += 1
        
        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")
        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.
    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}
        
        # 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
            current_concepts = []
            for token in sent:
                if 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:
                        # Si ya existe la arista, incrementar el peso
                        if G.has_edge(concept1, concept2):
                            G[concept1][concept2]['weight'] += 1
                        # Si no existe, crear nueva arista con peso 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)}")
        # Retornar un grafo vacío en caso de error
        return nx.Graph()

###############################################################################
def visualize_concept_graph(G, lang_code):
    """
    Visualiza el grafo de conceptos con nodos coloreados y flechas direccionales.
    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)
        
        # Calcular layout con más espacio
        pos = nx.spring_layout(DG, k=2, iterations=50)
        
        # 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 correctamente
        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.title("Red de conceptos relacionados", 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'
]