Upload 4 files

modules/studentact/claude_recommendations.py

@@ -29,6 +29,11 @@ TEXT_TYPES = {
         'academic_article': 'article académique',
         'university_work': 'travail universitaire',
         'general_communication': 'communication générale'
+    },
+    'pt': {
+        'academic_article': 'artigo acadêmico',
+        'university_work': 'trabalho universitário',
+        'general_communication': 'comunicação geral'
     }
 }
 
@@ -102,6 +107,51 @@ def generate_claude_recommendations(text, metrics, text_type, lang_code):
             4. Una sugerencia sobre qué herramienta de AIdeaText usar (Análisis Morfosintáctico, Análisis Semántico o Análisis del Discurso)
             
             Tu respuesta debe ser concisa y no exceder los 300 palabras."""
+        
+        elif lang_code == 'fr':
+            system_prompt = """Vous êtes un assistant spécialisé dans l'analyse de textes académiques et de communication écrite.
+            Votre tâche est d'analyser le texte de l'utilisateur et de fournir des recommandations personnalisées.
+            Utilisez un ton constructif et spécifique. Soyez clair et direct dans vos suggestions.
+            """
+            user_prompt = f"""Veuillez analyser ce texte de type '{formatted_metrics['text_type']}' 
+            et fournir des recommandations personnalisées pour l'améliorer.
+            
+            MÉTRIQUES D'ANALYSE:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXTE À ANALYSER:
+            {text[:2000]}
+            
+            Fournissez votre analyse avec le format suivant:
+            1. Un résumé bref (2-3 phrases) de l'analyse générale
+            2. 3-4 recommandations spécifiques et réalisables (chacune de 1-2 phrases)
+            3. Un exemple concret d'amélioration tiré du texte même de l'utilisateur
+            4. Une suggestion sur quel outil AIdeaText utiliser (Analyse Morphosyntaxique, Analyse Sémantique ou Analyse du Discours)
+            
+            Votre réponse doit être concise et ne pas dépasser 300 mots."""
+            
+        elif lang_code == 'pt':
+            system_prompt = """Você é um assistente especializado na análise de textos acadêmicos e comunicação escrita.
+            Sua tarefa é analisar o texto do usuário e fornecer recomendações personalizadas.
+            Use um tom construtivo e específico. Seja claro e direto com suas sugestões.
+            """
+            user_prompt = f"""Por favor, analise este texto do tipo '{formatted_metrics['text_type']}' 
+            e forneça recomendações personalizadas para melhorá-lo.
+            
+            MÉTRICAS DE ANÁLISE:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXTO PARA ANALISAR:
+            {text[:2000]}
+            
+            Forneça sua análise com o seguinte formato:
+            1. Um breve resumo (2-3 frases) da análise geral
+            2. 3-4 recomendações específicas e acionáveis (cada uma com 1-2 frases)
+            3. Um exemplo concreto de melhoria retirado do próprio texto do usuário
+            4. Uma sugestão sobre qual ferramenta do AIdeaText usar (Análise Morfossintática, Análise Semântica ou Análise do Discurso)
+            
+            Sua resposta deve ser concisa e não exceder 300 palavras."""
+         
         else:
             # Default to English
             system_prompt = """You are an assistant specialized in analyzing academic texts and written communication.
@@ -152,6 +202,8 @@ def generate_claude_recommendations(text, metrics, text_type, lang_code):
         logger.error(f"Error generating recommendations with Claude: {str(e)}")
         return get_fallback_recommendations(lang_code)
 
+##################################################################################
+##################################################################################
 def get_fallback_recommendations(lang_code):
     """
     Return fallback recommendations if Claude API fails
@@ -160,16 +212,45 @@ def get_fallback_recommendations(lang_code):
         return """
         **Análisis General**
         Tu texto presenta una estructura básica adecuada, pero hay áreas que pueden mejorarse para mayor claridad y cohesión.
-
         **Recomendaciones**:
         - Intenta variar tu vocabulario para evitar repeticiones innecesarias
         - Considera revisar la longitud de tus oraciones para mantener un mejor ritmo
         - Asegúrate de establecer conexiones claras entre las ideas principales
         - Revisa la consistencia en el uso de tiempos verbales
