feat: generate the filtering by manufacturer not complete

app.py

@@ -326,395 +326,403 @@ elif page == "🕵️ Análisis de Cliente":
                 
                 if not customer_match.empty:
                     cluster = customer_match['cluster_id'].values[0]
-                
-            with st.spinner(f"Seleccionando el modelo predictivo..."):
-                # Load the Corresponding Model
-                model_path = f'models/modelo_cluster_{cluster}.txt'
-                gbm = lgb.Booster(model_file=model_path)
-
-            with st.spinner("Preparando los datos..."):
-                # Load predict data for that cluster
-                predict_data = pd.read_csv(f'predicts/predict_cluster_{cluster}.csv')
-                
-                # Convert cliente_id to string
-                predict_data['cliente_id'] = predict_data['cliente_id'].astype(str)
-
-            with st.spinner("Filtrando data..."):
-                # Filter for the specific customer
-                customer_code_str = str(customer_code)
-                customer_data = predict_data[predict_data['cliente_id'] == customer_code_str]
-
-            with st.spinner("Geneerando predicciones de venta..."):
-                if not customer_data.empty:
-                    # Define features consistently with the training process
-                    lag_features = [f'precio_total_lag_{lag}' for lag in range(1, 25)]
-                    features = lag_features + ['mes', 'marca_id_encoded', 'año', 'cluster_id']
-    
-                    # Prepare data for prediction
-                    X_predict = customer_data[features]
-
-                    # Convert categorical features to 'category' dtype
-                    categorical_features = ['mes', 'marca_id_encoded', 'cluster_id']
-                    for feature in categorical_features:
-                        X_predict[feature] = X_predict[feature].astype('category')
+            
+            if fabricante_seleccionado == "Todos":
+                # Actuar como el comportamiento actual                
+                with st.spinner(f"Seleccionando el modelo predictivo..."):
+                    # Load the Corresponding Model
+                    model_path = f'models/modelo_cluster_{cluster}.txt'
+                    gbm = lgb.Booster(model_file=model_path)
+
+                with st.spinner("Preparando los datos..."):
+                    # Load predict data for that cluster
+                    predict_data = pd.read_csv(f'predicts/predict_cluster_{cluster}.csv')
                     
-                    # Make Prediction for the selected customer
-                    y_pred = gbm.predict(X_predict, num_iteration=gbm.best_iteration)
-
-                    # Reassemble the results
-                    results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
-                    results['ventas_predichas'] = y_pred
+                    # Convert cliente_id to string
+                    predict_data['cliente_id'] = predict_data['cliente_id'].astype(str)
+
+                with st.spinner("Filtrando data..."):
+                    # Filter for the specific customer
+                    customer_code_str = str(customer_code)
+                    customer_data = predict_data[predict_data['cliente_id'] == customer_code_str]
+
+                with st.spinner("Geneerando predicciones de venta..."):
+                    if not customer_data.empty:
+                        # Define features consistently with the training process
+                        lag_features = [f'precio_total_lag_{lag}' for lag in range(1, 25)]
+                        features = lag_features + ['mes', 'marca_id_encoded', 'año', 'cluster_id']
+        
+                        # Prepare data for prediction
+                        X_predict = customer_data[features]
+
+                        # Convert categorical features to 'category' dtype
+                        categorical_features = ['mes', 'marca_id_encoded', 'cluster_id']
+                        for feature in categorical_features:
+                            X_predict[feature] = X_predict[feature].astype('category')
+                        
+                        # Make Prediction for the selected customer
+                        y_pred = gbm.predict(X_predict, num_iteration=gbm.best_iteration)
+
+                        # Reassemble the results
+                        results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
+                        results['ventas_predichas'] = y_pred
+
+                        # Load actual data from df_agg_2024
+                        actual_sales = df_agg_2024[df_agg_2024['cliente_id'] == customer_code_str]
+                        
+                        if not actual_sales.empty:
+                            # Merge predictions with actual sales
+                            results = results.merge(actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
+                                                    on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], 
+                                                    how='left')
+                            results.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
+                        else:
+                            # If no actual sales data for 2024, fill 'ventas_reales' with 0
+                            results['ventas_reales'] = 0
 
