Fix Gradio compatibility issue

app.py

@@ -5,9 +5,15 @@ import plotly.graph_objects as go
 from prophet import Prophet
 import os
 import warnings
+import datetime
+import shutil # For moving files
+import traceback # For detailed error logging
+
+# Suppress all warnings for a cleaner output
 warnings.filterwarnings('ignore')
 
-# Performance optimization for Apple Silicon
+# --- Configuration and Environment Setup ---
+# Performance optimization for Apple Silicon/MKL based libraries
 os.environ["OMP_NUM_THREADS"] = "1"
 os.environ["OPENBLAS_NUM_THREADS"] = "1"
 os.environ["MKL_NUM_THREADS"] = "1"
@@ -17,24 +23,26 @@ RAW_DATA_DIR = "data/raw"
 PROCESSED_DATA_DIR = "data/processed"
 os.makedirs(PROCESSED_DATA_DIR, exist_ok=True)
 
-# Predefined trading pairs with expected formats
+# 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",
+        "description": "Euro to US Dollar Forex Pair (Sample)",
         "date_format": "%d.%m.%Y %H:%M:%S.%f %z",
         "has_timezone": True,
         "decimal_separator": ".",
         "required_columns": ["Open", "High", "Low", "Close"]
     },
     "BTCUSD": {
-        "description": "Bitcoin to US Dollar",
+        "description": "Bitcoin to US Dollar (Sample)",
         "date_format": "%Y-%m-%d %H:%M:%S",
         "has_timezone": False,
         "decimal_separator": ".",
         "required_columns": ["Open", "High", "Low", "Close"]
     },
     "AAPL": {
-        "description": "Apple Inc. Stock",
+        "description": "Apple Inc. Stock (Sample)",
         "date_format": "%Y-%m-%d",
         "has_timezone": False,
         "decimal_separator": ".",
@@ -42,35 +50,44 @@ TRADING_PAIRS = {
     }
 }
 
+# --- Data Preprocessing Functions ---
+
 def preprocess_data_file(raw_file_path, pair_name):
     """Preprocess raw data file to standardized format"""
     print(f"🔄 Preprocessing data for {pair_name}...")
     
+    # Get pair configuration, or use generic defaults for a new pair
+    config = TRADING_PAIRS.get(pair_name, {
+        "description": f"{pair_name} Trading Pair",
+        "date_format": None, # Use dynamic parsing for generic pairs
+        "has_timezone": False,
+        "decimal_separator": ".",
+        "required_columns": ["Open", "High", "Low", "Close"]
+    })
+
     try:
-        # Get pair configuration
-        config = TRADING_PAIRS.get(pair_name, TRADING_PAIRS["EURUSD"])
-        
-        # Read raw data with proper encoding
+        # Read raw data with robust encoding and generic delimiter detection
         encodings = ['utf-8', 'latin1', 'ISO-8859-1', 'cp1252']
         df = None
         
         for encoding in encodings:
             try:
-                df = pd.read_csv(raw_file_path, encoding=encoding)
+                # Attempt to read CSV, let pandas infer delimiter
+                df = pd.read_csv(raw_file_path, encoding=encoding, sep=None, engine='python')
                 print(f"✅ Successfully read {pair_name} data with {encoding} encoding")
                 break
             except (UnicodeDecodeError, pd.errors.ParserError):
                 continue
         
         if df is None:
-            raise Exception(f"❌ Failed to read {pair_name} data with any encoding")
+            raise Exception(f"❌ Failed to read {pair_name} data with any encoding/delimiter")
         
         # Standardize column names (case-insensitive)
         column_mapping = {}
         for col in df.columns:
-            col_lower = col.lower()
+            col_lower = col.lower().strip()
             
-            if any(keyword in col_lower for keyword in ['date', 'time', 'timestamp']):
+            if any(keyword in col_lower for keyword in ['date', 'time', 'timestamp', 'ds']):
                 column_mapping[col] = 'datetime'
             elif 'open' in col_lower:
                 column_mapping[col] = 'Open'
@@ -78,9 +95,9 @@ def preprocess_data_file(raw_file_path, pair_name):
                 column_mapping[col] = 'High'
             elif 'low' in col_lower:
                 column_mapping[col] = 'Low'
