Update app.py

app.py

@@ -1,10 +1,11 @@
-import pandas as pd
-import matplotlib.pyplot as plt
-import gradio as gr
-import tempfile
 import os
+import tempfile
 from datetime import datetime
 
+import gradio as gr
+import matplotlib.pyplot as plt
+import pandas as pd
+
 from statsforecast import StatsForecast
 from statsforecast.models import (
     HistoricAverage,
@@ -13,1261 +14,531 @@ from statsforecast.models import (
     WindowAverage,
     SeasonalWindowAverage,
     AutoETS,
-    AutoARIMA
+    AutoARIMA,
 )
 
 from utilsforecast.evaluation import evaluate
-from utilsforecast.losses import *
+from utilsforecast.losses import (
+    mae,
+    mape,
+    mase,
+    mse,
+    rmse,
+    smape,
+)
 
-# Import for TimeGPT
+# TimeGPT
 from nixtla import NixtlaClient
 
-# Function to load and process uploaded CSV
-def load_data(file):
-    if file is None:
-        return None, "Please upload a CSV file"
+
+# -----------------------------
+# Data helpers
+# -----------------------------
+REQUIRED_COLS = ["unique_id", "ds", "y"]
+
+
+def load_training_data(file_obj):
+    """Load training CSV. Keep ALL columns, but validate required cols."""
+    if file_obj is None:
+        return None, [], "Please upload a CSV file."
+
+    try:
+        df = pd.read_csv(file_obj.name if hasattr(file_obj, "name") else file_obj)
+        missing = [c for c in REQUIRED_COLS if c not in df.columns]
+        if missing:
+            return None, [], f"Missing required columns: {', '.join(missing)}"
+
+        df["ds"] = pd.to_datetime(df["ds"])
+        df = df.sort_values(["unique_id", "ds"]).reset_index(drop=True)
+
+        if df["y"].isna().any():
+            return None, [], "Data contains missing values in the 'y' column."
+
+        candidate_xcols = [c for c in df.columns if c not in REQUIRED_COLS]
+        return df, candidate_xcols, "Training data loaded successfully!"
+    except Exception as e:
+        return None, [], f"Error loading data: {e}"
+
+
+def load_future_x(file_obj, xcols):
+    """Load future predictors (X_df) for horizon. Must have unique_id, ds, and selected xcols."""
+    if not xcols:
+        return None, "No predictors selected."
+
+    if file_obj is None:
+        return None, "You selected predictors, so please upload a future predictors CSV (X_df)."
+
     try:
-        df = pd.read_csv(file)
-        required_cols = ['unique_id', 'ds', 'y']
-        missing_cols = [col for col in required_cols if col not in df.columns]
-        if missing_cols:
-            return None, f"Missing required columns: {', '.join(missing_cols)}"
-        
-        df['ds'] = pd.to_datetime(df['ds'])
-        df = df[required_cols]
-        df = df.sort_values(['unique_id', 'ds']).reset_index(drop=True)
-        
-        # Check for NaN values
-        if df['y'].isna().any():
-            return None, "Data contains missing values in the 'y' column"
-            
-        return df, "Data loaded successfully!"
+        X_df = pd.read_csv(file_obj.name if hasattr(file_obj, "name") else file_obj)
+        required = ["unique_id", "ds"] + list(xcols)
+        missing = [c for c in required if c not in X_df.columns]
+        if missing:
+            return None, f"Future predictors CSV missing: {', '.join(missing)}"
+
+        X_df["ds"] = pd.to_datetime(X_df["ds"])
+        X_df = X_df.sort_values(["unique_id", "ds"]).reset_index(drop=True)
+        return X_df, "Future predictors loaded."
     except Exception as e:
-        return None, f"Error loading data: {str(e)}"
+        return None, f"Error loading future predictors: {e}"
+
 
-# Helper function to calculate date offset based on frequency and horizon
 def calculate_date_offset(freq, horizon):
-    """Calculate a timedelta based on frequency code and horizon"""
-    if freq == 'H':
+    """Rough offset for plot windowing."""
+    if freq == "H":
         return pd.Timedelta(hours=horizon)
-    elif freq == 'D':
+    if freq == "D":
         return pd.Timedelta(days=horizon)
-    elif freq == 'B':
-        # For business days, use approximately 1.4x multiplier to account for weekends
-        return pd.Timedelta(days=int(horizon * 1.4))
-    elif freq == 'WS':
+    if freq == "B":
+        return pd.Timedelta(days=int(horizon * 1.4))  # approx weekends
+    if freq == "WS":
         return pd.Timedelta(weeks=horizon)
-    elif freq == 'MS':
-        return pd.Timedelta(days=horizon * 30)  # Approximate
-    elif freq == 'QS':
-        return pd.Timedelta(days=horizon * 90)  # Approximate
-    elif freq == 'YS':
-        return pd.Timedelta(days=horizon * 365)  # Approximate
-    else:
-        # Default fallback
-        return pd.Timedelta(days=horizon)
+    if freq == "MS":
+        return pd.Timedelta(days=horizon * 30)
+    if freq == "QS":
+        return pd.Timedelta(days=horizon * 90)
+    if freq == "YS":
+        return pd.Timedelta(days=horizon * 365)
+    return pd.Timedelta(days=horizon)
+
 
-# Function to generate and return a plot for validation results
-def create_forecast_plot(forecast_df, original_df, title="Forecasting Results", horizon=None, freq='D'):
+# -----------------------------
+# Plotting
+# -----------------------------
+def create_cv_plot(cv_df, original_df, title, horizon=None, freq="D"):
     plt.figure(figsize=(12, 7))
-    unique_ids = forecast_df['unique_id'].unique()
-    forecast_cols = [col for col in forecast_df.columns if col not in ['unique_id', 'ds', 'cutoff', 'y']]
-    
+
+    forecast_cols = [c for c in cv_df.columns if c not in ["unique_id", "ds", "cutoff", "y"]]
+    unique_ids = cv_df["unique_id"].unique()
+
     colors = plt.cm.tab10.colors
-    
-    # Track min and max dates for x-axis limits
     min_cutoff = None
-    
-    for i, unique_id in enumerate(unique_ids):
-        original_data = original_df[original_df['unique_id'] == unique_id]
-        plt.plot(original_data['ds'], original_data['y'], 'k-', linewidth=2, label=f'{unique_id} (Actual)')
-        
-        forecast_data = forecast_df[forecast_df['unique_id'] == unique_id]
-        
-        # Find the earliest cutoff date if available
-        if 'cutoff' in forecast_data.columns:
-            cutoffs = pd.to_datetime(forecast_data['cutoff'].unique())
+
+    for uid in unique_ids:
+        hist = original_df[original_df["unique_id"] == uid]
+        plt.plot(hist["ds"], hist["y"], "k-", linewidth=2, label=f"{uid} (Actual)")
+
+        f = cv_df[cv_df["unique_id"] == uid]
+
+        if "cutoff" in f.columns:
+            cutoffs = pd.to_datetime(f["cutoff"].unique())
             if len(cutoffs) > 0:
-                earliest_cutoff = cutoffs.min()
-                if min_cutoff is None or earliest_cutoff < min_cutoff:
-                    min_cutoff = earliest_cutoff
-                
-                # Add vertical line at each cutoff
+                earliest = cutoffs.min()
+                min_cutoff = earliest if (min_cutoff is None or earliest < min_cutoff) else min_cutoff
                 for cutoff in cutoffs:
-                    plt.axvline(x=cutoff, color='gray', linestyle='--', alpha=0.4)
-        
-        # Plot main prediction lines
+                    plt.axvline(x=cutoff, color="gray", linestyle="--", alpha=0.35)
+
         for j, col in enumerate(forecast_cols):
-            if col in forecast_data.columns:
-                # Clean up model name for legend
-                model_name = col.replace('_', ' ').title()
-                if model_name == 'Timegpt':
-                    model_name = 'TimeGPT'
-                
-                plt.plot(forecast_data['ds'], forecast_data[col], 
-                         color=colors[j % len(colors)], 
-                         linestyle='--', 
-                         linewidth=1.5,
-                         label=f'{model_name}')
+            if col in f.columns:
+                name = col.replace("_", " ").title()
+                if name == "Timegpt":
+                    name = "TimeGPT"
+                plt.plot(
+                    f["ds"],
+                    f[col],
+                    linestyle="--",
+                    linewidth=1.5,
+                    color=colors[j % len(colors)],
+                    label=name,
+                )
 
     plt.title(title, fontsize=16)
-    plt.xlabel('Date', fontsize=12)
-    plt.ylabel('Value', fontsize=12)
+    plt.xlabel("Date")
+    plt.ylabel("Value")
     plt.grid(True, alpha=0.3)
-    
-    # Better legend with smaller font and outside placement
-    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3, fontsize=10)
-    plt.tight_layout(rect=[0, 0.05, 1, 0.95])  # Adjust layout to make room for legend
-    
-    # Set x-axis limits based on cutoff and horizon
+    plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15), ncol=3, fontsize=10)
+    plt.tight_layout(rect=[0, 0.05, 1, 0.95])
+
     if min_cutoff is not None and horizon is not None:
