Update modules/database/semantic_mongo_live_db.py

modules/database/semantic_mongo_live_db.py

@@ -1,10 +1,18 @@
 # modules/database/semantic_mongo_live_db.py
 import logging
-from datetime import datetime, timezone
 import base64
-from bson import Binary
+from datetime import datetime, timezone
 from pymongo.errors import PyMongoError
 
+# Importaciones locales
+from .mongo_db import (
+    get_collection,
+    insert_document, 
+    find_documents, 
+    update_document, 
+    delete_document
+)
+
 # Configuración del logger
 logger = logging.getLogger(__name__)
 COLLECTION_NAME = 'student_semantic_live_analysis'
@@ -12,151 +20,163 @@ COLLECTION_NAME = 'student_semantic_live_analysis'
 def store_student_semantic_live_result(username, text, analysis_result, lang_code='en'):
     """
     Guarda el resultado del análisis semántico en vivo en MongoDB.
-    Versión mejorada con manejo robusto de errores y verificación de datos.
+    Versión mejorada con validación de datos y manejo de errores.
     """
     try:
-        # 1. Validación exhaustiva de los parámetros de entrada
+        # Validación de parámetros
         if not username or not isinstance(username, str):
-            logger.error("Nombre de usuario inválido o vacío")
+            logger.error("Nombre de usuario inválido")
             return False
 
         if not text or not isinstance(text, str):
-            logger.error("Texto de análisis inválido o vacío")
+            logger.error("Texto de análisis inválido")
             return False
 
         if not analysis_result or not isinstance(analysis_result, dict):
-            logger.error("Resultado de análisis inválido o vacío")
+            logger.error("Resultado de análisis inválido")
             return False
 
-        # 2. Preparación del gráfico conceptual con múltiples formatos soportados
+        # Preparar el gráfico conceptual
         concept_graph_data = None
-        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
+        if 'concept_graph' in analysis_result and analysis_result['concept_graph']:
             try:
-                graph_data = analysis_result['concept_graph']
-                
-                if isinstance(graph_data, bytes):
-                    # Codificar a base64 para almacenamiento eficiente
-                    concept_graph_data = base64.b64encode(graph_data).decode('utf-8')
-                elif isinstance(graph_data, str):
-                    # Si ya es string (base64), usarlo directamente
-                    concept_graph_data = graph_data
-                elif isinstance(graph_data, Binary):
-                    # Si es Binary de pymongo, convertirlo
-                    concept_graph_data = base64.b64encode(graph_data).decode('utf-8')
-                else:
-                    logger.warning(f"Formato de gráfico no soportado: {type(graph_data)}")
+                if isinstance(analysis_result['concept_graph'], bytes):
+                    concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
+                elif isinstance(analysis_result['concept_graph'], str):
+                    # Verificar si ya está en base64
+                    concept_graph_data = analysis_result['concept_graph']
             except Exception as e:
-                logger.error(f"Error al procesar gráfico conceptual: {str(e)}", exc_info=True)
-                # Continuar sin gráfico en lugar de fallar completamente
+                logger.error(f"Error al procesar gráfico: {str(e)}")
 
-        # 3. Preparación del documento con validación de campos
+        # Crear documento con campos validados
         analysis_document = {
             'username': username,
             'timestamp': datetime.now(timezone.utc),
-            'text': text[:10000],  # Limitar tamaño para prevenir documentos muy grandes
+            'text': text[:50000],  # Limitar tamaño
             'analysis_type': 'semantic_live',
             'language': lang_code,
+            'key_concepts': analysis_result.get('key_concepts', [])[:50],  # Limitar a 50 conceptos
+            'concept_centrality': analysis_result.get('concept_centrality', {}),
             'metadata': {
                 'version': '1.0',
                 'source': 'live_interface'
             }
         }
 
-        # Campos opcionales con validación
-        if 'key_concepts' in analysis_result and isinstance(analysis_result['key_concepts'], list):
-            analysis_document['key_concepts'] = analysis_result['key_concepts'][:50]  # Limitar a 50 conceptos
-
-        if 'concept_centrality' in analysis_result and isinstance(analysis_result['concept_centrality'], dict):
-            analysis_document['concept_centrality'] = analysis_result['concept_centrality']
-
         if concept_graph_data:
             analysis_document['concept_graph'] = concept_graph_data
 
-        # 4. Operación de base de datos con manejo de errores específico
+        # Operación de base de datos
         try:
-            collection = get_collection(COLLECTION_NAME)
-            if not collection:
-                logger.error("No se pudo obtener la colección MongoDB")
-                return False
-
-            result = collection.insert_one(analysis_document)
-            
-            if result.inserted_id:
-                logger.info(f"Análisis guardado exitosamente para {username}. ID: {result.inserted_id}")
+            result = insert_document(COLLECTION_NAME, analysis_document)
+            if result:
+                logger.info(f"Análisis en vivo guardado para {username}")
                 return True
-            
-            logger.error("La operación de inserción no devolvió un ID")
+            logger.error("Inserción fallida (sin ID devuelto)")
             return False
