Restore app.py + fix share=True for HF Spaces

app.py

@@ -10,7 +10,7 @@ Features:
 - Alpha signal generation
 - AI-powered market analysis with chain-of-thought reasoning
 
-API Key: set via K2_API_KEY environment variable
+API Key: IFM-4SpQ0qEg0Wlsw04O
 """
 import os
 import json
@@ -23,8 +23,6 @@ import numpy as np
 from datetime import datetime, timedelta
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-from scipy import stats
-from scipy.optimize import minimize
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -32,7 +30,7 @@ warnings.filterwarnings('ignore')
 # ──────────────────────────────────────────────────────────────
 # K2 Think V2 API Configuration
 # ──────────────────────────────────────────────────────────────
-K2_API_KEY = os.environ.get("K2_API_KEY")
+K2_API_KEY = os.environ.get("K2_API_KEY", "IFM-4SpQ0qEg0Wlsw04O")
 K2_BASE_URL = "https://api.k2think.ai/v1/chat/completions"
 K2_MODEL = "MBZUAI-IFM/K2-Think-v2"
 
@@ -178,22 +176,31 @@ def compute_technical_indicators(df: pd.DataFrame) -> pd.DataFrame:
     """Compute technical indicators"""
     df = df.copy()
     
+    # Returns
     df['Returns'] = df['Close'].pct_change()
+    
+    # Simple Moving Averages
     df['SMA_20'] = df['Close'].rolling(20).mean()
     df['SMA_50'] = df['Close'].rolling(50).mean()
     df['SMA_200'] = df['Close'].rolling(200).mean()
+    
+    # EMA
     df['EMA_12'] = df['Close'].ewm(span=12, adjust=False).mean()
     df['EMA_26'] = df['Close'].ewm(span=26, adjust=False).mean()
+    
+    # MACD
     df['MACD'] = df['EMA_12'] - df['EMA_26']
     df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
     df['MACD_Histogram'] = df['MACD'] - df['MACD_Signal']
     
+    # RSI
     delta = df['Close'].diff()
     gain = (delta.where(delta > 0, 0)).rolling(14).mean()
     loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
     rs = gain / (loss + 1e-10)
     df['RSI'] = 100 - (100 / (1 + rs))
     
+    # Bollinger Bands
     df['BB_Middle'] = df['Close'].rolling(20).mean()
     bb_std = df['Close'].rolling(20).std()
     df['BB_Upper'] = df['BB_Middle'] + 2 * bb_std
@@ -201,20 +208,24 @@ def compute_technical_indicators(df: pd.DataFrame) -> pd.DataFrame:
     df['BB_Width'] = (df['BB_Upper'] - df['BB_Lower']) / df['BB_Middle']
     df['BB_Position'] = (df['Close'] - df['BB_Lower']) / (df['BB_Upper'] - df['BB_Lower'] + 1e-10)
     
+    # VWAP
     typical_price = (df['High'] + df['Low'] + df['Close']) / 3
     df['VWAP'] = (typical_price * df['Volume']).cumsum() / (df['Volume'].cumsum() + 1e-10)
     
+    # ATR (Average True Range)
     high_low = df['High'] - df['Low']
     high_close = np.abs(df['High'] - df['Close'].shift())
     low_close = np.abs(df['Low'] - df['Close'].shift())
     tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
     df['ATR'] = tr.rolling(14).mean()
     
+    # Stochastic Oscillator
     low_14 = df['Low'].rolling(14).min()
     high_14 = df['High'].rolling(14).max()
     df['Stoch_K'] = 100 * (df['Close'] - low_14) / (high_14 - low_14 + 1e-10)
     df['Stoch_D'] = df['Stoch_K'].rolling(3).mean()
     
+    # Volume indicators
     df['Volume_MA'] = df['Volume'].rolling(20).mean()
     df['Volume_Ratio'] = df['Volume'] / (df['Volume_MA'] + 1e-10)
     
@@ -235,11 +246,13 @@ def generate_signals(df: pd.DataFrame) -> dict:
         'confidence': 50
     }
     
+    # Trend signal
     if latest['Close'] > latest['SMA_20'] > latest['SMA_50']:
         signals['trend'] = 'bullish'
     elif latest['Close'] < latest['SMA_20'] < latest['SMA_50']:
         signals['trend'] = 'bearish'
     
+    # Momentum signal
     if latest['RSI'] < 30:
         signals['momentum'] = 'oversold (bullish bounce potential)'
     elif latest['RSI'] > 70:
@@ -249,15 +262,18 @@ def generate_signals(df: pd.DataFrame) -> dict:
     elif latest['MACD'] < latest['MACD_Signal'] and prev['MACD'] >= prev['MACD_Signal']:
         signals['momentum'] = 'MACD bearish crossover'
     
+    # Volatility signal
     bb_width = latest['BB_Width']
     if bb_width > df['BB_Width'].quantile(0.9):
         signals['volatility'] = 'expanding (breakout likely)'
     elif bb_width < df['BB_Width'].quantile(0.1):
         signals['volatility'] = 'contracting (squeeze setup)'
     
+    # Volume signal
     if latest['Volume_Ratio'] > 2.0:
         signals['volume'] = 'heavy (institutional interest)'
     
+    # Composite score (0-100, >60 bullish, <40 bearish)
     score = 50
     if signals['trend'] == 'bullish': score += 15
     if signals['trend'] == 'bearish': score -= 15
@@ -270,6 +286,7 @@ def generate_signals(df: pd.DataFrame) -> dict:
     
     signals['composite_score'] = max(0, min(100, score))
     
+    # Confidence based on indicator agreement
     bullish_count = sum([
         signals['trend'] == 'bullish',
         'oversold' in signals['momentum'] or 'bullish crossover' in signals['momentum'],
@@ -294,24 +311,31 @@ def compute_risk_metrics(df: pd.DataFrame) -> dict:
     if len(returns) < 30:
         return {}
     
+    # Basic stats
     annual_return = returns.mean() * 252
     annual_vol = returns.std() * np.sqrt(252)
     sharpe = annual_return / (annual_vol + 1e-10)
     
+    # Sortino (downside deviation)
     downside = returns[returns < 0]
     downside_dev = downside.std() * np.sqrt(252) if len(downside) > 0 else 1e-10
     sortino = annual_return / (downside_dev + 1e-10)
     
+    # Max drawdown
     cumulative = (1 + returns).cumprod()
     running_max = cumulative.expanding().max()
     drawdown = (cumulative - running_max) / running_max
     max_dd = drawdown.min()
     
+    # VaR / CVaR
     var_95 = np.percentile(returns, 5)
     var_99 = np.percentile(returns, 1)
     cvar_95 = returns[returns <= var_95].mean() if len(returns[returns <= var_95]) > 0 else var_95
     
+    # Calmar
     calmar = annual_return / (abs(max_dd) + 1e-10)
+    
+    # Skewness and kurtosis
     skew = returns.skew()
     kurt = returns.kurtosis()
     
@@ -347,6 +371,7 @@ def create_candlestick_chart(df: pd.DataFrame, ticker: str):
         subplot_titles=(f'{ticker} Price', 'Volume', 'RSI')
     )
     
+    # Candlestick
     fig.add_trace(go.Candlestick(
         x=df.index,
         open=df['Open'],
@@ -356,11 +381,13 @@ def create_candlestick_chart(df: pd.DataFrame, ticker: str):
         name='Price'
     ), row=1, col=1)
     
+    # SMAs
     fig.add_trace(go.Scatter(x=df.index, y=df['SMA_20'], 
                               line=dict(color='orange', width=1), name='SMA 20'), row=1, col=1)
     fig.add_trace(go.Scatter(x=df.index, y=df['SMA_50'], 
                               line=dict(color='blue', width=1), name='SMA 50'), row=1, col=1)
     
+    # Bollinger Bands
     fig.add_trace(go.Scatter(x=df.index, y=df['BB_Upper'], 
                               line=dict(color='gray', width=1, dash='dash'), 
                               name='BB Upper', opacity=0.5), row=1, col=1)
@@ -368,11 +395,13 @@ def create_candlestick_chart(df: pd.DataFrame, ticker: str):
                               line=dict(color='gray', width=1, dash='dash'), 
                               name='BB Lower', opacity=0.5), row=1, col=1)
     
+    # Volume
     colors = ['green' if df['Close'].iloc[i] >= df['Open'].iloc[i] else 'red' 
               for i in range(len(df))]
     fig.add_trace(go.Bar(x=df.index, y=df['Volume'], 
                          marker_color=colors, name='Volume', opacity=0.7), row=2, col=1)
     
+    # RSI
     fig.add_trace(go.Scatter(x=df.index, y=df['RSI'], 
                               line=dict(color='purple', width=1.5), name='RSI'), row=3, col=1)
     fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
@@ -430,6 +459,7 @@ def create_return_distribution(returns: pd.Series, ticker: str):
         opacity=0.7
     ))
     
+    # Add normal overlay
     x_range = np.linspace(returns.min(), returns.max(), 100)
     mu, sigma = returns.mean(), returns.std()
     normal_pdf = len(returns) * (x_range[1] - x_range[0]) * stats.norm.pdf(x_range, mu, sigma)
@@ -455,6 +485,7 @@ def create_return_distribution(returns: pd.Series, ticker: str):
 def optimize_portfolio(tickers: list, period: str = "1y"):
     """Mean-variance optimization for a portfolio"""
     try:
+        # Fetch data
         data = {}
         for t in tickers:
             t = t.strip().upper()
@@ -467,6 +498,7 @@ def optimize_portfolio(tickers: list, period: str = "1y"):
         if len(data) < 2:
             return None, "Need at least 2 valid tickers for portfolio optimization."
         
+        # Align and compute returns
         prices = pd.DataFrame(data)
         prices = prices.dropna()
         returns = prices.pct_change().dropna()
@@ -474,8 +506,11 @@ def optimize_portfolio(tickers: list, period: str = "1y"):
         if len(returns) < 30:
             return None, "Insufficient data after alignment."
         
+        # Expected returns and covariance
         mu = returns.mean() * 252
         sigma = returns.cov() * 252
+        
+        # Optimize: max Sharpe
         n = len(mu)
         
         def neg_sharpe(weights):
@@ -485,16 +520,19 @@ def optimize_portfolio(tickers: list, period: str = "1y"):
             return -(port_return / (port_vol + 1e-10))
         
         constraints = {'type': 'eq', 'fun': lambda w: np.sum(w) - 1}
-        bounds = tuple((0, 0.5) for _ in range(n))
+        bounds = tuple((0, 0.5) for _ in range(n))  # Max 50% per asset
         x0 = np.ones(n) / n
         
         result = minimize(neg_sharpe, x0, method='SLSQP', bounds=bounds, constraints=constraints)
+        
         optimal_weights = result.x
         
+        # Portfolio metrics
         port_return = np.dot(optimal_weights, mu)
         port_vol = np.sqrt(np.dot(optimal_weights.T, np.dot(sigma, optimal_weights)))
         port_sharpe = port_return / (port_vol + 1e-10)
         
+        # Equal weight for comparison
         eq_weights = np.ones(n) / n
         eq_return = np.dot(eq_weights, mu)
         eq_vol = np.sqrt(np.dot(eq_weights.T, np.dot(sigma, eq_weights)))
@@ -524,6 +562,7 @@ def create_efficient_frontier(opt_result: dict):
     sigma = opt_result['covariance']
     n = len(mu)
     
+    # Generate random portfolios
     n_portfolios = 5000
     weights = np.random.dirichlet(np.ones(n), n_portfolios)
     
@@ -533,6 +572,7 @@ def create_efficient_frontier(opt_result: dict):
     
     fig = go.Figure()
     
+    # Scatter of random portfolios
     fig.add_trace(go.Scatter(
         x=port_vols, y=port_returns,
         mode='markers',
@@ -546,6 +586,7 @@ def create_efficient_frontier(opt_result: dict):
         name='Random Portfolios'
     ))
     
+    # Optimal portfolio
     fig.add_trace(go.Scatter(
         x=[opt_result['optimal_volatility']],
         y=[opt_result['optimal_return']],
@@ -556,6 +597,7 @@ def create_efficient_frontier(opt_result: dict):
         name='Optimal Portfolio'
     ))
     
+    # Equal weight
     fig.add_trace(go.Scatter(
         x=[opt_result['equal_volatility']],
         y=[opt_result['equal_return']],
@@ -587,17 +629,21 @@ def analyze_ticker(ticker: str, period: str = "6mo"):
         return None, None, None, None, "Please enter a ticker symbol."
     
     df, info = fetch_stock_data(ticker, period=period)
+    
     if df is None:
         return None, None, None, None, info
     
+    # Compute indicators
     df = compute_technical_indicators(df)
     signals = generate_signals(df)
     risk = compute_risk_metrics(df)
     
+    # Create charts
     candlestick = create_candlestick_chart(df, ticker)
     macd_chart = create_macd_chart(df, ticker)
     returns_chart = create_return_distribution(df['Returns'].dropna(), ticker)
     
+    # Summary text
     latest = df.iloc[-1]
     prev = df.iloc[-2] if len(df) > 1 else latest
     
@@ -652,6 +698,7 @@ def ai_analyze(ticker: str, period: str = "6mo"):
     risk = compute_risk_metrics(df)
     latest = df.iloc[-1]
     
+    # Build data summary
     data_summary = f"""
 Ticker: {ticker}
 Current Price: ${latest['Close']:.2f}