-        # Calculate date offset based on frequency and horizon
-        date_offset = calculate_date_offset(freq, horizon)
-        
-        # Calculate start date as 'horizon' units before the first cutoff
-        start_date = min_cutoff - date_offset
-        
-        # Find max date from forecast
-        max_date = forecast_df['ds'].max()
-        
-        plt.xlim(start_date, max_date)
-        
-        # Add an annotation for the training/test split
-        plt.annotate('Training | Test', 
-                     xy=(min_cutoff, plt.ylim()[0]),
-                     xytext=(0, -40),
-                     textcoords='offset points',
-                     horizontalalignment='center',
-                     fontsize=10)
-    
-    # Format date labels better
+        start = min_cutoff - calculate_date_offset(freq, horizon)
+        plt.xlim(start, cv_df["ds"].max())
+
     fig = plt.gcf()
-    ax = plt.gca()
     fig.autofmt_xdate()
-    
     return fig
 
-# Function to create a plot for future forecasts
-def create_future_forecast_plot(forecast_df, original_df, horizon=None, freq='D'):
+
+def create_future_plot(fcst_df, original_df, title="Future Forecast", horizon=None, freq="D"):
     plt.figure(figsize=(12, 7))
-    unique_ids = forecast_df['unique_id'].unique()
-    forecast_cols = [col for col in forecast_df.columns if col not in ['unique_id', 'ds']]
-    
+
+    forecast_cols = [c for c in fcst_df.columns if c not in ["unique_id", "ds"]]
+    unique_ids = fcst_df["unique_id"].unique()
     colors = plt.cm.tab10.colors
-    
-    # Track the forecast start date (min of forecast data)
-    forecast_start = None
-    if not forecast_df.empty:
-        forecast_start = pd.to_datetime(forecast_df['ds'].min())
-    
-    for i, unique_id in enumerate(unique_ids):
-        # Plot historical data
-        original_data = original_df[original_df['unique_id'] == unique_id]
-        plt.plot(original_data['ds'], original_data['y'], 'k-', linewidth=2, label=f'{unique_id} (Historical)')
-        
-        # Plot forecast data with shaded vertical line separator
-        forecast_data = forecast_df[forecast_df['unique_id'] == unique_id]
-        
-        # Add vertical line at the forecast start
-        if not forecast_data.empty and not original_data.empty:
-            forecast_start = forecast_data['ds'].min()
-            plt.axvline(x=forecast_start, color='gray', linestyle='--', alpha=0.5)
-            
-            # Add a shaded area for the forecast period
-            plt.axvspan(forecast_start, forecast_data['ds'].max(), alpha=0.1, color='blue')
-            
-            # Annotate the split point
-            plt.annotate('Historical | Forecast', 
-                         xy=(forecast_start, plt.ylim()[0]),
-                         xytext=(0, -40),
-                         textcoords='offset points',
-                         horizontalalignment='center',
-                         fontsize=10)
-        
-        # Plot main prediction lines
-        for j, col in enumerate(forecast_cols):
-            if col in forecast_data.columns:
-                # Clean up model name for legend
-                model_name = col.replace('_', ' ').title()
-                if model_name == 'Timegpt':
-                    model_name = 'TimeGPT'
-                
-                plt.plot(forecast_data['ds'], forecast_data[col], 
-                         color=colors[j % len(colors)], 
-                         linestyle='--', 
-                         linewidth=1.5,
-                         label=f'{model_name}')
-
-    plt.title('Future Forecast', fontsize=16)
-    plt.xlabel('Date', fontsize=12)
-    plt.ylabel('Value', fontsize=12)
+
+    for uid in unique_ids:
+        hist = original_df[original_df["unique_id"] == uid]
+        f = fcst_df[fcst_df["unique_id"] == uid]
+
+        plt.plot(hist["ds"], hist["y"], "k-", linewidth=2, label=f"{uid} (Historical)")
+
+        if not f.empty:
+            start = f["ds"].min()
+            plt.axvline(x=start, color="gray", linestyle="--", alpha=0.5)
+            plt.axvspan(start, f["ds"].max(), alpha=0.1)
+
+            for j, col in enumerate(forecast_cols):
+                name = col.replace("_", " ").title()
+                if name == "Timegpt":
+                    name = "TimeGPT"
+                plt.plot(
+                    f["ds"],
+                    f[col],
+                    linestyle="--",
+                    linewidth=1.5,
+                    color=colors[j % len(colors)],
+                    label=name,
+                )
+
+    plt.title(title, fontsize=16)
+    plt.xlabel("Date")
+    plt.ylabel("Value")
     plt.grid(True, alpha=0.3)
-    
-    # Better legend with smaller font and outside placement
-    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3, fontsize=10)
-    plt.tight_layout(rect=[0, 0.05, 1, 0.95])  # Adjust layout to make room for legend
-    
-    # Set x-axis limits based on forecast start and horizon
-    if forecast_start is not None and horizon is not None:
-        # Calculate date offset based on frequency and horizon
-        date_offset = calculate_date_offset(freq, horizon)
-        
-        # Calculate start date as 'horizon' units before the forecast start
-        start_date = forecast_start - date_offset
-        
-        # Get the last date from historical data that's before or at the start_date
-        historical_dates = pd.to_datetime(original_df['ds'])
-        historical_dates_before_start = historical_dates[historical_dates <= start_date]
-        
-        if not historical_dates_before_start.empty:
-            # Use the last available date in the historical data that's before our calculated start_date
-            adjusted_start_date = historical_dates_before_start.max()
-        else:
-            # Fallback to using the original start_date
-            adjusted_start_date = start_date
-        
-        # Set the x-axis limits
-        plt.xlim(adjusted_start_date, forecast_df['ds'].max())
-    
-    # Format date labels better
+    plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15), ncol=3, fontsize=10)
+    plt.tight_layout(rect=[0, 0.05, 1, 0.95])
+
+    if horizon is not None and not fcst_df.empty:
+        start = pd.to_datetime(fcst_df["ds"].min()) - calculate_date_offset(freq, horizon)
+        plt.xlim(start, fcst_df["ds"].max())
+
     fig = plt.gcf()
-    ax = plt.gca()
     fig.autofmt_xdate()
-    
     return fig
 
-# Function to export results to CSV
-def export_results(eval_df, cv_results, future_forecasts):
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    # Create temp directory if it doesn't exist
+
+# -----------------------------
+# Export
+# -----------------------------
+def export_results(eval_df, cv_df, future_df):
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
     temp_dir = tempfile.mkdtemp()
-    
-    result_files = []
-    
-    if eval_df is not None:
-        eval_path = os.path.join(temp_dir, f"evaluation_metrics_{timestamp}.csv")
-        eval_df.to_csv(eval_path, index=False)
-        result_files.append(eval_path)
-        
-    if cv_results is not None:
-        cv_path = os.path.join(temp_dir, f"cross_validation_results_{timestamp}.csv")
-        cv_results.to_csv(cv_path, index=False)
-        result_files.append(cv_path)
-        
-    if future_forecasts is not None:
-        forecast_path = os.path.join(temp_dir, f"forecasts_{timestamp}.csv")
-        future_forecasts.to_csv(forecast_path, index=False)
-        result_files.append(forecast_path)
-    
-    return result_files
-
-# Main forecasting logic
+    out = []
+
+    if eval_df is not None and not eval_df.empty:
+        p = os.path.join(temp_dir, f"evaluation_metrics_{ts}.csv")
+        eval_df.to_csv(p, index=False)
+        out.append(p)
+
+    if cv_df is not None and not cv_df.empty:
+        p = os.path.join(temp_dir, f"cross_validation_results_{ts}.csv")
+        cv_df.to_csv(p, index=False)
+        out.append(p)
+
+    if future_df is not None and not future_df.empty:
+        p = os.path.join(temp_dir, f"future_forecasts_{ts}.csv")
+        future_df.to_csv(p, index=False)
+        out.append(p)
+
+    return out
+
+
+# -----------------------------
+# Core run
+# -----------------------------
 def run_forecast(
-    file,
-    frequency,
-    eval_strategy,
-    horizon,
-    step_size,
-    num_windows,
-    use_historical_avg,
+    train_file,
+    freq,
+    season_length,
+    cv_h,
+    cv_step_size,
+    cv_windows,
+    future_h,
+    loss_name,
+    # models
+    use_histavg,
     use_naive,
-    use_seasonal_naive,
-    seasonality,
-    use_window_avg,
-    window_size,
-    use_seasonal_window_avg,
-    seasonal_window_size,
+    use_snaive,
+    use_winavg,
+    use_swinavg,
     use_autoets,
     use_autoarima,
+    # timegpt
     use_timegpt,
-    finetune_loss,
-    confidence_level,
-    future_horizon
+    nixtla_api_key,
+    # predictors
+    xcols,
+    future_x_file,
 ):
-    df, message = load_data(file)
+    # 1) Load training
+    df, candidate_xcols, msg = load_training_data(train_file)
     if df is None:
-        return None, None, None, None, None, None, message
-
-    # Initialize results
-    eval_df = None
-    cv_results = None
-    future_forecasts = None
-    
-    # Set up traditional statistical models
-    models = []
-    model_aliases = []
-
-    if use_historical_avg:
-        models.append(HistoricAverage(alias='historical_average'))
-        model_aliases.append('historical_average')
+        return None, None, None, msg, None
+
+    # base y-only df
+    df_y = df[["unique_id", "ds", "y"]].copy()
+
+    use_exog = bool(xcols)
+
+    # 2) Load future X if needed
+    X_future = None
+    if use_exog:
+        X_future, xmsg = load_future_x(future_x_file, xcols)
+        if X_future is None:
+            return None, None, None, xmsg, None
+
+        # enforce ordering expected by many workflows: unique_id, ds, y, x1..xk
+        df_exog = df[["unique_id", "ds", "y"] + list(xcols)].copy()
+
+    # 3) Choose loss function
+    loss_map = {
+        "mae": mae,
+        "mape": mape,
+        "mase": mase,
+        "mse": mse,
+        "rmse": rmse,
+        "smape": smape,
+    }
+    loss_fn = loss_map.get(loss_name, rmse)
+
+    # 4) Build models
+    univariate_models = []
+    exog_models = []
+
+    if use_histavg:
+        univariate_models.append(HistoricAverage(alias="hist_avg"))
     if use_naive:
-        models.append(Naive(alias='naive'))
-        model_aliases.append('naive')
-    if use_seasonal_naive:
-        models.append(SeasonalNaive(season_length=seasonality, alias='seasonal_naive'))
-        model_aliases.append('seasonal_naive')
-    if use_window_avg:
-        models.append(WindowAverage(window_size=window_size, alias='window_average'))
-        model_aliases.append('window_average')
-    if use_seasonal_window_avg:
-        models.append(SeasonalWindowAverage(season_length=seasonality, window_size=seasonal_window_size, alias='seasonal_window_average'))
-        model_aliases.append('seasonal_window_average')
+        univariate_models.append(Naive(alias="naive"))
+    if use_snaive:
+        univariate_models.append(SeasonalNaive(alias="seasonal_naive", season_length=season_length))
+    if use_winavg:
+        univariate_models.append(WindowAverage(alias="window_avg", window_size=season_length))
+    if use_swinavg:
+        univariate_models.append(SeasonalWindowAverage(alias="seasonal_window_avg", season_length=season_length))
     if use_autoets:
-        models.append(AutoETS(alias='autoets', season_length=seasonality))
-        model_aliases.append('autoets')
+        univariate_models.append(AutoETS(alias="autoets", season_length=season_length))
+
+    # AutoARIMA can use exogenous; route it accordingly if X selected
     if use_autoarima:
-        models.append(AutoARIMA(alias='autoarima', season_length=seasonality))
-        model_aliases.append('autoarima')
+        model = AutoARIMA(alias="autoarima", season_length=season_length)
+        if use_exog:
+            exog_models.append(model)
+        else:
+            univariate_models.append(model)
 
-    if not models and not use_timegpt:
-        return None, None, None, None, None, None, "Please select at least one forecasting model"
+    # 5) Cross-validation + evaluation + future forecast
+    eval_parts = []
+    cv_parts = []
+    future_parts = []
 
-    try:
-        # Initialize results with empty DataFrames
-        combined_eval_df = pd.DataFrame()
-        combined_cv_results = pd.DataFrame()
-        combined_future_forecasts = pd.DataFrame()
-        
-        # Run traditional statistical models if any are selected
-        if models:
-            sf = StatsForecast(models=models, freq=frequency, n_jobs=-1)
-            
-            # Run cross-validation for traditional models
-            if eval_strategy == "Cross Validation":
-                cv_results = sf.cross_validation(df=df, h=horizon, step_size=step_size, n_windows=num_windows)
-                evaluation = evaluate(df=cv_results, metrics=[bias, mae, rmse, mape], models=model_aliases)
-                eval_df = pd.DataFrame(evaluation).reset_index()
-                eval_df = eval_df.round({col: 2 for col in eval_df.columns[3:]})
-            else:  # Fixed window
-                cv_results = sf.cross_validation(df=df, h=horizon, step_size=10, n_windows=1)  # any step size for 1 window
-                evaluation = evaluate(df=cv_results, metrics=[bias, mae, rmse, mape], models=model_aliases)
-                eval_df = pd.DataFrame(evaluation).reset_index()
-            
-            # Generate future forecasts
-            future_forecasts = sf.forecast(df=df, h=future_horizon)
-            
-            # Store results
-            combined_eval_df = eval_df.copy() if eval_df is not None else pd.DataFrame()
-            combined_cv_results = cv_results.copy() if cv_results is not None else pd.DataFrame()
-            combined_cv_results = combined_cv_results
-            combined_future_forecasts = future_forecasts.copy() if future_forecasts is not None else pd.DataFrame()
-        
-        # Run TimeGPT if selected
-        if use_timegpt:
-            try:
-                # Get API key from environment variables
-                nixtla_api_key = os.getenv("NIXTLA_API_KEY")
-                if not nixtla_api_key:
-                    return None, None, None, None, None, None, "TimeGPT API key not found. Please set the NIXTLA_API_KEY environment variable."
-                
-                # Initialize Nixtla client
-                nixtla_client = NixtlaClient(api_key=nixtla_api_key)
-                
-                # Convert confidence_level to list format
-                level = [float(confidence_level)]
-                
-                # Run cross-validation for TimeGPT
-                if eval_strategy == "Cross Validation":
-                    timegpt_cv_df = nixtla_client.cross_validation(
-                        df=df, 
-                        h=horizon, 
-                        freq=frequency,
-                        n_windows=num_windows, 
-                        step_size=step_size
-                    )
-                    timegpt_cv_eval = evaluate(
-                        df=timegpt_cv_df, 
-                        metrics=[mape, mae, rmse, bias], 
-                        models=['TimeGPT'],
-                    )
-                    timegpt_eval_df = pd.DataFrame(timegpt_cv_eval).reset_index()
-                    timegpt_eval_df = timegpt_eval_df.round({col: 2 for col in timegpt_eval_df.columns[3:]})
-                else:  # Fixed window
-                    timegpt_cv_df = nixtla_client.cross_validation(
-                        df=df, 
-                        h=horizon, 
-                        freq=frequency, 
-                        n_windows=1, 
-                        step_size=10
-                    )
-                    timegpt_cv_eval = evaluate(
-                        df=timegpt_cv_df, 
-                        metrics=[mape, mae, rmse, bias], 
-                        models=['TimeGPT']
-                    )
-                    timegpt_eval_df = pd.DataFrame(timegpt_cv_eval).reset_index()
-                
-                # Generate future forecasts with TimeGPT
-                forecast_timegpt = nixtla_client.forecast(
-                    df=df, 
-                    h=future_horizon, 
-                    freq=frequency,
-                    finetune_loss=finetune_loss
-                )
-                
-                
-                # Combine results - using merge instead of concat to avoid duplicate rows
-                if not combined_eval_df.empty and not timegpt_eval_df.empty:
-                    # Get common columns for the join
-                    join_columns = ['unique_id', 'metric']
-                    # Merge the dataframes on unique_id and metric
-                    combined_eval_df = pd.merge(
-                        combined_eval_df, 
-                        timegpt_eval_df,
-                        on=join_columns,
-                        how='outer',
-                        suffixes=('', '_timegpt')
-                    )
-                    
-                    # Clean up any duplicated columns from the merge
-                    for col in combined_eval_df.columns:
-                        if col.endswith('_timegpt'):
-                            base_col = col.replace('_timegpt', '')
-                            # Fill NaN values in the original column with values from the _timegpt column
-                            if base_col in combined_eval_df.columns:
-                                combined_eval_df[base_col] = combined_eval_df[base_col].fillna(combined_eval_df[col])
-                            # Remove the _timegpt column
-                            combined_eval_df = combined_eval_df.drop(columns=[col])
-                else:
-                    combined_eval_df = timegpt_eval_df if not timegpt_eval_df.empty else combined_eval_df
-                
-                if not combined_cv_results.empty and not timegpt_cv_df.empty:
-                    # Make sure we're not duplicating the 'y' column
-                    if 'y' in combined_cv_results.columns and 'y' in timegpt_cv_df.columns:
-                        timegpt_cv_df_no_y = timegpt_cv_df.drop(columns=['y'])
-                        combined_cv_results = pd.merge(
-                            combined_cv_results, 
-                            timegpt_cv_df_no_y,
-                            on=['unique_id', 'ds', 'cutoff'],
-                            how='outer'
-                        )
-                    else:
-                        combined_cv_results = pd.concat([combined_cv_results, timegpt_cv_df], ignore_index=True)
-                else:
-                    combined_cv_results = timegpt_cv_df if not timegpt_cv_df.empty else combined_cv_results
-                
-                if not combined_future_forecasts.empty and not forecast_timegpt.empty:
-                    # Make sure we're merging on common columns
-                    combined_future_forecasts = pd.merge(
-                        combined_future_forecasts,
-                        forecast_timegpt,
-                        on=['unique_id', 'ds'],
-                        how='outer'
-                    )
-                else:
-                    combined_future_forecasts = forecast_timegpt if not forecast_timegpt.empty else combined_future_forecasts
-                
-            except Exception as e:
-                return None, None, None, None, None, None, f"Error with TimeGPT: {str(e)}"
-        
-        # Create plots
-        if not combined_cv_results.empty:
-            fig_validation = create_forecast_plot(
-                combined_cv_results, 
-                df, 
-                f"{eval_strategy} Results"
-            )
-        else:
-            fig_validation = None
-            
-        if not combined_future_forecasts.empty:
-            fig_future = create_future_forecast_plot(combined_future_forecasts, df)
-        else:
-            fig_future = None
-        
-        # Export results
-        export_files = export_results(combined_eval_df, combined_cv_results, combined_future_forecasts)
-        
-        return combined_eval_df, combined_cv_results, fig_validation, combined_future_forecasts, fig_future, export_files, "Analysis completed successfully!"
+    # Univariate pipeline
+    if univariate_models:
+        sf_u = StatsForecast(models=univariate_models, freq=freq, n_jobs=-1)
 
