Update app.py

app.py

@@ -1,147 +1,88 @@
-import gradio as gr
 import pandas as pd
-import numpy as np
-import plotly.graph_objects as go
-import joblib  # Para cargar el modelo ARIMA guardado
-import os  # Para manejar rutas de archivos
-
-# Función para cargar el modelo ARIMA guardado
-def load_arima_model():
-    model = joblib.load('arima_sales_model.pkl')  # Cargar el modelo ARIMA desde un archivo guardado (.pkl)
-    return model
-
-# Cargar el modelo ARIMA al inicio
-arima_model = load_arima_model()
-
-# Funciones de preprocesamiento y cálculo de crecimiento de ventas
-def drop(dataframe):
-    pass  # Implementar según sea necesario
-
-def date_format(dataframe):
-    pass  # Implementar según sea necesario
-
-def group_to_three(dataframe):
-    pass  # Implementar según sea necesario
-
-def get_forecast_period(period):
-    return period  # Retornar el periodo de pronóstico
-
-def sales_growth(df, forecasted_series):
-    return forecasted_series.diff()  # Calcular el crecimiento de ventas
-
-def merge_forecast_data(actual, predicted, future):
-    return pd.DataFrame({
-        "Actual Sales": actual,
-        "Predicted Sales": predicted,
-        "Forecasted Future Sales": future
-    })
-
-# Función para mostrar una alerta si el archivo no es CSV o si excede el tamaño
-def check_file(uploaded_file):
+import matplotlib.pyplot as plt
+import joblib
+import gradio as gr
+from dateutil.relativedelta import relativedelta
+import calendar
+
+def load_model():
+    try:
+        model = joblib.load('arima_sales_model.pkl')
+        return model, None
+    except Exception as e:
+        return None, f"Failed to load model: {str(e)}"
+
+def parse_date(date_str):
+    """Parse the custom date format 'Month-Year'."""
+    try:
+        date = pd.to_datetime(date_str, format="%B-%Y")
+        _, last_day = calendar.monthrange(date.year, date.month)
+        start_date = date.replace(day=1)
+        end_date = date.replace(day=last_day)
+        return start_date, end_date, None
+    except ValueError:
+        return None, None, "Date format should be 'Month-Year', e.g., 'January-2024'."
+
+def forecast_sales(uploaded_file, start_date_str, end_date_str):
     if uploaded_file is None:
-        return gr.Error("⚠️ No file uploaded. Please upload a CSV file.")
+        return "No file uploaded.", None, "Please upload a file."
 
-    # Verificar si el archivo es CSV
-    if not uploaded_file.endswith('.csv'):
-        return gr.Error("⚠️ Invalid file format. Please upload a CSV file.")
+    try:
+        df = pd.read_csv(uploaded_file)
+        if 'Date' not in df.columns or 'Sale' not in df.columns:
+            return None, "The uploaded file must contain 'Date' and 'Sale' columns.", "File does not have required columns."
+    except Exception as e:
+        return None, f"Failed to read the uploaded CSV file: {str(e)}", "Error reading file."
 
-    # Verificar el tamaño del archivo (200MB)
-    file_size = uploaded_file.size  # Verificar el tamaño del archivo
-    if file_size > 200 * 1024 * 1024:  # Limitar a 200MB
-        return gr.Error("⚠️ File size exceeds the 200MB limit. Please upload a smaller file.")
+    start_date, _, error = parse_date(start_date_str)
+    _, end_date, error_end = parse_date(end_date_str)
+    if error or error_end:
+        return None, error or error_end, "Invalid date format."
 
-    return None  # No hay error si el archivo es válido
+    df['Date'] = pd.to_datetime(df['Date'])
+    df = df.rename(columns={'Date': 'ds', 'Sale': 'y'})
 
-# Función principal para la carga de archivo y la predicción
-def upload_and_forecast(uploaded_file, period):
-    # Verificar si el archivo cargado es válido
-    error_message = check_file(uploaded_file)
-    if error_message:
-        return error_message
+    df_filtered = df[(df['ds'] >= start_date) & (df['ds'] <= end_date)]
 
-    # Leer y procesar el archivo CSV
-    df = pd.read_csv(uploaded_file)  # Leer el archivo CSV
-    df = drop(df)
-    df = date_format(df)
-    series = group_to_three(df)
+    arima_model, error = load_model()
+    if arima_model is None:
+        return None, error, "Failed to load ARIMA model."
 
