Complete trading analysis system with preprocessing

app.py

@@ -1,360 +1,541 @@
 import gradio as gr
 import pandas as pd
+import numpy as np
 import plotly.graph_objects as go
 from prophet import Prophet
 import os
-import numpy as np
-from datetime import datetime
+import re
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
 
-# 设置环境变量（优化M1芯片性能）
+# Performance optimization for Apple Silicon
 os.environ["OMP_NUM_THREADS"] = "1"
 os.environ["OPENBLAS_NUM_THREADS"] = "1"
 os.environ["MKL_NUM_THREADS"] = "1"
 
-# 预加载所有数据文件
-DATA_DIR = "data"
-available_tickers = {}
+# Define data directories
+RAW_DATA_DIR = "data/raw"
+PROCESSED_DATA_DIR = "data/processed"
+os.makedirs(PROCESSED_DATA_DIR, exist_ok=True)
 
-# 检查data目录是否存在
-if os.path.exists(DATA_DIR):
-    for filename in os.listdir(DATA_DIR):
-        if filename.endswith(".csv"):
-            ticker_name = filename.replace(".csv", "").upper()
-            file_path = os.path.join(DATA_DIR, filename)
+# Predefined trading pairs with expected formats
+TRADING_PAIRS = {
+    "EURUSD": {
+        "description": "Euro to US Dollar Forex Pair",
+        "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",
+        "date_format": "%Y-%m-%d %H:%M:%S",
+        "has_timezone": False,
+        "decimal_separator": ".",
+        "required_columns": ["Open", "High", "Low", "Close"]
+    },
+    "AAPL": {
+        "description": "Apple Inc. Stock",
+        "date_format": "%Y-%m-%d",
+        "has_timezone": False,
+        "decimal_separator": ".",
+        "required_columns": ["Open", "High", "Low", "Close", "Volume"]
+    }
+}
+
+def preprocess_data_file(raw_file_path, pair_name):
+    """Preprocess raw data file to standardized format"""
+    print(f"🔄 Preprocessing data for {pair_name}...")
+    
+    try:
+        # Get pair configuration
+        config = TRADING_PAIRS.get(pair_name, TRADING_PAIRS["EURUSD"])
+        
+        # Read raw data with proper encoding
+        encodings = ['utf-8', 'latin1', 'ISO-8859-1', 'cp1252']
+        df = None
+        
+        for encoding in encodings:
             try:
