Update app.py

app.py

@@ -31,47 +31,6 @@ def load_data():
             else:
                 data = pd.read_excel(uploaded_file)
             
-            # Procesar la columna de fecha HML_TXDATE (que es categórica)
-            if 'HML_TXDATE' in data.columns:
-                # Convertir directamente la columna categórica a valores de día de la semana
-                # Mapeamos cada valor posible a su día de la semana correspondiente
-                dia_semana_map = {
-                    '1': 'Lunes',
-                    '2': 'Martes', 
-                    '3': 'Miércoles',
-                    '4': 'Jueves',
-                    '5': 'Viernes',
-                    '6': 'Sábado',
-                    '7': 'Domingo'
-                }
-                
-                # Suponiendo que HML_TXDATE contiene valores numéricos del 1-7 o texto que puede convertirse
-                try:
-                    # Intentar limpiar y convertir a texto simple
-                    data['DIA_NUMERO'] = data['HML_TXDATE'].astype(str).str.extract(r'(\d+)').fillna('1')
-                    # Mapear a nombres de días
-                    data['DIA_SEMANA_ESP'] = data['DIA_NUMERO'].map(dia_semana_map)
-                    # Si no existe el mapeo, usar Lunes como valor predeterminado
-                    data['DIA_SEMANA_ESP'] = data['DIA_SEMANA_ESP'].fillna('Lunes')
-                    
-                    # Crear columna de semana (puede ser arbitraria si no hay info real de semana)
-                    if 'SEMANA' not in data.columns:
-                        data['SEMANA'] = 1  # Valor predeterminado
-                    
-                    # Crear columna de fecha solo (arbitraria si no hay info real)
-                    if 'FECHA_SOLO' not in data.columns:
-                        data['FECHA_SOLO'] = data['DIA_SEMANA_ESP']
-                    
-                    st.success("✅ Columna de fecha 'HML_TXDATE' procesada como día de la semana")
-                    
-                except Exception as e:
-                    st.warning(f"Error al procesar la columna HML_TXDATE: {e}")
-                    st.info("Procesando la columna como texto directo")
-                    # Usar directamente el valor como nombre del día
-                    data['DIA_SEMANA_ESP'] = data['HML_TXDATE']
-                    data['SEMANA'] = 1  # Valor predeterminado
-                    data['FECHA_SOLO'] = data['HML_TXDATE']
-            
             return data
         except Exception as e:
             st.error(f"Error al cargar el archivo: {e}")
@@ -79,36 +38,17 @@ def load_data():
     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_unit, metric_col=None, plot_type="Barras"):
+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
     
-    fig, ax = plt.subplots(figsize=(12, 6))
-    
-    # Determinar la columna de tiempo según la unidad seleccionada
-    if time_unit == "Día":
-        if 'FECHA_SOLO' not in data.columns:
-            st.error("La columna de fecha diaria no está disponible. Asegúrate de que la fecha fue procesada correctamente.")
-            return None
-        time_col = 'FECHA_SOLO'
-        time_label = 'Fecha'
-    elif time_unit == "Día de semana":
-        if 'DIA_SEMANA_ESP' not in data.columns:
-            st.error("La columna de día de semana no está disponible. Asegúrate de que la fecha fue procesada correctamente.")
-            return None
-        time_col = 'DIA_SEMANA_ESP'
-        time_label = 'Día de semana'
-    elif time_unit == "Semana":
-        if 'SEMANA' not in data.columns:
-            st.error("La columna de semana no está disponible. Asegúrate de que la fecha fue procesada correctamente.")
-            return None
-        time_col = 'SEMANA'
-        time_label = 'Semana'
-    else:
-        st.error(f"Unidad de tiempo '{time_unit}' no reconocida")
+    if time_col not in data.columns:
+        st.error(f"La columna de tiempo '{time_col}' no existe en el dataset")
         return None
     
+    fig, ax = plt.subplots(figsize=(14, 8))
+    
     # Contar unidades o usar la métrica especificada
     if metric_col is None or metric_col == 'Conteo':
         # Agrupar y contar filas