-                    # Load actual data from df_agg_2024
-                    actual_sales = df_agg_2024[df_agg_2024['cliente_id'] == customer_code_str]
-                    
-                    if not actual_sales.empty:
-                        # Merge predictions with actual sales
-                        results = results.merge(actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
-                                                on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], 
-                                                how='left')
-                        results.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
-                    else:
-                        # If no actual sales data for 2024, fill 'ventas_reales' with 0
-                        results['ventas_reales'] = 0
-
-                    # Ensure any missing sales data is filled with 0
-                    results['ventas_reales'].fillna(0, inplace=True)
-
-                    # Define the cutoff date for the last 12 months
-                    fecha_inicio = pd.to_datetime("2023-01-01")
-                    fecha_corte = pd.to_datetime("2024-09-01")
-
-                    # Convertir fecha_mes a datetime en el DataFrame historical_data
-                    historical_data['fecha_mes'] = pd.to_datetime(historical_data['fecha_mes'], errors='coerce')
-
-                    # Ensure cliente_id is of type string and strip any leading/trailing whitespace
-                    historical_data['cliente_id'] = historical_data['cliente_id'].astype(str).str.strip()
-                    customer_code_str = str(customer_code).strip()  # Ensure the customer code is also properly formatted
-
-                    filtered_historical_data = historical_data[historical_data['cliente_id'] == customer_code_str]
-
-
-                    # Filtrar los datos históricos por cliente y por el rango de fechas (2023)
-                    fecha_inicio_2023 = pd.to_datetime("2023-01-01")
-                    fecha_fin_2023 = pd.to_datetime("2023-12-31")
-
-                    datos_historicos = historical_data[
-                        (historical_data['cliente_id'] == customer_code_str) &
-                        (historical_data['fecha_mes'] >= fecha_inicio_2023) &
-                        (historical_data['fecha_mes'] <= fecha_fin_2023)
-                    ].groupby('fecha_mes')['precio_total'].sum().reset_index()
-
-                    # Renombrar la columna 'precio_total' a 'ventas_historicas' si no está vacía
-                    if not datos_historicos.empty:
-                        datos_historicos.rename(columns={'precio_total': 'ventas_historicas'}, inplace=True)
-                    else:
-                        # Si los datos históricos están vacíos, generar fechas de 2023 con ventas_historicas = 0
-                        fechas_2023 = pd.date_range(start='2023-01-01', end='2023-12-31', freq='M')
-                        datos_historicos = pd.DataFrame({'fecha_mes': fechas_2023, 'ventas_historicas': [0] * len(fechas_2023)})
-
-                    # Filtrar los datos de predicciones y ventas reales para 2024
-                    datos_cliente_total = results.groupby('fecha_mes').agg({
-                        'ventas_reales': 'sum',
-                        'ventas_predichas': 'sum'
-                    }).reset_index()
-
-                    # Asegurarnos de que fecha_mes en datos_cliente_total es datetime
-                    datos_cliente_total['fecha_mes'] = pd.to_datetime(datos_cliente_total['fecha_mes'], errors='coerce')
-
-                    # Generar un rango de fechas para 2024 si no hay predicciones
-                    fechas_2024 = pd.date_range(start='2024-01-01', end='2024-12-31', freq='M')
-                    fechas_df_2024 = pd.DataFrame({'fecha_mes': fechas_2024})
-
-                    # Asegurarnos de que fecha_mes en fechas_df_2024 es datetime
-                    fechas_df_2024['fecha_mes'] = pd.to_datetime(fechas_df_2024['fecha_mes'], errors='coerce')
-
-                    # Combinar datos históricos con predicciones y ventas reales usando un merge
-                    # Usamos how='outer' para asegurarnos de incluir todas las fechas de 2023 y 2024
-                    datos_combinados = pd.merge(datos_historicos, datos_cliente_total, on='fecha_mes', how='outer').sort_values('fecha_mes')
-
-                    # Rellenar los NaN: 0 en ventas_historicas donde faltan predicciones, y viceversa
-                    datos_combinados['ventas_historicas'].fillna(0, inplace=True)
-                    datos_combinados['ventas_predichas'].fillna(0, inplace=True)
-                    datos_combinados['ventas_reales'].fillna(0, inplace=True)
-
-                    # Crear la gráfica con Plotly
-                    fig = go.Figure()
-
-                    # Graficar ventas históricas
-                    fig.add_trace(go.Scatter(
-                        x=datos_combinados['fecha_mes'], 
-                        y=datos_combinados['ventas_historicas'], 
-                        mode='lines+markers', 
-                        name='Ventas Históricas', 
-                        line=dict(color='blue')
-                    ))
-
-                    # Graficar ventas predichas
-                    fig.add_trace(go.Scatter(
-                        x=datos_combinados['fecha_mes'], 
-                        y=datos_combinados['ventas_predichas'], 
-                        mode='lines+markers', 
-                        name='Ventas Predichas', 
-                        line=dict(color='orange')
-                    ))
-
-                    # Graficar ventas reales
-                    fig.add_trace(go.Scatter(
-                        x=datos_combinados['fecha_mes'], 
-                        y=datos_combinados['ventas_reales'], 
-                        mode='lines+markers', 
-                        name='Ventas Reales', 
-                        line=dict(color='green')
-                    ))
-
-                    # Personalizar el layout para enfocarse en 2023 y 2024
-                    fig.update_layout(
-                        title=f"Ventas Históricas, Predichas y Reales para Cliente {customer_code}",
-                        xaxis_title="Fecha",
-                        yaxis_title="Ventas (€)",
-                        height=600,
-                        xaxis_range=[fecha_inicio_2023, pd.to_datetime("2024-09-30")],  # Ajustar el rango del eje x a 2023-2024
-                        legend_title="Tipo de Ventas",
-                        hovermode="x unified"
-                    )
+                        # Ensure any missing sales data is filled with 0
+                        results['ventas_reales'].fillna(0, inplace=True)
 