-            elif 'close' in col_lower:
+            elif 'close' in col_lower or 'price' in col_lower:
                 column_mapping[col] = 'Close'
-            elif 'volume' in col_lower:
+            elif 'volume' in col_lower or 'vol' in col_lower:
                 column_mapping[col] = 'Volume'
         
         if column_mapping:
@@ -89,33 +106,30 @@ def preprocess_data_file(raw_file_path, pair_name):
         
         # Process datetime column
         datetime_col = None
-        for col in ['datetime', 'date', 'time', 'timestamp']:
+        for col in ['datetime', 'ds']:
             if col in df.columns:
                 datetime_col = col
                 break
         
         if datetime_col is None:
-            raise Exception("❌ No datetime column found in data")
+            raise Exception("❌ No datetime column found in data after renaming")
         
-        # Handle special EURUSD format with GMT
+        # Handle special EURUSD format with GMT (if pair is specifically EURUSD)
         if pair_name == "EURUSD" and df[datetime_col].astype(str).str.contains('GMT').any():
             print("🕗 Handling EURUSD special datetime format...")
-            # Clean GMT format
-            df[datetime_col] = df[datetime_col].str.replace(' GMT', '', regex=False)
-            
-            # Parse with specified format
+            df[datetime_col] = df[datetime_col].astype(str).str.replace(' GMT', '', regex=False)
             df[datetime_col] = pd.to_datetime(
                 df[datetime_col], 
-                format=config['date_format'],
+                format=config['date_format'], # Use specific format for EURUSD
                 errors='coerce',
                 utc=True
             )
         else:
-            # Standard datetime parsing
+            # Use robust generic datetime parsing for all other cases
             df[datetime_col] = pd.to_datetime(
                 df[datetime_col], 
                 errors='coerce',
-                utc=config['has_timezone']
+                utc=config.get('has_timezone', False) # Use config setting if available
             )
         
         # Remove rows with invalid dates
@@ -127,13 +141,20 @@ def preprocess_data_file(raw_file_path, pair_name):
         df.set_index(datetime_col, inplace=True)
         df.sort_index(inplace=True)
         
-        # Handle decimal separators if needed
+        # Handle non-standard decimal separators (e.g., European format ',')
         if config['decimal_separator'] != '.':
+            print(f"🛠️ Fixing decimal separator from {config['decimal_separator']} to '.'")
             for col in ['Open', 'High', 'Low', 'Close', 'Volume']:
                 if col in df.columns:
-                    df[col] = df[col].astype(str).str.replace(',', '.').astype(float)
+                    # Convert to string, replace comma with dot, then convert to float
+                    df[col] = df[col].astype(str).str.replace(config['decimal_separator'], '.', regex=False).astype(float)
+        
+        # Ensure price columns are numeric
+        for col in ['Open', 'High', 'Low', 'Close']:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
         
-        # Fill missing values
+        # Fill missing values (only after numeric conversion)
         for col in ['Open', 'High', 'Low', 'Close']:
             if col in df.columns:
                 missing_before = df[col].isna().sum()
@@ -146,13 +167,15 @@ def preprocess_data_file(raw_file_path, pair_name):
         df = df[~df.index.duplicated(keep='first')]
         print(f"🧹 Removed {before_count - len(df)} duplicate entries")
         
-        # Validate required columns
+        # Final validation
         missing_cols = [col for col in config['required_columns'] if col not in df.columns]
         if missing_cols:
-            print(f"❌ Missing required columns: {missing_cols}")
-            print(f"Available columns: {df.columns.tolist()}")
+            print(f"❌ Missing required columns: {missing_cols}. Available: {df.columns.tolist()}")
             return None
         
+        if len(df) < 2:
+            raise Exception("Dataset has fewer than 2 valid rows after preprocessing.")
+            
         # Save preprocessed data
         processed_file = os.path.join(PROCESSED_DATA_DIR, f"{pair_name}_processed.csv")
         df.to_csv(processed_file)
@@ -162,44 +185,47 @@ def preprocess_data_file(raw_file_path, pair_name):
         
     except Exception as e:
         print(f"❌ Preprocessing error for {pair_name}: {str(e)}")
+        traceback.print_exc()
         return None
 
 def load_available_data():
