update store graph

modules/database/semantic_mongo_db.py

@@ -1,13 +1,15 @@
 #/modules/database/semantic_mongo_db.py
 
-# Importaciones estándar
+# Importaciones estándar corregidas y optimizadas
 import io
 import base64
 from datetime import datetime, timezone
 import logging
+from PIL import Image  # Necesario para la optimización
 
 # Importaciones de terceros
 import matplotlib.pyplot as plt
+from pymongo.errors import PyMongoError
 
 # Importaciones locales
 from .mongo_db import (
@@ -19,60 +21,79 @@ from .mongo_db import (
 )
 
 # Configuración del logger
-logger = logging.getLogger(__name__)  # Cambiado de name a __name__
+logger = logging.getLogger(__name__)
 COLLECTION_NAME = 'student_semantic_analysis'
 
-####################################################################
-# modules/database/semantic_mongo_db.py
 def store_student_semantic_result(username, text, analysis_result, lang_code='en'):
     """
-    Guarda el resultado del análisis semántico en MongoDB.
-    Args:
-        username: Nombre del usuario
-        text: Texto completo analizado
-        analysis_result: Diccionario con los resultados del análisis
-        lang_code: Código de idioma (opcional, default 'en')
+    NOMBRE PRESERVADO. Guarda el resultado del análisis semántico en MongoDB.
+    Optimizado para evitar el error 413 (Request size too large) mediante compresión.
     """
     try:
-        # Verificar datos mínimos requeridos
-        if not username or not text or not analysis_result:
+        # 1. Validación de datos mínimos
+        if not all([username, text, analysis_result]):
             logger.error("Datos insuficientes para guardar el análisis")
             return False
 
-        # Preparar el gráfico conceptual
-        concept_graph_data = None
-        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error(f"No se pudo obtener la colección {COLLECTION_NAME}")
+            return False
+
+        # 2. Procesamiento Único del Gráfico (Optimizado y sin redundancias)
+        concept_graph_data = analysis_result.get('concept_graph')
+        final_graph_bytes = None
+
+        if concept_graph_data:
             try:
-                if isinstance(analysis_result['concept_graph'], bytes):
-                    concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
+                # Convertir de base64 a bytes si es necesario
+                if isinstance(concept_graph_data, str):
+                    final_graph_bytes = base64.b64decode(concept_graph_data)
                 else:
-                    logger.warning("El gráfico conceptual no está en formato bytes")
+                    final_graph_bytes = concept_graph_data
+
+                # --- COMPRESIÓN PARA EVITAR ERROR 413 ---
+                img = Image.open(io.BytesIO(final_graph_bytes))
+                if img.mode != 'RGB':
+                    img = img.convert('RGB')
+                
+                output = io.BytesIO()
+                # Calidad 75% reduce el peso drásticamente sin perder claridad en los nodos
+                img.save(output, format="JPEG", quality=75, optimize=True)
+                final_graph_bytes = output.getvalue()
+                
+                logger.info(f"Grafo optimizado: {len(final_graph_bytes)} bytes para usuario {username}")
             except Exception as e:
-                logger.error(f"Error al codificar gráfico conceptual: {str(e)}")
+                logger.warning(f"Error procesando gráfico, se intentará guardar original: {str(e)}")
+                # Si falla la compresión, mantenemos los bytes originales si existen
+                if not final_graph_bytes and isinstance(concept_graph_data, bytes):
+                    final_graph_bytes = concept_graph_data
 
-        # Crear documento para MongoDB
+        # 3. Preparar el documento (Estructura limpia)
         analysis_document = {
             'username': username,
-            'timestamp': datetime.now(timezone.utc), # Mejor práctica
-            'text': text,
-            'analysis_type': 'semantic',
+            'timestamp': datetime.now(timezone.utc),
+            'text': text[:50000],  # Límite de seguridad para textos extremadamente largos
+            'language': lang_code,
+            'analysis_type': 'standard_semantic',
             'key_concepts': analysis_result.get('key_concepts', []),
-            'concept_centrality': analysis_result.get('concept_centrality', {}),
-            'concept_graph': concept_graph_data,
-            'language': lang_code  # Usamos el parámetro directamente
+            'entities': analysis_result.get('entities', []),
+            'concept_graph': final_graph_bytes  # Los bytes ya procesados/comprimidos
         }
 
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis semántico guardado para {username}")
-            return True
-        
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
+        # 4. Inserción en MongoDB
+        try:
+            result = collection.insert_one(analysis_document)
+            if result.inserted_id:
+                logger.info(f"Análisis guardado exitosamente. ID: {result.inserted_id}")
+                return True
+            return False
+        except PyMongoError as e:
+            logger.error(f"Error de inserción en MongoDB: {str(e)}")
+            return False
 
     except Exception as e:
-        logger.error(f"Error al guardar el análisis semántico: {str(e)}", exc_info=True)
+        logger.error(f"Error inesperado en store_student_semantic_result: {str(e)}", exc_info=True)
         return False
 
 ####################################################################################