File size: 8,828 Bytes
c58df45 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 |
# 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 |