@@ -685,6 +732,7 @@ Max Drawdown: {risk.get('max_drawdown', 0)*100:.1f}%
 VaR 95%: {risk.get('var_95_daily', 0)*100:.2f}%
 """
     
+    # Call K2 Think V2
     client = K2ThinkClient()
     analysis = client.analyze_market(ticker, data_summary, technical_summary)
     
@@ -698,19 +746,23 @@ def analyze_portfolio(tickers_str: str, period: str = "1y"):
     if len(tickers) < 2:
         return None, None, "Please enter at least 2 tickers separated by commas."
     
+    # Optimize
     result, error = optimize_portfolio(tickers, period)
     
     if error:
         return None, None, error
     
+    # Create efficient frontier
     frontier = create_efficient_frontier(result)
     
+    # Weights comparison
     weights_df = pd.DataFrame({
         'Ticker': result['tickers'],
         'Optimal Weight (%)': result['optimal_weights'] * 100,
         'Equal Weight (%)': result['equal_weights'] * 100
     })
     
+    # Summary
     summary = f"""## Portfolio Optimization Results
 
 **Tickers:** {', '.join(result['tickers'])}
@@ -754,6 +806,7 @@ def ai_portfolio_advice(tickers_str: str, period: str = "1y"):
     if error:
         return error
     
