Update app.py

app.py

@@ -4,12 +4,23 @@ import yfinance as yf
 import plotly.graph_objects as go
 import plotly.express as px
 import numpy as np
+from datetime import datetime
 
-# Use a consistent 8-color palette
-COLORS = px.colors.qualitative.Plotly  # 10 colors, we use first 8
+# Fixed high thresholds (strict = fewer, stronger signals)
+THRESHOLDS = {
+    'RSI_lower': 15,        # Buy only if RSI < 15
+    'RSI_upper': 85,        # Sell only if RSI > 85
+    'Stochastic_lower': 15, # Buy only if Stochastic < 15
+    'Stochastic_upper': 85, # Sell only if Stochastic > 85
+    'CMF': 0.4,             # Buy if CMF < -0.4, Sell if CMF > 0.4
+    'BB': 5.0               # Require price 5% beyond Bollinger Band
+}
+
+# 8 distinct colors for tickers
+COLORS = px.colors.qualitative.Plotly
 
 # ======================
-# Indicator Calculations
+# Indicator Functions
 # ======================
 
 def calculate_rsi(df):
@@ -21,301 +32,236 @@ def calculate_rsi(df):
     return rsi
 
 def calculate_bollinger_bands(df):
-    middle_bb = df['Close'].rolling(window=20).mean()
-    std = df['Close'].rolling(window=20).std()
-    upper_bb = middle_bb + 2 * std
-    lower_bb = middle_bb - 2 * std
-    return middle_bb, upper_bb, lower_bb
+    ma = df['Close'].rolling(20).mean()
+    std = df['Close'].rolling(20).std()
+    return ma, ma + 2*std, ma - 2*std
 
 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
+    ll = df['Low'].rolling(14).min()
+    hh = df['High'].rolling(14).max()
+    k = ((df['Close'] - ll) / (hh - ll)) * 100
+    d = k.rolling(3).mean()
+    return k, d
 
 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
+    return mfv.rolling(window).sum() / df['Volume'].rolling(window).sum()
 
 # ======================
-# Signal Generation
+# Signal Logic (Fixed Thresholds)
 # ======================
 
-def generate_trading_signals(df, thresholds, enabled_signals):
-    # Calculate indicators
+def generate_signals(df):
     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)
 
-    # Initialize signal columns
-    for col in ['RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal']:
-        df[col] = 0
-
-    # RSI Signal
-    if 'RSI' in enabled_signals:
-        rsi_lower = thresholds['RSI_lower']
-        rsi_upper = thresholds['RSI_upper']
-        df['RSI_Signal'] = np.where(df['RSI'] < rsi_lower, 1, 0)
-        df['RSI_Signal'] = np.where(df['RSI'] > rsi_upper, -1, df['RSI_Signal'])
-
-    # Bollinger Bands Signal
-    if 'BB' in enabled_signals:
-        bb_buffer_pct = thresholds['BB'] / 100  # Convert % to decimal
-        below_lower = df['Close'] < df['LowerBB'] * (1 - bb_buffer_pct)
-        above_upper = df['Close'] > df['UpperBB'] * (1 + bb_buffer_pct)
-        # Require 2 consecutive days for confirmation (optional, reduces noise)
-        df['BB_Signal'] = np.where(below_lower & below_lower.shift(1), 1, 0)
-        df['BB_Signal'] = np.where(above_upper & above_upper.shift(1), -1, df['BB_Signal'])
-
-    # Stochastic Signal
-    if 'Stochastic' in enabled_signals:
-        stoch_lower = thresholds['Stochastic_lower']
-        stoch_upper = thresholds['Stochastic_upper']
-        df['Stochastic_Signal'] = np.where((df['SlowK'] < stoch_lower) & (df['SlowD'] < stoch_lower), 1, 0)
-        df['Stochastic_Signal'] = np.where((df['SlowK'] > stoch_upper) & (df['SlowD'] > stoch_upper), -1, df['Stochastic_Signal'])
-
-    # CMF Signal
-    if 'CMF' in enabled_signals:
-        cmf_thresh = thresholds['CMF']
-        df['CMF_Signal'] = np.where(df['CMF'] > cmf_thresh, -1, np.where(df['CMF'] < -cmf_thresh, 1, 0))
-
+    t = THRESHOLDS
+    df['RSI_Signal'] = np.where(df['RSI'] < t['RSI_lower'], 1,
+                      np.where(df['RSI'] > t['RSI_upper'], -1, 0))
+    
+    bb_buffer = t['BB'] / 100
+    below = df['Close'] < df['LowerBB'] * (1 - bb_buffer)
+    above = df['Close'] > df['UpperBB'] * (1 + bb_buffer)
+    df['BB_Signal'] = np.where(below & below.shift(1), 1,
+                     np.where(above & above.shift(1), -1, 0))
+    
+    df['Stochastic_Signal'] = np.where((df['SlowK'] < t['Stochastic_lower']) & (df['SlowD'] < t['Stochastic_lower']), 1,
+                             np.where((df['SlowK'] > t['Stochastic_upper']) & (df['SlowD'] > t['Stochastic_upper']), -1, 0))
+    
+    df['CMF_Signal'] = np.where(df['CMF'] < -t['CMF'], 1,
+                      np.where(df['CMF'] > t['CMF'], -1, 0))
     return df
 
 # ======================
