Update app.py

app.py

@@ -4,420 +4,111 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 import io
 import base64
-from PIL import Image
-import numpy as np
-from datetime import datetime
 
-# Configuración de la página
-st.set_page_config(
-    page_title="Visualizador de Datos",
-    page_icon="📊",
-    layout="wide"
-)
+# Configuración básica de la página
+st.set_page_config(page_title="Contador Simple", page_icon="📊")
 
 # Título de la aplicación
-st.title("📊 Visualizador de Datos")
-st.markdown("### Carga tu archivo CSV o Excel y crea visualizaciones personalizadas")
+st.title("📊 Visualizador de Conteos")
+st.markdown("### Carga tus archivos CSV y genera gráficos de conteo")
 
-# Función para cargar el archivo y procesar fechas
+# Función para cargar archivos múltiples
 def load_data():
-    uploaded_file = st.file_uploader("Carga tu archivo CSV o Excel", type=["csv", "xlsx", "xls"])
+    uploaded_files = st.file_uploader("Carga uno o más archivos CSV", type=["csv"], accept_multiple_files=True)
     
-    if uploaded_file is not None:
+    if not uploaded_files:
+        return None
+    
+    all_data = {}
+    
+    for uploaded_file in uploaded_files:
         try:
-            # Determinar el tipo de archivo y cargarlo
-            if uploaded_file.name.endswith('.csv'):
-                data = pd.read_csv(uploaded_file)
-            else:
-                data = pd.read_excel(uploaded_file)
-            
-            return data
+            # Cargar el archivo
+            df = pd.read_csv(uploaded_file)
+            # Guardar en el diccionario con el nombre del archivo como clave
+            all_data[uploaded_file.name] = df
+            st.success(f"✅ Archivo '{uploaded_file.name}' cargado correctamente")
         except Exception as e:
-            st.error(f"Error al cargar el archivo: {e}")
-            return None
-    return None
-
-# Función para generar gráficos basados en conteos por persona y día/semana
-def create_person_performance_plot(data, person_col, time_col, metric_col=None, plot_type="Barras"):
-    if person_col not in data.columns:
-        st.error(f"La columna de persona '{person_col}' no existe en el dataset")
-        return None
+            st.error(f"❌ Error al cargar '{uploaded_file.name}': {e}")
     
-    if time_col not in data.columns:
-        st.error(f"La columna de tiempo '{time_col}' no existe en el dataset")
-        return None
+    return all_data
+
+# Función para crear gráfico de conteo
+def create_count_plot(data, column):
+    fig, ax = plt.subplots(figsize=(10, 6))
     
-    fig, ax = plt.subplots(figsize=(14, 8))
+    # Contar valores
+    value_counts = data[column].value_counts().sort_values(ascending=False)
     
-    # Contar unidades o usar la métrica especificada
-    if metric_col is None or metric_col == 'Conteo':
-        # Agrupar y contar filas
-        performance_data = data.groupby([time_col, person_col]).size().reset_index(name='Unidades')
+    # Si hay demasiados valores únicos, mostrar solo los primeros 15
+    if len(value_counts) > 15:
+        value_counts = value_counts.head(15)
+        plt.title(f"Top 15 valores más frecuentes - {column}")
     else:
-        # Agrupar y sumar la métrica especificada
-        performance_data = data.groupby([time_col, person_col])[metric_col].sum().reset_index(name='Unidades')
+        plt.title(f"Conteo de valores - {column}")
     
-    # Calcular totales por persona para añadir a la leyenda
-    totales_persona = performance_data.groupby(person_col)['Unidades'].sum().reset_index()
-    totales_persona['Etiqueta'] = totales_persona.apply(lambda x: f"{x[person_col]} (Total: {x['Unidades']})", axis=1)
+    # Crear DataFrame para seaborn
+    count_df = value_counts.reset_index()
+    count_df.columns = [column, 'conteo']
     
-    # Fusionar con el dataframe principal
-    performance_data = pd.merge(performance_data, totales_persona[[person_col, 'Etiqueta']], on=person_col)
+    # Crear gráfico
+    bars = sns.barplot(x=column, y='conteo', data=count_df, ax=ax)
     