-                # 尝试不同编码读取
-                encodings = ['utf-8', 'gbk', 'latin1', 'ISO-8859-1']
-                df = None
+                df = pd.read_csv(raw_file_path, encoding=encoding)
+                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")
+        
+        # Standardize column names (case-insensitive)
+        column_mapping = {}
+        for col in df.columns:
+            col_lower = col.lower()
+            
+            if any(keyword in col_lower for keyword in ['date', 'time', 'timestamp']):
+                column_mapping[col] = 'datetime'
+            elif 'open' in col_lower:
+                column_mapping[col] = 'Open'
+            elif 'high' in col_lower:
+                column_mapping[col] = 'High'
+            elif 'low' in col_lower:
+                column_mapping[col] = 'Low'
+            elif 'close' in col_lower:
+                column_mapping[col] = 'Close'
+            elif 'volume' in col_lower:
+                column_mapping[col] = 'Volume'
+        
+        if column_mapping:
+            df.rename(columns=column_mapping, inplace=True)
+            print(f"🏷️ Standardized columns: {list(column_mapping.keys())} → {list(column_mapping.values())}")
+        
+        # Process datetime column
+        datetime_col = None
+        for col in ['datetime', 'date', 'time', 'timestamp']:
+            if col in df.columns:
+                datetime_col = col
+                break
+        
+        if datetime_col is None:
+            raise Exception("❌ No datetime column found in data")
+        
+        # Handle special EURUSD format with GMT
+        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] = pd.to_datetime(
+                df[datetime_col], 
+                format=config['date_format'],
+                errors='coerce',
+                utc=True
+            )
+        else:
+            # Standard datetime parsing
+            df[datetime_col] = pd.to_datetime(
+                df[datetime_col], 
+                errors='coerce',
+                utc=config['has_timezone']
+            )
+        
+        # Remove rows with invalid dates
+        before_count = len(df)
+        df = df.dropna(subset=[datetime_col])
+        print(f"🧹 Removed {before_count - len(df)} rows with invalid dates")
+        
+        # Set datetime as index
+        df.set_index(datetime_col, inplace=True)
+        df.sort_index(inplace=True)
+        
+        # Handle decimal separators if needed
+        if config['decimal_separator'] != '.':
+            for col in ['Open', 'High', 'Low', 'Close', 'Volume']:
+                if col in df.columns:
+                    df[col] = df[col].astype(str).str.replace(',', '.').astype(float)
+        
+        # Fill missing values
+        for col in ['Open', 'High', 'Low', 'Close']:
+            if col in df.columns:
+                missing_before = df[col].isna().sum()
+                if missing_before > 0:
+                    df[col] = df[col].fillna(method='ffill').fillna(method='bfill')
+                    print(f"  🔄 Filled {missing_before} missing values in {col}")
+        
+        # Remove duplicates
+        before_count = len(df)
+        df = df[~df.index.duplicated(keep='first')]
+        print(f"🧹 Removed {before_count - len(df)} duplicate entries")
+        
+        # Validate required columns
+        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()}")
+            return None
+        
+        # Save preprocessed data
+        processed_file = os.path.join(PROCESSED_DATA_DIR, f"{pair_name}_processed.csv")
+        df.to_csv(processed_file)
+        print(f"✅ Saved preprocessed data to {processed_file}")
+        
+        return df
+        
+    except Exception as e:
+        print(f"❌ Preprocessing error for {pair_name}: {str(e)}")
+        return None
+
+def load_available_data():
+    """Load and preprocess all available data files"""
+    available_data = {}
+    
+    if not os.path.exists(RAW_DATA_DIR):
+        print(f"⚠️ Raw data directory not found: {RAW_DATA_DIR}")
+        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
+            pair_name = filename.split('.')[0].upper()
+            
+            # Check if we have config for this pair, or use default
+            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",
+                    "has_timezone": False,
+                    "decimal_separator": ".",
+                    "required_columns": ["Open", "High", "Low", "Close"]
+                }
+            
+            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
+            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)
                 
-                for encoding in encodings:
+                if processed_mod_time > raw_mod_time:
+                    print(f"✅ Using existing preprocessed data for {pair_name}")
                     try:
-                        df = pd.read_csv(file_path, encoding=encoding)
-                        print(f"成功使用 {encoding} 编码加载 {filename}")
-                        break
-                    except UnicodeDecodeError:
+                        df = pd.read_csv(processed_file_path, index_col=0, parse_dates=True)
+                        available_data[pair_name] = df
                         continue
-                
-                if df is None:
-                    raise Exception("无法解码文件")
-                
-                # 自动检测日期列
-                date_col = None
-                for col in df.columns:
-                    if 'date' in col.lower() or 'time' in col.lower():
-                        date_col = col
-                        break
-                
-                # 如果没有找到日期列，尝试第一列
-                if date_col is None and len(df.columns) > 0:
-                    date_col = df.columns[0]
-                
-                # 转换日期列
-                if date_col:
-                    df[date_col] = pd.to_datetime(df[date_col], errors='coerce')
-                    df = df.dropna(subset=[date_col])
-                    df.set_index(date_col, inplace=True)
-                
-                # 检查必需的列
-                required_columns = ['Open', 'High', 'Low', 'Close']
-                found_columns = [col for col in required_columns if col in df.columns]
-                
-                if len(found_columns) < 3:  # 至少需要3列
-                    print(f"警告: {filename} 缺少必要列，将跳过")
-                    continue
-                
-                available_tickers[ticker_name] = {
-                    "file": file_path,
-                    "data": df
-                }
-                print(f"✅ 成功加载: {ticker_name} ({len(df)} 条记录)")
-            except Exception as e:
-                print(f"❌ 加载失败 {filename}: {str(e)}")
-else:
-    print(f"⚠️ 警告: 数据目录不存在 - {DATA_DIR}")
+                    except Exception as e:
+                        print(f"⚠️ Error loading preprocessed file: {str(e)}")
+            
+            # Preprocess the file
+            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")
+            else:
+                print(f"❌ Failed to load {pair_name} data")
+    
+    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())}")
+
+def get_available_pairs():
+    """Get list of available trading pairs with status"""
+    if not available_data:
+        return "⚠️ No data files found. Please upload CSV files to the 'data/raw' directory."
+    
+    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"
+    return status
 