-# Plotting Function
+# Ultra-Minimal Plot
 # ======================
 
-def plot_multi_ticker_signals(data_dict, enabled_signals, show_bollinger):
+def plot_chart(data_dict, show_bollinger, time_range):
     fig = go.Figure()
-    buy_hovers_all = []
-    sell_hovers_all = []
-
-    for idx, (ticker, df) in enumerate(data_dict.items()):
-        color = COLORS[idx % len(COLORS)]
-
-        # Plot price
+    
+    # Determine date range
+    all_dates = pd.concat([df.index.to_series() for df in data_dict.values()], ignore_index=True)
+    if all_dates.empty:
+        return fig
+    end = all_dates.max()
+    start = {
+        "1M": end - pd.DateOffset(months=1),
+        "3M": end - pd.DateOffset(months=3),
+        "6M": end - pd.DateOffset(months=6),
+        "1Y": end - pd.DateOffset(years=1),
+        "YTD": pd.to_datetime(f"{end.year}-01-01"),
+        "All": all_dates.min()
+    }[time_range]
+
+    buy_points = []
+    sell_points = []
+
+    for i, (ticker, df) in enumerate(data_dict.items()):
+        df = df[df.index >= start]
+        if df.empty:
+            continue
+        color = COLORS[i % len(COLORS)]
+        
+        # Price line
         fig.add_trace(go.Scatter(
-            x=df.index,
-            y=df['Close'],
+            x=df.index, y=df['Close'],
             mode='lines',
-            name=f'{ticker}',
-            line=dict(color=color, width=2),
-            legendgroup=ticker
+            line=dict(color=color, width=1.8),
+            name=ticker,
+            showlegend=True
         ))
 
-        # Optionally plot Bollinger Bands (only if enabled AND toggle is on)
-        if show_bollinger and 'BB' in enabled_signals:
+        # Optional Bollinger Bands (gray, subtle)
+        if show_bollinger:
             fig.add_trace(go.Scatter(
                 x=df.index, y=df['UpperBB'],
-                mode='lines',
-                line=dict(color=color, width=1, dash='dot'),
-                name=f'{ticker} Upper BB',
-                legendgroup=ticker,
-                showlegend=False
+                mode='lines', line=dict(color='rgba(150,150,150,0.4)', width=1, dash='dot'),
+                showlegend=False, hoverinfo='skip'
             ))
             fig.add_trace(go.Scatter(
                 x=df.index, y=df['LowerBB'],
-                mode='lines',
-                line=dict(color=color, width=1, dash='dot'),
-                fill='tonexty',
-                fillcolor=f'rgba{color[3:-1]},0.1)',  # Light fill
-                name=f'{ticker} Lower BB',
-                legendgroup=ticker,
-                showlegend=False
+                mode='lines', line=dict(color='rgba(150,150,150,0.4)', width=1, dash='dot'),
+                fill='tonexty', fillcolor='rgba(150,150,150,0.05)',
+                showlegend=False, hoverinfo='skip'
             ))
 