-
         **Herramienta recomendada**: 
         Te sugerimos utilizar el Análisis Morfosintáctico para identificar patrones en tu estructura de oraciones.
         """
+        
+    elif lang_code == 'fr':
+        return """
+        **Analyse Générale**
+        Votre texte présente une structure de base adéquate, mais certains aspects pourraient être améliorés pour plus de clarté et de cohésion.
+        
+        **Recommandations**:
+        - Essayez de varier votre vocabulaire pour éviter les répétitions inutiles
+        - Envisagez de revoir la longueur de vos phrases pour maintenir un meilleur rythme
+        - Assurez-vous d'établir des liens clairs entre les idées principales
+        - Vérifiez la cohérence dans l'utilisation des temps verbaux
+        
+        **Outil recommandé**: 
+        Nous vous suggérons d'utiliser l'Analyse Morphosyntaxique pour identifier les modèles dans la structure de vos phrases.
+        """
+    
+    elif lang_code == 'pt':
+        return """
+        **Análise Geral**
+        Seu texto apresenta uma estrutura básica adequada, mas há áreas que podem ser melhoradas para maior clareza e coesão.
+        
+        **Recomendações**:
+        - Tente variar seu vocabulário para evitar repetições desnecessárias
+        - Considere revisar o comprimento de suas frases para manter um melhor ritmo
+        - Certifique-se de estabelecer conexões claras entre as ideias principais
+        - Revise a consistência no uso dos tempos verbais
+        
+        **Ferramenta recomendada**: 
+        Sugerimos utilizar a Análise Morfossintática para identificar padrões na sua estrutura de frases.
+        """
+    
     else:
         return """
         **General Analysis**
@@ -187,7 +268,7 @@ def get_fallback_recommendations(lang_code):
 
 
 #######################################
-
+#######################################
 def store_recommendations(username, text, metrics, text_type, recommendations):
     """
     Store the recommendations in the database

modules/studentact/current_situation_analysis.py

@@ -10,7 +10,6 @@ import numpy as np
 import matplotlib.patches as patches
 import logging
 
-from translations.recommendations import RECOMMENDATIONS
 
 # 2. Configuración básica del logging
 logging.basicConfig(
@@ -622,6 +621,7 @@ def normalize_score(value, metric_type,
 
 #########################################################################
 #########################################################################
+
 def generate_recommendations(metrics, text_type, lang_code='es'):
     """
     Genera recomendaciones personalizadas basadas en las métricas del texto y el tipo de texto.
@@ -629,12 +629,18 @@ def generate_recommendations(metrics, text_type, lang_code='es'):
     Args:
         metrics: Diccionario con las métricas analizadas
         text_type: Tipo de texto ('academic_article', 'student_essay', 'general_communication')