-    except Exception as e:
-        return None, None, None, None, None, None, f"Error during forecasting: {str(e)}"
-
-# Sample CSV file generation
-def download_sample():
-    sample_data = """unique_id,ds,y
-^GSPC,2023-01-03,3824.139892578125
-^GSPC,2023-01-04,3852.969970703125
-^GSPC,2023-01-05,3808.10009765625
-^GSPC,2023-01-06,3895.080078125
-^GSPC,2023-01-09,3892.090087890625
-^GSPC,2023-01-10,3919.25
-^GSPC,2023-01-11,3969.610107421875
-^GSPC,2023-01-12,3983.169921875
-^GSPC,2023-01-13,3999.090087890625
-^GSPC,2023-01-17,3990.969970703125
-^GSPC,2023-01-18,3928.860107421875
-^GSPC,2023-01-19,3898.85009765625
-^GSPC,2023-01-20,3972.610107421875
-^GSPC,2023-01-23,4019.81005859375
-^GSPC,2023-01-24,4016.949951171875
-^GSPC,2023-01-25,4016.219970703125
-^GSPC,2023-01-26,4060.429931640625
-^GSPC,2023-01-27,4070.56005859375
-^GSPC,2023-01-30,4017.77001953125
-^GSPC,2023-01-31,4076.60009765625
-^GSPC,2023-02-01,4119.2099609375
-^GSPC,2023-02-02,4179.759765625
-^GSPC,2023-02-03,4136.47998046875
-^GSPC,2023-02-06,4111.080078125
-^GSPC,2023-02-07,4164
-^GSPC,2023-02-08,4117.85986328125
-^GSPC,2023-02-09,4081.5
-^GSPC,2023-02-10,4090.4599609375
-^GSPC,2023-02-13,4137.2900390625
-^GSPC,2023-02-14,4136.1298828125
-^GSPC,2023-02-15,4147.60009765625
-^GSPC,2023-02-16,4090.409912109375
-^GSPC,2023-02-17,4079.090087890625
-^GSPC,2023-02-21,3997.340087890625
-^GSPC,2023-02-22,3991.050048828125
-^GSPC,2023-02-23,4012.320068359375
-^GSPC,2023-02-24,3970.0400390625
-^GSPC,2023-02-27,3982.239990234375
-^GSPC,2023-02-28,3970.14990234375
-^GSPC,2023-03-01,3951.389892578125
-^GSPC,2023-03-02,3981.35009765625
-^GSPC,2023-03-03,4045.639892578125
-^GSPC,2023-03-06,4048.419921875
-^GSPC,2023-03-07,3986.3701171875
-^GSPC,2023-03-08,3992.010009765625
-^GSPC,2023-03-09,3918.320068359375
-^GSPC,2023-03-10,3861.590087890625
-^GSPC,2023-03-13,3855.760009765625
-^GSPC,2023-03-14,3919.2900390625
-^GSPC,2023-03-15,3891.929931640625
-^GSPC,2023-03-16,3960.280029296875
-^GSPC,2023-03-17,3916.639892578125
-^GSPC,2023-03-20,3951.570068359375
-^GSPC,2023-03-21,4002.8701171875
-^GSPC,2023-03-22,3936.969970703125
-^GSPC,2023-03-23,3948.719970703125
-^GSPC,2023-03-24,3970.989990234375
-^GSPC,2023-03-27,3977.530029296875
-^GSPC,2023-03-28,3971.27001953125
-^GSPC,2023-03-29,4027.81005859375
-^GSPC,2023-03-30,4050.830078125
-^GSPC,2023-03-31,4109.31005859375
-^GSPC,2023-04-03,4124.509765625
-^GSPC,2023-04-04,4100.60009765625
-^GSPC,2023-04-05,4090.3798828125
-^GSPC,2023-04-06,4105.02001953125
-^GSPC,2023-04-10,4109.10986328125
-^GSPC,2023-04-11,4108.93994140625
-^GSPC,2023-04-12,4091.949951171875
-^GSPC,2023-04-13,4146.22021484375
-^GSPC,2023-04-14,4137.64013671875
-^GSPC,2023-04-17,4151.31982421875
-^GSPC,2023-04-18,4154.8701171875
-^GSPC,2023-04-19,4154.52001953125
-^GSPC,2023-04-20,4129.7900390625
-^GSPC,2023-04-21,4133.52001953125
-^GSPC,2023-04-24,4137.0400390625
-^GSPC,2023-04-25,4071.6298828125
-^GSPC,2023-04-26,4055.989990234375
-^GSPC,2023-04-27,4135.35009765625
-^GSPC,2023-04-28,4169.47998046875
-^GSPC,2023-05-01,4167.8701171875
-^GSPC,2023-05-02,4119.580078125
-^GSPC,2023-05-03,4090.75
-^GSPC,2023-05-04,4061.219970703125
-^GSPC,2023-05-05,4136.25
-^GSPC,2023-05-08,4138.1201171875
-^GSPC,2023-05-09,4119.169921875
-^GSPC,2023-05-10,4137.64013671875
-^GSPC,2023-05-11,4130.6201171875
-^GSPC,2023-05-12,4124.080078125
-^GSPC,2023-05-15,4136.27978515625
-^GSPC,2023-05-16,4109.89990234375
-^GSPC,2023-05-17,4158.77001953125
-^GSPC,2023-05-18,4198.0498046875
-^GSPC,2023-05-19,4191.97998046875
-^GSPC,2023-05-22,4192.6298828125
-^GSPC,2023-05-23,4145.580078125
-^GSPC,2023-05-24,4115.240234375
-^GSPC,2023-05-25,4151.27978515625
-^GSPC,2023-05-26,4205.4501953125
-^GSPC,2023-05-30,4205.52001953125
-^GSPC,2023-05-31,4179.830078125
-^GSPC,2023-06-01,4221.02001953125
-^GSPC,2023-06-02,4282.3701171875
-^GSPC,2023-06-05,4273.7900390625
-^GSPC,2023-06-06,4283.85009765625
-^GSPC,2023-06-07,4267.52001953125
-^GSPC,2023-06-08,4293.93017578125
-^GSPC,2023-06-09,4298.85986328125
-^GSPC,2023-06-12,4338.93017578125
-^GSPC,2023-06-13,4369.009765625
-^GSPC,2023-06-14,4372.58984375
-^GSPC,2023-06-15,4425.83984375
-^GSPC,2023-06-16,4409.58984375
-^GSPC,2023-06-20,4388.7099609375
-^GSPC,2023-06-21,4365.68994140625
-^GSPC,2023-06-22,4381.89013671875
-^GSPC,2023-06-23,4348.330078125
-^GSPC,2023-06-26,4328.81982421875
-^GSPC,2023-06-27,4378.41015625
-^GSPC,2023-06-28,4376.85986328125
-^GSPC,2023-06-29,4396.43994140625
-^GSPC,2023-06-30,4450.3798828125
-^GSPC,2023-07-03,4455.58984375
-^GSPC,2023-07-05,4446.81982421875
-^GSPC,2023-07-06,4411.58984375
-^GSPC,2023-07-07,4398.9501953125
-^GSPC,2023-07-10,4409.52978515625
-^GSPC,2023-07-11,4439.259765625
-^GSPC,2023-07-12,4472.16015625
-^GSPC,2023-07-13,4510.0400390625
-^GSPC,2023-07-14,4505.419921875
-^GSPC,2023-07-17,4522.7900390625
-^GSPC,2023-07-18,4554.97998046875
-^GSPC,2023-07-19,4565.72021484375
-^GSPC,2023-07-20,4534.8701171875
-^GSPC,2023-07-21,4536.33984375
-^GSPC,2023-07-24,4554.64013671875
-^GSPC,2023-07-25,4567.4599609375
-^GSPC,2023-07-26,4566.75
-^GSPC,2023-07-27,4537.41015625
-^GSPC,2023-07-28,4582.22998046875
-^GSPC,2023-07-31,4588.9599609375
-^GSPC,2023-08-01,4576.72998046875
-^GSPC,2023-08-02,4513.39013671875
-^GSPC,2023-08-03,4501.89013671875
-^GSPC,2023-08-04,4478.02978515625
-^GSPC,2023-08-07,4518.43994140625
-^GSPC,2023-08-08,4499.3798828125
-^GSPC,2023-08-09,4467.7099609375
-^GSPC,2023-08-10,4468.830078125
-^GSPC,2023-08-11,4464.0498046875
-^GSPC,2023-08-14,4489.72021484375
-^GSPC,2023-08-15,4437.85986328125
-^GSPC,2023-08-16,4404.330078125
-^GSPC,2023-08-17,4370.35986328125
-^GSPC,2023-08-18,4369.7099609375
-^GSPC,2023-08-21,4399.77001953125
-^GSPC,2023-08-22,4387.5498046875
-^GSPC,2023-08-23,4436.009765625
-^GSPC,2023-08-24,4376.31005859375
-^GSPC,2023-08-25,4405.7099609375
-^GSPC,2023-08-28,4433.31005859375
-^GSPC,2023-08-29,4497.6298828125
-^GSPC,2023-08-30,4514.8701171875
-^GSPC,2023-08-31,4507.66015625
-^GSPC,2023-09-01,4515.77001953125
-^GSPC,2023-09-05,4496.830078125
-^GSPC,2023-09-06,4465.47998046875
-^GSPC,2023-09-07,4451.14013671875
-^GSPC,2023-09-08,4457.490234375
-^GSPC,2023-09-11,4487.4599609375
-^GSPC,2023-09-12,4461.89990234375
-^GSPC,2023-09-13,4467.43994140625
-^GSPC,2023-09-14,4505.10009765625
-^GSPC,2023-09-15,4450.31982421875
-^GSPC,2023-09-18,4453.52978515625
-^GSPC,2023-09-19,4443.9501953125
-^GSPC,2023-09-20,4402.2001953125
-^GSPC,2023-09-21,4330
-^GSPC,2023-09-22,4320.06005859375
-^GSPC,2023-09-25,4337.43994140625
-^GSPC,2023-09-26,4273.52978515625
-^GSPC,2023-09-27,4274.509765625
-^GSPC,2023-09-28,4299.7001953125
-^GSPC,2023-09-29,4288.0498046875
-^GSPC,2023-10-02,4288.39013671875
-^GSPC,2023-10-03,4229.4501953125
-^GSPC,2023-10-04,4263.75
-^GSPC,2023-10-05,4258.18994140625
-^GSPC,2023-10-06,4308.5
-^GSPC,2023-10-09,4335.66015625
-^GSPC,2023-10-10,4358.240234375
-^GSPC,2023-10-11,4376.9501953125
-^GSPC,2023-10-12,4349.60986328125
-^GSPC,2023-10-13,4327.77978515625
-^GSPC,2023-10-16,4373.6298828125
-^GSPC,2023-10-17,4373.2001953125
-^GSPC,2023-10-18,4314.60009765625
-^GSPC,2023-10-19,4278
-^GSPC,2023-10-20,4224.16015625
-^GSPC,2023-10-23,4217.0400390625
-^GSPC,2023-10-24,4247.68017578125
-^GSPC,2023-10-25,4186.77001953125
-^GSPC,2023-10-26,4137.22998046875
-^GSPC,2023-10-27,4117.3701171875
-^GSPC,2023-10-30,4166.81982421875
-^GSPC,2023-10-31,4193.7998046875
-^GSPC,2023-11-01,4237.85986328125
-^GSPC,2023-11-02,4317.77978515625
-^GSPC,2023-11-03,4358.33984375
-^GSPC,2023-11-06,4365.97998046875
-^GSPC,2023-11-07,4378.3798828125
-^GSPC,2023-11-08,4382.77978515625
-^GSPC,2023-11-09,4347.35009765625
-^GSPC,2023-11-10,4415.240234375
-^GSPC,2023-11-13,4411.5498046875
-^GSPC,2023-11-14,4495.7001953125
-^GSPC,2023-11-15,4502.8798828125
-^GSPC,2023-11-16,4508.240234375
-^GSPC,2023-11-17,4514.02001953125
-^GSPC,2023-11-20,4547.3798828125
-^GSPC,2023-11-21,4538.18994140625
-^GSPC,2023-11-22,4556.6201171875
-^GSPC,2023-11-24,4559.33984375
-^GSPC,2023-11-27,4550.43017578125
-^GSPC,2023-11-28,4554.89013671875
-^GSPC,2023-11-29,4550.580078125
-^GSPC,2023-11-30,4567.7998046875
-^GSPC,2023-12-01,4594.6298828125
-^GSPC,2023-12-04,4569.77978515625
-^GSPC,2023-12-05,4567.18017578125
-^GSPC,2023-12-06,4549.33984375
-^GSPC,2023-12-07,4585.58984375
-^GSPC,2023-12-08,4604.3701171875
-^GSPC,2023-12-11,4622.43994140625
-^GSPC,2023-12-12,4643.7001953125
-^GSPC,2023-12-13,4707.08984375
-^GSPC,2023-12-14,4719.5498046875
-^GSPC,2023-12-15,4719.18994140625
-^GSPC,2023-12-18,4740.56005859375
-^GSPC,2023-12-19,4768.3701171875
-^GSPC,2023-12-20,4698.35009765625
-^GSPC,2023-12-21,4746.75
-^GSPC,2023-12-22,4754.6298828125
-^GSPC,2023-12-26,4774.75
-^GSPC,2023-12-27,4781.580078125
-^GSPC,2023-12-28,4783.35009765625
-^GSPC,2023-12-29,4769.830078125
-^GSPC,2024-01-02,4742.830078125
-^GSPC,2024-01-03,4704.81005859375
-^GSPC,2024-01-04,4688.68017578125
-^GSPC,2024-01-05,4697.240234375
-^GSPC,2024-01-08,4763.5400390625
-^GSPC,2024-01-09,4756.5
-^GSPC,2024-01-10,4783.4501953125
-^GSPC,2024-01-11,4780.240234375
-^GSPC,2024-01-12,4783.830078125
-^GSPC,2024-01-16,4765.97998046875
-^GSPC,2024-01-17,4739.2099609375
-^GSPC,2024-01-18,4780.93994140625
-^GSPC,2024-01-19,4839.81005859375
-^GSPC,2024-01-22,4850.43017578125
-^GSPC,2024-01-23,4864.60009765625
-^GSPC,2024-01-24,4868.5498046875
-^GSPC,2024-01-25,4894.16015625
-^GSPC,2024-01-26,4890.97021484375
-^GSPC,2024-01-29,4927.93017578125
-^GSPC,2024-01-30,4924.97021484375
-^GSPC,2024-01-31,4845.64990234375
-^GSPC,2024-02-01,4906.18994140625
-^GSPC,2024-02-02,4958.60986328125
-^GSPC,2024-02-05,4942.81005859375
-^GSPC,2024-02-06,4954.22998046875
-^GSPC,2024-02-07,4995.06005859375
-^GSPC,2024-02-08,4997.91015625
-^GSPC,2024-02-09,5026.60986328125
-^GSPC,2024-02-12,5021.83984375
-^GSPC,2024-02-13,4953.169921875
-^GSPC,2024-02-14,5000.6201171875
-^GSPC,2024-02-15,5029.72998046875
-^GSPC,2024-02-16,5005.56982421875
-^GSPC,2024-02-20,4975.509765625
-^GSPC,2024-02-21,4981.7998046875
-^GSPC,2024-02-22,5087.02978515625
-^GSPC,2024-02-23,5088.7998046875
-^GSPC,2024-02-26,5069.52978515625
-^GSPC,2024-02-27,5078.18017578125
-^GSPC,2024-02-28,5069.759765625
-^GSPC,2024-02-29,5096.27001953125
-^GSPC,2024-03-01,5137.080078125
-^GSPC,2024-03-04,5130.9501953125
-^GSPC,2024-03-05,5078.64990234375
-^GSPC,2024-03-06,5104.759765625
-^GSPC,2024-03-07,5157.35986328125
-^GSPC,2024-03-08,5123.68994140625
-^GSPC,2024-03-11,5117.93994140625
-^GSPC,2024-03-12,5175.27001953125
-^GSPC,2024-03-13,5165.31005859375
-^GSPC,2024-03-14,5150.47998046875
-^GSPC,2024-03-15,5117.08984375
-^GSPC,2024-03-18,5149.419921875
-^GSPC,2024-03-19,5178.509765625
-^GSPC,2024-03-20,5224.6201171875
-^GSPC,2024-03-21,5241.52978515625
-^GSPC,2024-03-22,5234.18017578125
-^GSPC,2024-03-25,5218.18994140625
-^GSPC,2024-03-26,5203.580078125
-^GSPC,2024-03-27,5248.490234375
-^GSPC,2024-03-28,5254.35009765625
-^GSPC,2024-04-01,5243.77001953125
-^GSPC,2024-04-02,5205.81005859375
-^GSPC,2024-04-03,5211.490234375
-^GSPC,2024-04-04,5147.2099609375
-^GSPC,2024-04-05,5204.33984375
-^GSPC,2024-04-08,5202.39013671875
-^GSPC,2024-04-09,5209.91015625
-^GSPC,2024-04-10,5160.64013671875
-^GSPC,2024-04-11,5199.06005859375
-^GSPC,2024-04-12,5123.41015625
-^GSPC,2024-04-15,5061.81982421875
-^GSPC,2024-04-16,5051.41015625
-^GSPC,2024-04-17,5022.2099609375
-^GSPC,2024-04-18,5011.1201171875
-^GSPC,2024-04-19,4967.22998046875
-^GSPC,2024-04-22,5010.60009765625
-^GSPC,2024-04-23,5070.5498046875
-^GSPC,2024-04-24,5071.6298828125
-^GSPC,2024-04-25,5048.419921875
-^GSPC,2024-04-26,5099.9599609375
-^GSPC,2024-04-29,5116.169921875
-^GSPC,2024-04-30,5035.68994140625
-^GSPC,2024-05-01,5018.39013671875
-^GSPC,2024-05-02,5064.2001953125
-^GSPC,2024-05-03,5127.7900390625
-^GSPC,2024-05-06,5180.740234375
-^GSPC,2024-05-07,5187.7001953125
-^GSPC,2024-05-08,5187.669921875
-^GSPC,2024-05-09,5214.080078125
-^GSPC,2024-05-10,5222.68017578125
-^GSPC,2024-05-13,5221.419921875
-^GSPC,2024-05-14,5246.68017578125
-^GSPC,2024-05-15,5308.14990234375
-^GSPC,2024-05-16,5297.10009765625
-^GSPC,2024-05-17,5303.27001953125
-^GSPC,2024-05-20,5308.1298828125
-^GSPC,2024-05-21,5321.41015625
-^GSPC,2024-05-22,5307.009765625
-^GSPC,2024-05-23,5267.83984375
-^GSPC,2024-05-24,5304.72021484375
-^GSPC,2024-05-28,5306.0400390625
-^GSPC,2024-05-29,5266.9501953125
-^GSPC,2024-05-30,5235.47998046875
-^GSPC,2024-05-31,5277.509765625
-^GSPC,2024-06-03,5283.39990234375
-^GSPC,2024-06-04,5291.33984375
-^GSPC,2024-06-05,5354.02978515625
-^GSPC,2024-06-06,5352.9599609375
-^GSPC,2024-06-07,5346.990234375
-^GSPC,2024-06-10,5360.7900390625
-^GSPC,2024-06-11,5375.31982421875
-^GSPC,2024-06-12,5421.02978515625
-^GSPC,2024-06-13,5433.740234375
-^GSPC,2024-06-14,5431.60009765625
-^GSPC,2024-06-17,5473.22998046875
-^GSPC,2024-06-18,5487.02978515625
-^GSPC,2024-06-20,5473.169921875
-^GSPC,2024-06-21,5464.6201171875
-^GSPC,2024-06-24,5447.8701171875
-^GSPC,2024-06-25,5469.2998046875
-^GSPC,2024-06-26,5477.89990234375
-^GSPC,2024-06-27,5482.8701171875
-^GSPC,2024-06-28,5460.47998046875
-^GSPC,2024-07-01,5475.08984375
-^GSPC,2024-07-02,5509.009765625
-^GSPC,2024-07-03,5537.02001953125
-^GSPC,2024-07-05,5567.18994140625
-^GSPC,2024-07-08,5572.85009765625
-^GSPC,2024-07-09,5576.97998046875
-^GSPC,2024-07-10,5633.91015625
-^GSPC,2024-07-11,5584.5400390625
-^GSPC,2024-07-12,5615.35009765625
-^GSPC,2024-07-15,5631.22021484375
-^GSPC,2024-07-16,5667.2001953125
-^GSPC,2024-07-17,5588.27001953125
-^GSPC,2024-07-18,5544.58984375
-^GSPC,2024-07-19,5505
-^GSPC,2024-07-22,5564.41015625
-^GSPC,2024-07-23,5555.740234375
-^GSPC,2024-07-24,5427.1298828125
-^GSPC,2024-07-25,5399.22021484375
-^GSPC,2024-07-26,5459.10009765625
-^GSPC,2024-07-29,5463.5400390625
-^GSPC,2024-07-30,5436.43994140625
-^GSPC,2024-07-31,5522.2998046875
-^GSPC,2024-08-01,5446.68017578125
-^GSPC,2024-08-02,5346.56005859375
-^GSPC,2024-08-05,5186.330078125
-^GSPC,2024-08-06,5240.02978515625
-^GSPC,2024-08-07,5199.5
-^GSPC,2024-08-08,5319.31005859375
-^GSPC,2024-08-09,5344.16015625
-^GSPC,2024-08-12,5344.39013671875
-^GSPC,2024-08-13,5434.43017578125
-^GSPC,2024-08-14,5455.2099609375
-^GSPC,2024-08-15,5543.22021484375
-^GSPC,2024-08-16,5554.25
-^GSPC,2024-08-19,5608.25
-^GSPC,2024-08-20,5597.1201171875
-^GSPC,2024-08-21,5620.85009765625
-^GSPC,2024-08-22,5570.64013671875
-^GSPC,2024-08-23,5634.60986328125
-^GSPC,2024-08-26,5616.83984375
-^GSPC,2024-08-27,5625.7998046875
-^GSPC,2024-08-28,5592.18017578125
-^GSPC,2024-08-29,5591.9599609375
-^GSPC,2024-08-30,5648.39990234375
-^GSPC,2024-09-03,5528.93017578125
-^GSPC,2024-09-04,5520.06982421875
-^GSPC,2024-09-05,5503.41015625
-^GSPC,2024-09-06,5408.419921875
-^GSPC,2024-09-09,5471.0498046875
-^GSPC,2024-09-10,5495.52001953125
-^GSPC,2024-09-11,5554.1298828125
-^GSPC,2024-09-12,5595.759765625
-^GSPC,2024-09-13,5626.02001953125
-^GSPC,2024-09-16,5633.08984375
-^GSPC,2024-09-17,5634.580078125
-^GSPC,2024-09-18,5618.259765625
-^GSPC,2024-09-19,5713.64013671875
-^GSPC,2024-09-20,5702.5498046875
-^GSPC,2024-09-23,5718.56982421875
-^GSPC,2024-09-24,5732.93017578125
-^GSPC,2024-09-25,5722.259765625
-^GSPC,2024-09-26,5745.3701171875
-^GSPC,2024-09-27,5738.169921875
-^GSPC,2024-09-30,5762.47998046875
-^GSPC,2024-10-01,5708.75
-^GSPC,2024-10-02,5709.5400390625
-^GSPC,2024-10-03,5699.93994140625
-^GSPC,2024-10-04,5751.06982421875
-^GSPC,2024-10-07,5695.93994140625
-^GSPC,2024-10-08,5751.1298828125
-^GSPC,2024-10-09,5792.0400390625
-^GSPC,2024-10-10,5780.0498046875
-^GSPC,2024-10-11,5815.02978515625
-^GSPC,2024-10-14,5859.85009765625
-^GSPC,2024-10-15,5815.259765625
-^GSPC,2024-10-16,5842.47021484375
-^GSPC,2024-10-17,5841.47021484375
-^GSPC,2024-10-18,5864.669921875
-^GSPC,2024-10-21,5853.97998046875
-^GSPC,2024-10-22,5851.2001953125
-^GSPC,2024-10-23,5797.419921875
-^GSPC,2024-10-24,5809.85986328125
-^GSPC,2024-10-25,5808.1201171875
-^GSPC,2024-10-28,5823.52001953125
-^GSPC,2024-10-29,5832.919921875
-^GSPC,2024-10-30,5813.669921875
-^GSPC,2024-10-31,5705.4501953125
-^GSPC,2024-11-01,5728.7998046875
-^GSPC,2024-11-04,5712.68994140625
-^GSPC,2024-11-05,5782.759765625
-^GSPC,2024-11-06,5929.0400390625
-^GSPC,2024-11-07,5973.10009765625
-^GSPC,2024-11-08,5995.5400390625
-^GSPC,2024-11-11,6001.35009765625
-^GSPC,2024-11-12,5983.990234375
-^GSPC,2024-11-13,5985.3798828125
-^GSPC,2024-11-14,5949.169921875
-^GSPC,2024-11-15,5870.6201171875
-^GSPC,2024-11-18,5893.6201171875
-^GSPC,2024-11-19,5916.97998046875
-^GSPC,2024-11-20,5917.10986328125
-^GSPC,2024-11-21,5948.7099609375
-^GSPC,2024-11-22,5969.33984375
-^GSPC,2024-11-25,5987.3701171875
-^GSPC,2024-11-26,6021.6298828125
-^GSPC,2024-11-27,5998.740234375
-^GSPC,2024-11-29,6032.3798828125
-^GSPC,2024-12-02,6047.14990234375
-^GSPC,2024-12-03,6049.8798828125
-^GSPC,2024-12-04,6086.490234375
-^GSPC,2024-12-05,6075.10986328125
-^GSPC,2024-12-06,6090.27001953125
-^GSPC,2024-12-09,6052.85009765625
-^GSPC,2024-12-10,6034.91015625
-^GSPC,2024-12-11,6084.18994140625
-^GSPC,2024-12-12,6051.25
-^GSPC,2024-12-13,6051.08984375
-^GSPC,2024-12-16,6074.080078125
-^GSPC,2024-12-17,6050.60986328125
-^GSPC,2024-12-18,5872.16015625
-^GSPC,2024-12-19,5867.080078125
-^GSPC,2024-12-20,5930.85009765625
-^GSPC,2024-12-23,5974.06982421875
-^GSPC,2024-12-24,6040.0400390625
-^GSPC,2024-12-26,6037.58984375
-^GSPC,2024-12-27,5970.83984375
-^GSPC,2024-12-30,5906.93994140625
-^GSPC,2024-12-31,5881.6298828125
-^GSPC,2025-01-02,5868.5498046875
-^GSPC,2025-01-03,5942.47021484375
-^GSPC,2025-01-06,5975.3798828125
-^GSPC,2025-01-07,5909.02978515625
-^GSPC,2025-01-08,5918.25
-^GSPC,2025-01-10,5827.0400390625
-^GSPC,2025-01-13,5836.22021484375
-^GSPC,2025-01-14,5842.91015625
-^GSPC,2025-01-15,5949.91015625
-^GSPC,2025-01-16,5937.33984375
-^GSPC,2025-01-17,5996.66015625
-^GSPC,2025-01-21,6049.240234375
-^GSPC,2025-01-22,6086.3701171875
-^GSPC,2025-01-23,6118.7099609375
-^GSPC,2025-01-24,6101.240234375
-^GSPC,2025-01-27,6012.27978515625
-^GSPC,2025-01-28,6067.7001953125
-^GSPC,2025-01-29,6039.31005859375
-^GSPC,2025-01-30,6071.169921875
-^GSPC,2025-01-31,6040.52978515625
-^GSPC,2025-02-03,5994.56982421875
-^GSPC,2025-02-04,6037.8798828125
-^GSPC,2025-02-05,6061.47998046875
-^GSPC,2025-02-06,6083.56982421875
-^GSPC,2025-02-07,6025.990234375
-^GSPC,2025-02-10,6066.43994140625
-^GSPC,2025-02-11,6068.5
-^GSPC,2025-02-12,6051.97021484375
-^GSPC,2025-02-13,6115.06982421875
-^GSPC,2025-02-14,6114.6298828125
-^GSPC,2025-02-18,6129.580078125
-^GSPC,2025-02-19,6144.14990234375
-^GSPC,2025-02-20,6117.52001953125
-^GSPC,2025-02-21,6013.1298828125
-^GSPC,2025-02-24,5983.25
-^GSPC,2025-02-25,5955.25
-^GSPC,2025-02-26,5956.06005859375
-^GSPC,2025-02-27,5861.56982421875
-^GSPC,2025-02-28,5954.5
-^GSPC,2025-03-03,5849.72021484375
-^GSPC,2025-03-04,5778.14990234375
-^GSPC,2025-03-05,5842.6298828125
-^GSPC,2025-03-06,5738.52001953125
-^GSPC,2025-03-07,5770.2001953125
-^GSPC,2025-03-10,5614.56005859375
-^GSPC,2025-03-11,5572.06982421875
-^GSPC,2025-03-12,5599.2998046875
-^GSPC,2025-03-13,5521.52001953125
-^GSPC,2025-03-14,5638.93994140625
-^GSPC,2025-03-17,5675.1201171875
-^GSPC,2025-03-18,5614.66015625
-^GSPC,2025-03-19,5675.2900390625
-^GSPC,2025-03-20,5662.89013671875
-^GSPC,2025-03-21,5667.56005859375
-^GSPC,2025-03-24,5767.56982421875
-^GSPC,2025-03-25,5776.64990234375
-^GSPC,2025-03-26,5712.2001953125
-^GSPC,2025-03-27,5693.31005859375
-^GSPC,2025-03-28,5580.93994140625
-^GSPC,2025-03-31,5611.85009765625
-"""
-    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode='w', newline='')
-    temp.write(sample_data)
-    temp.close()
-    return temp.name
-
-# Global theme
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="indigo",
-    neutral_hue="gray"
-)
+        cv_u = sf_u.cross_validation(df=df_y, h=cv_h, step_size=cv_step_size, n_windows=cv_windows)
+        cv_parts.append(cv_u)
+
+        eval_u = evaluate(cv_u, metrics=[loss_fn])
+        eval_u["pipeline"] = "univariate"
+        eval_parts.append(eval_u)
+
+        fc_u = sf_u.forecast(df=df_y, h=future_h)
+        future_parts.append(fc_u)
+
+    # Exogenous pipeline (StatsForecast)
+    if exog_models:
+        sf_x = StatsForecast(models=exog_models, freq=freq, n_jobs=-1)
+
+        cv_x = sf_x.cross_validation(df=df_exog, h=cv_h, step_size=cv_step_size, n_windows=cv_windows)
+        cv_parts.append(cv_x)
+
+        eval_x = evaluate(cv_x, metrics=[loss_fn])
+        eval_x["pipeline"] = "exog"
+        eval_parts.append(eval_x)
+
+        fc_x = sf_x.forecast(df=df_exog, h=future_h, X_df=X_future)
+        future_parts.append(fc_x)
+
+    # TimeGPT
+    if use_timegpt:
+        if not nixtla_api_key:
+            return None, None, None, "TimeGPT selected but no Nixtla API key provided.", None
+
+        client = NixtlaClient(api_key=nixtla_api_key)
+
+        # Provide historical exog cols if selected
+        df_tgpt = df[["unique_id", "ds", "y"] + list(xcols)].copy() if use_exog else df_y
+
+        # Forecast
+        tgpt_fc = client.forecast(
+            df=df_tgpt,
+            h=future_h,
+            freq=freq,
+            X_df=X_future if use_exog else None,
+            hist_exog_list=list(xcols) if use_exog else None,
+        )
+
+        # Normalize column name to match plots/merges
+        # Nixtla typically outputs: unique_id, ds, TimeGPT (or yhat)
+        # We'll rename forecast column to "timegpt" if needed.
+        tgpt = tgpt_fc.copy()
+        for c in tgpt.columns:
+            if c.lower() in ("timegpt", "yhat", "y_hat", "forecast"):
+                tgpt = tgpt.rename(columns={c: "timegpt"})
+                break
+        if "timegpt" not in tgpt.columns:
+            # fallback: pick the first non-id col
+            non_id = [c for c in tgpt.columns if c not in ["unique_id", "ds"]]
+            if non_id:
+                tgpt = tgpt.rename(columns={non_id[0]: "timegpt"})
+
+        future_parts.append(tgpt)
+
+    if not eval_parts and not future_parts:
+        return None, None, None, "No models selected.", None
+
+    # 6) Merge CV, eval, future forecasts
+    eval_df = pd.concat(eval_parts, ignore_index=True) if eval_parts else None
+    cv_df = pd.concat(cv_parts, ignore_index=True) if cv_parts else None
+
+    # Merge future forecasts on (unique_id, ds)
+    future_df = None
+    if future_parts:
+        future_df = future_parts[0].copy()
+        for part in future_parts[1:]:
+            # avoid duplicate cols
+            overlap = set(future_df.columns).intersection(set(part.columns)) - {"unique_id", "ds"}
+            part2 = part.drop(columns=list(overlap), errors="ignore")
+            future_df = future_df.merge(part2, on=["unique_id", "ds"], how="outer")
 
