Upload 2 files

modules/semantic/semantic_interface.py

@@ -31,8 +31,7 @@ from ..database.chat_mongo_db import store_chat_history, get_chat_history
 ###############################
 
 # En semantic_interface.py
-
-def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
+def display_semantic_interface(lang_code, nlp_models, semantic_t):
     try:
         # 1. Inicializar el estado de la sesión
         if 'semantic_state' not in st.session_state:
@@ -44,11 +43,11 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
             }
 
         # 2. Área de carga de archivo con mensaje informativo
-        st.info(semantic_t.get('semantic_initial_instruction', 
+        st.info(semantic_t.get('initial_instruction', 
             'Para comenzar un nuevo análisis semántico, cargue un archivo de texto (.txt)'))
             
         uploaded_file = st.file_uploader(
-            semantic_t.get('semantic_file_uploader', 'Ingresar un archivo de texto para análisis semántico'),
+            semantic_t.get('semantic_file_uploader', 'Upload a text file for semantic analysis'),
             type=['txt'],
             key=f"semantic_file_uploader_{st.session_state.semantic_state['analysis_count']}"
         )
@@ -56,7 +55,7 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
         # 2.1 Verificar si hay un archivo cargado y un análisis pendiente
         if uploaded_file is not None and st.session_state.semantic_state.get('pending_analysis', False):
             try:
-                with st.spinner(semantic_t.get('semantic_processing', 'Semantic processing...')):
+                with st.spinner(semantic_t.get('processing', 'Processing...')):
                     # Realizar análisis
                     text_content = uploaded_file.getvalue().decode('utf-8')
                     
@@ -64,7 +63,6 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
                         text_content, 
                         lang_code,
                         nlp_models,
-                        t,
                         semantic_t
                     )
                     
@@ -83,11 +81,11 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
                         
                         if storage_success:
                             st.success(
-                                semantic_t.get('semantic_analysis_complete', 
+                                semantic_t.get('analysis_complete', 
                                 'Análisis completado y guardado. Para realizar un nuevo análisis, cargue otro archivo.')
                             )
                         else:
-                            st.error(semantic_t.get('semanctic_error_saving_message', 'There was a problem saving the semantic analysis. Please try again.'))
+                            st.error(semantic_t.get('error_message', 'Error saving analysis'))
                     else:
                         st.error(analysis_result['message'])
                     
@@ -96,7 +94,7 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
                     
             except Exception as e:
                 logger.error(f"Error en análisis semántico: {str(e)}")
-                st.error(semantic_t.get('semantic_error_processing_message', f'Error processing text: {str(e)}'))
+                st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
                 # Restablecer el flag de análisis pendiente en caso de error
                 st.session_state.semantic_state['pending_analysis'] = False
 
@@ -136,7 +134,7 @@ def display_semantic_interface(lang_code, nlp_models, t, semantic_t):
                 semantic_t
             )
         else:
-            st.info(semantic_t.get('semantic_upload_prompt', 'Cargue un archivo para comenzar el análisis semántico'))
+            st.info(semantic_t.get('upload_prompt', 'Cargue un archivo para comenzar el análisis'))
 
     except Exception as e:
         logger.error(f"Error general en interfaz semántica: {str(e)}")
@@ -149,7 +147,7 @@ def display_semantic_results(semantic_result, lang_code, semantic_t):
     Muestra los resultados del análisis semántico de conceptos clave.
     """
     if semantic_result is None or not semantic_result['success']:
-        st.warning(semantic_t.get('semantic_no_results', 'No semantic results available'))
+        st.warning(semantic_t.get('no_results', 'No results available'))
         return
 
     analysis = semantic_result['analysis']
@@ -203,7 +201,7 @@ def display_semantic_results(semantic_result, lang_code, semantic_t):
             unsafe_allow_html=True
         )
     else:
-        st.info(semantic_t.get('semantic_no_key_concepts', 'No key semantic concepts found'))
+        st.info(semantic_t.get('no_concepts', 'No key concepts found'))
 
     # Gráfico de conceptos
     # st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))

modules/semantic/semantic_process.py

@@ -5,23 +5,17 @@ import io
 import base64
 import logging
 
-##################################
 from ..text_analysis.semantic_analysis import (
     perform_semantic_analysis,
     identify_key_concepts,
     create_concept_graph,
     visualize_concept_graph
 )
-
-####################################
 from ..database.semantic_mongo_db import store_student_semantic_result
 
-#############################################
 logger = logging.getLogger(__name__)
 
-
-#######################################################################
-def process_semantic_input(text, lang_code, nlp_models, t, semantic_t):
+def process_semantic_input(text, lang_code, nlp_models, t):
     """
     Procesa el texto ingresado para realizar el análisis semántico.
     """
@@ -30,13 +24,7 @@ def process_semantic_input(text, lang_code, nlp_models, t, semantic_t):
         
         # Realizar el análisis semántico
         nlp = nlp_models[lang_code]
-        
-        analysis_result = perform_semantic_analysis(
-            text, 
-            nlp_models[lang_code],
-            lang_code,
-            semantic_t
-        )
+        analysis_result = perform_semantic_analysis(text, nlp, lang_code)
         
         if not analysis_result['success']:
             return {
@@ -62,7 +50,7 @@ def process_semantic_input(text, lang_code, nlp_models, t, semantic_t):
         # Devolver el resultado incluso si falla el guardado
         return {
             'success': True,
-            'message': semantic_t.get('success_message', 'Analysis completed successfully'),
+            'message': t.get('success_message', 'Analysis completed successfully'),
             'analysis': {
                 'key_concepts': analysis_result['key_concepts'],
                 'concept_graph': analysis_result['concept_graph']
@@ -77,7 +65,6 @@ def process_semantic_input(text, lang_code, nlp_models, t, semantic_t):
             'analysis': None
         }
 
-##########################################################################
 def format_semantic_results(analysis_result, t):
     """
     Formatea los resultados del análisis para su visualización.