@@ -117,33 +57,52 @@ def create_person_performance_plot(data, person_col, time_unit, metric_col=None,
         # Agrupar y sumar la métrica especificada
         performance_data = data.groupby([time_col, person_col])[metric_col].sum().reset_index(name='Unidades')
     
-    # Asegurarse de que el dataframe tiene las columnas necesarias
-    if set([time_col, person_col, 'Unidades']).issubset(performance_data.columns):
-        # Crear visualización según el tipo de gráfico
-        if plot_type == "Barras":
-            sns.barplot(x=time_col, y='Unidades', hue=person_col, data=performance_data, ax=ax)
-            plt.title(f"Unidades por {time_label} y Persona")
-            plt.xlabel(time_label)
-            plt.ylabel('Unidades')
-            plt.xticks(rotation=45, ha='right')
-            plt.legend(title="Persona")
-        elif plot_type == "Líneas":
-            sns.lineplot(x=time_col, y='Unidades', hue=person_col, data=performance_data, marker='o', ax=ax)
-            plt.title(f"Tendencia de Unidades por {time_label} y Persona")
-            plt.xlabel(time_label)
-            plt.ylabel('Unidades')
-            plt.xticks(rotation=45, ha='right')
-            plt.legend(title="Persona")
-    else:
-        plt.text(0.5, 0.5, "No se pudieron generar los datos para la visualización", 
-                ha='center', va='center', transform=ax.transAxes)
+    # 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)
+    
+    # Fusionar con el dataframe principal
+    performance_data = pd.merge(performance_data, totales_persona[[person_col, 'Etiqueta']], on=person_col)
+    
+    # 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}")
     
     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=(12, 6))
+    fig, ax = plt.subplots(figsize=(14, 8))
     
     # Preparar datos de conteo
     if x_col in data.columns:
@@ -166,10 +125,20 @@ def create_count_plot(data, x_col, plot_type):
                 plt.title(f"Frecuencia de valores - {x_col}")
             
             # Crear gráfico de barras
-            sns.barplot(x=x_col, y='count', data=count_data, ax=ax)
+            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.tight_layout()
+            plt.title(f"{plt.gca().get_title()} - Total: {total}")
             
         elif plot_type == "Pastel":
             # Contar valores
@@ -184,17 +153,32 @@ def create_count_plot(data, x_col, plot_type):
             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
-            counts.plot.pie(autopct='%1.1f%%', ax=ax)
+            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}")
+                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)
@@ -249,6 +233,90 @@ def main():
         col_type_df = pd.DataFrame(list(col_types.items()), columns=['Columna', 'Tipo'])
         st.dataframe(col_type_df)
         
+        # Sección para procesar columnas de fecha
+        st.subheader("Procesamiento de Columnas de Fecha")
+        
+        # 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"]
+        )
+        
+        # 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'
+                }
+                
+                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"])
         
@@ -256,21 +324,19 @@ def main():
         with tab1:
             st.subheader("Rendimiento por Persona y Tiempo")
             
-            col1, col2, col3, col4 = st.columns(4)
+            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"]
+                    [col for col in all_cols if col_types.get(col) == "Texto/Categórico" or col == "DIA_SEMANA"]
                 )
             
             with col2:
-                # Seleccionar unidad de tiempo
-                time_unit = st.selectbox(
-                    "Selecciona la unidad de tiempo",
-                    ["Día", "Día de semana", "Semana"]
-                )
+                # 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
@@ -279,7 +345,10 @@ def main():
                     ["Barras", "Líneas"]
                 )
             
-            with col4:
+            # 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)
@@ -292,7 +361,7 @@ def main():
                     fig = create_person_performance_plot(
                         data, 
                         person_col, 
-                        time_unit, 
+                        time_col, 
                         metric_col, 
                         plot_type
                     )
@@ -303,7 +372,7 @@ def main():
                         st.markdown(
                             get_image_download_link(
                                 fig, 
-                                f"Rendimiento_{person_col}_{time_unit}", 
+                                f"Rendimiento_{person_col}_{time_col}", 
                                 "📥 Descargar imagen"
                             ), 
                             unsafe_allow_html=True