Update app.py

app.py

@@ -12,6 +12,7 @@ import warnings
 import timesfm
 from prophet import Prophet
 
+
 class StockDataFetcher:
     """Handles fetching and preprocessing stock data"""
     
@@ -274,100 +275,153 @@ def prophet_forecast(ticker, start_date, end_date):
         return f"Error: {str(e)}", f"Error: {str(e)}", None
     
 # Functions for technical analysis
-def calculate_sma(df, window):
-    return df['Close'].rolling(window=window).mean()
-
-def calculate_ema(df, window):
-    return df['Close'].ewm(span=window, adjust=False).mean()
-
-def calculate_macd(df):
-    short_ema = df['Close'].ewm(span=12, adjust=False).mean()
-    long_ema = df['Close'].ewm(span=26, adjust=False).mean()
-    macd = short_ema - long_ema
-    signal = macd.ewm(span=9, adjust=False).mean()
-    return macd, signal
-
-def calculate_rsi(df):
-    delta = df['Close'].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
-    rs = gain / loss
-    rsi = 100 - (100 / (1 + rs))
-    return rsi
-
-def calculate_bollinger_bands(df):
-    middle_bb = df['Close'].rolling(window=20).mean()
-    upper_bb = middle_bb + 2 * df['Close'].rolling(window=20).std()
-    lower_bb = middle_bb - 2 * df['Close'].rolling(window=20).std()
-    return middle_bb, upper_bb, lower_bb
-
-def calculate_stochastic_oscillator(df):
-    lowest_low = df['Low'].rolling(window=14).min()
-    highest_high = df['High'].rolling(window=14).max()
-    slowk = ((df['Close'] - lowest_low) / (highest_high - lowest_low)) * 100
-    slowd = slowk.rolling(window=3).mean()
-    return slowk, slowd
-
-def calculate_cmf(df, window=20):
-    mfv = ((df['Close'] - df['Low']) - (df['High'] - df['Close'])) / (df['High'] - df['Low']) * df['Volume']
-    cmf = mfv.rolling(window=window).sum() / df['Volume'].rolling(window=window).sum()
-    return cmf
-
-def calculate_cci(df, window=20):
-    """Calculate Commodity Channel Index (CCI)."""
-    typical_price = (df['High'] + df['Low'] + df['Close']) / 3
-    sma = typical_price.rolling(window=window).mean()
-    mean_deviation = (typical_price - sma).abs().rolling(window=window).mean()
-    cci = (typical_price - sma) / (0.015 * mean_deviation)
-    return cci
 
 
-import numpy as np
+def smooth_moving_average(series: pd.Series, window: int) -> pd.Series:
+    if len(series) < window or window <= 0:
+        return pd.Series(series.mean(), index=series.index)
+    result = pd.Series(index=series.index, dtype=float)
+    result.iloc[:window] = series.iloc[:window].mean()
+    for i in range(window, len(series)):
+        result.iloc[i] = (result.iloc[i-1] * (window - 1) + series.iloc[i]) / window
+    return result.ffill().bfill().fillna(series.mean())
+
+def calculate_rsi(close: pd.Series, window: int = 14) -> pd.Series:
+    if len(close) <= window:
+        return pd.Series(50.0, index=close.index)
+    delta = close.diff()
+    gain = delta.where(delta > 0, 0.0)
+    loss = -delta.where(delta < 0, 0.0)
+    avg_gain = smooth_moving_average(gain, window)
+    avg_loss = smooth_moving_average(loss, window)
+    rs = np.where(avg_loss != 0, avg_gain / avg_loss, np.inf)
+    rsi = 100.0 - (100.0 / (1.0 + rs))
+    return pd.Series(rsi, index=close.index).replace([np.inf, -np.inf], np.nan).ffill().bfill().fillna(50.0)
+
+def calculate_stochastic(high: pd.Series, low: pd.Series, close: pd.Series, k_window=14, d_window=3):
+    if len(close) < k_window:
+        return pd.Series(50.0, index=close.index), pd.Series(50.0, index=close.index)
+    lowest = low.rolling(k_window, min_periods=1).min()
+    highest = high.rolling(k_window, min_periods=1).max()
+    k_pct = ((close - lowest) / (highest - lowest + 1e-10)) * 100
+    k_pct = k_pct.clip(0, 100)
+    d_pct = k_pct.rolling(d_window, min_periods=1).mean()
+    return k_pct.ffill().bfill().fillna(50.0), d_pct.ffill().bfill().fillna(50.0)
+
+def calculate_cci(high: pd.Series, low: pd.Series, close: pd.Series, window=20):
+    if len(close) < window:
+        return pd.Series(0.0, index=close.index)
+    typical_price = (high + low + close) / 3.0
+    sma = typical_price.rolling(window, min_periods=1).mean()
+    mean_deviation = (typical_price - sma).abs().rolling(window, min_periods=1).mean()
+    cci = (typical_price - sma) / (0.015 * mean_deviation + 1e-10)
+    return cci.ffill().bfill().fillna(0.0)
+
+# --- New Robust Helper Functions ---
+def calculate_sma_robust(series: pd.Series, window: int) -> pd.Series:
+    if len(series) < window or window <= 0:
+        return pd.Series(series.mean(), index=series.index)
+    return series.rolling(window=window, min_periods=window).mean().ffill().bfill().fillna(series.mean())
+
+def calculate_ema_robust(series: pd.Series, span: int) -> pd.Series:
+    if len(series) < span or span <= 0:
+        return pd.Series(series.mean(), index=series.index)
+    return series.ewm(span=span, adjust=False, min_periods=span).mean().ffill().bfill().fillna(series.mean())
+
+def calculate_macd_robust(close: pd.Series):
+    ema12 = calculate_ema_robust(close, 12)
+    ema26 = calculate_ema_robust(close, 26)
+    macd_line = ema12 - ema26
+    signal_line = calculate_ema_robust(macd_line, 9)
+    return macd_line, signal_line
+
+def calculate_bollinger_bands_robust(close: pd.Series, window=20, num_std=2.0):
+    if len(close) < window:
+        mid = pd.Series(close.mean(), index=close.index)
+        return mid, mid, mid
+    sma = calculate_sma_robust(close, window)
+    std = close.rolling(window=window, min_periods=window).std().fillna(1e-10)
+    upper = sma + num_std * std
+    lower = sma - num_std * std
+    return sma.ffill().bfill(), upper.ffill().bfill(), lower.ffill().bfill()
+
+# --- The Core Integration: generate_trading_signals ---
+def generate_trading_signals(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Generates trading signals using strict thresholds to minimize false positives.
+    Output columns match the expected names for the plotting functions.
+    """
+    df = df.copy()
+    close = df['Close']
+    has_hl = all(col in df.columns for col in ['High', 'Low'])
+    has_vol = 'Volume' in df.columns
+
+    high = df['High'] if has_hl else close
+    low = df['Low'] if has_hl else close
+    volume = df['Volume'] if has_vol else pd.Series(1.0, index=close.index)
+
+    # Calculate indicators using robust methods
+    rsi = calculate_rsi(close, window=14)
+    stoch_k, stoch_d = calculate_stochastic(high, low, close, k_window=14, d_window=3)
+    cci = calculate_cci(high, low, close, window=20)
+    sma30 = calculate_sma_robust(close, 30)
+    sma100 = calculate_sma_robust(close, 100)
+    macd_line, macd_signal_line = calculate_macd_robust(close)
+    _, bb_upper, bb_lower = calculate_bollinger_bands_robust(close, window=20, num_std=2.5)
+
+    # CMF Calculation
+    if has_hl and has_vol:
+        mfv = ((close - low) - (high - close)) / (high - low + 1e-10) * volume
+        cmf = mfv.rolling(window=20, min_periods=20).sum() / (volume.rolling(window=20, min_periods=20).sum() + 1e-10)
+        cmf = cmf.ffill().bfill().fillna(0.0)
+    else:
+        cmf = pd.Series(0.0, index=close.index)
+
+    # --- STRICT SIGNAL LOGIC (Output matches old function's schema) ---
+
+    # Initialize all signal columns to 0
+    for col in ['MACD_Signal', 'RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal', 'CCI_Signal']:
+        df[col] = 0
+
+    # 1. MACD Signal
+    macd_bull = (
+        (macd_line > macd_signal_line) &
+        (macd_line.shift(1) <= macd_signal_line.shift(1)) &
+        (macd_line > 0.5) &
+        ((macd_line - macd_signal_line) > 0.8)
+    )
+    macd_bear = (
+        (macd_line < macd_signal_line) &
+        (macd_line.shift(1) >= macd_signal_line.shift(1)) &
+        (macd_line < -0.5) &
+        ((macd_signal_line - macd_line) > 0.8)
+    )
+    df.loc[macd_bull, 'MACD_Signal'] = 1
+    df.loc[macd_bear, 'MACD_Signal'] = -1
+
+    # 2. RSI Signal
+    df.loc[rsi < 15, 'RSI_Signal'] = 1
+    df.loc[rsi > 85, 'RSI_Signal'] = -1
+
+    # 3. Bollinger Bands Signal
+    df.loc[close <= bb_lower, 'BB_Signal'] = 1
+    df.loc[close >= bb_upper, 'BB_Signal'] = -1
+
+    # 4. Stochastic Signal
+    stoch_buy = (stoch_k < 5) & (stoch_d < 5)
+    stoch_sell = (stoch_k > 95) & (stoch_d > 95)
+    df.loc[stoch_buy, 'Stochastic_Signal'] = 1
+    df.loc[stoch_sell, 'Stochastic_Signal'] = -1
+
+    # 5. CMF Signal
+    df.loc[cmf < -0.5, 'CMF_Signal'] = 1
+    df.loc[cmf > 0.5, 'CMF_Signal'] = -1
+
+    # 6. CCI Signal
+    df.loc[cci < -250, 'CCI_Signal'] = 1
+    df.loc[cci > 250, 'CCI_Signal'] = -1
 
-def generate_trading_signals(df):
-    # Calculate various indicators
-    df['SMA_30'] = calculate_sma(df, 30)
-    df['SMA_100'] = calculate_sma(df, 100)
-    df['EMA_12'] = calculate_ema(df, 12)
-    df['EMA_26'] = calculate_ema(df, 26)
-    df['RSI'] = calculate_rsi(df)
-    df['MiddleBB'], df['UpperBB'], df['LowerBB'] = calculate_bollinger_bands(df)
-    df['SlowK'], df['SlowD'] = calculate_stochastic_oscillator(df)
-    df['CMF'] = calculate_cmf(df)
-    df['CCI'] = calculate_cci(df)
-
-    # Less strict SMA Signal - Require only 1% difference (was 3%)
-    df['SMA_Signal'] = np.where((df['SMA_30'] > df['SMA_100']) & 
-                                 ((df['SMA_30'] - df['SMA_100']) / df['SMA_100'] > 0.01), 1, 0)
-
-    macd, signal = calculate_macd(df)
-
-    # Less strict MACD Signal - Reduce required MACD-signal gap from 1.0 to 0.3
-    df['MACD_Signal'] = np.select([
-        (macd > signal) & (macd.shift(1) <= signal.shift(1)) & ((macd - signal) > 0.3),   # Bullish crossover → Sell (inverted logic)
-        (macd < signal) & (macd.shift(1) >= signal.shift(1)) & ((signal - macd) > 0.3)    # Bearish crossover → Buy
-    ], [-1, 1], default=0)
-
-    # Less strict RSI Signal - Use common thresholds (30/70 instead of 15/90)
-    df['RSI_Signal'] = np.where(df['RSI'] < 30, 1, 0)
-    df['RSI_Signal'] = np.where(df['RSI'] > 90, -1, df['RSI_Signal'])
-
-    # Less strict Bollinger Bands Signal - Touch or slight breach (no 3% buffer)
-    df['BB_Signal'] = np.where(df['Close'] <= df['LowerBB'], 1, 0)
-    df['BB_Signal'] = np.where(df['Close'] >= df['UpperBB'], -1, df['BB_Signal'])
-
-    # Less strict Stochastic Signal - Standard overbought/oversold (20/80 instead of 10/95)
-    df['Stochastic_Signal'] = np.where((df['SlowK'] < 30) & (df['SlowD'] < 30), 1, 0)
-    df['Stochastic_Signal'] = np.where((df['SlowK'] > 100) & (df['SlowD'] > 100), -1, df['Stochastic_Signal'])
-
-    # Less strict CMF Signal - Use ±0.1 instead of ±0.4
-    df['CMF_Signal'] = np.where(df['CMF'] > 0.4, -1, np.where(df['CMF'] < -0.4, 1, 0))
-
-    # Less strict CCI Signal - Standard thresholds (±100 instead of ±220)
-    df['CCI_Signal'] = np.where(df['CCI'] < -100, 1, 0)
-    df['CCI_Signal'] = np.where(df['CCI'] > 120, -1, df['CCI_Signal'])
-
-    # Combined signal (still sums all component signals)
+    # Create the Combined_Signal by summing the individual signals
     df['Combined_Signal'] = df[['MACD_Signal', 'RSI_Signal', 'BB_Signal',
                                 'Stochastic_Signal', 'CMF_Signal', 'CCI_Signal']].sum(axis=1)