-    # Crear visualización según el tipo de gráfico
-    if plot_type == "Barras":
-        chart = sns.barplot(x=time_col, y='Unidades', hue='Etiqueta', data=performance_data, ax=ax)
-        
-        # Añadir etiquetas con los valores en cada barra
-        for container in chart.containers:
-            chart.bar_label(container, fmt='%d')
-            
-        plt.title(f"Unidades por {time_col} y Persona")
-        plt.xlabel(time_col)
-        plt.ylabel('Unidades')
-        plt.xticks(rotation=45, ha='right')
-        plt.legend(title="Persona (Total)")
-        
-    elif plot_type == "Líneas":
-        chart = sns.lineplot(x=time_col, y='Unidades', hue='Etiqueta', data=performance_data, marker='o', ax=ax)
-        
-        # Añadir etiquetas con los valores en cada punto
-        for line in ax.lines:
-            if len(line.get_xdata()) > 0:  # Verificar que la línea tiene datos
-                for x, y in zip(line.get_xdata(), line.get_ydata()):
-                    ax.text(x, y, f'{int(y)}', ha='center', va='bottom')
-                
-        plt.title(f"Tendencia de Unidades por {time_col} y Persona")
-        plt.xlabel(time_col)
-        plt.ylabel('Unidades')
-        plt.xticks(rotation=45, ha='right')
-        plt.legend(title="Persona (Total)")
-    
-    # Añadir el total general en el título
-    total_general = performance_data['Unidades'].sum()
-    plt.title(f"{plt.gca().get_title()} - Total General: {total_general}")
+    # Añadir etiquetas con el número exacto
+    for i, p in enumerate(bars.patches):
+        bars.annotate(f'{int(p.get_height())}', 
+                     (p.get_x() + p.get_width() / 2., p.get_height()),
+                     ha='center', va='bottom')
     
+    # Ajustar eje X para mejor visualización
+    plt.xticks(rotation=45, ha='right')
     plt.tight_layout()
-    return fig
-
-# Función para generar gráficos básicos basados en conteos
-def create_count_plot(data, x_col, plot_type):
-    fig, ax = plt.subplots(figsize=(14, 8))
-    
-    # Preparar datos de conteo
-    if x_col in data.columns:
-        # Eliminar valores nulos para el conteo
-        valid_data = data[x_col].dropna()
-        
-        if plot_type == "Barras":
-            # Contar valores y ordenar por frecuencia
-            count_data = valid_data.value_counts().reset_index()
-            count_data.columns = [x_col, 'count']
-            
-            # Ordenar por conteo de mayor a menor
-            count_data = count_data.sort_values('count', ascending=False)
-            
-            # Limitar a los 20 valores más frecuentes para mejor visualización
-            if len(count_data) > 20:
-                count_data = count_data.head(20)
-                plt.title(f"Top 20 valores más frecuentes - {x_col}")
-            else:
-                plt.title(f"Frecuencia de valores - {x_col}")
-            
-            # Crear gráfico de barras
-            chart = sns.barplot(x=x_col, y='count', data=count_data, ax=ax)
-            
-            # Añadir etiquetas con el número exacto y porcentaje
-            total = count_data['count'].sum()
-            for i, p in enumerate(chart.patches):
-                height = p.get_height()
-                percentage = (height/total) * 100
-                chart.annotate(f'{int(height)} ({percentage:.1f}%)', 
-                             (p.get_x() + p.get_width() / 2., height),
-                             ha='center', va='bottom')
-            
-            plt.xticks(rotation=45, ha='right')
-            plt.ylabel('Frecuencia')
-            plt.title(f"{plt.gca().get_title()} - Total: {total}")
-            
-        elif plot_type == "Pastel":
-            # Contar valores
-            counts = valid_data.value_counts()
-            
-            # Si hay muchos valores únicos, mostrar solo los top 10
-            if len(counts) > 10:
-                # Guardar el resto como "Otros"
-                otros = pd.Series({'Otros': counts[10:].sum()})
-                counts = pd.concat([counts[:10], otros])
-                plt.title(f"Top 10 valores más frecuentes - {x_col}")
-            else:
-                plt.title(f"Distribución de valores - {x_col}")
-            
-            # Calcular porcentajes
-            total = counts.sum()
-            
-            # Crear etiquetas con número y porcentaje
-            etiquetas = [f'{k}: {v} ({v/total:.1%})' for k, v in counts.items()]
-            
-            # Crear gráfico de pastel
-            wedges, texts = ax.pie(counts, wedgeprops={'edgecolor': 'w'})
-            
-            # Añadir leyenda con cantidades
-            ax.legend(wedges, etiquetas, title=f"Total: {total}", 
-                    loc="center left", bbox_to_anchor=(1, 0, 0.5, 1))
-            
-            plt.ylabel('')
-            
-        elif plot_type == "Histograma":
-            # Solo aplicable a datos numéricos
-            if pd.api.types.is_numeric_dtype(valid_data):
-                # Crear histograma
-                sns.histplot(valid_data, kde=True, ax=ax)
-                
-                # Añadir información sobre el total
-                total = len(valid_data)
-                plt.xlabel(x_col)
-                plt.ylabel('Frecuencia')
-                plt.title(f"Distribución de {x_col} - Total: {total}")
-            else:
-                plt.text(0.5, 0.5, "El histograma solo es aplicable a datos numéricos", 
-                         ha='center', va='center', transform=ax.transAxes)
-    else:
-        plt.text(0.5, 0.5, f"Columna '{x_col}' no encontrada en el dataset", 
-                 ha='center', va='center', transform=ax.transAxes)
     