-        lang_code: Código del idioma para las recomendaciones (es, en, fr, pt)
+        lang_code: Código del idioma para las recomendaciones (es, en, uk)
     
     Returns:
         dict: Recomendaciones organizadas por categoría en el idioma correspondiente
     """
     try:
+        # Añadir debug log para verificar el código de idioma recibido
+        logger.info(f"generate_recommendations llamado con idioma: {lang_code}")
+        
+        # Comprobar que importamos RECOMMENDATIONS correctamente
+        logger.info(f"Idiomas disponibles en RECOMMENDATIONS: {list(RECOMMENDATIONS.keys())}")
+        
         # Obtener umbrales según el tipo de texto
         thresholds = TEXT_TYPES[text_type]['thresholds']
         
@@ -701,17 +707,17 @@ def generate_recommendations(metrics, text_type, lang_code='es'):
         
     except Exception as e:
         logger.error(f"Error en generate_recommendations: {str(e)}")
-        # Retornar mensajes genéricos en caso de error
-        if lang_code == 'en':
-            return {
-                'vocabulary': ["Try enriching your vocabulary"],
-                'structure': ["Work on the structure of your sentences"],
-                'cohesion': ["Improve the connection between your ideas"],
-                'clarity': ["Try to express your ideas more clearly"],
-                'specific': ["Adapt your text according to its purpose"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Seek specific feedback from a tutor or teacher"]
+        
+        # Utilizar un enfoque basado en el idioma actual en lugar de casos codificados
+        # Esto permite manejar ucraniano y cualquier otro idioma futuro
+        fallback_translations = {
+            'en': {
+                'basic_recommendations': {
+                    'vocabulary': ["Try enriching your vocabulary"],
+                    'structure': ["Work on the structure of your sentences"],
+                    'cohesion': ["Improve the connection between your ideas"],
+                    'clarity': ["Try to express your ideas more clearly"],
+                    'specific': ["Adapt your text according to its purpose"],
                 },
                 'dimension_names': {
                     'vocabulary': 'Vocabulary',
@@ -728,71 +734,38 @@ def generate_recommendations(metrics, text_type, lang_code='es'):
                     'save_error': "Error saving analysis",
                     'area_priority': "Priority area"
                 }
-            }
-        elif lang_code == 'fr':
-            return {
-                'vocabulary': ["Essayez d'enrichir votre vocabulaire"],
-                'structure': ["Travaillez sur la structure de vos phrases"],
-                'cohesion': ["Améliorez la connexion entre vos idées"],
-                'clarity': ["Essayez d'exprimer vos idées plus clairement"],
-                'specific': ["Adaptez votre texte en fonction de son objectif"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Demandez des commentaires spécifiques à un tuteur ou un professeur"]
-                },
-                'dimension_names': {
-                    'vocabulary': 'Vocabulaire',
-                    'structure': 'Structure',
-                    'cohesion': 'Cohésion',
-                    'clarity': 'Clarté',
-                    'general': 'Général'
-                },
-                'ui_text': {
-                    'priority_intro': "C'est là que vous devriez concentrer vos efforts.",
-                    'detailed_recommendations': "Recommandations détaillées",
-                    'save_button': "Enregistrer l'analyse",
-                    'save_success': "Analyse enregistrée avec succès",
-                    'save_error': "Erreur lors de l'enregistrement de l'analyse",
-                    'area_priority': "Domaine prioritaire"
-                }
-            }
-        elif lang_code == 'pt':
-            return {
-                'vocabulary': ["Tente enriquecer seu vocabulário"],
-                'structure': ["Trabalhe na estrutura de suas frases"],
-                'cohesion': ["Melhore a conexão entre suas ideias"],
-                'clarity': ["Tente expressar suas ideias com mais clareza"],
-                'specific': ["Adapte seu texto de acordo com seu propósito"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Busque feedback específico de um tutor ou professor"]
+            },
+            'uk': {
+                'basic_recommendations': {
+                    'vocabulary': ["Розширте свій словниковий запас"],
+                    'structure': ["Покращіть структуру ваших речень"],
+                    'cohesion': ["Покращіть зв'язок між вашими ідеями"],
+                    'clarity': ["Висловлюйте свої ідеї ясніше"],
+                    'specific': ["Адаптуйте свій текст відповідно до його мети"],
                 },
                 'dimension_names': {
-                    'vocabulary': 'Vocabulário',
-                    'structure': 'Estrutura',
-                    'cohesion': 'Coesão',
-                    'clarity': 'Clareza',
-                    'general': 'Geral'
+                    'vocabulary': 'Словниковий запас',
+                    'structure': 'Структура',
+                    'cohesion': 'Зв\'язність',
+                    'clarity': 'Ясність',
+                    'general': 'Загальне'
                 },
                 'ui_text': {
-                    'priority_intro': "É aqui que você deve concentrar seus esforços.",
-                    'detailed_recommendations': "Recomendações detalhadas",
-                    'save_button': "Salvar análise",
-                    'save_success': "Análise salva com sucesso",
-                    'save_error': "Erro ao salvar análise",
-                    'area_priority': "Área prioritária"
+                    'priority_intro': "Це область, де ви повинні зосередити свої зусилля.",
+                    'detailed_recommendations': "Детальні рекомендації",
+                    'save_button': "Зберегти аналіз",
+                    'save_success': "Аналіз успішно збережено",
+                    'save_error': "Помилка при збереженні аналізу",
+                    'area_priority': "Пріоритетна область"
                 }
-            }
-        else:  # Español por defecto
-            return {
-                'vocabulary': ["Intenta enriquecer tu vocabulario"],
-                'structure': ["Trabaja en la estructura de tus oraciones"],
-                'cohesion': ["Mejora la conexión entre tus ideas"],
-                'clarity': ["Busca expresar tus ideas con mayor claridad"],
-                'specific': ["Adapta tu texto según su propósito"],
-                'priority': {
-                    'area': 'general',
-                    'tips': ["Busca retroalimentación específica de un tutor o profesor"]
+            },
+            'es': {
+                'basic_recommendations': {
+                    'vocabulary': ["Intenta enriquecer tu vocabulario"],
+                    'structure': ["Trabaja en la estructura de tus oraciones"],
+                    'cohesion': ["Mejora la conexión entre tus ideas"],
+                    'clarity': ["Busca expresar tus ideas con mayor claridad"],
+                    'specific': ["Adapta tu texto según su propósito"],
                 },
                 'dimension_names': {
                     'vocabulary': 'Vocabulario',
@@ -810,6 +783,30 @@ def generate_recommendations(metrics, text_type, lang_code='es'):
                     'area_priority': "Área prioritaria"
                 }
             }
+        }
+        
+        # Usar el idioma actual si está disponible, o inglés, o español como última opción
+        current_lang = fallback_translations.get(lang_code, 
+                       fallback_translations.get('en', 
+                       fallback_translations['es']))
+                       
+        basic_recommendations = current_lang['basic_recommendations']
+        
+        return {
+            'vocabulary': basic_recommendations['vocabulary'],
+            'structure': basic_recommendations['structure'],
+            'cohesion': basic_recommendations['cohesion'],
+            'clarity': basic_recommendations['clarity'],
+            'specific': basic_recommendations['specific'],
+            'priority': {
+                'area': 'general',
+                'tips': ["Busca retroalimentación específica de un tutor o profesor"]
+            },
+            'dimension_names': current_lang['dimension_names'],
+            'ui_text': current_lang['ui_text']
+        }
+
+
 
 
 #########################################################################
@@ -822,6 +819,7 @@ def generate_sentence_graphs(doc):
     plt.close()
     return fig
 
+############################################################################
 def generate_word_connections(doc):
     """Genera red de conexiones de palabras"""
     fig, ax = plt.subplots(figsize=(10, 6))
@@ -829,6 +827,7 @@ def generate_word_connections(doc):
     plt.close()
     return fig
 
+############################################################################
 def generate_connection_paths(doc):
     """Genera patrones de conexión"""
     fig, ax = plt.subplots(figsize=(10, 6))
@@ -836,6 +835,7 @@ def generate_connection_paths(doc):
     plt.close()
     return fig
 
+############################################################################
 def create_vocabulary_network(doc):
     """
     Genera el grafo de red de vocabulario.
