# database.py
# Versión 3 actualizada para manejar chat_history_v3
import streamlit as st
import logging
import os
from pymongo import MongoClient
import certifi
from datetime import datetime, timezone
import uuid
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
# Variables globales para Cosmos DB MongoDB API
mongo_client = None
mongo_db = None
analysis_collection = None
chat_collection_v3 = None # Nueva variable global para chat_history_v3
def initialize_mongodb_connection():
global mongo_client, mongo_db, analysis_collection, chat_collection_v3
try:
cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
if not cosmos_mongodb_connection_string:
logger.error("La variable de entorno MONGODB_CONNECTION_STRING no está configurada")
return False
mongo_client = MongoClient(cosmos_mongodb_connection_string,
tls=True,
tlsCAFile=certifi.where(),
retryWrites=False,
serverSelectionTimeoutMS=5000,
connectTimeoutMS=10000,
socketTimeoutMS=10000)
mongo_client.admin.command('ping')
mongo_db = mongo_client['aideatext_db']
analysis_collection = mongo_db['text_analysis']
chat_collection_v3 = mongo_db['chat_history_v3'] # Inicializar la nueva colección
# Crear índices para chat_history_v3
chat_collection_v3.create_index([("username", 1), ("timestamp", -1)])
chat_collection_v3.create_index([("username", 1), ("analysis_type", 1), ("timestamp", -1)])
logger.info("Conexión a Cosmos DB MongoDB API exitosa")
return True
except Exception as e:
logger.error(f"Error al conectar con Cosmos DB MongoDB API: {str(e)}", exc_info=True)
return False
def store_chat_history_v3(username, messages, analysis_type):
try:
logger.info(f"Guardando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
logger.debug(f"Mensajes a guardar: {messages}")
chat_document = {
'username': username,
'timestamp': datetime.now(timezone.utc).isoformat(),
'analysis_type': analysis_type,
'messages': messages
}
result = chat_collection_v3.insert_one(chat_document)
logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
return True
except Exception as e:
logger.error(f"Error al guardar el historial de chat para el usuario {username}: {str(e)}")
return False
def get_chat_history_v3(username, analysis_type=None, limit=10):
try:
logger.info(f"Obteniendo historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
query = {"username": username}
if analysis_type:
query["analysis_type"] = analysis_type
cursor = chat_collection_v3.find(query).sort("timestamp", -1).limit(limit)
chat_history = []
for chat in cursor:
chat_history.append({
"timestamp": chat["timestamp"],
"analysis_type": chat["analysis_type"],
"messages": chat["messages"]
})
logger.info(f"Se obtuvieron {len(chat_history)} entradas de chat para el usuario: {username}")
return chat_history
except Exception as e:
logger.error(f"Error al obtener el historial de chat para el usuario {username}: {str(e)}")
return []
def delete_chat_history_v3(username, analysis_type=None):
try:
logger.info(f"Eliminando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
query = {"username": username}
if analysis_type:
query["analysis_type"] = analysis_type
result = chat_collection_v3.delete_many(query)
logger.info(f"Se eliminaron {result.deleted_count} entradas de chat para el usuario: {username}")
return True
except Exception as e:
logger.error(f"Error al eliminar el historial de chat para el usuario {username}: {str(e)}")
return False
def export_chat_history_v3(username, analysis_type=None):
try:
logger.info(f"Exportando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
query = {"username": username}
if analysis_type:
query["analysis_type"] = analysis_type
cursor = chat_collection_v3.find(query).sort("timestamp", -1)
export_data = list(cursor)
logger.info(f"Se exportaron {len(export_data)} entradas de chat para el usuario: {username}")
return export_data
except Exception as e:
logger.error(f"Error al exportar el historial de chat para el usuario {username}: {str(e)}")
return []
# Funciones específicas para cada tipo de análisis
def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
if analysis_collection is None:
logger.error("La conexión a MongoDB no está inicializada")
return False
try:
word_count = {}
for word, color in repeated_words.items():
category = color # Asumiendo que 'color' es la categoría gramatical
word_count[category] = word_count.get(category, 0) + 1
analysis_document = {
'username': username,
'timestamp': datetime.now(timezone.utc).isoformat(),
'text': text,
'repeated_words': repeated_words,
'word_count': word_count,
'arc_diagrams': arc_diagrams,
'pos_analysis': pos_analysis,
'morphological_analysis': morphological_analysis,
'sentence_structure': sentence_structure,
'analysis_type': 'morphosyntax'
}
result = analysis_collection.insert_one(analysis_document)
logger.info(f"Análisis morfosintáctico guardado con ID: {result.inserted_id} para el usuario: {username}")
return True
except Exception as e:
logger.error(f"Error al guardar el análisis morfosintáctico para el usuario {username}: {str(e)}")
return False
# Aquí puedes agregar funciones similares para análisis semántico y de discurso
def get_student_data(username):
if analysis_collection is None or chat_collection_v3 is None:
logger.error("La conexión a MongoDB no está inicializada")
return None
formatted_data = {
"username": username,
"entries": [],
"entries_count": 0,
"word_count": {},
"chat_history": {
"morphosyntax": [],
"semantic": [],
"discourse": []
}
}
try:
logger.info(f"Buscando datos de análisis para el usuario: {username}")
cursor = analysis_collection.find({"username": username})
for entry in cursor:
formatted_entry = {
'timestamp': entry.get("timestamp"),
"analysis_type": entry.get("analysis_type", "morphosyntax")
}
if formatted_entry["analysis_type"] == "morphosyntax":
formatted_entry.update({
"text": entry.get("text", ""),
"word_count": entry.get("word_count", {}),
"arc_diagrams": entry.get("arc_diagrams", [])
})
for category, count in formatted_entry["word_count"].items():
formatted_data["word_count"][category] = formatted_data["word_count"].get(category, 0) + count
formatted_data["entries"].append(formatted_entry)
formatted_data["entries_count"] = len(formatted_data["entries"])
formatted_data["entries"].sort(key=lambda x: x["timestamp"], reverse=True)
# Obtener historial de chat para cada tipo de análisis
for analysis_type in ["morphosyntax", "semantic", "discourse"]:
chat_history = get_chat_history_v3(username, analysis_type)
formatted_data["chat_history"][analysis_type] = chat_history
except Exception as e:
logger.error(f"Error al obtener datos del estudiante {username}: {str(e)}")
logger.info(f"Datos formateados para {username}: {formatted_data}")
return formatted_data
# Puedes agregar más funciones según sea necesario para manejar otros tipos de datos o análisis