-                    # Mostrar la gráfica en Streamlit
-                    st.plotly_chart(fig)
+                        # Define the cutoff date for the last 12 months
+                        fecha_inicio = pd.to_datetime("2023-01-01")
+                        fecha_corte = pd.to_datetime("2024-09-01")
 
-                    # Calculate metrics for 2024 data
-                    datos_2024 = datos_combinados[datos_combinados['fecha_mes'].dt.year == 2024]
-                    actual = datos_2024['ventas_reales']
-                    predicted = datos_2024['ventas_predichas']
+                        # Convertir fecha_mes a datetime en el DataFrame historical_data
+                        historical_data['fecha_mes'] = pd.to_datetime(historical_data['fecha_mes'], errors='coerce')
 
-                    def calculate_mape(y_true, y_pred):
-                        mask = y_true != 0
-                        return np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100
+                        # Ensure cliente_id is of type string and strip any leading/trailing whitespace
+                        historical_data['cliente_id'] = historical_data['cliente_id'].astype(str).str.strip()
+                        customer_code_str = str(customer_code).strip()  # Ensure the customer code is also properly formatted
 
-                    mae = mean_absolute_error(actual, predicted)
-                    mse = mean_squared_error(actual, predicted)
-                    rmse = np.sqrt(mse)
-                    mape = calculate_mape(actual, predicted)
-                    smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100
+                        filtered_historical_data = historical_data[historical_data['cliente_id'] == customer_code_str]
 
-                    # Display metrics
-                    st.subheader("Métricas de Predicción (2024)")
-                    col1, col2, col3, col4 = st.columns(4)
-                    col1.metric("MAE", f"{mae:.2f} €",help="Promedio de la diferencia absoluta entre las predicciones y los valores reales.")
-                    col2.metric("MAPE", f"{mape:.2f}%",help="Porcentaje promedio de error en las predicciones.")
-                    col3.metric("RMSE", f"{rmse:.2f} €",help="Medida de la desviación estándar de los residuos de predicción.")
-                    col4.metric("SMAPE", f"{smape:.2f}%",help="Alternativa al MAPE que maneja mejor los valores cercanos a cero.")
 
+                        # Filtrar los datos históricos por cliente y por el rango de fechas (2023)
+                        fecha_inicio_2023 = pd.to_datetime("2023-01-01")
+                        fecha_fin_2023 = pd.to_datetime("2023-12-31")
 
-                    # Split space into two columns
-                    col1, col2 = st.columns(2)
+                        datos_historicos = historical_data[
+                            (historical_data['cliente_id'] == customer_code_str) &
+                            (historical_data['fecha_mes'] >= fecha_inicio_2023) &
+                            (historical_data['fecha_mes'] <= fecha_fin_2023)
+                        ].groupby('fecha_mes')['precio_total'].sum().reset_index()
 
-                    # Column 1: Radar chart for top manufacturers
-                    with col1:
-                        st.subheader("¡Esto tiene buena pinta!")
-                        st.info("Su cliente ha superado las ventas predichas de las siguientes marcas:")
+                        # Renombrar la columna 'precio_total' a 'ventas_historicas' si no está vacía
+                        if not datos_historicos.empty:
+                            datos_historicos.rename(columns={'precio_total': 'ventas_historicas'}, inplace=True)
+                        else:
+                            # Si los datos históricos están vacíos, generar fechas de 2023 con ventas_historicas = 0
+                            fechas_2023 = pd.date_range(start='2023-01-01', end='2023-12-31', freq='M')
+                            datos_historicos = pd.DataFrame({'fecha_mes': fechas_2023, 'ventas_historicas': [0] * len(fechas_2023)})
 