@@ -882,6 +882,7 @@ def create_vocabulary_network(doc):
     plt.axis('off')
     return fig
 
+############################################################################
 def create_syntax_complexity_graph(doc):
     """
     Genera el diagrama de arco de complejidad sintáctica.
@@ -961,7 +962,7 @@ def create_syntax_complexity_graph(doc):
         logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
         return None
 
-
+############################################################################
 def create_cohesion_heatmap(doc):
     """Genera un mapa de calor que muestra la cohesión entre párrafos/oraciones."""
     try:
@@ -1005,4 +1006,4 @@ def create_cohesion_heatmap(doc):
         
     except Exception as e:
         logger.error(f"Error en create_cohesion_heatmap: {str(e)}")
-        return None
+        return None

modules/studentact/current_situation_interface.py

@@ -16,7 +16,9 @@ try:
 except ImportError:
     # Si no existe el módulo, definimos una función placeholder
     def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
-        st.warning("Módulo de recomendaciones personalizadas no disponible. Por favor, contacte al administrador.")
+        # Obtener el mensaje de advertencia traducido si está disponible
+        warning = t.get('module_not_available', "Módulo de recomendaciones personalizadas no disponible. Por favor, contacte al administrador.")
+        st.warning(warning)
 
 from .current_situation_analysis import (
     analyze_text_dimensions, 
@@ -42,11 +44,10 @@ plt.rcParams['axes.spines.right'] = False
 
 logger = logging.getLogger(__name__)
 
-####################################
-# Definición global de los tipos de texto y sus umbrales
+# Definición de tipos de texto con umbrales
 TEXT_TYPES = {
     'academic_article': {
-        'name': 'Artículo Académico',
+        # Los nombres se obtendrán de las traducciones
         'thresholds': {
             'vocabulary': {'min': 0.70, 'target': 0.85},
             'structure': {'min': 0.75, 'target': 0.90},
@@ -55,7 +56,6 @@ TEXT_TYPES = {
         }
     },
     'student_essay': {
-        'name': 'Trabajo Universitario',
         'thresholds': {
             'vocabulary': {'min': 0.60, 'target': 0.75},
             'structure': {'min': 0.65, 'target': 0.80},
@@ -64,7 +64,6 @@ TEXT_TYPES = {
         }
     },
     'general_communication': {
-        'name': 'Comunicación General',
         'thresholds': {
             'vocabulary': {'min': 0.50, 'target': 0.65},
             'structure': {'min': 0.55, 'target': 0.70},
@@ -73,16 +72,21 @@ TEXT_TYPES = {
         }
     }
 }
-####################################
 
+####################################################
+####################################################
 def display_current_situation_interface(lang_code, nlp_models, t):
     """
     Interfaz simplificada con gráfico de radar para visualizar métricas.
     """
+    # Agregar logs para depuración
+    logger.info(f"Idioma: {lang_code}")
+    logger.info(f"Claves en t: {list(t.keys())}")
+    
     # Inicializar estados si no existen
     if 'text_input' not in st.session_state:
         st.session_state.text_input = ""
-    if 'text_area' not in st.session_state:  # Añadir inicialización de text_area
+    if 'text_area' not in st.session_state:
         st.session_state.text_area = ""
     if 'show_results' not in st.session_state:
         st.session_state.show_results = False
@@ -97,30 +101,64 @@ def display_current_situation_interface(lang_code, nlp_models, t):
         # Container principal con dos columnas
         with st.container():
             input_col, results_col = st.columns([1,2])
-            
-            with input_col:
-                # Text area con manejo de estado
-                text_input = st.text_area(
-                    t.get('input_prompt', "Escribe o pega tu texto aquí:"),
-                    height=400,
-                    key="text_area",
-                    value=st.session_state.text_input,
-                    help="Este texto será analizado para darte recomendaciones personalizadas"
-                )
+
+###############################################################################################
+            # CSS personalizado para que el formulario ocupe todo el alto disponible
+            st.markdown("""
+            <style>
+                /* Hacer que la columna tenga una altura definida */
+                [data-testid="column"] {
+                    min-height: 900px;
+                    height: 100vh; /* 100% del alto visible de la ventana */
+                }
+                
+                /* Hacer que el formulario ocupe el espacio disponible en la columna */
+                .stForm {
+                    height: calc(100% - 40px); /* Ajuste por márgenes y paddings */
+                    display: flex;
+                    flex-direction: column;
+                }
                 