-    # Realizar la predicción con el modelo ARIMA
-    forecast_period = get_forecast_period(period)
-    forecasted_values, confint = arima_model.predict(n_periods=forecast_period, return_conf_int=True)
-    
-    # Crear serie con los valores pronosticados
-    forecasted_series = pd.Series(forecasted_values)
-    forecasted_series.index = pd.date_range(df['Date'].iloc[-1], periods=forecast_period, freq='3D')
-    
-    # Calcular el crecimiento de las ventas
-    future_sales_growth = sales_growth(df, forecasted_series)
-    
-    # Combinar los datos para graficar
-    merged_data = merge_forecast_data(df['Sales'], series, forecasted_series)
-    
-    # Crear gráficos
-    fig_compare = go.Figure()
-    fig_compare.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Actual Sales'], mode='lines', name='Actual Sales'))
-    fig_compare.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Predicted Sales'], mode='lines', name='Predicted Sales', line=dict(color='#006400')))
-    fig_compare.update_layout(title='📊 Historical Sales Data', xaxis_title='Date', yaxis_title='Sales')
-
-    fig_forecast = go.Figure()
-    fig_forecast.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Actual Sales'], mode='lines', name='Actual Sales'))
-    fig_forecast.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=forecasted_series, mode='lines', name='Forecasted Sales'))
-    fig_forecast.update_layout(title='🔮 Forecasted Sales Data', xaxis_title='Date', yaxis_title='Sales')
-
-    return fig_compare, fig_forecast, future_sales_growth
-
-# Interfaz de Gradio
-def create_sidebar():
-    with gr.Column():
-        # Personalización del componente de carga de archivos
-        gr.Markdown("### 📂 Upload your sales data (CSV)")
-        uploaded_file = gr.File(
-            label="Choose your file",
-            elem_id="file-uploader",
-            type="filepath",  # Cambiado a 'filepath' para que retorne la ruta del archivo
-            file_count="single",  # Permite solo un archivo a la vez
-            file_types=[".csv"],  # Limita solo a archivos CSV
-            interactive=True,  # Hacer interactivo el componente para arrastrar y soltar
-        )
-        
-        # Botón para cargar el periodo de pronóstico
-        gr.Markdown("### ⏳ Forecast Period (Days)")
-        period = gr.Slider(minimum=30, maximum=90, step=1, label="Forecast period (in days)")
-
-        # Ruta del archivo de ejemplo
-        sample_file_path = "sample_data.csv"  # Ruta del archivo de ejemplo
-        # Verifica si el archivo existe, de lo contrario lo crea
-        if not os.path.exists(sample_file_path):  
-            sample_data = pd.DataFrame({
-                "Date": ["2023-01-01", "2023-01-02", "2023-01-03"],
-                "Sales": [100, 200, 300]
-            })
-            sample_data.to_csv(sample_file_path, index=False)  # Crea el archivo de ejemplo si no existe
+    try:
+        forecast = arima_model.get_forecast(steps=60)
+        forecast_index = pd.date_range(start=end_date, periods=61, freq='D')[1:]
+        forecast_df = pd.DataFrame({'Date': forecast_index, 'Sales Forecast': forecast.predicted_mean})
         
-        # Usamos `gr.Markdown` para crear un enlace de descarga del archivo de ejemplo
-        gr.Markdown(f"[Download our sample CSV](./{sample_file_path})")  # Enlace directo para descargar el archivo
-
-        return uploaded_file, period
-
-# Crear el sidebar y la interfaz principal
-uploaded_file, period = create_sidebar()
-
-output_plots = [
-    gr.Plot(label="📈 Historical vs Predicted Sales"),
-    gr.Plot(label="🔮 Forecasted Sales Data"),
-    gr.DataFrame(label="📊 Sales Growth")
-]
-
-iface = gr.Interface(
-    fn=upload_and_forecast,
-    inputs=[uploaded_file, period],
-    outputs=output_plots,
-    live=True,
-    title="Sales Forecasting System ✨",
-    description="Upload your sales data to start forecasting 🚀",
-    css=open("styles.css", "r").read()  # Cargar el archivo CSS para los estilos personalizados
-)
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.plot(df_filtered['ds'], df_filtered['y'], label='Actual Sales', color='blue')
+        ax.plot(forecast_df['Date'], forecast_df['Sales Forecast'], label='Sales Forecast', color='red', linestyle='--')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Sales')
+        ax.set_title('Sales Forecasting with ARIMA')
+        ax.legend()
+        return fig, "File loaded and processed successfully."
+    except Exception as e:
+        return None, f"Failed to generate plot: {str(e)}", "Plotting failed."
+
+def setup_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## MLCast v1.1 - Intelligent Sales Forecasting System")
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(label="Upload your store data")
+                start_date_input = gr.Textbox(label="Start Date", placeholder="January-2024")
+                end_date_input = gr.Textbox(label="End Date", placeholder="December-2024")
+                forecast_button = gr.Button("Forecast Sales")
+            with gr.Column(scale=2):
+                output_plot = gr.Plot()
+                output_message = gr.Textbox(label="Notifications", visible=True, lines=2)
+        forecast_button.click(
+            forecast_sales,
+            inputs=[file_input, start_date_input, end_date_input],
+            outputs=[output_plot, output_message]
+        )
+    return demo
 
-iface.launch()  # Lanzar la interfaz
+if __name__ == "__main__":
+    interface = setup_interface()
+    interface.launch()