-                        # Group results by manufacturer to calculate the total predicted and actual sales
-                        grouped_results = results.groupby('marca_id_encoded').agg({
+                        # Filtrar los datos de predicciones y ventas reales para 2024
+                        datos_cliente_total = results.groupby('fecha_mes').agg({
                             'ventas_reales': 'sum',
                             'ventas_predichas': 'sum'
                         }).reset_index()
 
-                        # Identify manufacturers that exceeded predicted sales
-                        overperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] > grouped_results['ventas_predichas']].copy()
-
-                        if not overperforming_manufacturers.empty:
-                            # Calculate the extra amount (difference between actual and predicted sales)
-                            overperforming_manufacturers['extra_amount'] = overperforming_manufacturers['ventas_reales'] - overperforming_manufacturers['ventas_predichas']
-
-                            # Sort by the highest extra amount
-                            overperforming_manufacturers = overperforming_manufacturers.sort_values(by='extra_amount', ascending=False)
-
-                            # Limit to top 10 overperforming manufacturers
-                            top_overperformers = overperforming_manufacturers.head(10)
-
-                            # Display two cards per row
-                            for i in range(0, len(top_overperformers), 2):
-                                cols = st.columns(2)  # Create two columns for two cards in a row
-
-                                for j, col in enumerate(cols):
-                                    if i + j < len(top_overperformers):
-                                        row = top_overperformers.iloc[i + j]
-                                        manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
-                                        predicted = row['ventas_predichas']
-                                        actual = row['ventas_reales']
-                                        extra = row['extra_amount']
-
-                                        # Use st.metric for compact display in each column
-                                        with col:
-                                            st.metric(
-                                                label=f"{manufacturer_name}",
-                                                value=f"{actual:.2f}€",
-                                                delta=f"Exceeded by {extra:.2f}€",
-                                                delta_color="normal"
-                                            )
-
-
-                        # Radar chart logic remains the same
-                        customer_df = df[df["CLIENTE"] == str(customer_code)]
-                        all_manufacturers = customer_df.iloc[:, 1:].T
-                        all_manufacturers.index = all_manufacturers.index.astype(str)
-
-                        customer_euros = euros_proveedor[euros_proveedor["CLIENTE"] == str(customer_code)]
-                        sales_data = customer_euros.iloc[:, 1:].T
-                        sales_data.index = sales_data.index.astype(str)
-
-                        sales_data_filtered = sales_data.drop(index='CLIENTE', errors='ignore')
-                        sales_data_filtered = sales_data_filtered.apply(pd.to_numeric, errors='coerce')
-                        all_manufacturers = all_manufacturers.apply(pd.to_numeric, errors='coerce')
-
-                        top_units = all_manufacturers.sort_values(by=all_manufacturers.columns[0], ascending=False).head(10)
-                        top_sales = sales_data_filtered.sort_values(by=sales_data_filtered.columns[0], ascending=False).head(10)
-                        combined_top = pd.concat([top_units, top_sales]).index.unique()[:20]
-
-                        combined_top = [m for m in combined_top if m in all_manufacturers.index and m in sales_data_filtered.index]
-
-                        if combined_top:
-                            combined_data = pd.DataFrame({
-                                'units': all_manufacturers.loc[combined_top, all_manufacturers.columns[0]],
-                                'sales': sales_data_filtered.loc[combined_top, sales_data_filtered.columns[0]]
-                            }).fillna(0)
-
-                            combined_data_sorted = combined_data.sort_values(by=['units', 'sales'], ascending=False)
-                            non_zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] > 0]
-                            
-                            if len(non_zero_manufacturers) < 3:
-                                zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] == 0].head(3 - len(non_zero_manufacturers))
-                                manufacturers_to_show = pd.concat([non_zero_manufacturers, zero_manufacturers])
+                        # Asegurarnos de que fecha_mes en datos_cliente_total es datetime
+                        datos_cliente_total['fecha_mes'] = pd.to_datetime(datos_cliente_total['fecha_mes'], errors='coerce')
+
+                        # Generar un rango de fechas para 2024 si no hay predicciones
+                        fechas_2024 = pd.date_range(start='2024-01-01', end='2024-12-31', freq='M')
+                        fechas_df_2024 = pd.DataFrame({'fecha_mes': fechas_2024})
+
+                        # Asegurarnos de que fecha_mes en fechas_df_2024 es datetime
+                        fechas_df_2024['fecha_mes'] = pd.to_datetime(fechas_df_2024['fecha_mes'], errors='coerce')
+
+                        # Combinar datos históricos con predicciones y ventas reales usando un merge
+                        # Usamos how='outer' para asegurarnos de incluir todas las fechas de 2023 y 2024
+                        datos_combinados = pd.merge(datos_historicos, datos_cliente_total, on='fecha_mes', how='outer').sort_values('fecha_mes')
+
+                        # Rellenar los NaN: 0 en ventas_historicas donde faltan predicciones, y viceversa
+                        datos_combinados['ventas_historicas'].fillna(0, inplace=True)
+                        datos_combinados['ventas_predichas'].fillna(0, inplace=True)
+                        datos_combinados['ventas_reales'].fillna(0, inplace=True)
+
+                        # Crear la gráfica con Plotly
+                        fig = go.Figure()
+
+                        # Graficar ventas históricas
+                        fig.add_trace(go.Scatter(
+                            x=datos_combinados['fecha_mes'], 
+                            y=datos_combinados['ventas_historicas'], 
+                            mode='lines+markers', 
+                            name='Ventas Históricas', 
+                            line=dict(color='blue')
+                        ))
+
+                        # Graficar ventas predichas
+                        fig.add_trace(go.Scatter(
+                            x=datos_combinados['fecha_mes'], 
+                            y=datos_combinados['ventas_predichas'], 
+                            mode='lines+markers', 
+                            name='Ventas Predichas', 
+                            line=dict(color='orange')
+                        ))
+
+                        # Graficar ventas reales
+                        fig.add_trace(go.Scatter(
+                            x=datos_combinados['fecha_mes'], 
+                            y=datos_combinados['ventas_reales'], 
+                            mode='lines+markers', 
+                            name='Ventas Reales', 
+                            line=dict(color='green')
+                        ))
+
+                        # Personalizar el layout para enfocarse en 2023 y 2024
+                        fig.update_layout(
+                            title=f"Ventas Históricas, Predichas y Reales para Cliente {customer_code}",
+                            xaxis_title="Fecha",
+                            yaxis_title="Ventas (€)",
+                            height=600,
+                            xaxis_range=[fecha_inicio_2023, pd.to_datetime("2024-09-30")],  # Ajustar el rango del eje x a 2023-2024
+                            legend_title="Tipo de Ventas",
+                            hovermode="x unified"
+                        )
+
+                        # Mostrar la gráfica en Streamlit
+                        st.plotly_chart(fig)
+
+                        # Calculate metrics for 2024 data
+                        datos_2024 = datos_combinados[datos_combinados['fecha_mes'].dt.year == 2024]
+                        actual = datos_2024['ventas_reales']
+                        predicted = datos_2024['ventas_predichas']
+
+                        def calculate_mape(y_true, y_pred):
+                            mask = y_true != 0
+                            return np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100
+
+                        mae = mean_absolute_error(actual, predicted)
+                        mse = mean_squared_error(actual, predicted)
+                        rmse = np.sqrt(mse)
+                        mape = calculate_mape(actual, predicted)
+                        smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100
+
+                        # Display metrics
+                        st.subheader("Métricas de Predicción (2024)")
+                        col1, col2, col3, col4 = st.columns(4)
+                        col1.metric("MAE", f"{mae:.2f} €",help="Promedio de la diferencia absoluta entre las predicciones y los valores reales.")
+                        col2.metric("MAPE", f"{mape:.2f}%",help="Porcentaje promedio de error en las predicciones.")
+                        col3.metric("RMSE", f"{rmse:.2f} €",help="Medida de la desviación estándar de los residuos de predicción.")
+                        col4.metric("SMAPE", f"{smape:.2f}%",help="Alternativa al MAPE que maneja mejor los valores cercanos a cero.")
+
+
+                        # Split space into two columns
+                        col1, col2 = st.columns(2)
+
+                        # Column 1: Radar chart for top manufacturers
+                        with col1:
+                            st.subheader("¡Esto tiene buena pinta!")
+                            st.info("Su cliente ha superado las ventas predichas de las siguientes marcas:")
+
+                            # Group results by manufacturer to calculate the total predicted and actual sales
+                            grouped_results = results.groupby('marca_id_encoded').agg({
+                                'ventas_reales': 'sum',
+                                'ventas_predichas': 'sum'
+                            }).reset_index()
+
+                            # Identify manufacturers that exceeded predicted sales
+                            overperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] > grouped_results['ventas_predichas']].copy()
+
+                            if not overperforming_manufacturers.empty:
+                                # Calculate the extra amount (difference between actual and predicted sales)
+                                overperforming_manufacturers['extra_amount'] = overperforming_manufacturers['ventas_reales'] - overperforming_manufacturers['ventas_predichas']
+
+                                # Sort by the highest extra amount
+                                overperforming_manufacturers = overperforming_manufacturers.sort_values(by='extra_amount', ascending=False)
+
+                                # Limit to top 10 overperforming manufacturers
+                                top_overperformers = overperforming_manufacturers.head(10)
+
+                                # Display two cards per row
+                                for i in range(0, len(top_overperformers), 2):
+                                    cols = st.columns(2)  # Create two columns for two cards in a row
+
+                                    for j, col in enumerate(cols):
+                                        if i + j < len(top_overperformers):
+                                            row = top_overperformers.iloc[i + j]
+                                            manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
+                                            predicted = row['ventas_predichas']
+                                            actual = row['ventas_reales']
+                                            extra = row['extra_amount']
+
+                                            # Use st.metric for compact display in each column
+                                            with col:
+                                                st.metric(
+                                                    label=f"{manufacturer_name}",
+                                                    value=f"{actual:.2f}€",
+                                                    delta=f"Exceeded by {extra:.2f}€",
+                                                    delta_color="normal"
+                                                )
+
+
+                            # Radar chart logic remains the same
+                            customer_df = df[df["CLIENTE"] == str(customer_code)]
+                            all_manufacturers = customer_df.iloc[:, 1:].T
+                            all_manufacturers.index = all_manufacturers.index.astype(str)
+
+                            customer_euros = euros_proveedor[euros_proveedor["CLIENTE"] == str(customer_code)]
+                            sales_data = customer_euros.iloc[:, 1:].T
+                            sales_data.index = sales_data.index.astype(str)
+
+                            sales_data_filtered = sales_data.drop(index='CLIENTE', errors='ignore')
+                            sales_data_filtered = sales_data_filtered.apply(pd.to_numeric, errors='coerce')
+                            all_manufacturers = all_manufacturers.apply(pd.to_numeric, errors='coerce')
+
+                            top_units = all_manufacturers.sort_values(by=all_manufacturers.columns[0], ascending=False).head(10)
+                            top_sales = sales_data_filtered.sort_values(by=sales_data_filtered.columns[0], ascending=False).head(10)
+                            combined_top = pd.concat([top_units, top_sales]).index.unique()[:20]
+
+                            combined_top = [m for m in combined_top if m in all_manufacturers.index and m in sales_data_filtered.index]
+
+                            if combined_top:
+                                combined_data = pd.DataFrame({
+                                    'units': all_manufacturers.loc[combined_top, all_manufacturers.columns[0]],
+                                    'sales': sales_data_filtered.loc[combined_top, sales_data_filtered.columns[0]]
+                                }).fillna(0)
+
+                                combined_data_sorted = combined_data.sort_values(by=['units', 'sales'], ascending=False)
+                                non_zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] > 0]
+                                
+                                if len(non_zero_manufacturers) < 3:
+                                    zero_manufacturers = combined_data_sorted[combined_data_sorted['units'] == 0].head(3 - len(non_zero_manufacturers))
+                                    manufacturers_to_show = pd.concat([non_zero_manufacturers, zero_manufacturers])
+                                else:
+                                    manufacturers_to_show = non_zero_manufacturers
+
+                                values = manufacturers_to_show['units'].tolist()
+                                amounts = manufacturers_to_show['sales'].tolist()
+                                manufacturers = [get_supplier_name(m) for m in manufacturers_to_show.index]
+
+                                if manufacturers:
+                                    fig = radar_chart(manufacturers, values, amounts, f'Gráfico de radar para los {len(manufacturers)} principales fabricantes del cliente {customer_code}')
+                                    st.pyplot(fig)
+
+                        # Column 2: Alerts and additional analysis
+                        with col2:
+                            st.subheader("¡Puede que tengas que revisar esto!")
+                            st.warning("Se esperaba que tu cliente comprara más productos de las siguientes marcas:")
+
+                            # Group results by manufacturer to calculate the total predicted and actual sales
+                            grouped_results = results.groupby('marca_id_encoded').agg({
+                                'ventas_reales': 'sum',
+                                'ventas_predichas': 'sum'
+                            }).reset_index()
+
+                            # Identify manufacturers that didn't meet predicted sales
+                            underperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] < grouped_results['ventas_predichas']].copy()
+
+                            if not underperforming_manufacturers.empty:
+                                # Calculate the missed amount
+                                underperforming_manufacturers['missed_amount'] = underperforming_manufacturers['ventas_predichas'] - underperforming_manufacturers['ventas_reales']
+
+                                # Sort by the highest missed amount
+                                underperforming_manufacturers = underperforming_manufacturers.sort_values(by='missed_amount', ascending=False)
+
+                                # Limit to top 10 missed amounts
+                                top_misses = underperforming_manufacturers.head(10)
+
+                                # Display two cards per row
+                                for i in range(0, len(top_misses), 2):
+                                    cols = st.columns(2)  # Create two columns for two cards in a row
+
+                                    for j, col in enumerate(cols):
+                                        if i + j < len(top_misses):
+                                            row = top_misses.iloc[i + j]
+                                            manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
+                                            predicted = row['ventas_predichas']
+                                            actual = row['ventas_reales']
+                                            missed = row['missed_amount']
+
+                                            # Use st.metric for compact display in each column
+                                            with col:
+                                                st.metric(
+                                                    label=f"{manufacturer_name}",
+                                                    value=f"{actual:.2f}€",
+                                                    delta=f"Missed by {missed:.2f}€",
+                                                    delta_color="inverse"
+                                                )
                             else:
-                                manufacturers_to_show = non_zero_manufacturers
+                                st.success("All manufacturers have met or exceeded predicted sales.")
+
+
+
+                            # Gráfico de ventas anuales
+                            ventas_clientes['codigo_cliente'] = ventas_clientes['codigo_cliente'].astype(str).str.strip()
+
+                            sales_columns = ['VENTA_2021', 'VENTA_2022', 'VENTA_2023']
+                            if all(col in ventas_clientes.columns for col in sales_columns):
+                                customer_sales_data = ventas_clientes[ventas_clientes['codigo_cliente'] == customer_code]
+
+                                if not customer_sales_data.empty:
+                                    customer_sales = customer_sales_data[sales_columns].values[0]
+                                    years = ['2021', '2022', '2023']
+
+                                    # Convert 'fecha_mes' to datetime format if it's not already
+                                    if not pd.api.types.is_datetime64_any_dtype(results['fecha_mes']):
+                                        results['fecha_mes'] = pd.to_datetime(results['fecha_mes'], errors='coerce')
+
+                                    # Add the 2024 actual and predicted data
+                                    if 'ventas_predichas' in results.columns and 'ventas_reales' in results.columns:
+                                        actual_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_reales'].sum()
+                                        predicted_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_predichas'].sum()
+
+                                        # Assuming only 9 months of actual data are available, annualize the sales
+                                        months_available = 9
+                                        actual_sales_2024_annual = (actual_sales_2024 / months_available) * 12
+
+                                        # Prepare data for the bar chart
+                                        sales_values = list(customer_sales) + [actual_sales_2024_annual]
+                                        predicted_values = list(customer_sales) + [predicted_sales_2024]
+
+                                        years.append('2024')
+
+                                        # Create the bar chart for historical and 2024 data
+                                        fig_sales_bar = go.Figure()
+                                        fig_sales_bar.add_trace(go.Bar(
+                                            x=years[:3],  
+                                            y=sales_values[:3],
+                                            name="Historical Sales",
+                                            marker_color='blue'
+                                        ))
+
+                                        fig_sales_bar.add_trace(go.Bar(
+                                            x=[years[3]],  
+                                            y=[sales_values[3]],
+                                            name="2024 Actual Sales (Annualized)",
+                                            marker_color='green'
+                                        ))
+
+                                        fig_sales_bar.add_trace(go.Bar(
+                                            x=[years[3]],  
+                                            y=[predicted_values[3]],
+                                            name="2024 Predicted Sales",
+                                            marker_color='orange'
+                                        ))
+
+                                        # Customize layout
+                                        fig_sales_bar.update_layout(
+                                            title=f"Ventas anuales de tu cliente",
+                                            xaxis_title="Year",
+                                            yaxis_title="Sales (€)",
+                                            barmode='group',
+                                            height=600,
+                                            legend_title_text="Sales Type",
+                                            hovermode="x unified"
+                                        )
+
+                                        # Display the chart
+                                        st.plotly_chart(fig_sales_bar, use_container_width=True)
+
+                                    else:
+                                        st.warning(f"No predicted or actual data found for customer {customer_code} for 2024.")
 