-
-        except PyMongoError as mongo_error:
-            logger.error(f"Error de MongoDB al guardar análisis: {str(mongo_error)}", exc_info=True)
+        except PyMongoError as e:
+            logger.error(f"Error de MongoDB: {str(e)}")
             return False
 
     except Exception as e:
-        logger.error(f"Error inesperado al guardar análisis: {str(e)}", exc_info=True)
+        logger.error(f"Error inesperado: {str(e)}", exc_info=True)
         return False
 
 def get_student_semantic_live_analysis(username, limit=10):
     """
     Recupera los análisis semánticos en vivo de un estudiante.
-    Versión mejorada con paginación y manejo de errores.
+    Versión corregida con consulta adecuada.
     """
     try:
-        # Validación de parámetros
-        if not username or not isinstance(username, str):
-            logger.error("Nombre de usuario inválido para recuperación")
-            return []
-
-        if not isinstance(limit, int) or limit <= 0:
-            limit = 10  # Valor por defecto si el límite es inválido
-
-        # Consulta con proyección para optimizar transferencia
         query = {
             "username": username,
-            "analysis_type": "semantic_live"
+            "analysis_type": "semantic_live"  # Corregido a semantic_live
         }
         
         projection = {
             "timestamp": 1,
-            "text": {"$substr": ["$text", 0, 200]},  # Solo primeros 200 caracteres
-            "key_concepts": {"$slice": ["$key_concepts", 10]},  # Solo primeros 10 conceptos
+            "text": {"$substr": ["$text", 0, 200]},  # Solo primeros 200 chars
+            "key_concepts": 1,
             "concept_graph": 1,
-            "_id": 1,
-            "metadata": 1
+            "_id": 1
         }
         
-        # Operación de base de datos con manejo de errores
-        try:
-            collection = get_collection(COLLECTION_NAME)
-            if not collection:
-                logger.error("No se pudo obtener la colección MongoDB")
-                return []
+        results = find_documents(
+            COLLECTION_NAME,
+            query,
+            projection=projection,
+            sort=[("timestamp", -1)],
+            limit=limit
+        )
+        
+        logger.info(f"Recuperados {len(results)} análisis en vivo para {username}")
+        return results
+        
+    except PyMongoError as e:
+        logger.error(f"Error de MongoDB: {str(e)}")
+        return []
+    except Exception as e:
+        logger.error(f"Error inesperado: {str(e)}")
+        return []
 
-            cursor = collection.find(query, projection).sort("timestamp", -1).limit(limit)
-            results = list(cursor)
-            
-            # Post-procesamiento para asegurar formato consistente
-            for doc in results:
-                if 'concept_graph' in doc and isinstance(doc['concept_graph'], str):
-                    try:
-                        # Convertir base64 string a bytes para compatibilidad
-                        doc['concept_graph'] = base64.b64decode(doc['concept_graph'])
-                    except Exception as e:
-                        logger.warning(f"Error al decodificar gráfico: {str(e)}")
-                        doc.pop('concept_graph', None)
-            
-            logger.info(f"Recuperados {len(results)} análisis para {username}")
-            return results
+def update_student_semantic_live_analysis(analysis_id, update_data):
+    """Actualiza un análisis existente con manejo de errores"""
+    try:
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+        return update_document(COLLECTION_NAME, query, update) > 0
+    except PyMongoError as e:
+        logger.error(f"Error al actualizar: {str(e)}")
+        return False
 
-        except PyMongoError as mongo_error:
-            logger.error(f"Error de MongoDB al recuperar análisis: {str(mongo_error)}")
-            return []
+def delete_student_semantic_live_analysis(analysis_id):
+    """Elimina un análisis con manejo de errores"""
+    try:
+        query = {"_id": analysis_id}
+        return delete_document(COLLECTION_NAME, query) > 0
+    except PyMongoError as e:
+        logger.error(f"Error al eliminar: {str(e)}")
+        return False
 
+def get_student_semantic_live_data(username):
+    """
+    Obtiene todos los análisis semánticos en vivo de un estudiante.
+    Versión corregida que usa la función _live.
+    """
+    try:
+        analyses = get_student_semantic_live_analysis(username, limit=None)
+        
+        formatted_analyses = []
+        for analysis in analyses:
+            formatted_analysis = {
+                'timestamp': analysis.get('timestamp'),
+                'text': analysis.get('text', ''),
+                'key_concepts': analysis.get('key_concepts', []),
+                'concept_graph': analysis.get('concept_graph')
+            }
+            formatted_analyses.append(formatted_analysis)
+        
+        return {
+            'username': username,
+            'entries': formatted_analyses,
+            'count': len(formatted_analyses),
+            'status': 'success'
+        }
+    
     except Exception as e:
-        logger.error(f"Error inesperado al recuperar análisis: {str(e)}", exc_info=True)
-        return []
+        logger.error(f"Error al obtener datos: {str(e)}")
+        return {
+            'username': username,
+            'entries': [],
+            'count': 0,
+            'status': 'error',
+            'error': str(e)
+        }
 
 __all__ = [
     'store_student_semantic_live_result',
-    'get_student_semantic_live_analysis'
+    'get_student_semantic_live_analysis',
+    'update_student_semantic_live_analysis',
+    'delete_student_semantic_live_analysis',
+    'get_student_semantic_live_data'
 ]