Update src/streamlit_app.py

src/streamlit_app.py

@@ -155,173 +155,191 @@ example_files = []
 if os.path.exists(examples_folder):
     example_files = [f for f in os.listdir(examples_folder) if f.endswith(".gpx")]
 
-# ========== LÓGICA EXACTA DE APPTEST.PY ==========
+# ========== INICIO LÓGICA EXACTA DE APPTEST.PY CON ADAPTACIONES PARA HF SPACES ==========
 
-# Opciones de selección de datos de ejemplo - EXACTAMENTE COMO APPTEST.PY
+# Opciones de selección de datos de ejemplo
 st.subheader("Datos de Ejemplo")
-usar_datos_exp = st.checkbox("Usar datos de ejemplo: datos_exp.csv") if len(example_files) > 0 else False
-usar_datos_process = st.checkbox("Usar datos de ejemplo: datos_process.csv") if len(example_files) > 1 else False
+usar_datos_ejemplo = False
+archivo_ejemplo_seleccionado = None
 
-# Para GPX, adaptamos pero mantenemos la estructura:
 if example_files:
-    for i, example_file in enumerate(example_files):
-        if i == 0:
-            usar_datos_exp = st.checkbox(f"Usar datos de ejemplo: {example_file}")
-        elif i == 1:
-            usar_datos_process = st.checkbox(f"Usar datos de ejemplo: {example_file}")
+    # Crear checkbox para cada archivo de ejemplo - IGUAL QUE EN APPTEST.PY
+    for example_file in example_files:
+        if st.checkbox(f"Usar datos de ejemplo: {example_file}"):
+            if not usar_datos_ejemplo:  # Solo permitir uno a la vez
+                usar_datos_ejemplo = True
+                archivo_ejemplo_seleccionado = example_file
 
-# Inicializar variable de datos - EXACTAMENTE COMO APPTEST.PY
+# Inicializar variables de datos - IGUAL QUE EN APPTEST.PY
 data = None
+gpx_content = None
 
-# Verificar qué checkbox está seleccionado y cargar el archivo correspondiente - EXACTAMENTE COMO APPTEST.PY
-if usar_datos_exp and not usar_datos_process:
-    if example_files:
-        try:
-            example_path = os.path.join(examples_folder, example_files[0])
-            with open(example_path, 'r', encoding='utf-8') as f:
-                gpx_content = f.read()
-            # Simular DataFrame como en apptest.py
-            data = pd.DataFrame({'source': ['example'], 'filename': [example_files[0]], 'loaded': [True]})
-            st.success(f"Datos de ejemplo ({example_files[0]}) cargados exitosamente.")
-            st.dataframe(data, use_container_width=True)
-        except Exception as e:
-            st.error(f"Error cargando ejemplo: {e}")
-            
-elif usar_datos_process and not usar_datos_exp:
-    if len(example_files) > 1:
-        try:
-            example_path = os.path.join(examples_folder, example_files[1])
-            with open(example_path, 'r', encoding='utf-8') as f:
-                gpx_content = f.read()
-            # Simular DataFrame como en apptest.py
-            data = pd.DataFrame({'source': ['example'], 'filename': [example_files[1]], 'loaded': [True]})
-            st.success(f"Datos de ejemplo ({example_files[1]}) cargados exitosamente.")
-            st.dataframe(data, use_container_width=True)
-        except Exception as e:
-            st.error(f"Error cargando ejemplo: {e}")
-            
-elif usar_datos_exp and usar_datos_process:
-    st.error("Por favor, selecciona solo un conjunto de datos de ejemplo a la vez.")
+# Cargar archivo de ejemplo si está seleccionado - IGUAL QUE EN APPTEST.PY
+if usar_datos_ejemplo and archivo_ejemplo_seleccionado:
+    try:
+        example_path = os.path.join(examples_folder, archivo_ejemplo_seleccionado)
+        # USANDO PANDAS COMO EN APPTEST.PY para mantener consistencia
+        with open(example_path, 'r', encoding='utf-8') as f:
+            gpx_content = f.read()
+        
+        st.success(f"Datos de ejemplo ({archivo_ejemplo_seleccionado}) cargados exitosamente.")
+        
+        # Crear un DataFrame simulado para mantener la lógica de apptest.py
+        data = pd.DataFrame({'status': ['loaded'], 'source': ['example'], 'filename': [archivo_ejemplo_seleccionado]})
+        st.dataframe(data, use_container_width=True)
+        
+    except Exception as e:
+        st.error(f"Error cargando archivo de ejemplo: {e}")
 