-                # Función para manejar cambios de texto
-                if text_input != st.session_state.text_input:
-                    st.session_state.text_input = text_input
-                    st.session_state.show_results = False
+                /* Hacer que el área de texto se expanda dentro del formulario */
+                .stForm .stTextArea {
+                    flex: 1;
+                    display: flex;
+                    flex-direction: column;
+                }
                 
-                if st.button(
-                    t.get('analyze_button', "Analizar mi escritura"),
-                    type="primary",
-                    disabled=not text_input.strip(),
-                    use_container_width=True,
-                ):
+                /* El textarea en sí debe expandirse */
+                .stForm .stTextArea textarea {
+                    flex: 1;
+                    min-height: 750px !important;
+                }
+            </style>
+            """, unsafe_allow_html=True)
+            
+###############################################################################################
+            with input_col:
+                with st.form(key=f"text_input_form_{lang_code}"):
+                    text_input = st.text_area(
+                        t.get('input_prompt', "Escribe o pega tu texto aquí:"),
+                        height=800,
+                        key=f"text_area_{lang_code}",
+                        value=st.session_state.text_input,
+                        help=t.get('help', "Este texto será analizado para darte recomendaciones personalizadas")
+                    )
+                    
+                    submit_button = st.form_submit_button(
+                        t.get('analyze_button', "Analizar mi escritura"),
+                        type="primary",
+                        use_container_width=True
+                    )
+                    
+                    if submit_button:
+                        if text_input.strip():
+                            st.session_state.text_input = text_input
+
+#######################################################################
+                # Código para análisis...
                     try:
-                        with st.spinner(t.get('processing', "Analizando...")):
+                        with st.spinner(t.get('processing', "Analizando...")):  # Usando t.get directamente
                             doc = nlp_models[lang_code](text_input)
                             metrics = analyze_text_dimensions(doc)
                             
@@ -140,33 +178,50 @@ def display_current_situation_interface(lang_code, nlp_models, t):
                             
                     except Exception as e:
                         logger.error(f"Error en análisis: {str(e)}")
-                        st.error(t.get('analysis_error', "Error al analizar el texto"))
+                        st.error(t.get('analysis_error', "Error al analizar el texto"))  # Usando t.get directamente
             
             # Mostrar resultados en la columna derecha
             with results_col:
                 if st.session_state.show_results and st.session_state.current_metrics is not None:
-                    # Primero los radio buttons para tipo de texto
-                    st.markdown("### Tipo de texto")
+                    # Primero los radio buttons para tipo de texto - usando t.get directamente
+                    st.markdown(f"### {t.get('text_type_header', 'Tipo de texto')}")
+                    
+                    # Preparar opciones de tipos de texto con nombres traducidos
+                    text_type_options = {}
+                    for text_type_key in TEXT_TYPES.keys():
+                        # Fallback a nombres genéricos si no hay traducción
+                        default_names = {
+                            'academic_article': 'Academic Article' if lang_code == 'en' else 'Артикул академічний' if lang_code == 'uk' else 'Artículo Académico',
+                            'student_essay': 'Student Essay' if lang_code == 'en' else 'Студентське есе' if lang_code == 'uk' else 'Trabajo Universitario',
+                            'general_communication': 'General Communication' if lang_code == 'en' else 'Загальна комунікація' if lang_code == 'uk' else 'Comunicación General'
+                        }
+                        text_type_options[text_type_key] = default_names.get(text_type_key, text_type_key)
+                    
                     text_type = st.radio(
-                        label="Tipo de texto",
+                        label=t.get('text_type_header', "Tipo de texto"),  # Usando t.get directamente
                         options=list(TEXT_TYPES.keys()),
-                        format_func=lambda x: TEXT_TYPES[x]['name'],
+                        format_func=lambda x: text_type_options.get(x, x),
                         horizontal=True,
                         key="text_type_radio",
                         label_visibility="collapsed",
-                        help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
+                        help=t.get('text_type_help', "Selecciona el tipo de texto para ajustar los criterios de evaluación")  # Usando t.get directamente
                     )
                     
                     st.session_state.current_text_type = text_type
                     
-                    # Crear subtabs
-                    subtab1, subtab2 = st.tabs(["Diagnóstico", "Recomendaciones"])
+                    # Crear subtabs con nombres traducidos
+                    diagnosis_tab = "Diagnosis" if lang_code == 'en' else "Діагностика" if lang_code == 'uk' else "Diagnóstico"
+                    recommendations_tab = "Recommendations" if lang_code == 'en' else "Рекомендації" if lang_code == 'uk' else "Recomendaciones"
+                    
+                    subtab1, subtab2 = st.tabs([diagnosis_tab, recommendations_tab])
                     
                     # Mostrar resultados en el primer subtab
                     with subtab1:
                         display_diagnosis(
                             metrics=st.session_state.current_metrics,
-                            text_type=text_type
+                            text_type=text_type,
+                            lang_code=lang_code,
+                            t=t  # Pasar t directamente, no current_situation_t
                         )
                     
                     # Mostrar recomendaciones en el segundo subtab
@@ -182,13 +237,59 @@ def display_current_situation_interface(lang_code, nlp_models, t):
 
     except Exception as e:
         logger.error(f"Error en interfaz principal: {str(e)}")
-        st.error("Ocurrió un error al cargar la interfaz")
+        st.error(t.get('error_interface', "Ocurrió un error al cargar la interfaz"))  # Usando t.get directamente
 
-def display_diagnosis(metrics, text_type=None):
+#################################################################
+#################################################################
+def display_diagnosis(metrics, text_type=None, lang_code='es', t=None):
     """
     Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
     """
     try:
+        # Asegurar que tenemos traducciones
+        if t is None:
+            t = {}
+
+        # Traducciones para títulos y etiquetas
+        dimension_labels = {
+            'es': {
+                'title': "Tipo de texto",
+                'vocabulary': "Vocabulario",
+                'structure': "Estructura",
+                'cohesion': "Cohesión",
+                'clarity': "Claridad",
+                'improvement': "⚠️ Por mejorar",
+                'acceptable': "📈 Aceptable",
+                'optimal': "✅ Óptimo",
+                'target': "Meta: {:.2f}"
+            },
+            'en': {
+                'title': "Text Type",
+                'vocabulary': "Vocabulary",
+                'structure': "Structure",
+                'cohesion': "Cohesion",
+                'clarity': "Clarity",
+                'improvement': "⚠️ Needs improvement",
+                'acceptable': "📈 Acceptable", 
+                'optimal': "✅ Optimal",
+                'target': "Target: {:.2f}"
+            },
+            'uk': {
+                'title': "Тип тексту",
+                'vocabulary': "Словниковий запас",
+                'structure': "Структура",
+                'cohesion': "Зв'язність",
+                'clarity': "Ясність",
+                'improvement': "⚠️ Потребує покращення",
+                'acceptable': "📈 Прийнятно",
+                'optimal': "✅ Оптимально",
+                'target': "Ціль: {:.2f}"
+            }
+        }
+        
+        # Obtener traducciones para el idioma actual, con fallback a español
+        labels = dimension_labels.get(lang_code, dimension_labels['es'])
+        
         # Usar valor por defecto si no se especifica tipo
         text_type = text_type or 'student_essay'
         
@@ -202,52 +303,54 @@ def display_diagnosis(metrics, text_type=None):
         with metrics_col:
             metrics_config = [
                 {
-                    'label': "Vocabulario",
+                    'label': labels['vocabulary'],
                     'key': 'vocabulary',
                     'value': metrics['vocabulary']['normalized_score'],
-                    'help': "Riqueza y variedad del vocabulario",
+                    'help': t.get('vocabulary_help', "Riqueza y variedad del vocabulario"),
                     'thresholds': thresholds['vocabulary']
                 },
                 {
-                    'label': "Estructura",
+                    'label': labels['structure'],
                     'key': 'structure',
                     'value': metrics['structure']['normalized_score'],
-                    'help': "Organización y complejidad de oraciones",
+                    'help': t.get('structure_help', "Organización y complejidad de oraciones"),
                     'thresholds': thresholds['structure']
                 },
                 {
-                    'label': "Cohesión",
+                    'label': labels['cohesion'],
                     'key': 'cohesion',
                     'value': metrics['cohesion']['normalized_score'],
-                    'help': "Conexión y fluidez entre ideas",
+                    'help': t.get('cohesion_help', "Conexión y fluidez entre ideas"),
                     'thresholds': thresholds['cohesion']
                 },
                 {
-                    'label': "Claridad",
+                    'label': labels['clarity'],
                     'key': 'clarity',
                     'value': metrics['clarity']['normalized_score'],
-                    'help': "Facilidad de comprensión del texto",
+                    'help': t.get('clarity_help', "Facilidad de comprensión del texto"),
                     'thresholds': thresholds['clarity']
                 }
             ]
 
-            # Mostrar métricas
+            # Mostrar métricas con textos traducidos
             for metric in metrics_config:
                 value = metric['value']
                 if value < metric['thresholds']['min']:
-                    status = "⚠️ Por mejorar"
+                    status = labels['improvement']
                     color = "inverse"
                 elif value < metric['thresholds']['target']:
-                    status = "📈 Aceptable"
+                    status = labels['acceptable']
                     color = "off"
                 else:
-                    status = "✅ Óptimo"
+                    status = labels['optimal']
                     color = "normal"
                 
+                target_text = labels['target'].format(metric['thresholds']['target'])
+                
                 st.metric(
                     metric['label'],
                     f"{value:.2f}",
-                    f"{status} (Meta: {metric['thresholds']['target']:.2f})",
+                    f"{status} ({target_text})",
                     delta_color=color,
                     help=metric['help']
                 )
@@ -255,17 +358,29 @@ def display_diagnosis(metrics, text_type=None):
 
         # Gráfico radar en la columna derecha
         with graph_col:
-            display_radar_chart(metrics_config, thresholds)
+            display_radar_chart(metrics_config, thresholds, lang_code)  # Pasar el parámetro lang_code
 
     except Exception as e:
         logger.error(f"Error mostrando resultados: {str(e)}")
-        st.error("Error al mostrar los resultados")
+        st.error(t.get('error_results', "Error al mostrar los resultados"))
 
-def display_radar_chart(metrics_config, thresholds):
+##################################################################
+##################################################################
+def display_radar_chart(metrics_config, thresholds, lang_code='es'):
     """
     Muestra el gráfico radar con los resultados.
     """
     try:
+        # Traducción de las etiquetas de leyenda según el idioma
+        legend_translations = {
+            'es': {'min': 'Mínimo', 'target': 'Meta', 'user': 'Tu escritura'},
+            'en': {'min': 'Minimum', 'target': 'Target', 'user': 'Your writing'},
+            'uk': {'min': 'Мінімум', 'target': 'Ціль', 'user': 'Ваш текст'}
+        }
+        
+        # Usar español por defecto si el idioma no está soportado
+        translations = legend_translations.get(lang_code, legend_translations['es'])
+        
         # Preparar datos para el gráfico
         categories = [m['label'] for m in metrics_config]
         values_user = [m['value'] for m in metrics_config]
@@ -291,14 +406,14 @@ def display_radar_chart(metrics_config, thresholds):
         ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
         ax.set_ylim(0, 1)
 
-        # Dibujar áreas de umbrales
-        ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label='Mínimo', alpha=0.5)
-        ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label='Meta', alpha=0.5)
+        # Dibujar áreas de umbrales con etiquetas traducidas
+        ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, label=translations['min'], alpha=0.5)
+        ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, label=translations['target'], alpha=0.5)
         ax.fill_between(angles, target_values, [1]*len(angles), color='#2ecc71', alpha=0.1)
         ax.fill_between(angles, [0]*len(angles), min_values, color='#e74c3c', alpha=0.1)
 
-        # Dibujar valores del usuario
-        ax.plot(angles, values_user, '#3498db', linewidth=2, label='Tu escritura')
+        # Dibujar valores del usuario con etiqueta traducida
+        ax.plot(angles, values_user, '#3498db', linewidth=2, label=translations['user'])
         ax.fill(angles, values_user, '#3498db', alpha=0.2)
 
         # Ajustar leyenda

modules/studentact/student_activities_v2.py

@@ -1,4 +1,4 @@
- ##############
+##############
 ###modules/studentact/student_activities_v2.py
 
 import streamlit as st
@@ -40,15 +40,17 @@ def display_student_activities(username: str, lang_code: str, t: dict):
         t: Diccionario de traducciones
     """
     try:
