Upload 281 files

.gitattributes

@@ -33,3 +33,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/assets/img/AIdeaText_Logo_vectores.png filter=lfs diff=lfs merge=lfs -text
+src/assets/img/AIdeaTextCard.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/ALPHA_Startup[[:space:]]Badges.png filter=lfs diff=lfs merge=lfs -text
+src/assets/img/assets_img_logo_92x92.ico filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2535.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2585.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2587.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2590.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2678.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2727.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2735.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2790.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/_MG_2845.JPG filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/AIdeaTextCard.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/Facebook_CoverPhoto_820x312.jpg filter=lfs diff=lfs merge=lfs -text
+src/assets/img/socialmedia/Facebook_CoverPhoto-1_820x312.jpg filter=lfs diff=lfs merge=lfs -text

src/assets/img/socialmedia/txt.txt

@@ -0,0 +1 @@
+txtx

src/modules/23-7-2024_auth.py

@@ -0,0 +1,135 @@
+### auth.py
+import os
+from azure.cosmos import CosmosClient, exceptions
+import bcrypt
+import base64
+
+################################################################################################################
+def clean_and_validate_key(key):
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Azure Cosmos DB configuration
+endpoint = os.environ.get("COSMOS_ENDPOINT")
+key = os.environ.get("COSMOS_KEY")
+
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
+
+try:
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client("user_database")
+    container = database.get_container_client("users")
+    # Prueba de conexión
+    database_list = list(client.list_databases())
+    print(f"Conexión exitosa. Bases de datos encontradas: {len(database_list)}")
+except Exception as e:
+    print(f"Error al conectar con Cosmos DB: {str(e)}")
+    raise
+
+#############################################################################################################3
+def hash_password(password):
+    """Hash a password for storing."""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+################################################################################################################
+def verify_password(stored_password, provided_password):
+    """Verify a stored password against one provided by user"""
+    return bcrypt.checkpw(provided_password.encode('utf-8'), stored_password.encode('utf-8'))
+    
+################################################################################################################
+def register_user(username, password, additional_info=None):
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        existing_user = list(container.query_items(query=query, enable_cross_partition_query=True))
+        
+        if existing_user:
+            return False  # User already exists
+        
+        new_user = {
+            'id': username,
+            'password': hash_password(password),
+            'role': 'Estudiante',
+            'additional_info': additional_info or {}
+        }
+        
+        new_user['partitionKey'] = username
+        
+        container.create_item(body=new_user)
+        return True
+    except exceptions.CosmosHttpResponseError as e:
+        print(f"Error al registrar usuario: {str(e)}")
+        return False
+
+        
+################################################################################################################
+def authenticate_user(username, password):
+    """Authenticate a user."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            stored_user = results[0]
+            if verify_password(stored_user['password'], password):
+                return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False
+
+
+################################################################################################################
+def get_user_role(username):
+    """Get the role of a user."""
+    try:
+        query = f"SELECT c.role FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            return results[0]['role']
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return None
+
+################################################################################################################
+def update_user_info(username, new_info):
+    """Update user information."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            user = results[0]
+            user['additional_info'].update(new_info)
+            container.upsert_item(user, partition_key=username)
+            return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False
+
+################################################################################################################
+def delete_user(username):
+    """Delete a user."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            user = results[0]
+            container.delete_item(item=user['id'], partition_key=username)
+            return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False

src/modules/23-7-2024_ui.py

@@ -0,0 +1,344 @@
+# modules/ui.py
+# Importaciones estandar de python
+import io
+import streamlit as st
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import squarify
+import pandas as pd
+from datetime import datetime
+import base64
+from spacy import displacy
+import re
+from .morpho_analysis import POS_COLORS, POS_TRANSLATIONS  # Asegúrate de que esta importación esté presente
+print("POS_COLORS:", POS_COLORS)
+print("POS_TRANSLATIONS:", POS_TRANSLATIONS)
+
+# Importaciones locales
+from .auth import authenticate_user, register_user, get_user_role
+from .database import get_student_data, store_analysis_result
+from .morpho_analysis import get_repeated_words_colors, highlight_repeated_words, POS_COLORS, POS_TRANSLATIONS
+from .syntax_analysis import visualize_syntax
+
+#########################################################################
+# Define colors for grammatical categories
+POS_COLORS = {
+    'ADJ': '#FFA07A',    # Light Salmon
+    'ADP': '#98FB98',    # Pale Green
+    'ADV': '#87CEFA',    # Light Sky Blue
+    'AUX': '#DDA0DD',    # Plum
+    'CCONJ': '#F0E68C',  # Khaki
+    'DET': '#FFB6C1',    # Light Pink
+    'INTJ': '#FF6347',   # Tomato
+    'NOUN': '#90EE90',   # Light Green
+    'NUM': '#FAFAD2',    # Light Goldenrod Yellow
+    'PART': '#D3D3D3',   # Light Gray
+    'PRON': '#FFA500',   # Orange
+    'PROPN': '#20B2AA',  # Light Sea Green
+    'SCONJ': '#DEB887',  # Burlywood
+    'SYM': '#7B68EE',    # Medium Slate Blue
+    'VERB': '#FF69B4',   # Hot Pink
+    'X': '#A9A9A9',      # Dark Gray
+}
+
+POS_TRANSLATIONS = {
+    'es': {
+        'ADJ': 'Adjetivo',
+        'ADP': 'Adposición',
+        'ADV': 'Adverbio',
+        'AUX': 'Auxiliar',
+        'CCONJ': 'Conjunción Coordinante',
+        'DET': 'Determinante',
+        'INTJ': 'Interjección',
+        'NOUN': 'Sustantivo',
+        'NUM': 'Número',
+        'PART': 'Partícula',
+        'PRON': 'Pronombre',
+        'PROPN': 'Nombre Propio',
+        'SCONJ': 'Conjunción Subordinante',
+        'SYM': 'Símbolo',
+        'VERB': 'Verbo',
+        'X': 'Otro',
+    },
+    'en': {
+        'ADJ': 'Adjective',
+        'ADP': 'Adposition',
+        'ADV': 'Adverb',
+        'AUX': 'Auxiliary',
+        'CCONJ': 'Coordinating Conjunction',
+        'DET': 'Determiner',
+        'INTJ': 'Interjection',
+        'NOUN': 'Noun',
+        'NUM': 'Number',
+        'PART': 'Particle',
+        'PRON': 'Pronoun',
+        'PROPN': 'Proper Noun',
+        'SCONJ': 'Subordinating Conjunction',
+        'SYM': 'Symbol',
+        'VERB': 'Verb',
+        'X': 'Other',
+    },
+    'fr': {
+        'ADJ': 'Adjectif',
+        'ADP': 'Adposition',
+        'ADV': 'Adverbe',
+        'AUX': 'Auxiliaire',
+        'CCONJ': 'Conjonction de Coordination',
+        'DET': 'Déterminant',
+        'INTJ': 'Interjection',
+        'NOUN': 'Nom',
+        'NUM': 'Nombre',
+        'PART': 'Particule',
+        'PRON': 'Pronom',
+        'PROPN': 'Nom Propre',
+        'SCONJ': 'Conjonction de Subordination',
+        'SYM': 'Symbole',
+        'VERB': 'Verbe',
+        'X': 'Autre',
+    }
+}
+
+##########################################################################
+def login_page():
+    st.title("Iniciar Sesión")
+    username = st.text_input("Usuario")
+    password = st.text_input("Contraseña", type='password')
+    if st.button("Iniciar Sesión"):
+        if authenticate_user(username, password):
+            st.success(f"Bienvenido, {username}!")
+            st.session_state.logged_in = True
+            st.session_state.username = username
+            st.session_state.role = get_user_role(username)
+            st.experimental_rerun()
+        else:
+            st.error("Usuario o contraseña incorrectos")
+
+##########################################################################
+def register_page():
+    st.title("Registrarse")
+    new_username = st.text_input("Nuevo Usuario")
+    new_password = st.text_input("Nueva Contraseña", type='password')
+    
+    additional_info = {}
+    additional_info['carrera'] = st.text_input("Carrera")
+
+    if st.button("Registrarse"):
+        if register_user(new_username, new_password, additional_info):
+            st.success("Registro exitoso. Por favor, inicia sesión.")
+        else:
+            st.error("El usuario ya existe o ocurrió un error durante el registro")
+
+##########################################################################
+def get_chatbot_response(input_text):
+    # Esta función debe ser implementada o importada de otro módulo
+    # Por ahora, retornamos un mensaje genérico
+    return "Lo siento, el chatbot no está disponible en este momento."
+
+##########################################################################
+def display_chat_interface():
+    st.markdown("### Chat con AIdeaText")
+
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    for i, (role, text) in enumerate(st.session_state.chat_history):
+        if role == "user":
+            st.text_area(f"Tú:", value=text, height=50, key=f"user_message_{i}", disabled=True)
+        else:
+            st.text_area(f"AIdeaText:", value=text, height=50, key=f"bot_message_{i}", disabled=True)
+
+    user_input = st.text_input("Escribe tu mensaje aquí:")
+
+    if st.button("Enviar"):
+        if user_input:
+            st.session_state.chat_history.append(("user", user_input))
+            response = get_chatbot_response(user_input)
+            st.session_state.chat_history.append(("bot", response))
+            st.experimental_rerun()
+
+##########################################################################
+
+def display_student_progress(username, lang_code='es'):
+    print("lang_code:", lang_code)
+    student_data = get_student_data(username)
+    
+    if student_data is None:
+        st.warning("No se encontraron datos para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+        return
+
+    st.title(f"Progreso de {username}")
+
+    if student_data['entries_count'] > 0:
+        if 'word_count' in student_data and student_data['word_count']:
+            st.subheader("Total de palabras por categoría gramatical")
+            
+            df = pd.DataFrame(list(student_data['word_count'].items()), columns=['category', 'count'])
+            df['label'] = df.apply(lambda x: f"{POS_TRANSLATIONS[lang_code].get(x['category'], x['category'])}", axis=1)
+            
+            # Ordenar el DataFrame por conteo de palabras, de mayor a menor
+            df = df.sort_values('count', ascending=False)
+            
+            fig, ax = plt.subplots(figsize=(12, 6))
+            bars = ax.bar(df['label'], df['count'], color=[POS_COLORS.get(cat, '#CCCCCC') for cat in df['category']])
+            
+            ax.set_xlabel('Categoría Gramatical')
+            ax.set_ylabel('Cantidad de Palabras')
+            ax.set_title('Total de palabras por categoría gramatical')
+            plt.xticks(rotation=45, ha='right')
+            
+            # Añadir etiquetas de valor en las barras
+            for bar in bars:
+                height = bar.get_height()
+                ax.text(bar.get_x() + bar.get_width()/2., height,
+                        f'{height}',
+                        ha='center', va='bottom')
+            
+            plt.tight_layout()
+            
+            buf = io.BytesIO()
+            fig.savefig(buf, format='png')
+            buf.seek(0)
+            st.image(buf, use_column_width=True)
+        else:
+            st.info("No hay datos de conteo de palabras disponibles.")    
+        
+        # Diagramas de Arco (consolidados)
+        st.header("Diagramas de Arco")
+        with st.expander("Ver todos los Diagramas de Arco"):
+            for i, entry in enumerate(student_data['entries']):
+                if 'arc_diagrams' in entry and entry['arc_diagrams']:
+                    st.subheader(f"Entrada {i+1} - {entry['timestamp']}")
+                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+        
+        # Diagramas de Red (consolidados)
+        st.header("Diagramas de Red")
+        with st.expander("Ver todos los Diagramas de Red"):
+            for i, entry in enumerate(student_data['entries']):
+                if 'network_diagram' in entry and entry['network_diagram']:
+                    st.subheader(f"Entrada {i+1} - {entry['timestamp']}")
+                    try:
+                        # Decodificar la imagen base64
+                        image_bytes = base64.b64decode(entry['network_diagram'])
+                        st.image(image_bytes)
+                    except Exception as e:
+                        st.error(f"Error al mostrar el diagrama de red: {str(e)}")
+    else:
+        st.warning("No se encontraron entradas para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+
+##############################################################Mostrar entradas recientes######################################################################
+        #st.header("Entradas Recientes")
+        #for i, entry in enumerate(student_data['entries'][:5]):  # Mostrar las 5 entradas más recientes
+            #with st.expander(f"Entrada {i+1} - {entry['timestamp']}"):
+                #st.write(entry['text'])
+    #else:
+        #st.warning("No se encontraron entradas para este estudiante.")
+        #st.info("Intenta realizar algunos análisis de texto primero.")
+    
+##########################################################################
+def display_text_analysis_interface(nlp_models, lang_code):
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis morfológico y sintáctico",
+            'input_label': "Ingrese un texto para analizar (máx. 5,000 palabras):",
+            'input_placeholder': "El objetivo de esta aplicación es que mejore sus habilidades de redacción. Para ello, después de ingresar su texto y presionar el botón obtendrá tres vistas horizontales. La primera, le indicará las palabras que se repiten por categoría gramátical; la segunda, un diagrama de arco le indicara las conexiones sintácticas en cada oración; y la tercera, es un grafo en el cual visualizara la configuración de su texto.",  
+            'analyze_button': "Analizar texto",
+            'repeated_words': "Palabras repetidas",
+            'legend': "Leyenda: Categorías gramaticales",
+            'arc_diagram': "Análisis sintáctico: Diagrama de arco",
+            'network_diagram': "Análisis sintáctico: Diagrama de red",
+            'sentence': "Oración"
+        },
+        'en': {
+            'title': "AIdeaText - Morphological and Syntactic Analysis",
+            'input_label': "Enter a text to analyze (max 5,000 words):",
+            'input_placeholder': "The goal of this app is for you to improve your writing skills. To do this, after entering your text and pressing the button you will get three horizontal views. The first will indicate the words that are repeated by grammatical category; second, an arc diagram will indicate the syntactic connections in each sentence; and the third is a graph in which you will visualize the configuration of your text.",
+            'analyze_button': "Analyze text",
+            'repeated_words': "Repeated words",
+            'legend': "Legend: Grammatical categories",
+            'arc_diagram': "Syntactic analysis: Arc diagram",
+            'network_diagram': "Syntactic analysis: Network diagram",
+            'sentence': "Sentence"
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse morphologique et syntaxique",
+            'input_label': "Entrez un texte à analyser (max 5 000 mots) :",
+            'input_placeholder': "Le but de cette application est d'améliorer vos compétences en rédaction. Pour ce faire, après avoir saisi votre texte et appuyé sur le bouton vous obtiendrez trois vues horizontales. Le premier indiquera les mots répétés par catégorie grammaticale; deuxièmement, un diagramme en arcs indiquera les connexions syntaxiques dans chaque phrase; et le troisième est un graphique dans lequel vous visualiserez la configuration de votre texte.",
+            'analyze_button': "Analyser le texte",
+            'repeated_words': "Mots répétés",
+            'legend': "Légende : Catégories grammaticales",
+            'arc_diagram': "Analyse syntaxique : Diagramme en arc",
+            'network_diagram': "Analyse syntaxique : Diagramme de réseau",
+            'sentence': "Phrase"
+        }
+    }
+
+    t = translations[lang_code]
+
+    if 'input_text' not in st.session_state:
+        st.session_state.input_text = ""
+
+    # Añadimos una clave única basada en el idioma seleccionado
+    sentence_input = st.text_area(
+        t['input_label'],
+        height=150,
+        placeholder=t['input_placeholder'],
+        value=st.session_state.input_text,
+        key=f"text_input_{lang_code}"  # Clave única basada en el idioma
+    )
+    st.session_state.input_text = sentence_input
+
+#    sentence_input = st.text_area(t['input_label'], height=150, placeholder=t['input_placeholder'], value=st.session_state.input_text)
+#    st.session_state.input_text = sentence_input
+
+    if st.button(t['analyze_button'], key=f"analyze_button_{lang_code}"):
+        if sentence_input:
+            doc = nlp_models[lang_code](sentence_input)
+
+            with st.expander(t['repeated_words'], expanded=True):
+                word_colors = get_repeated_words_colors(doc)
+                highlighted_text = highlight_repeated_words(doc, word_colors)
+                st.markdown(highlighted_text, unsafe_allow_html=True)
+
+            st.markdown(f"##### {t['legend']}")
+            legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
+            for pos, color in POS_COLORS.items():
+                if pos in POS_TRANSLATIONS:
+                    legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[pos]}</span></div>"
+            legend_html += "</div>"
+            st.markdown(legend_html, unsafe_allow_html=True)
+
+            with st.expander(t['arc_diagram'], expanded=True):
+                sentences = list(doc.sents)
+                arc_diagrams = []
+                for i, sent in enumerate(sentences):
+                    st.subheader(f"{t['sentence']} {i+1}")
+                    html = displacy.render(sent, style="dep", options={"distance": 100})
+                    html = html.replace('height="375"', 'height="200"')
+                    html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                    html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                    st.write(html, unsafe_allow_html=True)
+                    arc_diagrams.append(html)
+
+            with st.expander(t['network_diagram'], expanded=True):
+                fig = visualize_syntax(sentence_input, nlp_models[lang_code], lang_code)
+                st.pyplot(fig)
+
+            if store_analysis_result(
+                st.session_state.username,
+                sentence_input,
+                word_colors,
+                arc_diagrams,
+                fig
+            ):
+                st.success("Análisis guardado correctamente.")
+            else:
+                st.error("Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.")
+                st.error(f"Falló el guardado del análisis. Username: {st.session_state.username}")
+
+##########################################################################
+def display_teacher_interface():
+    st.write("Bienvenido, profesor. Aquí podrás ver el progreso de tus estudiantes.")
+    # Aquí puedes agregar la lógica para mostrar el progreso de los estudiantes

src/modules/__init__.py

@@ -0,0 +1,319 @@
+# modules/__init__.py
+
+def load_auth_functions():
+    from .auth.auth import authenticate_student, register_student, update_student_info, delete_student
+    return {
+        'authenticate_student': authenticate_student,
+        'register_student': register_student,
+        'update_student_info': update_student_info,
+        'delete_student': delete_student
+    }
+
+# Agregar nuevo import para current_situation
+def load_current_situation_functions():
+    """
+    Carga las funciones relacionadas con el análisis de situación actual.
+    Returns:
+        dict: Diccionario con las funciones de situación actual
+    """
+    from .studentact.current_situation_interface import (
+        display_current_situation_interface,
+        display_metrics_in_one_row,
+        display_empty_metrics_row,
+        display_metrics_analysis, 
+        display_comparison_results,
+        display_metrics_and_suggestions,
+        display_radar_chart,
+        suggest_improvement_tools,
+        prepare_metrics_config
+        )
+    
+    from .studentact.current_situation_analysis import (
+            correlate_metrics,
+            analyze_text_dimensions,
+            analyze_clarity,
+            analyze_vocabulary_diversity,
+            analyze_cohesion,
+            analyze_structure,
+            get_dependency_depths,
+            normalize_score, 
+            generate_sentence_graphs, 
+            generate_word_connections, 
+            generate_connection_paths,         
+            create_vocabulary_network,
+            create_syntax_complexity_graph,
+            create_cohesion_heatmap
+        )
+    
+    return {
+        'display_current_situation_interface': display_current_situation_interface,
+        'display_metrics_in_one_row': display_metrics_in_one_line,
+        'display_empty_metrics_row': display_empty_metrics_row,
+        'display_metrics_analysis': display_metrics_analysis, 
+        'display_comparison_results': display_comparison_results,
+        'display_metrics_and_suggestions': display_metrics_and_suggestions,
+        'display_radar_chart': display_radar_chart,
+        'suggest_improvement_tools': suggest_improvement_tools,
+        'prepare_metrics_config': prepare_metrics_config,
+        'display_empty_metrics_row' : display_empty_metrics_row,
+        'correlate_metrics': correlate_metrics,
+        'analyze_text_dimensions': analyze_text_dimensions,
+        'analyze_clarity': analyze_clarity,
+        'analyze_vocabulary_diversity': analyze_vocabulary_diversity,
+        'analyze_cohesion': analyze_cohesion,
+        'analyze_structure': analyze_structure,
+        'get_dependency_depths': get_dependency_depths,
+        'normalize_score': normalize_score, 
+        'generate_sentence_graphs': generate_sentence_graphs, 
+        'generate_word_connections': generate_word_connections, 
+        'generate_connection_paths': generate_connection_paths,         
+        'create_vocabulary_network': create_vocabulary_network,
+        'create_syntax_complexity_graph': create_syntax_complexity_graph,
+        'create_cohesion_heatmap': create_cohesion_heatmap 
+    }
+
+def load_database_functions():
+
+    from .database.database_init import (
+    initialize_database_connections, 
+    get_container, 
+    get_mongodb
+    )
+
+    # Importar funciones SQL
+    from .database.sql_db import (
+        create_student_user,
+        get_student_user,
+        update_student_user,
+        delete_student_user,
+        store_application_request,
+        store_student_feedback,
+        record_login,
+        record_logout,
+        get_recent_sessions,
+        get_user_total_time
+    )
+    
+    from .database.mongo_db import (
+        get_collection,
+        insert_document,
+        find_documents,
+        update_document,
+        delete_document,
+    )
+    
+    from .database.morphosintax_mongo_db import (
+        store_student_morphosyntax_result,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis,
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
+
+    from .database.semantic_mongo_db import (
+        store_student_semantic_result,
+        get_student_semantic_analysis,
+        update_student_semantic_analysis,
+        delete_student_semantic_analysis,
+        get_student_semantic_data
+    )
+
+    from .database.discourse_mongo_db import (
+        store_student_discourse_result,
+        get_student_discourse_analysis,
+        update_student_discourse_analysis,
+        delete_student_discourse_analysis,
+        get_student_discourse_data
+    )
+
+    # Agregar nueva importación para current_situation
+    from .database.current_situation_mongo_db import (
+        store_current_situation_result,
+        verify_storage,
+        get_recent_sessions,
+        get_student_situation_history,
+        update_exercise_status
+    )
+
+    # Importar nuevas funciones de análisis morfosintáctico iterativo
+    from .morphosyntax_iterative_mongo_db import (
+        store_student_morphosyntax_base,
+        store_student_morphosyntax_iteration,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis, 
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
+    
+    from .database.chat_mongo_db import store_chat_history, get_chat_history
+
+    return {
+        # Nuevas funciones morfosintácticas iterativas
+        'store_student_morphosyntax_base': store_student_morphosyntax_base,
+        'store_student_morphosyntax_iteration': store_student_morphosyntax_iteration,
+        'get_student_morphosyntax_iterative_analysis': get_student_morphosyntax_analysis,  # Renombrada para evitar conflicto
+        'update_student_morphosyntax_iterative': update_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'delete_student_morphosyntax_iterative': delete_student_morphosyntax_analysis,     # Renombrada para evitar conflicto
+        'get_student_morphosyntax_iterative_data': get_student_morphosyntax_data,  
+        'store_current_situation_result': store_current_situation_result,
+        'verify_storage': verify_storage,
+        'get_recent_sessions': get_recent_sessions,
+        'get_student_situation_history': get_student_situation_history,
+        'update_exercise_status': update_exercise_status,
+        'initialize_database_connections': initialize_database_connections,
+        'get_container': get_container,
+        'get_mongodb': get_mongodb,
+        'create_student_user': create_student_user,
+        'get_student_user': get_student_user,
+        'update_student_user': update_student_user,
+        'delete_student_user': delete_student_user,
+        'store_application_request': store_application_request,
+        'store_student_feedback': store_student_feedback,
+        'get_collection': get_collection,
+        'insert_document': insert_document,
+        'find_documents': find_documents,
+        'update_document': update_document,
+        'delete_document': delete_document,
+        'store_student_morphosyntax_result': store_student_morphosyntax_result,
+        'get_student_morphosyntax_analysis': get_student_morphosyntax_analysis,
+        'update_student_morphosyntax_analysis': update_student_morphosyntax_analysis,
+        'delete_student_morphosyntax_analysis': delete_student_morphosyntax_analysis,
+        'get_student_morphosyntax_data': get_student_morphosyntax_data,
+        'store_student_semantic_result': store_student_semantic_result,
+        'get_student_semantic_analysis': get_student_semantic_analysis,
+        'update_student_semantic_analysis': update_student_semantic_analysis,
+        'delete_student_semantic_analysis': delete_student_semantic_analysis,
+        'get_student_semantic_data': get_student_semantic_data,
+        'store_chat_history': store_chat_history,
+        'get_chat_history': get_chat_history, 
+        'store_student_discourse_result': store_student_discourse_result,
+        'get_student_discourse_analysis': get_student_discourse_analysis,
+        'update_student_discourse_analysis': update_student_discourse_analysis,
+        'delete_student_discourse_analysis': delete_student_discourse_analysis,
+        'get_student_discourse_data': get_student_discourse_data, 
+        'record_login': record_login,
+        'record_logout': record_logout,
+        'get_recent_sessions': get_recent_sessions,
+        'get_user_total_time': get_user_total_time
+    }
+
+def load_ui_functions():
+    # No importamos nada de ui.py aquí
+    return {}  # Retornamos un diccionario vacío
+
+def load_student_activities_v2_functions():
+    from .studentact.student_activities_v2 import display_student_activities
+    return {
+        'display_student_progress': display_student_activities
+    }
+
+def load_morphosyntax_functions():
+    from .morphosyntax.morphosyntax_interface import (
+        initialize_arc_analysis_state,
+        reset_arc_analysis_state,
+        display_arc_diagrams,
+        display_morphosyntax_results
+    )
+    from .morphosyntax.morphosyntax_process import (
+        process_morphosyntactic_input,
+        format_analysis_results,
+        perform_advanced_morphosyntactic_analysis  # Añadir esta función
+    )
+    
+    return {
+        #Interface
+        'initialize_arc_analysis_state': initialize_arc_analysis_state,
+        'reset_arc_analysis_state': reset_morpho_state,
+        'display_arc_diagrams': display_arc_diagrams,
+        'display_morphosyntax_interface': display_morphosyntax_interface,
+        #Process
+        'process_morphosyntactic_input': process_morphosyntactic_input,
+        'format_analysis_results': format_analysis_results,
+        'perform_advanced_morphosyntactic_analysis': perform_advanced_morphosyntactic_analysis
+    }
+
+def load_semantic_functions():
+    from .semantic.semantic_interface import (
+        display_semantic_interface, 
+        display_semantic_results
+    )
+    from modules.semantic.semantic_process import (
+        process_semantic_input, 
+        format_semantic_results
+    )
+
+    return {
+        'display_semantic_interface': display_semantic_interface,
+        'display_semantic_results': display_semantic_results,
+        'process_semantic_input': process_semantic_input,
+        'format_semantic_results': format_analysis_results,
+    }
+
+
+def load_discourse_functions():
+    from .discourse.discourse_interface import (
+        display_discourse_interface, 
+        display_discourse_results
+    )
+    from modules.discourse.discourse_process import (
+        perform_discourse_analysis,      # Este es el nombre correcto de la función
+        extract_key_concepts,            # Función adicional que necesitamos
+        generate_concept_graph,          # Función adicional que necesitamos
+        calculate_similarity_matrix      # Función adicional que necesitamos
+    )
+    
+    return {
+        'display_discourse_interface': display_discourse_interface,
+        'display_discourse_results': display_discourse_results,
+        'perform_discourse_analysis': perform_discourse_analysis,
+        'extract_key_concepts': extract_key_concepts,
+        'generate_concept_graph': generate_concept_graph,
+        'calculate_similarity_matrix': calculate_similarity_matrix
+    }
+
+def load_admin_functions():
+    from .admin.admin_ui import admin_page
+    return {
+        'admin_page': admin_page
+    }
+
+def load_utils_functions():
+    from .utils.spacy_utils import load_spacy_models
+    return {
+        'load_spacy_models': load_spacy_models
+    }
+
+def load_chatbot_functions():
+    """
+    Carga las funciones del módulo de chatbot
+    Returns:
+        dict: Diccionario con las funciones del chatbot
+    """
+    from modules.chatbot.sidebar_chat import (
+        display_sidebar_chat
+    )
+    
+    from modules.chatbot.chat_process import (
+        ChatProcessor
+    )
+    
+    return {
+        'display_sidebar_chat': display_sidebar_chat,
+        'ChatProcessor': ChatProcessor
+    }
+
+# Función para cargar todas las funciones
+def load_all_functions():
+    return {
+        **load_auth_functions(),
+        **load_database_functions(),
+        # **load_ui_functions(),
+        **load_admin_functions(),
+        **load_morphosyntax_functions(),
+        **load_semantic_functions(),
+        **load_discourse_functions(),
+        **load_utils_functions(),
+        **load_chatbot_functions(),
+        **load_student_activities_functions(),
+        **load_current_situation_functions()  # Agregar el nuevo loader
+    }

src/modules/__init__Old-V3.py

@@ -0,0 +1,180 @@
+# modules/__init__.py
+
+def load_auth_functions():
+    from .auth.auth import authenticate_user, register_user
+    return {
+        'authenticate_user': authenticate_user,
+        'register_user': register_user
+    }
+
+def load_database_function():
+    from .database.database_oldFromV2 import (
+        initialize_mongodb_connection,
+        initialize_database_connections,
+        create_admin_user,
+        create_student_user,
+        get_user,
+        get_student_data,
+        get_user_files,
+        delete_file,
+        store_application_request,
+        store_user_feedback,
+        store_morphosyntax_result,
+        store_semantic_result,
+        store_discourse_analysis_result,
+        store_chat_history,
+        export_analysis_and_chat,
+        manage_file_contents
+    )
+    return {
+        'initialize_mongodb_connection': initialize_mongodb_connection,
+        'initialize_database_connections': initialize_database_connections,
+        'create_admin_user': create_admin_user,
+        'create_student_user': create_student_user,
+        'get_user': get_user,
+        'get_student_data': get_student_data,
+        'get_user_files': get_user_files,
+        'delete_file': delete_file,
+        'store_application_request': store_application_request,
+        'store_user_feedback': store_user_feedback,
+        'store_morphosyntax_result': store_morphosyntax_result,
+        'store_semantic_result': store_semantic_result,
+        'store_discourse_analysis_result': store_discourse_analysis_result,
+        'store_chat_history': store_chat_history,
+        'export_analysis_and_chat': export_analysis_and_chat,
+        'manage_file_contents': manage_file_contents
+    }
+
+def load_ui_functions():
+    # No importamos nada de ui.py aquí
+    return {}  # Retornamos un diccionario vacío
+
+
+def load_student_activities_functions():
+    from .studentact.student_activities_v2 import display_student_progress
+    return {
+        'display_student_progress': display_student_progress
+    }
+
+def load_morphosyntax_functions():
+    from .morphosyntax.morphosyntax_interface import display_morphosyntax_interface
+    from .morphosyntax.morphosyntax_process import process_morphosyntactic_input
+    return {
+        'display_morphosyntax_interface': display_morphosyntax_interface,
+        'process_morphosyntactic_input': process_morphosyntactic_input
+    }
+
+def load_semantic_functions():
+    from .semantic.semantic_interface_68ok import display_semantic_interface
+    from .semantic.semantic_process import process_semantic_input
+    return {
+        'display_semantic_interface': display_semantic_interface,
+        'process_semantic_input': process_semantic_input
+    }
+
+def load_discourse_functions():
+    from .discourse.discourse_interface import display_discourse_interface
+    from .discourse.discourse_process import process_discourse_input
+    return {
+        'display_discourse_interface': display_discourse_interface,
+        'process_discourse_input': process_discourse_input
+    }
+
+def load_email_functions():
+    from .email.email import send_email_notification
+    return {
+        'send_email_notification': send_email_notification
+    }
+
+def load_admin_functions():
+    from .admin.admin_ui import admin_page
+    return {
+        'admin_page': admin_page
+    }
+
+def load_text_analysis_functions():
+    from .text_analysis.morpho_analysis import (
+        generate_arc_diagram,
+        perform_advanced_morphosyntactic_analysis,
+        perform_pos_analysis,
+        perform_morphological_analysis,
+        analyze_sentence_structure,
+        get_repeated_words_colors,
+        highlight_repeated_words,
+    )
+    from .text_analysis.semantic_analysis import (
+        perform_semantic_analysis,
+        generate_summary,
+        extract_entities,
+        analyze_sentiment,
+        create_topic_graph,
+        visualize_topic_graph,
+        ENTITY_LABELS
+    )
+    from .text_analysis.discourse_analysis import (
+        perform_discourse_analysis,
+        compare_semantic_analysis
+    )
+    return {
+        'generate_arc_diagram': generate_arc_diagram,
+        'perform_advanced_morphosyntactic_analysis': perform_advanced_morphosyntactic_analysis,
+        'perform_pos_analysis': perform_pos_analysis,
+        'perform_morphological_analysis': perform_morphological_analysis,
+        'analyze_sentence_structure': analyze_sentence_structure,
+        'get_repeated_words_colors': get_repeated_words_colors,
+        'highlight_repeated_words': highlight_repeated_words,
+        'perform_semantic_analysis': perform_semantic_analysis,
+        'generate_summary': generate_summary,
+        'extract_entities': extract_entities,
+        'analyze_sentiment': analyze_sentiment,
+        'create_topic_graph': create_topic_graph,
+        'visualize_topic_graph': visualize_topic_graph,
+        'ENTITY_LABELS': ENTITY_LABELS,
+        'perform_discourse_analysis': perform_discourse_analysis,
+        'compare_semantic_analysis': compare_semantic_analysis
+    }
+
+def load_utils_functions():
+    from .utils.spacy_utils import load_spacy_models
+    return {
+        'load_spacy_models': load_spacy_models
+    }
+
+def load_chatbot_functions():
+    from .chatbot.chatbot import (
+        ClaudeAPIChat,
+        initialize_chatbot,
+        process_chat_input,
+        get_connectors,
+        handle_semantic_commands,
+        generate_topics_visualization,
+        extract_topics,
+        get_semantic_chatbot_response
+    )
+    return {
+        'ClaudeAPIChat': ClaudeAPIChat,
+        'initialize_chatbot': initialize_chatbot,
+        'process_chat_input': process_chat_input,
+        'get_connectors': get_connectors,
+        'handle_semantic_commands': handle_semantic_commands,
+        'generate_topics_visualization': generate_topics_visualization,
+        'extract_topics': extract_topics,
+        'get_semantic_chatbot_response': get_semantic_chatbot_response
+    }
+
+# Función para cargar todas las funciones
+def load_all_functions():
+    return {
+        **load_auth_functions(),
+        **load_database_function(),
+        # **load_ui_functions(),
+        **load_admin_functions(),
+        **load_morphosyntax_functions(),
+        **load_semantic_functions(),
+        **load_discourse_functions(),
+        **load_text_analysis_functions(),
+        **load_utils_functions(),
+        **load_chatbot_functions(),
+        **load_email_functions()
+        **load_student_activities_functions()  # Añadimos las nuevas funciones de actividades del estudiante
+    }

src/modules/admin/admin_ui.py

@@ -0,0 +1,250 @@
+#modules/admin/admin_ui.py
+
+import streamlit as st
+
+from datetime import datetime
+
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    get_teacher_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user,
+    record_login, 
+    record_logout, 
+    get_recent_sessions,
+    get_user_total_time
+)
+
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+
+from ..auth.auth import hash_password  # Agregar esta importación al inicio
+
+#######################################################################################
+def format_duration(seconds):
+    """Convierte segundos a formato legible"""
+    if not seconds:
+        return "0h 0m"
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    return f"{hours}h {minutes}m"
+
+def admin_page():
+    st.title("Panel de Administración")
+    st.write(f"Bienvenido, {st.session_state.username}")
+
+    # Crear tres tabs para las diferentes secciones
+    tab1, tab2, tab3 = st.tabs([
+        "Gestión de Usuarios",
+        "Búsqueda de Usuarios",
+        "Actividad de la Plataforma"
+    ])
+
+    
+########################################################
+    # Tab 1: Gestión de Usuarios
+    with tab1:
+        st.header("Crear Nuevo Usuario Estudiante")
+        
+        # Crear dos columnas para el formulario
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_username = st.text_input(
+                "Correo electrónico del nuevo usuario", 
+                key="admin_new_username"
+            )
+        
+        with col2:
+            new_password = st.text_input(
+                "Contraseña", 
+                type="password", 
+                key="admin_new_password"
+            )
+        
+        if st.button("Crear Usuario", key="admin_create_user", type="primary"):
+            if new_username and new_password:  # Verificamos que ambos campos tengan valor
+                try:
+                    # Hashear la contraseña antes de crear el usuario
+                    hashed_password = hash_password(new_password)
+                    if create_student_user(new_username, hashed_password, {'partitionKey': new_username}):
+                        st.success(f"Usuario estudiante {new_username} creado exitosamente")
+                    else:
+                        st.error("Error al crear el usuario estudiante")
+                except Exception as e:
+                    st.error(f"Error al crear usuario: {str(e)}")
+            else:
+                st.warning("Por favor complete todos los campos")
+
+#######################################################################                
+    # Tab 2: Búsqueda de Usuarios
+    with tab2:
+        st.header("Búsqueda de Usuarios")
+        
+        search_col1, search_col2 = st.columns([2,1])
+        
+        with search_col1:
+            student_username = st.text_input(
+                "Nombre de usuario del estudiante", 
+                key="admin_view_student"
+            )
+        
+        with search_col2:
+            search_button = st.button(
+                "Buscar", 
+                key="admin_view_student_data",
+                type="primary"
+            )
+
+        if search_button:
+            student = get_student_user(student_username)
+            if student:
+                # Crear tabs para diferentes tipos de información
+                info_tab1, info_tab2, info_tab3 = st.tabs([
+                    "Información Básica",
+                    "Análisis Realizados",
+                    "Tiempo en Plataforma"
+                ])
+                
+                with info_tab1:
+                    st.subheader("Información del Usuario")
+                    st.json(student)
+
+                with info_tab2:
+                    st.subheader("Análisis Realizados")
+                    student_data = get_student_morphosyntax_analysis(student_username)
+                    if student_data:
+                        st.json(student_data)
+                    else:
+                        st.info("No hay datos de análisis para este estudiante.")
+
+                with info_tab3:
+                    st.subheader("Tiempo en Plataforma")
+                    total_time = get_user_total_time(student_username)
+                    if total_time:
+                        st.metric(
+                            "Tiempo Total", 
+                            format_duration(total_time)
+                        )
+                    else:
+                        st.info("No hay registros de tiempo para este usuario")
+            else:
+                st.error("Estudiante no encontrado")
+
+#######################################################################      
+    # Tab 3: Actividad de la Plataforma
+    with tab3:
+        st.header("Actividad Reciente")
+        
+        # Agregar botón de actualización
+        if st.button("Actualizar datos", key="refresh_sessions", type="primary"):
+            st.rerun()
+        
+        # Mostrar spinner mientras carga
+        with st.spinner("Cargando datos de sesiones..."):
+            # Obtener sesiones recientes
+            recent_sessions = get_recent_sessions(20)  # Aumentado a 20 para más datos
+        
+        if recent_sessions:
+            # Crear dataframe para mostrar los datos
+            sessions_data = []
+            for session in recent_sessions:
+                try:
+                    # Manejar el formato de fecha con manejo de excepciones
+                    try:
+                        login_time = datetime.fromisoformat(
+                            session['loginTime'].replace('Z', '+00:00')
+                        ).strftime("%Y-%m-%d %H:%M:%S")
+                    except Exception as e:
+                        login_time = session['loginTime']
+                    
+                    # Manejar el caso de logout_time cuando la sesión está activa
+                    if session.get('logoutTime') and session['logoutTime'] != "Activo":
+                        try:
+                            logout_time = datetime.fromisoformat(
+                                session['logoutTime'].replace('Z', '+00:00')
+                            ).strftime("%Y-%m-%d %H:%M:%S")
+                        except Exception as e:
+                            logout_time = session['logoutTime']
+                    else:
+                        logout_time = "Activo"
+                    
+                    # Agregar datos a la lista
+                    sessions_data.append({
+                        "Usuario": session.get('username', 'Desconocido'),
+                        "Inicio de Sesión": login_time,
+                        "Fin de Sesión": logout_time,
+                        "Duración": format_duration(session.get('sessionDuration', 0))
+                    })
+                except Exception as e:
+                    st.error(f"Error procesando sesión: {str(e)}")
+                    continue
+            
+            # Mostrar información de depuración si hay problemas
+            with st.expander("Información de depuración", expanded=False):
+                st.write("Datos crudos recuperados:")
+                st.json(recent_sessions)
+                
+                st.write("Datos procesados para mostrar:")
+                st.json(sessions_data)
+            
+            # Mostrar tabla con estilos
+            st.dataframe(
+                sessions_data,
+                hide_index=True,
+                column_config={
+                    "Usuario": st.column_config.TextColumn(
+                        "Usuario",
+                        width="medium"
+                    ),
+                    "Inicio de Sesión": st.column_config.TextColumn(
+                        "Inicio de Sesión",
+                        width="medium"
+                    ),
+                    "Fin de Sesión": st.column_config.TextColumn(
+                        "Fin de Sesión",
+                        width="medium"
+                    ),
+                    "Duración": st.column_config.TextColumn(
+                        "Duración",
+                        width="small"
+                    )
+                }
+            )
+            
+            # Añadir métricas resumen
+            total_sessions = len(sessions_data)
+            total_users = len(set(session['Usuario'] for session in sessions_data))
+            
+            metric_col1, metric_col2 = st.columns(2)
+            with metric_col1:
+                st.metric("Total de Sesiones", total_sessions)
+            with metric_col2:
+                st.metric("Usuarios Únicos", total_users)
+        else:
+            st.info("No hay registros de sesiones recientes o hubo un problema al recuperarlos.")
+            
+            # Ayuda de depuración
+            if st.button("Mostrar diagnóstico"):
+                st.write("Verificando la función get_recent_sessions:")
+                container = get_container("users_sessions")
+                if container:
+                    st.success("✅ Conectado al contenedor users_sessions")
+                else:
+                    st.error("❌ No se pudo conectar al contenedor users_sessions")
+
+
+#######################################################################      
+    # Agregar una línea divisoria antes del botón
+    st.markdown("---")
+
+#######################################################################      
+    # Centrar el botón de cierre de sesión
+    col1, col2, col3 = st.columns([2,1,2])
+    with col2:
+        if st.button("Cerrar Sesión", key="admin_logout", type="primary", use_container_width=True):
+            from ..auth.auth import logout
+            logout()
+            st.rerun()

src/modules/auth/auth.py

@@ -0,0 +1,195 @@
+##########modules/auth/auth.py
+
+import os
+import streamlit as st
+from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos.exceptions import CosmosHttpResponseError
+import bcrypt
+import base64
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user,
+    record_login,
+    record_logout
+)
+
+import logging
+
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+
+def clean_and_validate_key(key):
+    """Limpia y valida la clave de CosmosDB"""
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Verificar las variables de entorno
+endpoint = os.getenv("COSMOS_ENDPOINT")
+key = os.getenv("COSMOS_KEY")
+
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
+
+
+def authenticate_user(username, password):
+    """Autentica un usuario y registra el inicio de sesión"""
+    try:
+        user_item = get_user(username)
+        
+        if not user_item:
+            logger.warning(f"Usuario no encontrado: {username}")
+            return False, None
+            
+        if verify_password(user_item['password'], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
+            
+            try:
+                session_id = record_login(username)
+                if session_id:
+                    st.session_state.session_id = session_id
+                    st.session_state.username = username
+                    st.session_state.login_time = datetime.now(timezone.utc).isoformat()
+                    logger.info(f"Sesión iniciada: {session_id}")
+                else:
+                    logger.warning("No se pudo registrar la sesión")
+            except Exception as e:
+                logger.error(f"Error al registrar inicio de sesión: {str(e)}")
+            
+            return True, user_item['role']
+            
+        logger.warning(f"Contraseña incorrecta para usuario: {username}")
+        return False, None
+        
+    except Exception as e:
+        logger.error(f"Error durante la autenticación del usuario: {str(e)}")
+        return False, None
+
+def authenticate_student(username, password):
+    """Autentica un estudiante"""
+    success, role = authenticate_user(username, password)
+    if success and role == 'Estudiante':
+        return True, role
+    return False, None
+
+def authenticate_admin(username, password):
+    """Autentica un administrador"""
+    success, role = authenticate_user(username, password)
+    if success and role == 'Administrador':
+        return True, role
+    return False, None
+
+def register_student(username, password, additional_info=None):
+    """Registra un nuevo estudiante"""
+    try:
+        if get_student_user(username):
+            logger.warning(f"Estudiante ya existe: {username}")
+            return False
+
+        hashed_password = hash_password(password)
+        
+        # Asegurarse que additional_info tenga el rol correcto
+        if not additional_info:
+            additional_info = {}
+        additional_info['role'] = 'Estudiante'
+        
+        success = create_student_user(username, hashed_password, additional_info)
+        if success:
+            logger.info(f"Nuevo estudiante registrado: {username}")
+            return True
+            
+        logger.error(f"Error al crear estudiante: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error al registrar estudiante: {str(e)}")
+        return False
+
+def update_student_info(username, new_info):
+    """Actualiza la información de un estudiante"""
+    try:
+        if 'password' in new_info:
+            new_info['password'] = hash_password(new_info['password'])
+            
+        success = update_student_user(username, new_info)
+        if success:
+            logger.info(f"Información actualizada: {username}")
+            return True
+            
+        logger.error(f"Error al actualizar: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error en actualización: {str(e)}")
+        return False
+
+def delete_student(username):
+    """Elimina un estudiante"""
+    try:
+        success = delete_student_user(username)
+        if success:
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+            
+        logger.error(f"Error al eliminar: {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error en eliminación: {str(e)}")
+        return False
+
+def logout():
+    """Cierra la sesión del usuario"""
+    try:
+        if 'session_id' in st.session_state and 'username' in st.session_state:
+            success = record_logout(
+                st.session_state.username, 
+                st.session_state.session_id
+            )
+            if success:
+                logger.info(f"Sesión cerrada: {st.session_state.username}")
+            else:
+                logger.warning(f"Error al registrar cierre de sesión: {st.session_state.username}")
+        
+    except Exception as e:
+        logger.error(f"Error en logout: {str(e)}")
+    finally:
+        st.session_state.clear()
+
+def hash_password(password):
+    """Hashea una contraseña"""
+    return bcrypt.hashpw(
+        password.encode('utf-8'), 
+        bcrypt.gensalt()
+    ).decode('utf-8')
+
+def verify_password(stored_password, provided_password):
+    """Verifica una contraseña"""
+    return bcrypt.checkpw(
+        provided_password.encode('utf-8'), 
+        stored_password.encode('utf-8')
+    )
+
+__all__ = [
+    'authenticate_user',
+    'authenticate_admin',
+    'authenticate_student',
+    'register_student',
+    'update_student_info',
+    'delete_student',
+    'logout',
+    'hash_password',
+    'verify_password'
+]