-# Opción para cargar datos personalizados - EXACTAMENTE COMO APPTEST.PY
+# Opción para cargar datos personalizados - EXACTO COMO APPTEST.PY
 st.subheader("Carga tus Datos")
 uploaded_file = st.file_uploader("Carga un archivo GPX con los datos experimentales:", type="gpx")
 
 if uploaded_file is not None:
     try:
-        # Leer datos cargados - EXACTAMENTE COMO APPTEST.PY
-        # En apptest.py usa: data = pd.read_csv(uploaded_file)
-        # Aquí adaptamos para GPX pero manteniendo la estructura:
-        
-        # Método que funciona en HF Spaces
-        file_content = uploaded_file.read()
-        
-        # Detectar encoding
-        import chardet
-        detected = chardet.detect(file_content)
-        encoding = detected.get('encoding', 'utf-8')
-        
+        # MÉTODO EXACTO DE APPTEST.PY PARA HUGGING FACE SPACES
+        # Primero intentar como lo hace apptest.py con pandas (aunque no sea CSV)
         try:
-            gpx_content = file_content.decode(encoding)
-        except:
-            gpx_content = file_content.decode('utf-8', errors='ignore')
-        
-        # Crear DataFrame simulado como en apptest.py
-        data = pd.DataFrame({
-            'source': ['uploaded'],
-            'filename': [uploaded_file.name],
-            'size_bytes': [len(file_content)],
-            'encoding': [encoding],
-            'loaded': [True]
-        })
+            # Leer como bytes primero
+            file_bytes = uploaded_file.getvalue()
+            
+            # Intentar decodificar con diferentes encodings como hace apptest.py internamente
+            gpx_content = None
+            for encoding in ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']:
+                try:
+                    gpx_content = file_bytes.decode(encoding)
+                    break
+                except UnicodeDecodeError:
+                    continue
+            
+            if gpx_content is None:
+                # Fallback: usar el método original de streamlit
+                uploaded_file.seek(0)  # Reset file pointer
+                gpx_content = uploaded_file.read().decode('utf-8')
         
-        st.success("Datos cargados exitosamente desde el archivo proporcionado.")
-        st.dataframe(data, use_container_width=True)
+        except Exception as e:
+            # Último recurso: método directo
+            uploaded_file.seek(0)
+            gpx_content = uploaded_file.read().decode('utf-8')
         
+        if gpx_content:
+            st.success("Datos cargados exitosamente desde el archivo proporcionado.")
+            
+            # Crear DataFrame simulado para mantener consistencia con apptest.py
+            data = pd.DataFrame({
+                'status': ['loaded'], 
+                'source': ['uploaded'], 
+                'filename': [uploaded_file.name],
+                'size': [len(gpx_content)]
+            })
+            st.dataframe(data, use_container_width=True)
+        else:
+            st.error("No se pudo leer el contenido del archivo")
+            
     except Exception as e:
         st.error(f"Error leyendo archivo: {e}")
-        data = None
-        gpx_content = None
+        # Debug information
+        st.write("Información de debug:")
+        st.write(f"Tipo de archivo: {type(uploaded_file)}")
+        st.write(f"Nombre de archivo: {uploaded_file.name if uploaded_file else 'None'}")
 
-# Validación para asegurarse de que se cargaron datos - EXACTAMENTE COMO APPTEST.PY
+# Validación para asegurarse de que se cargaron datos - EXACTO COMO APPTEST.PY
 if data is None:
     st.warning("No se han cargado datos. Por favor, selecciona un archivo o usa datos de ejemplo.")
 else:
     st.write("### Datos listos para su análisis.")
     