-    """Load and preprocess all available data files"""
+    """Load and preprocess all available data files, handling raw folder creation."""
+    global TRADING_PAIRS, available_data
     available_data = {}
     
-    # Check if raw data directory exists
+    # Check if data exists in a generic 'data' folder and move it to 'data/raw'
     if not os.path.exists(RAW_DATA_DIR):
-        print(f"⚠️ Raw data directory not found: {RAW_DATA_DIR}")
-        # Check if data is in root directory instead
+        print(f"⚠️ Raw data directory not found: {RAW_DATA_DIR}. Checking 'data/'...")
         if os.path.exists("data") and os.path.isdir("data"):
-            for filename in os.listdir("data"):
-                if filename.endswith('.csv'):
-                    # Create raw directory structure
-                    os.makedirs(RAW_DATA_DIR, exist_ok=True)
-                    # Move file to raw directory
-                    import shutil
-                    shutil.move(os.path.join("data", filename), os.path.join(RAW_DATA_DIR, filename))
-                    print(f"✅ Moved {filename} to {RAW_DATA_DIR}")
-    
-    # Check again after potential move
+            csv_files = [f for f in os.listdir("data") if f.endswith('.csv')]
+            if csv_files:
+                os.makedirs(RAW_DATA_DIR, exist_ok=True)
+                for filename in csv_files:
+                    try:
+                        shutil.move(os.path.join("data", filename), os.path.join(RAW_DATA_DIR, filename))
+                        print(f"✅ Moved {filename} to {RAW_DATA_DIR}")
+                    except Exception as e:
+                        print(f"⚠️ Could not move {filename}: {e}")
+            else:
+                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}")
+        print(f"❌ Still cannot find raw data directory: {RAW_DATA_DIR}. Please check your file structure.")
         return available_data
     
     print(f"🔍 Scanning for data files in {RAW_DATA_DIR}...")
     
-    # Scan for CSV files in raw data directory
     for filename in os.listdir(RAW_DATA_DIR):
         if filename.endswith('.csv'):
-            # Extract pair name from filename
+            # Extract pair name from filename (e.g., EURUSD.csv -> EURUSD)
             pair_name = filename.split('.')[0].upper()
             