-    plt.tight_layout()
     return fig
 
-# Función para descargar imágenes
-def get_image_download_link(fig, filename, text):
+# Función para descargar imagen
+def get_download_link(fig, filename):
     buf = io.BytesIO()
     fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
     buf.seek(0)
     b64 = base64.b64encode(buf.read()).decode()
-    href = f'<a href="data:image/png;base64,{b64}" download="{filename}.png">{text}</a>'
+    href = f'<a href="data:image/png;base64,{b64}" download="{filename}.png">📥 Descargar imagen</a>'
     return href
 
 # Función principal
 def main():
     # Cargar datos
-    data = load_data()
+    all_data = load_data()
     
-    if data is not None:
-        # Mostrar información básica del dataset
-        st.subheader("Vista previa de los datos")
-        st.dataframe(data.head())
+    if all_data:
+        # Seleccionar archivo
+        selected_file = st.selectbox("Selecciona un archivo", list(all_data.keys()))
         
-        st.subheader("Información del dataset")
-        col1, col2 = st.columns(2)
-        with col1:
-            st.info(f"Número de filas: {data.shape[0]}")
-        with col2:
-            st.info(f"Número de columnas: {data.shape[1]}")
+        # Obtener el DataFrame seleccionado
+        data = all_data[selected_file]
         
-        # Mostrar lista de columnas disponibles
-        st.subheader("Columnas disponibles")
-        all_cols = data.columns.tolist()
-        
-        # Identificar tipo de datos para cada columna
-        col_types = {}
-        for col in all_cols:
-            if pd.api.types.is_numeric_dtype(data[col]):
-                col_types[col] = "Numérico"
-            elif pd.api.types.is_datetime64_dtype(data[col]):
-                col_types[col] = "Fecha/Hora"
-            else:
-                col_types[col] = "Texto/Categórico"
-        
-        # Mostrar tipos de columnas
-        col_type_df = pd.DataFrame(list(col_types.items()), columns=['Columna', 'Tipo'])
-        st.dataframe(col_type_df)
+        # Mostrar información básica
+        st.subheader(f"Vista previa: {selected_file}")
+        st.dataframe(data.head())
         
-        # Sección para procesar columnas de fecha
-        st.subheader("Procesamiento de Columnas de Fecha")
+        # Mostrar información de filas y columnas
+        st.info(f"Filas: {data.shape[0]} | Columnas: {data.shape[1]}")
         