-    # Aquí es donde apptest.py procesa los datos del DataFrame
-    # Nosotros procesamos el contenido GPX
-    
-    if 'gpx_content' in locals() and gpx_content:
-        # Procesar GPX
-        with st.spinner("🔄 Procesando datos GPX..."):
-            gpx_data = process_gpx_data(gpx_content)
-        
-        if gpx_data and gpx_data['success']:
-            st.success("🎉 ¡Archivo GPX procesado exitosamente!")
-            
-            # Extraer datos procesados
-            heatmap_data = gpx_data['heatmap_data']
-            track_segments = gpx_data['track_segments']
-            total_distance = gpx_data['total_distance']
-            total_time = gpx_data['total_time']
-            center = gpx_data['center']
-            
-            # Dashboard de métricas
-            st.markdown("### 📊 Resumen de la Ruta")
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.metric("📏 Distancia", f"{total_distance/1000:.2f} km" if total_distance > 0 else "N/A")
-            with col2:
-                hours = int(total_time // 3600) if total_time > 0 else 0
-                minutes = int((total_time % 3600) // 60) if total_time > 0 else 0
-                st.metric("⏱️ Tiempo", f"{hours}h {minutes}m" if total_time > 0 else "N/A")
-            with col3:
-                st.metric("📍 Puntos GPS", f"{len(heatmap_data):,}")
-            
-            # Crear y mostrar mapas
-            st.markdown("### 🗺️ Visualización de Movimientos")
-            
-            with st.spinner("🗺️ Generando mapas..."):
-                heat_map, spaghetti_map = create_maps(heatmap_data, track_segments, center)
+    # VERIFICAR QUE TENEMOS CONTENIDO GPX VÁLIDO
+    if gpx_content is None:
+        st.error("Error: No se pudo extraer el contenido GPX del archivo")
+    else:
+        # Validar que es contenido GPX válido
+        if not ("<?xml" in gpx_content and ("gpx" in gpx_content.lower() or "trk" in gpx_content.lower())):
+            st.error("El archivo no parece contener datos GPX válidos")
+            with st.expander("Ver contenido del archivo para debug"):
+                st.text(gpx_content[:500])
+        else:
+            # PROCESAR DATOS GPX
+            with st.spinner("🔄 Procesando datos GPX..."):
+                gpx_data = process_gpx_data(gpx_content)
             
-            if heat_map and spaghetti_map:
-                col1, col2 = st.columns(2)
+            if gpx_data and gpx_data['success']:
+                st.success("🎉 ¡Archivo GPX procesado exitosamente!")
                 
-                with col1:
-                    st.markdown("#### 🔥 Mapa de Calor")
-                    folium_static(heat_map, width=600, height=500)
+                # Extraer datos procesados
+                heatmap_data = gpx_data['heatmap_data']
+                track_segments = gpx_data['track_segments']
+                total_distance = gpx_data['total_distance']
+                total_time = gpx_data['total_time']
+                center = gpx_data['center']
+                
+                # Dashboard de métricas
+                st.markdown("### 📊 Resumen de la Ruta")
+                col1, col2, col3 = st.columns(3)
                 
+                with col1:
+                    st.metric("📏 Distancia", f"{total_distance/1000:.2f} km" if total_distance > 0 else "N/A")
                 with col2:
-                    st.markdown("#### 🍝 Diagrama de Spaghetti")
-                    folium_static(spaghetti_map, width=600, height=500)
+                    hours = int(total_time // 3600) if total_time > 0 else 0
+                    minutes = int((total_time % 3600) // 60) if total_time > 0 else 0
+                    st.metric("⏱️ Tiempo", f"{hours}h {minutes}m" if total_time > 0 else "N/A")
+                with col3:
+                    st.metric("📍 Puntos GPS", f"{len(heatmap_data):,}")
+                
+                # Crear y mostrar mapas
+                st.markdown("### 🗺️ Visualización de Movimientos")
+                
+                with st.spinner("🗺️ Generando mapas..."):
+                    heat_map, spaghetti_map = create_maps(heatmap_data, track_segments, center)
+                
+                if heat_map and spaghetti_map:
+                    col1, col2 = st.columns(2)
                     
-                # Información técnica adicional
-                with st.expander("ℹ️ Información técnica"):
-                    st.write(f"**Archivo:** {data['filename'].iloc[0]}")
-                    st.write(f"**Fuente:** {data['source'].iloc[0]}")
-                    st.write(f"**Tracks:** {len(set(seg['track_idx'] for seg in track_segments))}")
-                    st.write(f"**Segmentos:** {len(track_segments)}")
-                    st.write(f"**Centro:** {center[0]:.6f}, {center[1]:.6f}")
-                    st.write(f"**Puntos totales:** {len(heatmap_data)}")
+                    with col1:
+                        st.markdown("#### 🔥 Mapa de Calor")
+                        folium_static(heat_map, width=600, height=500)
                     
-            else:
-                st.error("❌ Error generando los mapas")
+                    with col2:
+                        st.markdown("#### 🍝 Diagrama de Spaghetti")
+                        folium_static(spaghetti_map, width=600, height=500)
+                        
+                    # Información técnica adicional
+                    with st.expander("ℹ️ Información técnica"):
+                        st.write(f"**Archivo:** {uploaded_file.name if uploaded_file else archivo_ejemplo_seleccionado}")
+                        st.write(f"**Fuente:** {'Archivo cargado' if uploaded_file else 'Archivo de ejemplo'}")
+                        st.write(f"**Tracks:** {len(set(seg['track_idx'] for seg in track_segments))}")
+                        st.write(f"**Segmentos:** {len(track_segments)}")
+                        st.write(f"**Centro:** {center[0]:.6f}, {center[1]:.6f}")
+                        st.write(f"**Puntos totales:** {len(heatmap_data)}")
+                        st.write(f"**Tamaño del archivo:** {len(gpx_content)} caracteres")
+                        
+                else:
+                    st.error("❌ Error generando los mapas")
+                    
+            elif gpx_data and not gpx_data['success']:
+                st.error(f"❌ Error procesando GPX: {gpx_data['error']}")
                 
-        elif gpx_data and not gpx_data['success']:
-            st.error(f"❌ Error procesando GPX: {gpx_data['error']}")
-        else:
-            st.error("❌ Error desconocido procesando el archivo GPX")
-    else:
-        st.error("❌ No se pudo extraer el contenido GPX")
+                # Debug completo
+                with st.expander("🔧 Información completa de debugging"):
+                    st.write("**Información del archivo:**")
+                    st.write(f"- Nombre: {uploaded_file.name if uploaded_file else archivo_ejemplo_seleccionado}")
+                    st.write(f"- Tamaño: {len(gpx_content)} caracteres")
+                    st.write(f"- Tipo de fuente: {'Cargado' if uploaded_file else 'Ejemplo'}")
+                    
+                    st.write("**Primeros 1000 caracteres del archivo:**")
+                    st.text(gpx_content[:1000] if gpx_content else "Sin contenido")
+                    
+                    st.write("**Últimos 500 caracteres del archivo:**")
+                    st.text(gpx_content[-500:] if gpx_content and len(gpx_content) > 500 else "Archivo muy corto")
+            else:
+                st.error("❌ Error desconocido procesando el archivo GPX")
 
-# Mostrar ejemplos disponibles
-if example_files and data is None:
+# Mostrar ejemplos disponibles si no hay datos cargados
+if data is None and example_files:
     st.markdown("### 📋 Ejemplos disponibles:")
     for i, file in enumerate(example_files, 1):
         st.write(f"{i}. **{file}**")
 
 # Footer
 st.markdown("---")
-st.markdown("🚀 **Optimizado para Hugging Face Spaces** | 📊 **Estructura idéntica a apptest.py**", unsafe_allow_html=True)
+st.markdown("🚀 **Optimizado para Hugging Face Spaces** | 📊 **Compatible con apptest.py**", unsafe_allow_html=True)