-        # Collect signals for markers
-        signal_cols = [col for col in df.columns if col.endswith('_Signal')]
+        # Collect signals
         for date in df.index:
-            total_signal = sum(df.loc[date, col] for col in signal_cols)
-            if total_signal > 0:  # Buy
-                active = [col.replace('_Signal', '') for col in signal_cols if df.loc[date, col] == 1]
-                hover = f"<b>{ticker}</b><br>Buy: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${df.loc[date, 'Close']:.2f}"
-                buy_hovers_all.append((date, df.loc[date, 'Close'] * 0.995, hover, color))
-            elif total_signal < 0:  # Sell
-                active = [col.replace('_Signal', '') for col in signal_cols if df.loc[date, col] == -1]
-                hover = f"<b>{ticker}</b><br>Sell: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${df.loc[date, 'Close']:.2f}"
-                sell_hovers_all.append((date, df.loc[date, 'Close'] * 1.005, hover, color))
-
-    # Add buy markers
-    if buy_hovers_all:
-        x, y, text, colors = zip(*buy_hovers_all)
+            signals = [
+                ('RSI', df.loc[date, 'RSI_Signal']),
+                ('BB', df.loc[date, 'BB_Signal']),
+                ('Stochastic', df.loc[date, 'Stochastic_Signal']),
+                ('CMF', df.loc[date, 'CMF_Signal'])
+            ]
+            total = sum(sig for _, sig in signals)
+            price = df.loc[date, 'Close']
+            active = [name for name, sig in signals if sig == (1 if total > 0 else -1)]
+            if total > 0:
+                hover = f"<b>{ticker}</b><br>Buy: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${price:.2f}"
+                buy_points.append((date, price * 0.997, hover))
+            elif total < 0:
+                hover = f"<b>{ticker}</b><br>Sell: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${price:.2f}"
+                sell_points.append((date, price * 1.003, hover))
+
+    # White ▲ Buy
+    if buy_points:
+        x, y, text = zip(*buy_points)
         fig.add_trace(go.Scatter(
             x=x, y=y,
             mode='markers',
-            marker=dict(symbol='triangle-up', size=9, color=colors, line=dict(color='white', width=0.8)),
-            name='Buy Signals',
-            hoverinfo='text',
+            marker=dict(symbol='triangle-up', size=9, color='white', line=dict(color='black', width=0.8)),
             hovertext=text,
-            showlegend=True
+            hoverinfo='text',
+            showlegend=False
         ))
 
-    # Add sell markers
-    if sell_hovers_all:
-        x, y, text, colors = zip(*sell_hovers_all)
+    # Black ▼ Sell
+    if sell_points:
+        x, y, text = zip(*sell_points)
         fig.add_trace(go.Scatter(
             x=x, y=y,
             mode='markers',
-            marker=dict(symbol='triangle-down', size=9, color=colors, line=dict(color='white', width=0.8)),
-            name='Sell Signals',
-            hoverinfo='text',
+            marker=dict(symbol='triangle-down', size=9, color='black', line=dict(color='white', width=0.8)),
             hovertext=text,
-            showlegend=True
+            hoverinfo='text',
+            showlegend=False
         ))
 