+    # Build portfolio data
     portfolio_data = f"""
 Holdings:
 {chr(10).join([f"- {t}: {w*100:.1f}%" for t, w in zip(result['tickers'], result['optimal_weights'])])}
@@ -766,9 +819,10 @@ Individual Asset Returns (annual):
 {chr(10).join([f"- {t}: {r*100:.1f}%" for t, r in zip(result['tickers'], result['annual_returns'])])}
 """
     
+    # Correlation matrix
     corr = result['covariance']
     for i in range(len(corr)):
-        corr.iloc[i, i] = np.nan
+        corr.iloc[i, i] = np.nan  # Hide diagonal
     
     risk_metrics = f"""
 Correlation Matrix (off-diagonal):
@@ -802,6 +856,7 @@ def build_app():
         """
     ) as demo:
         
+        # Header
         gr.HTML("""
         <div class="main-title">🔥 AlphaForge x K2 Think V2</div>
         <div class="subtitle">Elite Quantitative Trading Platform powered by MBZUAI's State-of-the-Art Reasoning Model</div>
@@ -847,6 +902,7 @@ def build_app():
             
             error_output = gr.Textbox(label="Status", visible=False)
             
+            # Bind buttons
             analyze_btn.click(
                 fn=analyze_ticker,
                 inputs=[ticker_input, period_input],
@@ -985,6 +1041,7 @@ def build_app():
 if __name__ == "__main__":
     demo = build_app()
     
+    # For HuggingFace Spaces
     demo.queue().launch(
         server_name="0.0.0.0",
         server_port=7860,