-def analyze_stock(ticker):
-    """分析股票/外汇数据"""
+def analyze_trading_pair(pair_name):
+    """Analyze a specific trading pair"""
     try:
-        # 检查是否有可用数据
-        if not available_tickers:
-            return "❌ 错误: 没有找到任何数据文件。请检查data/目录", None, None
-        
-        # 模糊匹配股票代码
-        ticker_upper = ticker.upper()
-        matched_ticker = None
+        print(f"\n🔍 Starting analysis for {pair_name}")
         
-        # 尝试精确匹配
-        if ticker_upper in available_tickers:
-            matched_ticker = ticker_upper
-        else:
-            # 尝试部分匹配
-            for name in available_tickers.keys():
-                if ticker_upper in name or name in ticker_upper:
-                    matched_ticker = 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 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
+                )
+            pair_name = matched_pair
         
-        if not matched_ticker:
-            return (f"❌ 未找到匹配的数据: {ticker}\n"
-                    f"可用数据: {', '.join(available_tickers.keys())}"), None, None
-        
-        # 获取数据
-        hist = available_tickers[matched_ticker]["data"].copy()
+        # 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:
-            # 尝试查找相似列名
-            col_mapping = {}
-            for col in missing_cols:
-                for existing_col in hist.columns:
-                    if col.lower() in existing_col.lower() or existing_col.lower() in col.lower():
-                        col_mapping[existing_col] = col
-            
-            if col_mapping:
-                hist.rename(columns=col_mapping, inplace=True)
-                missing_cols = [col for col in required_cols if col not in hist.columns]
-            
-            if missing_cols:
-                return (f"❌ 数据格式错误: 缺少必要列: {', '.join(missing_cols)}\n"
-                        f"可用列: {', '.join(hist.columns)}"), None, None
+            return (
+                f"❌ Missing required columns: {', '.join(missing_cols)}\n"
+                f"Available columns: {', '.join(hist.columns)}",
+                None, None
+            )
+        
+        # Create candlestick chart
+        fig = go.Figure()
         
-        # 创建K线图
-        fig = go.Figure(data=[go.Candlestick(
+        # Add candlestick
+        fig.add_trace(go.Candlestick(
             x=hist.index,
             open=hist['Open'],
             high=hist['High'],
             low=hist['Low'],
             close=hist['Close'],
-            name='价格'
-        )])
+            name='Price'
+        ))
         
-        # 添加移动平均线
+        # Add moving averages if enough data
         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日均线',
+                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日均线',
+                x=hist.index,
+                y=hist['MA50'],
+                mode='lines',
+                name='50-period MA',
                 line=dict(color='orange', width=1.5)
             ))
         
+        # Update layout
         fig.update_layout(
-            title=f"{matched_ticker} 价格走势 (本地数据)",
-            xaxis_title="日期",
-            yaxis_title="价格",
+            title=f"{pair_name} Price Analysis",
+            xaxis_title="Date",
+            yaxis_title="Price",
             template="plotly_white",
             hovermode="x unified",
-            height=500
+            height=500,
+            margin=dict(l=50, r=50, t=50, b=50)
         )
         
-        # 预测 - 使用Prophet (修复版本)
+        # Create forecast using Prophet
+        forecast_fig = None
+        forecast_result = ""
+        
         try:
-            # 准备数据
-            df = hist[['Close']].reset_index()
-            df.columns = ['ds', 'y']
-            
-            # 移除NaN值
-            df = df.dropna()
-            
-            # 确保有足够数据
-            if len(df) < 30:
-                raise ValueError("数据点不足，无法进行预测")
-            
-            # 创建并拟合模型 (修复: 移除stan_backend)
-            model = Prophet(
-                daily_seasonality=True,
-                yearly_seasonality=True,
-                interval_width=0.95,
-                uncertainty_samples=1000
-            )
-            
-            model.fit(df)
-            
-            # 创建未来数据框 (30天预测)
-            future = model.make_future_dataframe(periods=30, freq='D')
-            forecast = model.predict(future)
+            # Prepare data for Prophet
+            prophet_df = hist[['Close']].reset_index()
+            prophet_df.columns = ['ds', 'y']
+            prophet_df = prophet_df.dropna()
             