-# Gradio interface
-with gr.Blocks(title="Time Series Forecasting App", theme=theme) as app:
-    gr.Markdown("# 📈 Time Series Forecasting App")
-    gr.Markdown("Upload a CSV with `unique_id`, `ds`, and `y` columns to apply forecasting models.")
-    
-    # Disclaimer about external predictors
-    with gr.Accordion("Disclaimer", open=True):
-        gr.Markdown("""
-        **Disclaimer:** For simplicity, this app does not allow the use of external predictors. 
-        However, they can be easily included in the underlying statsforecast (for AutoARIMA) 
-        and the TimeGPT implementation by Nixtla. To use external predictors, you would need to modify 
-        the code to include them in your forecasting models.
-        """)
+        future_df = future_df.sort_values(["unique_id", "ds"]).reset_index(drop=True)
+
+    # 7) Plots
+    cv_plot = create_cv_plot(
+        cv_df, df_y, title="Cross-Validation Forecasts", horizon=cv_h, freq=freq
+    ) if cv_df is not None and not cv_df.empty else None
+
+    future_plot = create_future_plot(
+        future_df, df_y, title="Future Forecast", horizon=future_h, freq=freq
+    ) if future_df is not None and not future_df.empty else None
+
+    # 8) Export files
+    files = export_results(eval_df, cv_df, future_df)
+
+    # Message
+    msg2 = msg
+    if use_exog:
+        msg2 += f" | Predictors used: {', '.join(xcols)}"
+
+    return eval_df, cv_plot, future_df, msg2, files
+
+
+# -----------------------------
+# UI wiring
+# -----------------------------
+def on_train_upload(file_obj):
+    df, xchoices, msg = load_training_data(file_obj)
+    return (
+        msg,
+        gr.update(choices=xchoices, value=[]),
+        gr.update(visible=True),
+    )
+
+
+with gr.Blocks(title="StatsForecast + TimeGPT (with Predictors)") as demo:
+    gr.Markdown(
+        """
+# StatsForecast + TimeGPT Forecasting Demo (with optional predictors)
+
+**Training CSV required columns:** `unique_id, ds, y`  
+**Optional predictors:** any extra columns in the training CSV.
+
+If you select predictors, upload a **future predictors CSV** (`X_df`) with columns:
+`unique_id, ds, <selected predictors...>` covering the forecast horizon.
+"""
+    )
 
     with gr.Row():
