app.py

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):
    if uploaded_file is None:
        return gr.Error("⚠️ No file uploaded. Please upload a CSV file.")

    # Verificar si el archivo es CSV
    if not uploaded_file.endswith('.csv'):
        return gr.Error("⚠️ Invalid file format. Please upload a CSV 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.")

    return None  # No hay error si el archivo es válido

# 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

    # 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)

    # 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
        
        # 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
)

iface.launch()  # Lanzar la interfaz