-            # 预测图表
-            fig2 = go.Figure()
-            
-            # 历史数据
-            fig2.add_trace(go.Scatter(
-                x=df['ds'], 
-                y=df['y'], 
-                mode='lines', 
-                name='历史价格',
-                line=dict(color='blue', width=2)
-            ))
-            
-            # 预测数据
-            fig2.add_trace(go.Scatter(
-                x=forecast['ds'], 
-                y=forecast['yhat'], 
-                mode='lines', 
-                name='预测价格',
-                line=dict(color='red', width=2, dash='dash')
-            ))
-            
-            # 预测区间
-            fig2.add_trace(go.Scatter(
-                x=forecast['ds'].tolist() + forecast['ds'][::-1].tolist(),
-                y=forecast['yhat_upper'].tolist() + forecast['yhat_lower'][::-1].tolist(),
-                fill='toself',
-                fillcolor='rgba(255,0,0,0.1)',
-                line=dict(color='rgba(255,255,255,0)'),
-                name='置信区间'
-            ))
-            
-            fig2.update_layout(
-                title=f"{matched_ticker} 30天价格预测",
-                xaxis_title="日期",
-                yaxis_title="价格",
-                template="plotly_white",
-                hovermode="x unified",
-                height=500
-            )
-            
-        except Exception as e:
-            print(f"预测错误: {str(e)}")
-            fig2 = None
-            forecast_error = str(e)
-        
-        # 技术指标计算
-        if 'MA20' not in hist.columns and len(hist) >= 20:
-            hist['MA20'] = hist['Close'].rolling(20).mean()
+            if len(prophet_df) < 30:
+                forecast_result = "⚠️ Not enough data points for reliable forecasting (need at least 30)"
+            else:
+                # Create and fit model
+                model = Prophet(
+                    daily_seasonality=True,
+                    yearly_seasonality=True,
+                    interval_width=0.95,
+                    changepoint_prior_scale=0.05
+                )
+                
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    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()
+                
+                # Historical data
+                forecast_fig.add_trace(go.Scatter(
+                    x=prophet_df['ds'],
+                    y=prophet_df['y'],
+                    mode='lines',
+                    name='Historical',
+                    line=dict(color='blue', width=2)
+                ))
+                
+                # Forecast data
+                forecast_fig.add_trace(go.Scatter(
+                    x=forecast['ds'],
+                    y=forecast['yhat'],
+                    mode='lines',
+                    name='Forecast',
+                    line=dict(color='red', width=2, dash='dash')
+                ))
+                
+                # Confidence interval
+                forecast_fig.add_trace(go.Scatter(
+                    x=forecast['ds'].tolist() + forecast['ds'][::-1].tolist(),
+                    y=forecast['yhat_upper'].tolist() + forecast['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"
+                )
+                
+                # 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}"
+                )
         
-        if 'MA50' not in hist.columns and len(hist) >= 50:
-            hist['MA50'] = hist['Close'].rolling(50).mean()
+        except Exception as e:
+            forecast_result = f"⚠️ Forecasting error: {str(e)}"
+            print(forecast_result)
         
+        # Technical analysis
         current_price = hist['Close'].iloc[-1]
-        ma20 = hist['MA20'].iloc[-1] if 'MA20' in hist.columns else None
-        ma50 = hist['MA50'].iloc[-1] if 'MA50' in hist.columns else None
+        signal = "📊 Analyzing market conditions..."
         
-        # 信号判断
-        signal = "🔍 数据不足，无法判断信号"
-        if ma20 is not None:
+        if 'MA20' in hist.columns:
+            ma20 = hist['MA20'].iloc[-1]
             if current_price > ma20:
-                signal = "📈 看涨 (价格 > 20日均线)"
+                signal = "📈 BULLISH: Price above 20-period MA"
             else:
-                signal = "📉 看跌 (价格 < 20日均线)"
+                signal = "📉 BEARISH: Price below 20-period MA"
         
-        if ma20 is not None and ma50 is not None:
-            if current_price > ma20 > ma50:
-                signal = "🚀 强烈看涨 (黄金交叉)"
-            elif current_price < ma20 < ma50:
-                signal = "💣 强烈看跌 (死亡交叉)"
+        if 'MA50' in hist.columns:
+            ma50 = hist['MA50'].iloc[-1]
+            if current_price > ma20 and ma20 > ma50:
+                signal = "🚀 STRONG BULLISH: Golden Cross pattern"
+            elif current_price < ma20 and ma20 < ma50:
+                signal = "💣 STRONG BEARISH: Death Cross pattern"
         
-        # 计算回报率
-        period_return = (current_price / hist['Close'].iloc[0] - 1) * 100
+        # 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
         result_text = (
-            f"📊 {matched_ticker} 分析报告\n"
-            f"💰 当前价格: {current_price:.5f}\n"
-            f"📈 20日均线: {ma20:.5f}\n" if ma20 is not None else ""
-            f"📉 50日均线: {ma50:.5f}\n" if ma50 is not None else ""
-            f"🎯 交易信号: {signal}\n"
-            f"📊 总回报率: {period_return:.2f}%\n"
-            f"💾 数据记录: {len(hist)} 条\n"
-            f"🕒 更新时间: {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+            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"{forecast_result}"
         )
         
-        return result_text, fig, fig2
-        
+        print(f"✅ Analysis completed for {pair_name}")
+        return result_text, fig, forecast_fig
+    
     except Exception as e:
-        error_msg = f"❌ 分析错误: {str(e)}"
+        error_msg = f"❌ Analysis error: {str(e)}"
         print(error_msg)
+        import traceback
+        traceback.print_exc()
         return error_msg, None, None
 
-def list_available_data():
-    """列出可用数据"""
-    if not available_tickers:
-        return "⚠️ 未找到数据文件。请将CSV文件放入data/目录"
-    return "✅ 可用数据: " + ", ".join(available_tickers.keys())
-
-def get_app_version():
-    """获取应用版本信息"""
-    return f"📈 外汇/股票AI分析系统 v2.1\n" \
-           f"🕒 最后更新: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n" \
-           f"📊 可用数据集: {len(available_tickers)}"
-
-# 创建Gradio界面
-with gr.Blocks(title="外汇AI分析系统", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📈 外汇/股票AI分析系统 (本地数据版)")
-    gr.Markdown("✅ 优势: 无需网络，数据稳定，隐私安全，适合中长期分析")
+# Create Gradio interface
+with gr.Blocks(title="Trading Pair AI Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📈 Trading Pair AI Analysis System")
+    gr.Markdown("### Analyze forex, stocks, and crypto with AI-powered insights")
     
-    # 状态信息
     with gr.Row():
-        version_info = gr.Textbox(label="系统信息", value=get_app_version(), interactive=False)
-        data_status = gr.Textbox(label="数据状态", value=list_available_data(), interactive=False)
+        with gr.Column(scale=2):
+            data_status = gr.Textbox(
+                label="📊 Available Data", 
+                value=get_available_pairs(),
+                interactive=False,
+                lines=5
+            )
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### ℹ️ System Information")
+            system_info = gr.Textbox(
+                value=f"📈 Trading Analysis System v2.0\n"
+                      f"🕒 Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+                      f"🧮 Loaded pairs: {len(available_data)}",
+                interactive=False
+            )
     
-    # 分析区域
     with gr.Row():
-        ticker_input = gr.Textbox(label="数据名称", value="EURUSD", placeholder="输入数据文件名，如: EURUSD, AAPL")
-        analyze_btn = gr.Button("分析", variant="primary", size="lg")
+        with gr.Column():
+            pair_input = gr.Textbox(
+                label="🔍 Trading Pair", 
+                value="EURUSD",
+                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
+            - Ensure your CSV has Open, High, Low, Close columns
+            """)
     
-    # 结果区域
-    signal_output = gr.Textbox(label="分析结果", lines=6)
+    result_output = gr.Textbox(label="📝 Analysis Results", lines=8)
     
     with gr.Row():
-        kchart = gr.Plot(label="价格走势与技术指标")
-        pred_chart = gr.Plot(label="30天价格预测")
+        price_chart = gr.Plot(label="📊 Price Chart & Technical Indicators")
+        forecast_chart = gr.Plot(label="🔮 30-Day Price Forecast")
     
-    # 使用指南
-    gr.Markdown("""
-    ### 📋 使用指南
-    1. **输入数据名称**：使用数据文件名（不含.csv后缀），例如 `EURUSD`
-    2. **点击"分析"**：系统将加载本地数据并生成分析报告
-    3. **查看结果**：包括技术指标、交易信号和价格预测
-    4. **数据更新**：上传新的CSV文件到data/目录，重新部署应用
-    
-    ### 🔍 数据格式要求
-    CSV文件应包含以下列（不区分大小写）：
-    - 日期列 (Date/Time)
-    - 开盘价 (Open)
-    - 最高价 (High)
-    - 最低价 (Low)
-    - 收盘价 (Close)
-    
-    ### 💡 提示
-    - 首次加载可能需要1-2分钟
-    - 数据越多，预测越准确（建议至少6个月数据）
-    - 支��多种金融产品：外汇、股票、加密货币
-    """)
+    with gr.Accordion("📁 Data Upload Instructions", open=False):
+        gr.Markdown("""
+        ### How to Add Your Own Data
+        
+        1. **Prepare your CSV file** with these columns:
+           - Date/Time column (any format)
+           - Open, High, Low, Close prices
+           - Volume (optional)
+        
+        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`
+        
+        3. **Restart the application**:
+           - Go to Settings → Restart Space
+           - Wait 2-3 minutes for rebuild
+        
+        4. **Your data will be automatically preprocessed** and ready for analysis!
+        """)
     
-    # 示例按钮
-    with gr.Row():
-        gr.Examples(
-            examples=[
-                ["EURUSD"],
-                ["AAPL"],
-                ["BTCUSD"]
-            ],
-            inputs=ticker_input,
-            label="常用数据示例",
-            examples_per_page=3
-        )
+    # Examples for quick testing
+    examples = gr.Examples(
+        examples=[
+            ["EURUSD"],
+            ["BTCUSD"],
+            ["AAPL"]
+        ],
+        inputs=pair_input,
+        label="Try these examples:"
+    )
     
-    # 分析按钮点击事件
+    # Analysis function
     analyze_btn.click(
-        fn=analyze_stock,
-        inputs=ticker_input,
-        outputs=[signal_output, kchart, pred_chart]
+        fn=analyze_trading_pair,
+        inputs=pair_input,
+        outputs=[result_output, price_chart, forecast_chart]
     )
 
-# 启动应用
+# Launch the app
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",

pre_treat_data.rtf

@@ -0,0 +1,25 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2822
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 # \uc0\u22312 \u26412 \u22320  Mac \u19978 \u36816 \u34892 \
+import pandas as pd\
+\
+# \uc0\u35835 \u21462 \u21407 \u22987 \u25991 \u20214 \
+df = pd.read_csv('data/EURUSD2022_2025.csv')\
+\
+# \uc0\u20551 \u35774 \u26085 \u26399 \u21015 \u21517 \u20026  'Date'\
+if 'Date' in df.columns:\
+    # \uc0\u31227 \u38500  GMT \u37096 \u20998 \u24182 \u26631 \u20934 \u21270 \u26684 \u24335 \
+    df['Date'] = df['Date'].str.replace(' GMT', '', regex=False)\
+    df['Date'] = pd.to_datetime(df['Date'], format='%d.%m.%Y %H:%M:%S.%f %z', utc=True)\
+    \
+    # \uc0\u37325 \u32622 \u32034 \u24341 \
+    df.set_index('Date', inplace=True)\
+    \
+    # \uc0\u20445 \u23384 \u26631 \u20934 \u21270 \u25991 \u20214 \
+    df.to_csv('data/EURUSD_standard.csv')\
+    print("\uc0\u9989  \u24050 \u21019 \u24314 \u26631 \u20934 \u21270 \u25991 \u20214 : data/EURUSD_standard.csv")}