-        st.header(t.get('activities_title', 'Mis Actividades'))
+        # Cambiado de "Mis Actividades" a "Registro de mis actividades"
+        #st.header(t.get('activities_title', 'Registro de mis actividades'))
 
         # Tabs para diferentes tipos de análisis
+        # Cambiado "Análisis del Discurso" a "Análisis comparado de textos"
         tabs = st.tabs([
-            t.get('current_situation_activities', 'Mi Situación Actual'),
-            t.get('morpho_activities', 'Análisis Morfosintáctico'),
-            t.get('semantic_activities', 'Análisis Semántico'),
-            t.get('discourse_activities', 'Análisis del Discurso'),
-            t.get('chat_activities', 'Conversaciones con el Asistente')
+            t.get('current_situation_activities', 'Registros de la función: Mi Situación Actual'),
+            t.get('morpho_activities', 'Registros de mis análisis morfosintácticos'),
+            t.get('semantic_activities', 'Registros de mis análisis semánticos'),
+            t.get('discourse_activities', 'Registros de mis análisis comparado de textos'),
+            t.get('chat_activities', 'Registros de mis conversaciones con el tutor virtual')
         ])
 
         # Tab de Situación Actual
@@ -63,7 +65,7 @@ def display_student_activities(username: str, lang_code: str, t: dict):
         with tabs[2]:
             display_semantic_activities(username, t)
 