-            # Check if we have config for this pair, or use default
+            # --- Generalization Improvement ---
+            # If pair is not in TRADING_PAIRS, add it with generic defaults
             if pair_name not in TRADING_PAIRS:
                 TRADING_PAIRS[pair_name] = {
-                    "description": f"{pair_name} Trading Pair",
-                    "date_format": "%Y-%m-%d %H:%M:%S",
+                    "description": f"{pair_name} Trading Pair (Generic)",
+                    "date_format": None, # Indicates dynamic parsing
                     "has_timezone": False,
                     "decimal_separator": ".",
                     "required_columns": ["Open", "High", "Low", "Close"]
@@ -208,19 +234,19 @@ 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 if preprocessed file exists and is newer than raw file
+            # Check for existing preprocessed 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)
                 
                 if processed_mod_time > raw_mod_time:
-                    print(f"✅ Using existing preprocessed data for {pair_name}")
                     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")
                         continue
                     except Exception as e:
-                        print(f"⚠️ Error loading preprocessed file: {str(e)}")
+                        print(f"⚠️ Error loading preprocessed file for {pair_name}: {str(e)}. Reprocessing.")
             
             # Preprocess the file
             print(f"🔄 Processing {pair_name} data...")
@@ -229,68 +255,75 @@ def load_available_data():
                 available_data[pair_name] = df
                 print(f"✅ Successfully loaded {pair_name} with {len(df)} records")
             else:
-                print(f"❌ Failed to load {pair_name} data")
+                print(f"❌ Failed to load {pair_name} data. See error above.")
     
     return available_data
 
-# Load available data at startup
-print("🚀 Initializing data processing system...")
-available_data = load_available_data()
-print(f"📊 Available trading pairs: {list(available_data.keys())}")
+# --- Analysis Functions ---
 
 def get_available_pairs():
-    """Get list of available trading pairs with status"""
+    """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."
+        return "⚠️ No data files found. Please upload CSV files to the 'data/raw' directory and restart the app."
     
     status = "✅ Available trading pairs:\n"
     for pair in sorted(available_data.keys()):
         df = available_data[pair]
         records = len(df)
-        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"
+        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):
-    """Analyze a specific trading pair"""
+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
+    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")
+    default_error_df = gr.DataFrame(headers=["Error"], value=[["Analysis failed"]])
+    
+    # Check if data is available (case-insensitive search)
+    matched_pair = None
+    for available_pair in available_data.keys():
+        if pair_name == available_pair or pair_name.upper() == available_pair.upper():
+            matched_pair = available_pair
+            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
+        )
+    
+    pair_name = matched_pair
+    hist = available_data[pair_name].copy()
+    
     try:
-        print(f"\n🔍 Starting analysis for {pair_name}")
-        
-        # Check if data is available
-        if pair_name not in available_data:
-            # Try case-insensitive match
-            matched_pair = None
-            for available_pair in available_data.keys():
-                if pair_name.upper() == available_pair.upper():
-                    matched_pair = available_pair
-                    break
+        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
+            )
             
-            if matched_pair is None:
-                available_pairs = ", ".join(available_data.keys())
-                return (
-                    f"❌ Data not available for '{pair_name}'\n"
-                    f"Available pairs: {available_pairs}\n"
-                    f"Upload your data to 'data/raw' directory and restart the app",
-                    None, None, None
-                )
-            pair_name = matched_pair
-        
-        # Get the data
-        hist = available_data[pair_name].copy()
-        print(f"📈 Loaded {len(hist)} records for {pair_name}")
-        
         # Basic data validation
         required_cols = ['Open', 'High', 'Low', 'Close']
-        missing_cols = [col for col in required_cols if col not in hist.columns]
-        
-        if missing_cols:
+        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)}\n"
-                f"Available columns: {', '.join(hist.columns)}",
-                None, None, None
+                f"❌ Missing required columns: {', '.join(missing_cols)}\nAvailable columns: {', '.join(hist.columns)}",
+                default_error_fig, default_error_fig, default_error_df
             )
         
-        # Create candlestick chart
+        # --- 1. Candlestick Chart with Technical Indicators (MAs) ---
         fig = go.Figure()
         
         # Add candlestick
@@ -303,48 +336,32 @@ def analyze_trading_pair(pair_name):
             name='Price'
         ))
         
-        # Add moving averages if enough data
+        # 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)
-            ))
+            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA20'], mode='lines', name='20-period 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)
-            ))
-        
-        # Update layout
+            fig.add_trace(go.Scatter(x=hist.index, y=hist['MA50'], mode='lines', name='50-period 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,
-            margin=dict(l=50, r=50, t=50, b=50)
         )
         
-        # Create forecast using Prophet
-        forecast_fig = None
-        forecast_table = None
-        forecast_result = ""
+        # --- 2. Forecasting using Prophet ---
+        forecast_fig = default_error_fig
+        forecast_table = default_error_df
+        forecast_result = "No forecast data available"
         
         try:
-            print("🔮 Starting forecast generation...")
-            
-            # Prepare data for Prophet - USE ONLY RECENT DATA TO AVOID MEMORY ISSUES
-            # Take last 365 days (1 year) of data for forecasting
+            # 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()
@@ -352,172 +369,149 @@ def analyze_trading_pair(pair_name):
             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)"
-                print(forecast_result)
+                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:
-                # Create and fit model - WITH EXPLICIT ERROR HANDLING
-                try:
-                    print("⚙️ Creating Prophet model...")
-                    model = Prophet(
-                        daily_seasonality=True,
-                        yearly_seasonality=True,
-                        interval_width=0.95,
-                        changepoint_prior_scale=0.05,
-                        stan_backend=None  # CRITICAL FIX
-                    )
-                    
-                    print("🔧 Fitting model to data...")
-                    model.fit(prophet_df)
-                    print("✅ Model fitted successfully")
-                    
-                    # Create future dataframe (30 days forecast)
-                    print("📅 Generating 30-day forecast...")
-                    future = model.make_future_dataframe(periods=30, freq='D')
-                    forecast = model.predict(future)
-                    print(f"✅ Generated forecast for {len(forecast)} periods")
-                    
-                    # Create 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 data
-                    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')
-                    ))
-                    
-                    # 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"
-                    )
-                    
-                    # Create forecast table (next 30 days only)
-                    future_dates = forecast[forecast['ds'] > prophet_df['ds'].max()].head(30)
-                    
-                    # Format dates and prices
-                    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['yhat'].diff().apply(
-                        lambda x: "📈 Rising" if x > 0 else "📉 Falling" if x < 0 else "➡️ Stable"
-                    )
-                    
-                    # Create table data
-                    table_data = future_dates[['Date', 'Predicted Price', 'Lower Bound', 'Upper Bound', 'Trend']].values.tolist()
-                    table_headers = ["Date", "Predicted Price", "Lower Bound", "Upper Bound", "Trend"]
-                    
-                    forecast_table = gr.DataFrame(
-                        headers=table_headers,
-                        value=table_data,
-                        datatype=["str", "str", "str", "str", "str"],
-                        label=f"{pair_name} 30-Day Price Forecast Table",
-                        interactive=False
-                    )
-                    
-                    # Get last forecast values
-                    last_forecast = forecast.iloc[-1]
-                    forecast_result = (
-                        f"🔮 30-Day Forecast:\n"
-                        f"Predicted price: {last_forecast['yhat']:.5f}\n"
-                        f"Range: {last_forecast['yhat_lower']:.5f} to {last_forecast['yhat_upper']:.5f}"
-                    )
-                    print("✅ Forecast generated successfully")
+                # Initialize Prophet model with CRITICAL FIX (stan_backend=None)
+                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
+                )
+                
+                # 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
+                     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_fig = go.Figure()
                 
-                except Exception as model_error:
-                    error_details = str(model_error)
-                    if "MemoryError" in error_details:
-                        forecast_result = "⚠️ Memory error during forecasting. Try reducing data size."
-                    elif "ValueError" in error_details:
-                        forecast_result = f"⚠️ Data format error: {error_details}"
-                    else:
-                        forecast_result = f"⚠️ Model error: {error_details}"
-                    print(f"❌ Forecasting failed: {forecast_result}")
-                    import traceback
-                    traceback.print_exc()
-        
-        except Exception as e:
-            forecast_result = f"⚠️ Unexpected forecasting error: {str(e)}"
-            print(forecast_result)
-            import traceback
+                # 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 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')))
+                
+                # 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"
+                )
+                
+                # Create 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"]
+                
+                forecast_table = gr.DataFrame(headers=table_headers, value=table_data)
+                
+                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}"
+                )
+                print("✅ Forecast generated successfully")
+                
+        except Exception as model_error:
+            forecast_result = f"⚠️ Forecasting failed. Error: {str(model_error)}"
+            print(f"❌ Forecasting failed: {forecast_result}")
             traceback.print_exc()
-        
-        # Technical analysis
+
+        # --- 3. Technical Analysis Signal & Metrics ---
         current_price = hist['Close'].iloc[-1]
         signal = "📊 Analyzing market conditions..."
         
-        if 'MA20' in hist.columns:
+        # Signal based on MAs
+        if 'MA50' in hist.columns and 'MA20' in hist.columns:
             ma20 = hist['MA20'].iloc[-1]
-            if current_price > ma20:
-                signal = "📈 BULLISH: Price above 20-period MA"
-            else:
-                signal = "📉 BEARISH: Price below 20-period MA"
-        
-        if 'MA50' in hist.columns:
             ma50 = hist['MA50'].iloc[-1]
+            
             if current_price > ma20 and ma20 > ma50:
-                signal = "🚀 STRONG BULLISH: Golden Cross pattern"
+                signal = "🚀 **STRONG BULLISH**: Price above 20MA, and 20MA > 50MA (Golden Cross potential)"
             elif current_price < ma20 and ma20 < ma50:
-                signal = "💣 STRONG BEARISH: Death Cross pattern"
+                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
-        volatility = hist['Close'].pct_change().std() * np.sqrt(252) * 100  # Annualized volatility
         
-        # Create result text
+        # 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"{'=' * 40}\n"
-            f"💰 Current Price: {current_price:.5f}\n"
-            f"📈 Total Return: {total_return:.2f}%\n"
-            f"⚡ Volatility: {volatility:.2f}%\n"
-            f"🎯 Signal: {signal}\n"
-            f"{'=' * 40}\n"
+            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"{forecast_result}"
         )
         
         print(f"✅ Analysis completed for {pair_name}")
         return result_text, fig, forecast_fig, forecast_table
-    
+        
     except Exception as e:
-        error_msg = f"❌ Analysis error: {str(e)}"
+        error_msg = f"❌ Major Analysis Error for {pair_name}: {str(e)}"
         print(error_msg)
-        import traceback
         traceback.print_exc()
-        return error_msg, None, None, None
+        
+        return (
+            error_msg,
+            default_error_fig, 
+            default_error_fig, 
+            default_error_df
+        )
+
+# --- Application Initialization ---
+
+print("🚀 Initializing data processing system...")
+available_data = load_available_data()
+print(f"📊 Available trading pairs: {list(available_data.keys())}")
+
+# --- Gradio Interface ---
 
-# Create Gradio interface
 with gr.Blocks(title="Trading Pair AI Analyzer") as demo:
     gr.Markdown("# 📈 Trading Pair AI Analysis System")
-    gr.Markdown("### Analyze forex, stocks, and crypto with AI-powered insights")
+    gr.Markdown("### Analyze financial instruments with interactive charts and 30-day AI-powered forecasts (Prophet)")
     
     with gr.Row():
         with gr.Column(scale=2):
@@ -525,85 +519,75 @@ with gr.Blocks(title="Trading Pair AI Analyzer") as demo:
                 label="📊 Available Data", 
                 value=get_available_pairs(),
                 interactive=False,
-                lines=5
+                lines=5,
+                autoscroll=True
             )
         
         with gr.Column(scale=1):
             gr.Markdown("### ℹ️ System Information")
             system_info = gr.Textbox(
-                value=f"📈 Trading Analysis System v2.1\n"
-                      f"🕒 Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-                      f"🧮 Loaded pairs: {len(available_data)}",
-                interactive=False
+                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
             )
     
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=2):
             pair_input = gr.Textbox(
-                label="🔍 Trading Pair", 
-                value="EURUSD",
+                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", variant="primary")
-        
-        with gr.Column():
-            gr.Markdown("### 💡 Quick Tips")
-            gr.Markdown("""
-            - Use pair names from the available data list
-            - System automatically preprocesses your data
-            - First analysis may take 30-60 seconds
-            - Forecast table shows next 30 days of predicted prices
-            """)
-    
-    result_output = gr.Textbox(label="📝 Analysis Results", lines=8)
-    
-    with gr.Tabs():
-        with gr.TabItem("📊 Charts"):
-            with gr.Row():
-                price_chart = gr.Plot(label="📊 Price Chart & Technical Indicators")
-                forecast_chart = gr.Plot(label="🔮 30-Day Price Forecast")
+            analyze_btn = gr.Button("🚀 Analyze Pair", variant="primary")
         
-        with gr.TabItem("📈 Forecast Table"):
+        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("📋 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 Price Forecast Table",
-                interactive=False
+                label="30-Day Predicted Prices Table",
+                interactive=False,
+                wrap=True
             )
     
-    with gr.Accordion("📁 Data Upload Instructions", open=False):
+    with gr.Accordion("📁 Data & Usage Instructions", open=False):
         gr.Markdown("""
-        ### How to Add Your Own Data
+        ### How to Add Your Own Data (General Instrument Handling)
         
-        1. **Prepare your CSV file** with these columns:
-           - Date/Time column (any format)
-           - Open, High, Low, Close prices
-           - Volume (optional)
+        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**:
-           - Go to your Space Files tab
-           - Create directories: `data/raw/`
-           - Upload your CSV files to `data/raw/`
-           - Example filenames: `EURUSD.csv`, `BTCUSD.csv`
+        2.  **Upload to Hugging Face Space**: Upload your CSV file(s) to the designated folder: `data/raw/`
         
-        3. **Restart the application**:
-           - Go to Settings → Restart Space
-           - Wait 2-3 minutes for rebuild
+        3.  **Restart the application**: Go to the Space Settings and select 'Restart Space'.
         
-        4. **Your data will be automatically preprocessed** and ready for analysis!
+        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 = gr.Examples(
-        examples=[
-            ["EURUSD"],
-            ["BTCUSD"],
-            ["AAPL"]
-        ],
-        inputs=pair_input,
-        label="Try these examples:"
-    )
+    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(