-        # Seleccionar columna para procesar como fecha
-        date_col = st.selectbox(
-            "Selecciona una columna para procesar como fecha",
-            ["Ninguna"] + [col for col in all_cols if col_types.get(col) == "Texto/Categórico"]
-        )
+        # Seleccionar columna para visualizar
+        column = st.selectbox("Selecciona una columna para contar", data.columns)
         
-        # Si se seleccionó una columna
-        if date_col != "Ninguna":
-            # Seleccionar tipo de procesamiento
-            date_process_type = st.radio(
-                "¿Cómo quieres procesar esta columna?",
-                ["Como día de semana (1-7)", "Como fecha con formato"]
-            )
-            
-            if date_process_type == "Como día de semana (1-7)":
-                # Mapeo para días de la semana
-                dia_semana_map = {
-                    '1': 'Lunes',
-                    '2': 'Martes', 
-                    '3': 'Miércoles',
-                    '4': 'Jueves',
-                    '5': 'Viernes',
-                    '6': 'Sábado',
-                    '7': 'Domingo'
-                }
+        # Botón para generar gráfico
+        if st.button("Generar Gráfico de Conteo"):
+            # Verificar que la columna existe y tiene datos
+            if column in data.columns and not data[column].empty:
+                # Crear y mostrar el gráfico
+                fig = create_count_plot(data, column)
+                st.pyplot(fig)
                 
