Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -536,160 +536,6 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 
-def display_discourse_activities(username: str, t: dict):
-    """
-    Solución simplificada para mostrar análisis de discurso con máxima tolerancia a errores
-    """
-    try:
-        # Importar directamente la colección
-        from ..database.mongo_db import get_collection
-        
-        # Registrar información de inicio
-        logger.info(f"Intentando obtener análisis de discurso para {username}")
-        
-        # Obtener colección directamente
-        collection = get_collection('student_discourse_analysis')
-        if not collection:
-            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
-            return
-        
-        # Consulta simplificada: solo por username
-        results = list(collection.find({"username": username}).sort("timestamp", -1))
-        logger.info(f"Recuperados {len(results)} documentos para {username}")
-        
-        if not results:
-            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
-            return
-        
-        # Mostrar cada resultado
-        for doc in results:
-            try:
-                # Extraer y formatear fecha con manejo de errores
-                timestamp_str = doc.get('timestamp', 'Fecha desconocida')
-                try:
-                    if isinstance(timestamp_str, str):
-                        dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
-                        formatted_date = dt.strftime("%d/%m/%Y %H:%M:%S")
-                    else:
-                        formatted_date = str(timestamp_str)
-                except:
-                    formatted_date = str(timestamp_str)
-                
-                # Crear expander
-                expander_label = f"Análisis: {formatted_date}"
-                with st.expander(expander_label):
-                    # Mostrar texto si existe
-                    if 'text1' in doc and doc['text1']:
-                        st.text_area("Texto analizado", 
-                                    value=doc['text1'], 
-                                    height=100, 
-                                    disabled=True)
-                    
-                    # Mostrar conceptos clave si existen
-                    has_concepts = False
-                    
-                    # Intentar mostrar conceptos clave en dos columnas
-                    if 'key_concepts1' in doc or 'key_concepts2' in doc:
-                        has_concepts = True
-                        col1, col2 = st.columns(2)
-                        
-                        # Columna 1
-                        with col1:
-                            st.markdown("**Conceptos clave (Texto 1)**")
-                            if 'key_concepts1' in doc and doc['key_concepts1']:
-                                try:
-                                    # Mostrar simple como texto para evitar errores de formato
-                                    concepts = doc['key_concepts1']
-                                    if isinstance(concepts, list):
-                                        concept_text = ""
-                                        for c in concepts:
-                                            if isinstance(c, list) and len(c) >= 2:
-                                                concept_text += f"• {c[0]}: {c[1]}\n"
-                                            else:
-                                                concept_text += f"• {c}\n"
-                                        st.text(concept_text)
-                                    else:
-                                        st.text(str(concepts))
-                                except:
-                                    st.text("Error mostrando conceptos")
-                            else:
-                                st.text("Sin conceptos disponibles")
-                        
-                        # Columna 2
-                        with col2:
-                            st.markdown("**Conceptos clave (Texto 2)**")
-                            if 'key_concepts2' in doc and doc['key_concepts2']:
-                                try:
-                                    # Mostrar simple como texto para evitar errores de formato
-                                    concepts = doc['key_concepts2']
-                                    if isinstance(concepts, list):
-                                        concept_text = ""
-                                        for c in concepts:
-                                            if isinstance(c, list) and len(c) >= 2:
-                                                concept_text += f"• {c[0]}: {c[1]}\n"
-                                            else:
-                                                concept_text += f"• {c}\n"
-                                        st.text(concept_text)
-                                    else:
-                                        st.text(str(concepts))
-                                except:
-                                    st.text("Error mostrando conceptos")
-                            else:
-                                st.text("Sin conceptos disponibles")
-                    
-                    # Buscar visualizaciones
-                    st.markdown("---")
-                    st.markdown("**Visualizaciones**")
-                    
-                    # Variable para verificar si se mostró alguna visualización
-                    shown_images = 0
-                    
-                    # Mostrar todas las visualizaciones posibles
-                    for field_name in ['graph1', 'graph2', 'combined_graph']:
-                        if field_name in doc and doc[field_name]:
-                            try:
-                                data = doc[field_name]
-                                
-                                # Si es bytes, mostrar directamente
-                                if isinstance(data, bytes):
-                                    st.image(data, caption=field_name, use_column_width=True)
-                                    shown_images += 1
-                                    
-                                # Si es string, intentar como base64
-                                elif isinstance(data, str):
-                                    try:
-                                        import base64
-                                        image_bytes = base64.b64decode(data)
-                                        st.image(image_bytes, caption=field_name, use_column_width=True)
-                                        shown_images += 1
-                                    except:
-                                        # Si falla la decodificación, solo registrarlo
-                                        logger.error(f"No se pudo decodificar {field_name}")
-                            except Exception as img_err:
-                                logger.error(f"Error mostrando {field_name}: {str(img_err)}")
-                    
-                    # Mensaje si no hay visualizaciones
-                    if shown_images == 0:
-                        st.info("No hay visualizaciones disponibles para este análisis")
-                        
-                    # Mostrar los datos crudos para depuración (opcional)
-                    with st.expander("Datos completos del análisis", expanded=False):
-                        # Filtrar campos binarios y muy grandes
-                        filtered_doc = {k: v for k, v in doc.items() 
-                                      if not isinstance(v, bytes) 
-                                      and not (isinstance(v, str) and len(str(v)) > 500)}
-                        st.json(filtered_doc)
-            
-            except Exception as doc_err:
-                logger.error(f"Error procesando documento: {str(doc_err)}")
-                st.error(f"Error procesando análisis: {str(doc_err)}")
-                
-    except Exception as e:
-        logger.error(f"Error general: {str(e)}")
-        st.error(f"Error recuperando análisis: {str(e)}")
-        # Mostrar el error completo para depuración
-        st.exception(e)
-
 #################################################################################   
 
 def display_discourse_comparison(analysis: dict, t: dict):