feat: update filter per manufacturer

app.py

@@ -300,11 +300,12 @@ elif page == "🕵️ Análisis de Cliente":
     </p>
     """, unsafe_allow_html=True)
 
-    # Customer selection
+    # Combine text input and dropdown into a single searchable selectbox
     customer_code = st.selectbox(
         "Escribe o selecciona el código de tu cliente",
-        df['CLIENTE'].unique(),
-        format_func=lambda x: str(x),
+        df['CLIENTE'].unique(),  # All customer codes
+
+        format_func=lambda x: str(x),  # Ensures the values are displayed as strings
         help="Start typing to search for a specific customer code"
     )
 
@@ -313,187 +314,189 @@ elif page == "🕵️ Análisis de Cliente":
             with st.spinner("Estamos identificando el grupo del cliente..."):
                 # Find Customer's Cluster
                 customer_match = customer_clusters[customer_clusters['cliente_id'] == customer_code]
+                time.sleep(1)
+                
                 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)
 
-            # Filter customer data after customer code is selected
-            customer_code_str = str(customer_code)
-            customer_data = predict_data[predict_data['cliente_id'] == customer_code_str]
-
-            if not customer_data.empty:
-                st.success(f"Datos para el cliente {customer_code_str} encontrados.")
-                results = customer_data.copy()
-
-                # Manufacturer selection after customer analysis
-                manufacturer_options = ['Todos'] + sorted(nombres_proveedores['nombre'].unique())
-                selected_manufacturer = st.selectbox("Selecciona el fabricante", manufacturer_options)
-
-                if selected_manufacturer != 'Todos':
-                    manufacturer_code = nombres_proveedores[nombres_proveedores['nombre'] == selected_manufacturer]['codigo'].values[0]
-                    results_filtered = results[results['marca_id_encoded'] == manufacturer_code]
-                    historical_data_filtered = historical_data[historical_data['marca_id_encoded'] == manufacturer_code]
-                else:
-                    results_filtered = results
-                    historical_data_filtered = historical_data
-
-                with st.spinner("Generando predicciones de venta..."):
-                    if not results_filtered.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 = results_filtered[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_filtered['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_filtered = results_filtered.merge(
-                                actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
-                                on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], 
-                                how='left'
-                            )
-                            results_filtered.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
-                        else:
-                            # If no actual sales data for 2024, create the column with 0s
-                            results_filtered['ventas_reales'] = 0
+            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]
 
-                        # Ensure any missing sales data is filled with 0
-                        results_filtered['ventas_reales'].fillna(0, inplace=True)
+            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]
 
-                        # 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")
+                    # 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)
 
-                        # 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")
+                    # Reassemble the results
+                    results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
+                    results['ventas_predichas'] = y_pred
 
-                        datos_historicos = historical_data_filtered[
-                            (historical_data_filtered['cliente_id'] == customer_code_str) & 
-                            (historical_data_filtered['fecha_mes'] >= fecha_inicio_2023) & 
-                            (historical_data_filtered['fecha_mes'] <= fecha_fin_2023)
-                        ].groupby('fecha_mes')['precio_total'].sum().reset_index()
+                    # 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
 
-                        # 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)})
+                    # Ensure any missing sales data is filled with 0
+                    results['ventas_reales'].fillna(0, inplace=True)
 
-                        # Filtrar los datos de predicciones y ventas reales para 2024
-                        datos_cliente_total = results_filtered.groupby('fecha_mes').agg({
-                            'ventas_reales': 'sum',
-                            'ventas_predichas': 'sum'
-                        }).reset_index()
+                    # 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')
 
-                        # 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})
-
-                        # Combinar datos históricos con predicciones y ventas reales usando un merge
-                        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.")
+                    # 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:
-                        st.warning(f"No se encontraron datos filtrados para el cliente {customer_code_str}.")
+                        # 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"
+                    )
+
+                    # 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)
@@ -864,4 +867,4 @@ elif page == "💡 Recomendación de Artículos":
 #             else:
 #                 st.warning("⚠️ No recommendations found for the provided basket.")
 #         else:
-#             st.warning("⚠️ Please select at least one article and set its quantity.")
+#             st.warning("⚠️ Please select at least one article and set its quantity.")