-                try:
-                    # Extraer números de la columna
-                    data['DIA_NUMERO'] = data[date_col].astype(str).str.extract(r'(\d+)').fillna('1')
-                    # Mapear a nombres de días
-                    data['DIA_SEMANA'] = data['DIA_NUMERO'].map(dia_semana_map)
-                    # Si no existe el mapeo, usar Lunes como valor predeterminado
-                    data['DIA_SEMANA'] = data['DIA_SEMANA'].fillna('Lunes')
-                    
-                    st.success(f"✅ Columna '{date_col}' procesada como día de semana")
-                    
-                except Exception as e:
-                    st.error(f"Error al procesar la columna como día de semana: {e}")
-            
-            elif date_process_type == "Como fecha con formato":
-                # Permitir al usuario especificar el formato
-                date_format = st.text_input(
-                    "Ingresa el formato de fecha",
-                    value="%Y/%m/%d %H:%M:%S",
-                    help="Ejemplos: %Y/%m/%d para aaaa/mm/dd, %d/%m/%Y para dd/mm/aaaa, %Y-%m-%d %H:%M:%S para aaaa-mm-dd HH:MM:SS"
-                )
-                
-                try:
-                    # Convertir a datetime con el formato especificado
-                    data['FECHA_DATETIME'] = pd.to_datetime(data[date_col], format=date_format, errors='coerce')
-                    
-                    if not data['FECHA_DATETIME'].isna().all():
-                        # Extraer componentes
-                        data['DIA_SEMANA'] = data['FECHA_DATETIME'].dt.day_name()
-                        data['FECHA_SOLO'] = data['FECHA_DATETIME'].dt.date
-                        data['SEMANA'] = data['FECHA_DATETIME'].dt.isocalendar().week
-                        data['MES'] = data['FECHA_DATETIME'].dt.month
-                        data['AÑO'] = data['FECHA_DATETIME'].dt.year
-                        
-                        # Crear una columna con el formato español
-                        dias_esp = {
-                            'Monday': 'Lunes',
-                            'Tuesday': 'Martes',
-                            'Wednesday': 'Miércoles',
-                            'Thursday': 'Jueves',
-                            'Friday': 'Viernes',
-                            'Saturday': 'Sábado',
-                            'Sunday': 'Domingo'
-                        }
-                        data['DIA_SEMANA'] = data['DIA_SEMANA'].map(dias_esp)
-                        
-                        st.success(f"✅ Columna '{date_col}' procesada como fecha con formato: {date_format}")
-                    else:
-                        st.error("No se pudo convertir ningún valor. Verifica el formato.")
-                        
-                except Exception as e:
-                    st.error(f"Error al procesar la columna como fecha: {e}")
-        
-        # Actualizar la lista de columnas disponibles después del procesamiento
-        all_cols = data.columns.tolist()
-        
-        # Pestaña para diferentes tipos de visualización
-        tab1, tab2 = st.tabs(["Visualización por Persona/Tiempo", "Visualización Simple"])
-        
-        # Pestaña 1: Visualización por Persona y Tiempo
-        with tab1:
-            st.subheader("Rendimiento por Persona y Tiempo")
-            
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                # Seleccionar columna de persona
-                person_col = st.selectbox(
-                    "Selecciona la columna de Persona",
-                    [col for col in all_cols if col_types.get(col) == "Texto/Categórico" or col == "DIA_SEMANA"]
-                )
-            
-            with col2:
-                # Seleccionar columna de tiempo
-                time_options = ["DIA_SEMANA", "SEMANA", "MES", "AÑO", "FECHA_SOLO"] + all_cols
-                time_col = st.selectbox("Selecciona la columna de Tiempo", time_options)
-            
-            with col3:
-                # Seleccionar tipo de gráfico
-                plot_type = st.selectbox(
-                    "Tipo de gráfico para rendimiento", 
-                    ["Barras", "Líneas"]
-                )
-            
-            # Opciones adicionales
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                # Seleccionar columna métrica (opcional)
-                metric_options = ["Conteo"] + [col for col in all_cols if col_types.get(col) == "Numérico"]
-                metric_col = st.selectbox("Métrica a medir", metric_options)
-                if metric_col == "Conteo":
-                    metric_col = None
-            
-            # Botón para generar visualización de rendimiento
-            if st.button("Generar Visualización de Rendimiento"):
-                try:
-                    fig = create_person_performance_plot(
-                        data, 
-                        person_col, 
-                        time_col, 
-                        metric_col, 
-                        plot_type
-                    )
-                    if fig:
-                        st.pyplot(fig)
-                        
-                        # Botón para descargar la imagen
-                        st.markdown(
-                            get_image_download_link(
-                                fig, 
-                                f"Rendimiento_{person_col}_{time_col}", 
-                                "📥 Descargar imagen"
-                            ), 
-                            unsafe_allow_html=True
-                        )
-                except Exception as e:
-                    st.error(f"Error al generar el gráfico: {e}")
-                    st.info("Sugerencia: Verifica que las columnas seleccionadas existan y sean compatibles.")
-        
-        # Pestaña 2: Visualización Simple
-        with tab2:
-            st.subheader("Visualización de Conteos Simples")
-            
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                # Visualizaciones basadas en conteo
-                plot_type = st.selectbox(
-                    "Tipo de gráfico simple", 
-                    ["Barras", "Pastel", "Histograma"]
-                )
-            
-            with col2:
-                # Seleccionar columna para analizar
-                x_col = st.selectbox("Selecciona la columna para analizar", all_cols)
-            
-            # Crear gráfico simple
-            if st.button("Generar Visualización Simple"):
-                try:
-                    st.subheader("Visualización")
-                    fig = create_count_plot(data, x_col, plot_type)
-                    st.pyplot(fig)
-                    
-                    # Botón para descargar la imagen
-                    st.markdown(
-                        get_image_download_link(
-                            fig, 
-                            f"{plot_type}_{x_col}", 
-                            "📥 Descargar imagen"
-                        ), 
-                        unsafe_allow_html=True
-                    )
-                    
-                except Exception as e:
-                    st.error(f"Error al generar el gráfico: {e}")
-                    st.info("Sugerencia: Verifica que la columna seleccionada sea compatible con el tipo de gráfico.")
+                # Botón para descargar imagen
+                st.markdown(get_download_link(fig, f"conteo_{selected_file}_{column}"), unsafe_allow_html=True)
+            else:
+                st.error(f"La columna '{column}' no existe o está vacía.")
 
 # Ejecutar la aplicación
 if __name__ == "__main__":