#/modules/database/semantic_mongo_db.py # 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 ( get_collection, insert_document, find_documents, update_document, delete_document ) # Configuración del logger logger = logging.getLogger(__name__) COLLECTION_NAME = 'student_semantic_analysis' def store_student_semantic_result(username, text, analysis_result, lang_code='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: # 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 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: # Convertir de base64 a bytes si es necesario if isinstance(concept_graph_data, str): final_graph_bytes = base64.b64decode(concept_graph_data) else: 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.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 # 3. Preparar el documento (Estructura limpia) analysis_document = { 'username': username, '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', []), 'entities': analysis_result.get('entities', []), 'concept_graph': final_graph_bytes # Los bytes ya procesados/comprimidos } # 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 inesperado en store_student_semantic_result: {str(e)}", exc_info=True) return False #################################################################################### def get_student_semantic_analysis(username, limit=10): """ Recupera los análisis semánticos de un estudiante. Ordena correctamente resolviendo discrepancias de formato de fecha. """ try: collection = get_collection(COLLECTION_NAME) if collection is None: logger.error("No se pudo obtener la colección semantic") return [] query = { "username": username, "concept_graph": {"$exists": True, "$ne": None} } # Pipeline de agregación para unificar el tipo de dato antes de ordenar pipeline = [ {"$match": query}, {"$addFields": { "normalized_date": { "$convert": { "input": "$timestamp", "to": "date", "onError": None, # Si hay un formato inválido, no rompe la consulta "onNull": None } } }}, # Ordenamos usando la fecha ya normalizada {"$sort": {"normalized_date": -1}} ] # Aplicamos el límite solo si se especifica (útil para get_student_semantic_data) if limit is not None: pipeline.append({"$limit": limit}) # Proyectamos solo los campos necesarios pipeline.append({ "$project": { "timestamp": 1, "text": 1, "key_concepts": 1, "concept_graph": 1, "analysis_type": 1, "_id": 1 } }) results = list(collection.aggregate(pipeline)) logger.info(f"Recuperados {len(results)} análisis para {username}") return results except PyMongoError as e: logger.error(f"Error de MongoDB en la agregación: {str(e)}") return [] except Exception as e: logger.error(f"Error inesperado al recuperar análisis: {str(e)}") return [] #################################################################################################### def update_student_semantic_analysis(analysis_id, update_data): """ Actualiza un análisis semántico existente. Args: analysis_id: ID del análisis a actualizar update_data: Datos a actualizar """ query = {"_id": analysis_id} update = {"$set": update_data} return update_document(COLLECTION_NAME, query, update) def delete_student_semantic_analysis(analysis_id): """ Elimina un análisis semántico. Args: analysis_id: ID del análisis a eliminar """ query = {"_id": analysis_id} return delete_document(COLLECTION_NAME, query) ############################################################################ def get_student_semantic_data(username): """ Obtiene todos los análisis semánticos de un estudiante. Args: username: Nombre del usuario Returns: dict: Diccionario con todos los análisis del estudiante """ try: analyses = get_student_semantic_analysis(username, limit=None) formatted_analyses = [] for analysis in analyses: # Asegurarse de que los campos existan antes de acceder a ellos formatted_analysis = { 'timestamp': analysis.get('timestamp'), 'text': analysis.get('text', ''), # Usar get() con valor por defecto 'key_concepts': analysis.get('key_concepts', []), 'entities': analysis.get('entities', []), 'concept_graph': analysis.get('concept_graph') # Mantener el gráfico } 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 al obtener datos semánticos para {username}: {str(e)}") return { 'username': username, 'entries': [], 'count': 0, 'status': 'error', 'error': str(e) } ########################################################################## # Exportar las funciones necesarias __all__ = [ 'store_student_semantic_result', 'get_student_semantic_analysis', 'update_student_semantic_analysis', 'delete_student_semantic_analysis', 'get_student_semantic_data' ]