+    # Ultra-minimal black theme
     fig.update_layout(
-        title="Multi-Ticker Technical Signals (RSI, BB, Stochastic, CMF)",
-        xaxis_title="Date",
-        yaxis_title="Price",
-        plot_bgcolor='#1e1e1e',
-        paper_bgcolor='#1e1e1e',
-        font=dict(color='white'),
+        xaxis=dict(showgrid=False, zeroline=False, showline=False, ticks='', showticklabels=True),
+        yaxis=dict(showgrid=False, zeroline=False, showline=False, ticks='', showticklabels=True, tickprefix='$'),
+        plot_bgcolor='black',
+        paper_bgcolor='black',
+        font=dict(color='white', size=12),
+        showlegend=True,
         legend=dict(
             orientation='h',
             yanchor='bottom',
             y=1.02,
             xanchor='center',
             x=0.5,
-            bgcolor='rgba(30,30,30,0.8)'
+            bgcolor='rgba(0,0,0,0.6)',
+            font=dict(size=11)
         ),
-        height=800,
-        width=1200,
-        hovermode='closest'
+        margin=dict(l=20, r=20, t=30, b=30),
+        height=700,
+        width=1100,
+        hovermode='x unified'
     )
-    fig.update_xaxes(rangeslider_visible=True)
     return fig
 
 # ======================
-# Main Analysis Function
+# Main Function
 # ======================
 
-def stock_analysis(
-    ticker,
-    start_date,
-    end_date,
-    rsi_lower,
-    rsi_upper,
-    bb_buffer,
-    stoch_lower,
-    stoch_upper,
-    cmf_threshold,
-    show_bollinger
-):
+def run_analysis(tickers_str, start_date, end_date, show_bollinger, time_range):
     try:
-        tickers = [t.strip().upper() for t in ticker.split(',') if t.strip()][:8]
+        tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:8]
         if not tickers:
-            raise ValueError("No valid ticker provided")
+            raise ValueError("Enter at least one ticker symbol")
 
-        enabled_signals = ['RSI', 'BB', 'Stochastic', 'CMF']
-        thresholds = {
-            'RSI_lower': rsi_lower,
-            'RSI_upper': rsi_upper,
-            'BB': bb_buffer,
-            'Stochastic_lower': stoch_lower,
-            'Stochastic_upper': stoch_upper,
-            'CMF': cmf_threshold
-        }
-
-        data_dict = {}
+        data = {}
         for t in tickers:
             df = yf.download(t, start=start_date, end=end_date)
-            if df.empty:
-                continue
-            if isinstance(df.columns, pd.MultiIndex):
-                df.columns = df.columns.droplevel(1)
-            df = generate_trading_signals(df, thresholds, enabled_signals)
-            df_last = df.tail(min(360, len(df)))
-            data_dict[t] = df_last
+            if not df.empty:
+                if isinstance(df.columns, pd.MultiIndex):
+                    df.columns = df.columns.droplevel(1)
+                data[t] = generate_signals(df)
 
-        if not data_dict:
-            raise ValueError("No data retrieved for any ticker")
+        if not data:
+            raise ValueError("No data found for the given tickers and date range")
 
-        return plot_multi_ticker_signals(data_dict, enabled_signals, show_bollinger)
+        return plot_chart(data, show_bollinger, time_range)
 
     except Exception as e:
         fig = go.Figure()
-        fig.add_annotation(
-            text=f"Error: {str(e)}",
-            x=0.5, y=0.5,
-            showarrow=False,
-            font=dict(color="red", size=16)
-        )
-        fig.update_layout(
-            plot_bgcolor='#1e1e1e',
-            paper_bgcolor='#1e1e1e',
-            height=800,
-            width=1200
-        )
+        fig.add_annotation(text=f"Error: {str(e)}", x=0.5, y=0.5, showarrow=False, font=dict(color="red", size=16))
+        fig.update_layout(plot_bgcolor='black', paper_bgcolor='black', height=700, width=1100)
         return fig
 
 # ======================
-# Gradio Interface
+# Gradio UI (No Threshold Sliders!)
 # ======================
 