-                            values = manufacturers_to_show['units'].tolist()
-                            amounts = manufacturers_to_show['sales'].tolist()
-                            manufacturers = [get_supplier_name(m) for m in manufacturers_to_show.index]
-
-                            if manufacturers:
-                                fig = radar_chart(manufacturers, values, amounts, f'Gráfico de radar para los {len(manufacturers)} principales fabricantes del cliente {customer_code}')
-                                st.pyplot(fig)
-
-                    # Column 2: Alerts and additional analysis
-                    with col2:
-                        st.subheader("¡Puede que tengas que revisar esto!")
-                        st.warning("Se esperaba que tu cliente comprara más productos de las siguientes marcas:")
-
-                        # Group results by manufacturer to calculate the total predicted and actual sales
-                        grouped_results = results.groupby('marca_id_encoded').agg({
-                            'ventas_reales': 'sum',
-                            'ventas_predichas': 'sum'
-                        }).reset_index()
-
-                        # Identify manufacturers that didn't meet predicted sales
-                        underperforming_manufacturers = grouped_results[grouped_results['ventas_reales'] < grouped_results['ventas_predichas']].copy()
-
-                        if not underperforming_manufacturers.empty:
-                            # Calculate the missed amount
-                            underperforming_manufacturers['missed_amount'] = underperforming_manufacturers['ventas_predichas'] - underperforming_manufacturers['ventas_reales']
-
-                            # Sort by the highest missed amount
-                            underperforming_manufacturers = underperforming_manufacturers.sort_values(by='missed_amount', ascending=False)
-
-                            # Limit to top 10 missed amounts
-                            top_misses = underperforming_manufacturers.head(10)
-
-                            # Display two cards per row
-                            for i in range(0, len(top_misses), 2):
-                                cols = st.columns(2)  # Create two columns for two cards in a row
-
-                                for j, col in enumerate(cols):
-                                    if i + j < len(top_misses):
-                                        row = top_misses.iloc[i + j]
-                                        manufacturer_name = get_supplier_name_encoded(row['marca_id_encoded'])
-                                        predicted = row['ventas_predichas']
-                                        actual = row['ventas_reales']
-                                        missed = row['missed_amount']
-
-                                        # Use st.metric for compact display in each column
-                                        with col:
-                                            st.metric(
-                                                label=f"{manufacturer_name}",
-                                                value=f"{actual:.2f}€",
-                                                delta=f"Missed by {missed:.2f}€",
-                                                delta_color="inverse"
-                                            )
-                        else:
-                            st.success("All manufacturers have met or exceeded predicted sales.")
-
-
-
-                        # Gráfico de ventas anuales
-                        ventas_clientes['codigo_cliente'] = ventas_clientes['codigo_cliente'].astype(str).str.strip()
-
-                        sales_columns = ['VENTA_2021', 'VENTA_2022', 'VENTA_2023']
-                        if all(col in ventas_clientes.columns for col in sales_columns):
-                            customer_sales_data = ventas_clientes[ventas_clientes['codigo_cliente'] == customer_code]
-
-                            if not customer_sales_data.empty:
-                                customer_sales = customer_sales_data[sales_columns].values[0]
-                                years = ['2021', '2022', '2023']
-
-                                # Convert 'fecha_mes' to datetime format if it's not already
-                                if not pd.api.types.is_datetime64_any_dtype(results['fecha_mes']):
-                                    results['fecha_mes'] = pd.to_datetime(results['fecha_mes'], errors='coerce')
-
-                                # Add the 2024 actual and predicted data
-                                if 'ventas_predichas' in results.columns and 'ventas_reales' in results.columns:
-                                    actual_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_reales'].sum()
-                                    predicted_sales_2024 = results[results['fecha_mes'].dt.year == 2024]['ventas_predichas'].sum()
-
-                                    # Assuming only 9 months of actual data are available, annualize the sales
-                                    months_available = 9
-                                    actual_sales_2024_annual = (actual_sales_2024 / months_available) * 12
-
-                                    # Prepare data for the bar chart
-                                    sales_values = list(customer_sales) + [actual_sales_2024_annual]
-                                    predicted_values = list(customer_sales) + [predicted_sales_2024]
-
-                                    years.append('2024')
-
-                                    # Create the bar chart for historical and 2024 data
-                                    fig_sales_bar = go.Figure()
-                                    fig_sales_bar.add_trace(go.Bar(
-                                        x=years[:3],  
-                                        y=sales_values[:3],
-                                        name="Historical Sales",
-                                        marker_color='blue'
-                                    ))
-
-                                    fig_sales_bar.add_trace(go.Bar(
-                                        x=[years[3]],  
-                                        y=[sales_values[3]],
-                                        name="2024 Actual Sales (Annualized)",
-                                        marker_color='green'
-                                    ))
-
-                                    fig_sales_bar.add_trace(go.Bar(
-                                        x=[years[3]],  
-                                        y=[predicted_values[3]],
-                                        name="2024 Predicted Sales",
-                                        marker_color='orange'
-                                    ))
-
-                                    # Customize layout
-                                    fig_sales_bar.update_layout(
-                                        title=f"Ventas anuales de tu cliente",
-                                        xaxis_title="Year",
-                                        yaxis_title="Sales (€)",
-                                        barmode='group',
-                                        height=600,
-                                        legend_title_text="Sales Type",
-                                        hovermode="x unified"
-                                    )
-
-                                    # Display the chart
-                                    st.plotly_chart(fig_sales_bar, use_container_width=True)
-
-                                else:
-                                    st.warning(f"No predicted or actual data found for customer {customer_code} for 2024.")
+            else:
+                with st.spinner(f"Mostrando datos para el fabricante {fabricante_seleccionado}..."):
+                    # Mostrar el cliente y el fabricante seleccionados
+                    st.write(f"**Cliente seleccionado:** {customer_code}")
+                    st.write(f"**Fabricante seleccionado:** {fabricante_seleccionado}")
 
 # Customer Recommendations Page
 elif page == "💡 Recomendación de Artículos":