Fix Gradio compatibility issue

app.py

@@ -6,8 +6,8 @@ from prophet import Prophet
 import os
 import warnings
 import datetime
-import shutil # For moving files
-import traceback # For detailed error logging
+import shutil
+import traceback
 
 # Suppress all warnings for a cleaner output
 warnings.filterwarnings('ignore')
@@ -26,7 +26,6 @@ os.makedirs(PROCESSED_DATA_DIR, exist_ok=True)
 # Predefined trading pairs with expected formats. 
 # This dictionary will be dynamically updated in load_available_data.
 TRADING_PAIRS = {
-    # Default configs for known pairs
     "EURUSD": {
         "description": "Euro to US Dollar Forex Pair (Sample)",
         "date_format": "%d.%m.%Y %H:%M:%S.%f %z",
@@ -154,7 +153,7 @@ def preprocess_data_file(raw_file_path, pair_name):
             if col in df.columns:
                 df[col] = pd.to_numeric(df[col], errors='coerce')
         
-        # Fill missing values (only after numeric conversion)
+        # Fill missing values
         for col in ['Open', 'High', 'Low', 'Close']:
             if col in df.columns:
                 missing_before = df[col].isna().sum()
@@ -189,7 +188,7 @@ def preprocess_data_file(raw_file_path, pair_name):
         return None
 
 def load_available_data():
-    """Load and preprocess all available data files, handling raw folder creation."""
+    """Load and preprocess all available data files."""
     global TRADING_PAIRS, available_data
     available_data = {}
     
@@ -210,22 +209,20 @@ def load_available_data():
                 print("No CSV files found in 'data/' to move.")
         
     if not os.path.exists(RAW_DATA_DIR):
-        print(f"❌ Still cannot find raw data directory: {RAW_DATA_DIR}. Please check your file structure.")
+        print(f"❌ Still cannot find raw data directory: {RAW_DATA_DIR}.")
         return available_data
     
     print(f"🔍 Scanning for data files in {RAW_DATA_DIR}...")
     
     for filename in os.listdir(RAW_DATA_DIR):
         if filename.endswith('.csv'):
-            # Extract pair name from filename (e.g., EURUSD.csv -> EURUSD)
             pair_name = filename.split('.')[0].upper()
             
-            # --- Generalization Improvement ---
-            # If pair is not in TRADING_PAIRS, add it with generic defaults
+            # Generalization: Add generic config if not exists
             if pair_name not in TRADING_PAIRS:
                 TRADING_PAIRS[pair_name] = {
                     "description": f"{pair_name} Trading Pair (Generic)",
-                    "date_format": None, # Indicates dynamic parsing
+                    "date_format": None, 
                     "has_timezone": False,
                     "decimal_separator": ".",
                     "required_columns": ["Open", "High", "Low", "Close"]
@@ -234,7 +231,7 @@ def load_available_data():
             raw_file_path = os.path.join(RAW_DATA_DIR, filename)
             processed_file_path = os.path.join(PROCESSED_DATA_DIR, f"{pair_name}_processed.csv")
             
-            # Check for existing preprocessed file
+            # Check existing processed file
             if os.path.exists(processed_file_path):
                 raw_mod_time = os.path.getmtime(raw_file_path)
                 processed_mod_time = os.path.getmtime(processed_file_path)
@@ -243,28 +240,27 @@ def load_available_data():
                     try:
                         df = pd.read_csv(processed_file_path, index_col=0, parse_dates=True)
                         available_data[pair_name] = df
-                        print(f"✅ Using existing preprocessed data for {pair_name} with {len(df)} records")
+                        print(f"✅ Using existing preprocessed data for {pair_name}")
                         continue
                     except Exception as e:
-                        print(f"⚠️ Error loading preprocessed file for {pair_name}: {str(e)}. Reprocessing.")
+                        print(f"⚠️ Error loading preprocessed file for {pair_name}. Reprocessing.")
             
-            # Preprocess the file
+            # Preprocess
             print(f"🔄 Processing {pair_name} data...")
             df = preprocess_data_file(raw_file_path, pair_name)
             if df is not None:
                 available_data[pair_name] = df
-                print(f"✅ Successfully loaded {pair_name} with {len(df)} records")
+                print(f"✅ Successfully loaded {pair_name}")
             else:
-                print(f"❌ Failed to load {pair_name} data. See error above.")
+                print(f"❌ Failed to load {pair_name} data.")
     
     return available_data
 
 # --- Analysis Functions ---
 
 def get_available_pairs():
-    """Get list of available trading pairs with status for UI"""
     if not available_data:
-        return "⚠️ No data files found. Please upload CSV files to the 'data/raw' directory and restart the app."
+        return "⚠️ No data files found. Please upload CSV files to 'data/raw'."
     
     status = "✅ Available trading pairs:\n"
     for pair in sorted(available_data.keys()):
@@ -273,24 +269,17 @@ def get_available_pairs():
         if records > 0:
             date_range = f"{df.index.min().strftime('%Y-%m-%d')} to {df.index.max().strftime('%Y-%m-%d')}"
             status += f"• {pair}: {records} records ({date_range})\n"
-        else:
-            status += f"• {pair}: 0 records (Data Error)\n"
     return status
 
 def analyze_trading_pair(pair_name: str):
-    """
-    Analyzes a specific trading pair, generates candlestick chart,
-    calculates technical indicators, and runs a Prophet forecast.
-    """
-    
-    pair_name = pair_name.upper().strip() # Normalize input
+    pair_name = pair_name.upper().strip()
     print(f"\n🔍 Starting analysis for {pair_name}")
     
-    # Initial return values for error case
-    default_error_fig = go.Figure().update_layout(title="Analysis Failed", xaxis_title="Time", yaxis_title="Price")
+    # Defaults for error case
+    default_error_fig = go.Figure().update_layout(title="Analysis Failed")
     default_error_df = gr.DataFrame(headers=["Error"], value=[["Analysis failed"]])
     
-    # Check if data is available (case-insensitive search)
+    # Match pair name
     matched_pair = None
     for available_pair in available_data.keys():
         if pair_name == available_pair or pair_name.upper() == available_pair.upper():
@@ -298,308 +287,151 @@ def analyze_trading_pair(pair_name: str):
             break
             
     if matched_pair is None:
-        available_pairs = ", ".join(available_data.keys()) or "None"
-        return (
-            f"❌ Data not available for '{pair_name}'\nAvailable pairs: {available_pairs}",
-            default_error_fig, default_error_fig, default_error_df
-        )
+        return f"❌ Data not available for '{pair_name}'", default_error_fig, default_error_fig, default_error_df
     
     pair_name = matched_pair
     hist = available_data[pair_name].copy()
     
     try:
         if len(hist) < 5:
-             return (
-                f"❌ Data is too short for analysis. Only {len(hist)} records.",
-                default_error_fig, default_error_fig, default_error_df
-            )
-            
-        # Basic data validation
-        required_cols = ['Open', 'High', 'Low', 'Close']
-        if not all(col in hist.columns for col in required_cols):
-            missing_cols = [col for col in required_cols if col not in hist.columns]
-            return (
-                f"❌ Missing required columns: {', '.join(missing_cols)}\nAvailable columns: {', '.join(hist.columns)}",
-                default_error_fig, default_error_fig, default_error_df
-            )
+             return f"❌ Data too short ({len(hist)} records).", default_error_fig, default_error_fig, default_error_df
         
-        # --- 1. Candlestick Chart with Technical Indicators (MAs) ---
+        # 1. Candlestick Chart
         fig = go.Figure()
-        
-        # Add candlestick
         fig.add_trace(go.Candlestick(
-            x=hist.index,
-            open=hist['Open'],
-            high=hist['High'],
-            low=hist['Low'],
-            close=hist['Close'],
-            name='Price'
+            x=hist.index, open=hist['Open'], high=hist['High'],
+            low=hist['Low'], close=hist['Close'], name='Price'
         ))
         
-        # Add moving averages
         if len(hist) >= 20:
-            hist['MA20'] = hist['Close'].rolling(window=20, min_periods=1).mean()
-            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA20'], mode='lines', name='20-period MA', line=dict(color='blue', width=1.5)))
+            hist['MA20'] = hist['Close'].rolling(window=20).mean()
+            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA20'], mode='lines', name='20 MA', line=dict(color='blue', width=1.5)))
         
         if len(hist) >= 50:
-            hist['MA50'] = hist['Close'].rolling(window=50, min_periods=1).mean()
-            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA50'], mode='lines', name='50-period MA', line=dict(color='orange', width=1.5)))
+            hist['MA50'] = hist['Close'].rolling(window=50).mean()
+            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA50'], mode='lines', name='50 MA', line=dict(color='orange', width=1.5)))
         
         fig.update_layout(
-            title=f"{pair_name} Price Analysis",
-            xaxis_title="Date",
-            yaxis_title="Price",
-            template="plotly_white",
-            hovermode="x unified",
-            xaxis_rangeslider_visible=False, # Hide the bottom slider for cleaner look
-            height=500,
+            title=f"{pair_name} Price Analysis", xaxis_title="Date", yaxis_title="Price",
+            template="plotly_white", hovermode="x unified", xaxis_rangeslider_visible=False, height=500
         )
         
-        # --- 2. Forecasting using Prophet ---
+        # 2. Prophet Forecast
         forecast_fig = default_error_fig
         forecast_table = default_error_df
         forecast_result = "No forecast data available"
         
         try:
-            # Use last 1 year (365 days) of data for forecasting, ensures manageable size and recent relevance
             prophet_df = hist[['Close']].copy().last('365D').reset_index()
             prophet_df.columns = ['ds', 'y']
             prophet_df = prophet_df.dropna()
             
-            print(f"📊 Using {len(prophet_df)} data points for forecasting")
-            
-            if len(prophet_df) < 30:
-                forecast_result = f"⚠️ Not enough recent data points for forecasting (have {len(prophet_df)}, need at least 30 historical daily points for good results)."
-                
-            else:
-                # Initialize Prophet model with CRITICAL FIX (stan_backend=None)
+            if len(prophet_df) >= 30:
                 model = Prophet(
-                    daily_seasonality=False, # Use False unless intra-day data is used
-                    yearly_seasonality=True,
-                    interval_width=0.95,
-                    changepoint_prior_scale=0.05,
-                    stan_backend=None # CRITICAL FIX for better compatibility
+                    daily_seasonality=False, yearly_seasonality=True,
+                    interval_width=0.95, changepoint_prior_scale=0.05,
+                    stan_backend=None # Critical Fix
                 )
                 
-                # Automatically add custom daily seasonality if data is less than daily resolution
-                if (prophet_df['ds'].diff().min().total_seconds() < 86400 * 0.9): # < 90% of a day
+                if (prophet_df['ds'].diff().min().total_seconds() < 86400 * 0.9):
                      model.add_seasonality(name='subdaily', period=1, fourier_order=5, prior_scale=0.1)
 
                 model.fit(prophet_df)
-                
-                # Create future dataframe (30 days forecast)
                 future = model.make_future_dataframe(periods=30, freq='D')
                 forecast = model.predict(future)
                 
-                # Create forecast chart
+                # Forecast Chart
                 forecast_fig = go.Figure()
-                
-                # Historical data (only show last 90 days for clarity)
                 hist_recent = prophet_df[prophet_df['ds'] >= (prophet_df['ds'].max() - pd.Timedelta(days=90))]
-                forecast_fig.add_trace(go.Scatter(x=hist_recent['ds'], y=hist_recent['y'], mode='lines', name='Historical', line=dict(color='blue', width=2)))
+                forecast_fig.add_trace(go.Scatter(x=hist_recent['ds'], y=hist_recent['y'], mode='lines', name='History', line=dict(color='blue')))
                 
-                # Forecast data
-                # Show forecast from last 30 days of historical data + future
                 forecast_recent = forecast[forecast['ds'] >= (prophet_df['ds'].max() - pd.Timedelta(days=30))]
-                forecast_fig.add_trace(go.Scatter(x=forecast_recent['ds'], y=forecast_recent['yhat'], mode='lines', name='Forecast', line=dict(color='red', width=2, dash='dash')))
+                forecast_fig.add_trace(go.Scatter(x=forecast_recent['ds'], y=forecast_recent['yhat'], mode='lines', name='Forecast', line=dict(color='red', dash='dash')))
                 
-                # Confidence interval
                 forecast_fig.add_trace(go.Scatter(
                     x=forecast_recent['ds'].tolist() + forecast_recent['ds'][::-1].tolist(),
                     y=forecast_recent['yhat_upper'].tolist() + forecast_recent['yhat_lower'][::-1].tolist(),
                     fill='toself', fillcolor='rgba(255,0,0,0.1)', line=dict(color='rgba(255,255,255,0)'), name='95% CI'
                 ))
                 
-                forecast_fig.update_layout(
-                    title=f"{pair_name} 30-Day Price Forecast", xaxis_title="Date", yaxis_title="Price",
-                    template="plotly_white", height=500, hovermode="x unified"
-                )
+                forecast_fig.update_layout(title=f"{pair_name} 30-Day Forecast", template="plotly_white", height=500)
                 
-                # Create forecast table
+                # Forecast Table
                 future_dates = forecast[forecast['ds'] > prophet_df['ds'].max()].head(30)
-                
-                # Calculate trend based on yhat difference
                 future_dates['Trend_Value'] = future_dates['yhat'].diff()
-                future_dates.iloc[0, future_dates.columns.get_loc('Trend_Value')] = future_dates.iloc[0]['yhat'] - prophet_df.iloc[-1]['y']
-                
-                future_dates['Date'] = future_dates['ds'].dt.strftime('%Y-%m-%d')
-                future_dates['Predicted Price'] = future_dates['yhat'].apply(lambda x: f"{x:.5f}")
-                future_dates['Lower Bound'] = future_dates['yhat_lower'].apply(lambda x: f"{x:.5f}")
-                future_dates['Upper Bound'] = future_dates['yhat_upper'].apply(lambda x: f"{x:.5f}")
-                future_dates['Trend'] = future_dates['Trend_Value'].apply(
-                    lambda x: "📈 Rising" if x > 0 else "📉 Falling" if x < 0 else "➡️ Stable"
-                )
                 
-                table_data = future_dates[['Date', 'Predicted Price', 'Lower Bound', 'Upper Bound', 'Trend']].values.tolist()
-                table_headers = ["Date", "Predicted Price", "Lower Bound", "Upper Bound", "Trend"]
+                # Fix first trend value NaN by comparing to last historical
+                if not future_dates.empty:
+                    future_dates.iloc[0, future_dates.columns.get_loc('Trend_Value')] = future_dates.iloc[0]['yhat'] - prophet_df.iloc[-1]['y']
                 
-                forecast_table = gr.DataFrame(headers=table_headers, value=table_data)
+                future_dates['Date'] = future_dates['ds'].dt.strftime('%Y-%m-%d')
+                future_dates['Price'] = future_dates['yhat'].apply(lambda x: f"{x:.5f}")
+                future_dates['Trend'] = future_dates['Trend_Value'].apply(lambda x: "📈 Up" if x > 0 else "📉 Down" if x < 0 else "➡️ Flat")
                 
-                last_forecast = forecast.iloc[-1]
-                forecast_result = (
-                    f"🔮 30-Day Forecast:\n"
-                    f"Predicted price for {last_forecast['ds'].strftime('%Y-%m-%d')}: **{last_forecast['yhat']:.5f}**\n"
-                    f"95% Confidence Range: {last_forecast['yhat_lower']:.5f} to {last_forecast['yhat_upper']:.5f}"
+                forecast_table = gr.DataFrame(
+                    headers=["Date", "Price", "Trend"],
+                    value=future_dates[['Date', 'Price', 'Trend']].values.tolist()
                 )
-                print("✅ Forecast generated successfully")
                 
-        except Exception as model_error:
-            forecast_result = f"⚠️ Forecasting failed. Error: {str(model_error)}"
-            print(f"❌ Forecasting failed: {forecast_result}")
+                last_f = forecast.iloc[-1]
+                forecast_result = f"🔮 Forecast (Day 30): {last_f['yhat']:.5f} (Range: {last_f['yhat_lower']:.5f} - {last_f['yhat_upper']:.5f})"
+                
+        except Exception as e:
+            forecast_result = f"⚠️ Forecast Error: {str(e)}"
             traceback.print_exc()
 
-        # --- 3. Technical Analysis Signal & Metrics ---
+        # 3. Signals
         current_price = hist['Close'].iloc[-1]
-        signal = "📊 Analyzing market conditions..."
-        
-        # Signal based on MAs
-        if 'MA50' in hist.columns and 'MA20' in hist.columns:
+        signal = "Neutral"
+        if 'MA50' in hist.columns:
             ma20 = hist['MA20'].iloc[-1]
             ma50 = hist['MA50'].iloc[-1]
+            if current_price > ma20 and ma20 > ma50: signal = "🚀 STRONG BULLISH"
+            elif current_price < ma20 and ma20 < ma50: signal = "💣 STRONG BEARISH"
+            elif current_price > ma20: signal = "📈 BULLISH"
+            elif current_price < ma20: signal = "📉 BEARISH"
             
-            if current_price > ma20 and ma20 > ma50:
-                signal = "🚀 **STRONG BULLISH**: Price above 20MA, and 20MA > 50MA (Golden Cross potential)"
-            elif current_price < ma20 and ma20 < ma50:
-                signal = "💣 **STRONG BEARISH**: Price below 20MA, and 20MA < 50MA (Death Cross potential)"
-            elif current_price > ma20:
-                 signal = "📈 **BULLISH**: Price above 20-period MA"
-            elif current_price < ma20:
-                 signal = "📉 **BEARISH**: Price below 20-period MA"
-        
-        # Calculate performance metrics
-        start_price = hist['Close'].iloc[0]
-        total_return = (current_price / start_price - 1) * 100
-        
-        # Annualized volatility: assumes daily data, adjusts for time period if needed (simple)
-        # Use a more robust check for non-daily data, e.g., daily returns if frequency is higher than daily
-        volatility = hist['Close'].pct_change().std() * np.sqrt(252) * 100 
-        
-        # Create final result text
         result_text = (
-            f"📊 **{pair_name} Analysis Report**\n"
-            f"{'=' * 50}\n"
-            f"💰 **Current Price**: {current_price:.5f}\n"
-            f"📈 **Total Return (full period)**: {total_return:.2f}%\n"
-            f"⚡ **Annualized Volatility**: {volatility:.2f}%\n"
-            f"🎯 **Technical Signal**: {signal}\n"
-            f"{'=' * 50}\n"
+            f"📊 **{pair_name} Report**\n{'='*30}\n"
+            f"💰 Price: {current_price:.5f}\n"
+            f"🎯 Signal: {signal}\n"
             f"{forecast_result}"
         )
         
-        print(f"✅ Analysis completed for {pair_name}")
         return result_text, fig, forecast_fig, forecast_table
         
     except Exception as e:
-        error_msg = f"❌ Major Analysis Error for {pair_name}: {str(e)}"
-        print(error_msg)
-        traceback.print_exc()
-        
-        return (
-            error_msg,
-            default_error_fig, 
-            default_error_fig, 
-            default_error_df
-        )
+        return f"❌ Error: {str(e)}", default_error_fig, default_error_fig, default_error_df
 
-# --- Application Initialization ---
+# --- Gradio App ---
 
-print("🚀 Initializing data processing system...")
+print("🚀 Initializing...")
 available_data = load_available_data()
-print(f"📊 Available trading pairs: {list(available_data.keys())}")
 
-# --- Gradio Interface ---
-
-with gr.Blocks(title="Trading Pair AI Analyzer") as demo:
-    gr.Markdown("# 📈 Trading Pair AI Analysis System")
-    gr.Markdown("### Analyze financial instruments with interactive charts and 30-day AI-powered forecasts (Prophet)")
+with gr.Blocks(title="Trading AI") as demo:
+    gr.Markdown("# 📈 Trading Pair AI Analysis")
     
     with gr.Row():
-        with gr.Column(scale=2):
-            data_status = gr.Textbox(
-                label="📊 Available Data", 
-                value=get_available_pairs(),
-                interactive=False,
-                lines=5,
-                autoscroll=True
-            )
-        
-        with gr.Column(scale=1):
-            gr.Markdown("### ℹ️ System Information")
-            system_info = gr.Textbox(
-                value=(
-                    f"📈 Trading Analysis System v2.3\n"
-                    f"🕒 Last updated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-                    f"🧮 Loaded pairs: {len(available_data)}"
-                ),
-                interactive=False,
-                lines=3
-            )
+        data_status = gr.Textbox(label="Available Data", value=get_available_pairs(), lines=4)
+        pair_input = gr.Textbox(label="Input Pair", value=list(available_data.keys())[0] if available_data else "EURUSD")
+        analyze_btn = gr.Button("🚀 Analyze", variant="primary")
+    
+    result_output = gr.Textbox(label="Summary", lines=4)
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            pair_input = gr.Textbox(
-                label="🔍 Trading Pair to Analyze", 
-                value=list(available_data.keys())[0] if available_data else "EURUSD", # Set default to first available pair
-                placeholder="Enter pair name (e.g., EURUSD, BTCUSD, AAPL)"
-            )
-            analyze_btn = gr.Button("🚀 Analyze Pair", variant="primary")
-        
-        with gr.Column(scale=3):
-            result_output = gr.Textbox(label="📝 Analysis & Forecast Summary", lines=6, max_lines=6)
-
-    # Tabs for Visual Output
     with gr.Tabs():
-        with gr.TabItem("📈 Price Chart & Indicators"):
-            price_chart = gr.Plot(label="Candlestick Chart with 20/50-period Moving Averages")
-            
-        with gr.TabItem("🔮 Price Forecast Chart"):
-            forecast_chart = gr.Plot(label="30-Day Price Forecast (Prophet Model)")
+        with gr.TabItem("Charts"):
+            with gr.Row():
+                price_chart = gr.Plot()
+                forecast_chart = gr.Plot()
+        with gr.TabItem("Table"):
+            forecast_table = gr.DataFrame()
             
-        with gr.TabItem("📋 Forecast Table"):
-            forecast_table = gr.DataFrame(
-                headers=["Date", "Predicted Price", "Lower Bound", "Upper Bound", "Trend"],
-                value=[],
-                datatype=["str", "str", "str", "str", "str"],
-                label="30-Day Predicted Prices Table",
-                interactive=False,
-                wrap=True
-            )
-    
-    with gr.Accordion("📁 Data & Usage Instructions", open=False):
-        gr.Markdown("""
-        ### How to Add Your Own Data (General Instrument Handling)
-        
-        1.  **Prepare your CSV file** with at least these columns:
-            -   **Date/Time** column (any reasonable format)
-            -   **Open, High, Low, Close** prices (case-insensitive column names are handled).
-        
-        2.  **Upload to Hugging Face Space**: Upload your CSV file(s) to the designated folder: `data/raw/`
-        
-        3.  **Restart the application**: Go to the Space Settings and select 'Restart Space'.
-        
-        4.  **Automatic Processing**: Your data will be automatically loaded, cleaned, and a new pair entry will appear in the 'Available Data' section, ready for analysis. The system is designed to generalize to *any* instrument/pair name you upload (e.g., `TSLA.csv`, `GBPCHF.csv`).
-        """)
-    
-    # Examples for quick testing
-    examples_list = [pair for pair in available_data.keys() if pair in ["EURUSD", "BTCUSD", "AAPL"]]
-    if examples_list:
-        gr.Examples(
-            examples=[[pair] for pair in examples_list],
-            inputs=pair_input,
-            label="Try these examples:"
-        )
-    
-    # Analysis function
-    analyze_btn.click(
-        fn=analyze_trading_pair,
-        inputs=pair_input,
-        outputs=[result_output, price_chart, forecast_chart, forecast_table]
-    )
+    analyze_btn.click(analyze_trading_pair, inputs=pair_input, outputs=[result_output, price_chart, forecast_chart, forecast_table])
 
-# Launch the app
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
+        share=False,
+        ssr_mode=False  # <--- CRITICAL FIX: Disables SSR to prevent KeyError: 1
     )