-        with gr.Column(scale=2):
-            file_input = gr.File(label="Upload CSV file", file_types=[".csv"])
-
-            download_btn = gr.Button("Download Sample Data", variant="secondary")
-            download_output = gr.File(label="Click to download", visible=True)
-            download_btn.click(fn=download_sample, outputs=download_output)
-
-            with gr.Accordion("Data & Validation Settings", open=True):
-                frequency = gr.Dropdown(
-                    choices=[
-                        ("Hourly", "H"),
-                        ("Business Day", "B"),
-                        ("Daily", "D"), 
-                        ("Weekly", "WS"), 
-                        ("Monthly", "MS"), 
-                        ("Quarterly", "QS"), 
-                        ("Yearly", "YS")
-                    ], 
-                    label="Data Frequency", 
-                    value="D"
-                )
-                
-                # Evaluation Strategy
-                eval_strategy = gr.Radio(
-                    choices=["Fixed Window", "Cross Validation"], 
-                    label="Evaluation Strategy", 
-                    value="Cross Validation"
-                )
-                
-                # Fixed Window settings
-                with gr.Group(visible=True) as fixed_window_box:
-                    gr.Markdown("### Fixed Window Settings")
-                    horizon = gr.Slider(1, 100, value=10, step=1, label="Validation Horizon (steps ahead to predict)")
-                
-                # Cross Validation settings
-                with gr.Group(visible=True) as cv_box:
-                    gr.Markdown("### Cross Validation Settings")
-                    with gr.Row():
-                        step_size = gr.Slider(1, 50, value=10, step=1, label="Step Size (distance between windows)")
-                        num_windows = gr.Slider(1, 20, value=5, step=1, label="Number of Windows")
-                
-                # Future forecast settings (always visible)
-                with gr.Group():
-                    gr.Markdown("### Future Forecast Settings")
-                    future_horizon = gr.Slider(1, 100, value=10, step=1, label="Future Forecast Horizon (steps to predict)")
-
-            with gr.Accordion("Model Configuration", open=True):
-                with gr.Tabs() as model_tabs:
-                    # Traditional Statistical Models Tab
-                    with gr.TabItem("Statistical Models"):
-                        gr.Markdown("## Basic Models")
-                        with gr.Row():
-                            use_historical_avg = gr.Checkbox(label="Historical Average", value=True)
-                            use_naive = gr.Checkbox(label="Naive", value=True)
-                        
-                        # Common seasonality parameter at the top level
-                        with gr.Group():
-                            gr.Markdown("### Seasonality Configuration")
-                            gr.Markdown("This seasonality period affects Seasonal Naive, Seasonal Window Average, AutoETS, and AutoARIMA models")
-                            seasonality = gr.Number(label="Seasonality Period", value=5)
-                        
-                        gr.Markdown("### Seasonal Models")
-                        with gr.Row():
-                            use_seasonal_naive = gr.Checkbox(label="Seasonal Naive", value=True)
-                        
-                        gr.Markdown("### Window-based Models")
-                        with gr.Row():
-                            use_window_avg = gr.Checkbox(label="Window Average", value=False)
-                            window_size = gr.Number(label="Window Size", value=10)
-                        
-                        with gr.Row():
-                            use_seasonal_window_avg = gr.Checkbox(label="Seasonal Window Average", value=False)
-                            seasonal_window_size = gr.Number(label="Seasonal Window Size", value=2)
-                        
-                        gr.Markdown("### Advanced Models (use seasonality from above)")
-                        with gr.Row():
-                            use_autoets = gr.Checkbox(label="AutoETS (Exponential Smoothing)", value=False)
-                            use_autoarima = gr.Checkbox(label="AutoARIMA", value=False)
-                    
-                    # Transformer Models Tab (TimeGPT)
-                    with gr.TabItem("Transformer Models"):
-                        gr.Markdown("## TimeGPT Model")
-                        gr.Markdown("TimeGPT uses a transformer architecture for state-of-the-art time series forecasting")
-                        
-                        with gr.Row():
-                            use_timegpt = gr.Checkbox(label="Use TimeGPT", value=True)
-                        
-                        with gr.Group():
-                            gr.Markdown("### TimeGPT Configuration")
-                            with gr.Row():
-                                finetune_loss = gr.Dropdown(
-                                    choices=["mape", "mae", "rmse", "smape"], 
-                                    label="Finetune Loss Metric", 
-                                    value="mape"
-                                )
-                                confidence_level = gr.Slider(50, 99, value=95, step=1, label="Confidence Level (%)")
-                        
-                        gr.Markdown("""
-                        **Note:** Using TimeGPT requires a valid API key. The API key should 
-                        be set as an environment variable named `NIXTLA_API_KEY`. This space uses a trial key, which is rate limited.
-                        """)
-
-        with gr.Column(scale=3):
-            message_output = gr.Textbox(label="Status Message")
-            
-            with gr.Tabs() as tabs:
-                with gr.TabItem("Validation Results"):
-                    eval_output = gr.Dataframe(label="Evaluation Metrics")
-                    validation_plot = gr.Plot(label="Validation Plot")
-                    validation_output = gr.Dataframe(label="Validation Data", visible=False)
-                    
-                    with gr.Row():
-                        show_data_btn = gr.Button("Show Validation Data")
-                        hide_data_btn = gr.Button("Hide Validation Data", visible=False)
-                    
-                    def show_data():
-                        return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
-                    
-                    def hide_data():
-                        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
-                    
-                    show_data_btn.click(
-                        fn=show_data,
-                        outputs=[validation_output, hide_data_btn, show_data_btn]
-                    )
-                    
-                    hide_data_btn.click(
-                        fn=hide_data,
-                        outputs=[validation_output, hide_data_btn, show_data_btn]
-                    )
-                
-                with gr.TabItem("Future Forecast"):
-                    forecast_plot = gr.Plot(label="Future Forecast Plot")
-                    forecast_output = gr.Dataframe(label="Future Forecast Data", visible=False)
-                    
-                    with gr.Row():
-                        show_forecast_btn = gr.Button("Show Forecast Data")
-                        hide_forecast_btn = gr.Button("Hide Forecast Data", visible=False)
-                    
-                    def show_forecast():
-                        return gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
-                    
-                    def hide_forecast():
-                        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
-                    
-                    show_forecast_btn.click(
-                        fn=show_forecast,
-                        outputs=[forecast_output, hide_forecast_btn, show_forecast_btn]
-                    )
-                    
-                    hide_forecast_btn.click(
-                        fn=hide_forecast,
-                        outputs=[forecast_output, hide_forecast_btn, show_forecast_btn]
-                    )
-                
-                with gr.TabItem("Export Results"):
-                    export_files = gr.Files(label="Download Results")
-
-    with gr.Row(visible=True) as run_row:
-        submit_btn = gr.Button("Run Validation and Forecast", variant="primary", size="lg")
-    
-    # Update visibility of the appropriate box based on evaluation strategy
-    def update_eval_boxes(strategy):
-        return (gr.update(visible=strategy == "Fixed Window"), 
-                gr.update(visible=strategy == "Cross Validation"))
-        
-    eval_strategy.change(
-        fn=update_eval_boxes,
-        inputs=[eval_strategy],
-        outputs=[fixed_window_box, cv_box]
+        train_file = gr.File(label="Upload training CSV", file_types=[".csv"])
+        status = gr.Textbox(label="Status", value="Upload a CSV to begin.", interactive=False)
+
+    xcols = gr.Dropdown(
+        choices=[],
+        multiselect=True,
+        label="Predictor columns (X) (optional)",
+        info="Select exogenous/predictor columns from the training data. Requires X_df for the forecast horizon.",
+    )
+    future_x_file = gr.File(
+        label="Upload future predictors CSV (X_df) (required if predictors selected)",
+        file_types=[".csv"],
+    )
+
+    with gr.Accordion("Forecast settings", open=True):
+        with gr.Row():
+            freq = gr.Dropdown(
+                choices=["H", "D", "B", "WS", "MS", "QS", "YS"],
+                value="D",
+                label="Frequency (pandas offset alias)",
+            )
+            season_length = gr.Number(value=7, label="Season length", precision=0)
+
+        with gr.Row():
+            cv_h = gr.Number(value=14, label="CV horizon (h)", precision=0)
+            cv_step_size = gr.Number(value=1, label="CV step size", precision=0)
+            cv_windows = gr.Number(value=3, label="CV windows", precision=0)
+
+        future_h = gr.Number(value=30, label="Future forecast horizon", precision=0)
+
+        loss_name = gr.Dropdown(
+            choices=["rmse", "mae", "mse", "mape", "smape", "mase"],
+            value="rmse",
+            label="Evaluation metric",
+        )
+
+    with gr.Accordion("Models", open=True):
+        with gr.Row():
+            use_histavg = gr.Checkbox(value=False, label="HistoricAverage")
+            use_naive = gr.Checkbox(value=True, label="Naive")
+            use_snaive = gr.Checkbox(value=False, label="SeasonalNaive")
+            use_winavg = gr.Checkbox(value=False, label="WindowAverage")
+            use_swinavg = gr.Checkbox(value=False, label="SeasonalWindowAverage")
+            use_autoets = gr.Checkbox(value=True, label="AutoETS")
+            use_autoarima = gr.Checkbox(value=True, label="AutoARIMA (supports predictors)")
+
+    with gr.Accordion("TimeGPT", open=False):
+        use_timegpt = gr.Checkbox(value=False, label="Enable TimeGPT")
+        nixtla_api_key = gr.Textbox(
+            label="Nixtla API Key",
+            placeholder="Paste your Nixtla API key here",
+            type="password",
+        )
+
+    run_btn = gr.Button("Run Forecast", variant="primary")
+
+    gr.Markdown("## Outputs")
+    eval_df_out = gr.Dataframe(label="Evaluation metrics (by pipeline)")
+    cv_plot_out = gr.Plot(label="Cross-validation plot")
+    future_df_out = gr.Dataframe(label="Future forecasts")
+    files_out = gr.Files(label="Download results")
+
+    # Update predictor choices when training file is uploaded
+    train_file.change(
+        fn=on_train_upload,
+        inputs=[train_file],
+        outputs=[status, xcols, xcols],  # last output toggles visible; harmless
     )
 
-    # Run forecast when button is clicked
-    submit_btn.click(
+    run_btn.click(
         fn=run_forecast,
         inputs=[
-            file_input, frequency, eval_strategy, horizon, step_size, num_windows,
-            use_historical_avg, use_naive, use_seasonal_naive, seasonality,
-            use_window_avg, window_size, use_seasonal_window_avg, seasonal_window_size,
-            use_autoets, use_autoarima, use_timegpt, finetune_loss, confidence_level,
-            future_horizon
+            train_file,
+            freq,
+            season_length,
+            cv_h,
+            cv_step_size,
+            cv_windows,
+            future_h,
+            loss_name,
+            use_histavg,
+            use_naive,
+            use_snaive,
+            use_winavg,
+            use_swinavg,
+            use_autoets,
+            use_autoarima,
+            use_timegpt,
+            nixtla_api_key,
+            xcols,
+            future_x_file,
         ],
-        outputs=[
-            eval_output, 
-            validation_output,
-            validation_plot, 
-            forecast_output, 
-            forecast_plot, 
-            export_files, 
-            message_output]
+        outputs=[eval_df_out, cv_plot_out, future_df_out, status, files_out],
     )
 
-if __name__ == "__main__":
-    app.launch(share=False)
+demo.launch()