-        # Tab de Análisis del Discurso
+        # Tab de Análisis del Discurso (mantiene nombre interno pero UI muestra "Análisis comparado de textos")
         with tabs[3]:
             display_discourse_activities(username, t)
             
@@ -461,14 +463,15 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 def display_discourse_activities(username: str, t: dict):
-    """Muestra actividades de análisis del discurso"""
+    """Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)"""
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
         analyses = get_student_discourse_analysis(username)
         
         if not analyses:
             logger.info("No se encontraron análisis del discurso")
-            st.info(t.get('no_discourse_analyses', 'No hay análisis del discurso registrados'))
+            # Usamos el término "análisis comparado de textos" en la UI
+            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
             return
 
         logger.info(f"Procesando {len(analyses)} análisis del discurso")
@@ -502,7 +505,8 @@ def display_discourse_activities(username: str, t: dict):
 
     except Exception as e:
         logger.error(f"Error mostrando análisis del discurso: {str(e)}")
-        st.error(t.get('error_discourse', 'Error al mostrar análisis del discurso'))
+        # Usamos el término "análisis comparado de textos" en la UI
+        st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
 
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
@@ -557,6 +561,7 @@ def display_chat_activities(username: str, t: dict):
 #################################################################################        
 def display_discourse_comparison(analysis: dict, t: dict):
     """Muestra la comparación de análisis del discurso"""
+    # Cambiado para usar "textos comparados" en la UI
     st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
     
     col1, col2 = st.columns(2)
@@ -568,4 +573,4 @@ def display_discourse_comparison(analysis: dict, t: dict):
     with col2:
         st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
         df2 = pd.DataFrame(analysis['key_concepts2'])
-        st.dataframe(df2)   
+        st.dataframe(df2)