-custom_theme = gr.themes.Monochrome(
-    primary_hue="blue",
-    secondary_hue="purple",
-    neutral_hue="gray",
-    radius_size=gr.themes.sizes.radius_sm,
-    font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
-)
-
-with gr.Blocks(theme=custom_theme) as demo:
-    gr.Markdown("# 📈 Multi-Ticker Signal Analyzer")
-    gr.Markdown("Analyze up to 8 stocks using **RSI, Bollinger Bands, Stochastic, and CMF** with custom thresholds.")
-
+with gr.Blocks(theme=gr.themes.Default()) as demo:
+    gr.Markdown("### 🔍 Strict Multi-Ticker Signal Viewer (Fixed High Thresholds)")
+    
     with gr.Row():
         with gr.Column(scale=1):
-            ticker_input = gr.Textbox(
+            tickers_input = gr.Textbox(
                 label="Tickers (comma-separated, max 8)",
-                placeholder="e.g., AAPL, MSFT, GOOGL, NVDA, TSLA, AMD, META, AMZN",
-                value="NVDA, AAPL, MSFT"
+                value="NVDA, AAPL, MSFT, TSLA"
             )
-            start_date_input = gr.Textbox(label="Start Date", value="2022-01-01")
-            end_date_input = gr.Textbox(label="End Date", value="2026-01-01")
-
-            gr.Markdown("### 🔧 Signal Thresholds")
-            rsi_lower = gr.Slider(5, 40, value=20, label="RSI Buy Threshold (Lower)")
-            rsi_upper = gr.Slider(60, 95, value=80, label="RSI Sell Threshold (Upper)")
-            stoch_lower = gr.Slider(5, 40, value=20, label="Stochastic Buy Threshold")
-            stoch_upper = gr.Slider(60, 95, value=80, label="Stochastic Sell Threshold")
-            cmf_threshold = gr.Slider(0.05, 0.8, value=0.3, label="CMF Signal Threshold (abs)")
-            bb_buffer = gr.Slider(0.5, 10, value=3.0, label="Bollinger Band Buffer (%)")
-
-            show_bollinger = gr.Checkbox(label="Show Bollinger Bands on Chart", value=False)
-
-            analyze_btn = gr.Button("Analyze", variant="primary")
-
-    signals_output = gr.Plot(label="Trading Signals")
-
-    analyze_btn.click(
-        stock_analysis,
-        inputs=[
-            ticker_input,
-            start_date_input,
-            end_date_input,
-            rsi_lower,
-            rsi_upper,
-            bb_buffer,
-            stoch_lower,
-            stoch_upper,
-            cmf_threshold,
-            show_bollinger
-        ],
-        outputs=signals_output
+            start_input = gr.Textbox(label="Start Date", value="2022-01-01")
+            end_input = gr.Textbox(label="End Date", value="2026-01-01")
+            
+            show_bb = gr.Checkbox(label="Show Bollinger Bands", value=False)
+            time_range = gr.Radio(
+                choices=["1M", "3M", "6M", "1Y", "YTD", "All"],
+                value="1Y",
+                label="Time Range"
+            )
+            
+            btn = gr.Button("Analyze", variant="primary")
+        
+        chart = gr.Plot()
+    
+    btn.click(
+        run_analysis,
+        inputs=[tickers_input, start_input, end_input, show_bb, time_range],
+        outputs=chart
     )
 
     gr.Markdown("""
-    ### 📌 Notes
-    - **Buy**: Green ▲ | **Sell**: Red ▼  
-    - Hover to see which indicators triggered the signal  
-    - Higher thresholds = fewer, stronger signals  
-    - Bollinger Bands can be toggled on/off for clarity
+    - **▲ White** = Buy | **▼ Black** = Sell  
+    - Indicators: **RSI, Bollinger Bands, Stochastic, CMF**  
+    - Thresholds are **fixed and strict** (e.g., RSI buy < 15, sell > 85)  
+    - Toggle Bollinger Bands for context  
+    - Hover over signals to see details
     """)
 
-# Launch
 if __name__ == "__main__":
     demo.launch()