Update app.py

app.py

@@ -2,21 +2,15 @@ import gradio as gr
 import pandas as pd
 import yfinance as yf
 import plotly.graph_objects as go
+import plotly.express as px
 import numpy as np
 
-# Functions for calculating indicators
-def calculate_sma(df, window):
-    return df['Close'].rolling(window=window).mean()
+# Use a consistent 8-color palette
+COLORS = px.colors.qualitative.Plotly  # 10 colors, we use first 8
 
-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
+# ======================
+# Indicator Calculations
+# ======================
 
 def calculate_rsi(df):
     delta = df['Close'].diff()
@@ -28,8 +22,9 @@ def calculate_rsi(df):
 
 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()
+    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
 
 def calculate_stochastic_oscillator(df):
@@ -44,373 +39,222 @@ def calculate_cmf(df, window=20):
     cmf = mfv.rolling(window=window).sum() / df['Volume'].rolling(window=window).sum()
     return cmf
 
-def calculate_cci(df, window=20):
-    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
-
-# Function to adjust thresholds based on sensitivity
-def adjust_thresholds_by_sensitivity(sensitivity):
-    """
-    Convert a single sensitivity value (1-10) to appropriate thresholds
-    1 = Most sensitive (more signals)
-    10 = Least sensitive (fewer, stronger signals)
-    """
-    # Map sensitivity to thresholds
-    if sensitivity == 1:  # Most sensitive
-        return {
-            'SMA': 5,
-            'RSI_lower': 30,
-            'RSI_upper': 70,
-            'BB': 0.5,
-            'Stochastic_lower': 20,
-            'Stochastic_upper': 80,
-            'CMF': 0.1,
-            'CCI': 100
-        }
-    elif sensitivity == 10:  # Least sensitive
-        return {
-            'SMA': 50,
-            'RSI_lower': 5,
-            'RSI_upper': 95,
-            'BB': 5,
-            'Stochastic_lower': 5,
-            'Stochastic_upper': 95,
-            'CMF': 0.6,
-            'CCI': 300
-        }
-    else:
-        # Linear interpolation between extremes
-        factor = (sensitivity - 1) / 9  # 0 to 1
-        return {
-            'SMA': int(5 + (50 - 5) * factor),
-            'RSI_lower': int(30 - (30 - 5) * factor),
-            'RSI_upper': int(70 + (95 - 70) * factor),
-            'BB': 0.5 + (5 - 0.5) * factor,
-            'Stochastic_lower': int(20 - (20 - 5) * factor),
-            'Stochastic_upper': int(80 + (95 - 80) * factor),
-            'CMF': 0.1 + (0.6 - 0.1) * factor,
-            'CCI': int(100 + (300 - 100) * factor)
-        }
+# ======================
+# Signal Generation
+# ======================
 
 def generate_trading_signals(df, thresholds, enabled_signals):
-    # 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)
+    # Calculate indicators
     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)
 
-    # Initialize all signals as 0 (no signal)
-    signal_columns = ['SMA_Signal', 'MACD_Signal', 'RSI_Signal', 'BB_Signal', 
-                      'Stochastic_Signal', 'CMF_Signal', 'CCI_Signal']
-    for col in signal_columns:
+    # Initialize signal columns
+    for col in ['RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal']:
         df[col] = 0
-    
-    # Only generate signals for enabled indicators
-    
-    # SMA Signal
-    if 'SMA' in enabled_signals:
-        sma_threshold = thresholds['SMA']
-        df['SMA_Diff_Pct'] = (df['SMA_30'] - df['SMA_100']) / df['SMA_100'] * 100
-        df['SMA_Signal'] = np.where(df['SMA_Diff_Pct'] > sma_threshold, 1, 0)
-        df['SMA_Signal'] = np.where(df['SMA_Diff_Pct'] < -sma_threshold, -1, df['SMA_Signal'])
-    
-    # MACD Signal
-    if 'MACD' in enabled_signals:
-        macd, signal = calculate_macd(df)
-        df['MACD'] = macd
-        df['MACD_Signal_Line'] = signal
-        df['MACD_Signal'] = np.select([(macd > signal) & (macd.shift(1) <= signal.shift(1)),
-                                      (macd < signal) & (macd.shift(1) >= signal.shift(1))], [1, -1], default=0)
-    
-    # RSI Signals
+
+    # 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
+
+    # Bollinger Bands Signal
     if 'BB' in enabled_signals:
-        bb_buffer = thresholds['BB'] / 100  # Convert percentage to decimal
-        df['BB_Signal'] = np.where(
-            (df['Close'] < df['LowerBB'] * (1 - bb_buffer)) & 
-            (df['Close'].shift(1) < df['LowerBB'].shift(1) * (1 - bb_buffer)) & 
-            (df['Close'].shift(2) < df['LowerBB'].shift(2) * (1 - bb_buffer)), 1, 0
-        )
-        df['BB_Signal'] = np.where(
-            (df['Close'] > df['UpperBB'] * (1 + bb_buffer)) & 
-            (df['Close'].shift(1) > df['UpperBB'].shift(1) * (1 + bb_buffer)) & 
-            (df['Close'].shift(2) > df['UpperBB'].shift(2) * (1 + bb_buffer)), -1, df['BB_Signal']
-        )
-    
-    # Stochastic 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 Signals
+
+    # CMF Signal
     if 'CMF' in enabled_signals:
-        cmf_threshold = thresholds['CMF']
-        df['CMF_Signal'] = np.where(df['CMF'] > cmf_threshold, -1, np.where(df['CMF'] < -cmf_threshold, 1, 0))
-    
-    # CCI Signals
-    if 'CCI' in enabled_signals:
-        cci_threshold = thresholds['CCI']
-        df['CCI_Signal'] = np.where(df['CCI'] < -cci_threshold, 1, 0)
-        df['CCI_Signal'] = np.where(df['CCI'] > cci_threshold, -1, df['CCI_Signal'])
+        cmf_thresh = thresholds['CMF']
+        df['CMF_Signal'] = np.where(df['CMF'] > cmf_thresh, -1, np.where(df['CMF'] < -cmf_thresh, 1, 0))
 
     return df
 
-def plot_simplified_signals(df, ticker, enabled_signals):
-    # Create a figure with improved styling
+# ======================
+# Plotting Function
+# ======================
+
+def plot_multi_ticker_signals(data_dict, enabled_signals, show_bollinger):
     fig = go.Figure()
-    
-    # Use a line chart instead of candlestick for simplicity
-    fig.add_trace(go.Scatter(
-        x=df.index, 
-        y=df['Close'],
-        mode='lines', 
-        name='Price', 
-        line=dict(color='#26a69a', width=2),
-        opacity=0.9
-    ))
-    
-    # Add SMA lines
-    fig.add_trace(go.Scatter(
-        x=df.index, y=df['SMA_30'], 
-        mode='lines', 
-        name='SMA 30', 
-        line=dict(color='#42a5f5', width=1.5, dash='dot')
-    ))
-    
-    fig.add_trace(go.Scatter(
-        x=df.index, y=df['SMA_100'], 
-        mode='lines', 
-        name='SMA 100', 
-        line=dict(color='#5e35b1', width=1.5, dash='dot')
-    ))
-
-    # Add bollinger bands with lighter appearance
-    if 'BB' in enabled_signals:
+    buy_hovers_all = []
+    sell_hovers_all = []
+
+    for idx, (ticker, df) in enumerate(data_dict.items()):
+        color = COLORS[idx % len(COLORS)]
+
+        # Plot price
         fig.add_trace(go.Scatter(
-            x=df.index, y=df['UpperBB'],
+            x=df.index,
+            y=df['Close'],
             mode='lines',
-            name='Upper BB',
-            line=dict(color='rgba(250, 250, 250, 0.3)', width=1),
-            showlegend=True
-        ))
-        
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['LowerBB'],
-            mode='lines',
-            name='Lower BB',
-            line=dict(color='rgba(250, 250, 250, 0.3)', width=1),
-            fill='tonexty',
-            fillcolor='rgba(173, 216, 230, 0.1)',
-            showlegend=True
+            name=f'{ticker}',
+            line=dict(color=color, width=2),
+            legendgroup=ticker
         ))
 
-    # Group signals by type to reduce legend clutter
-    buy_signals_df = pd.DataFrame(index=df.index)
-    sell_signals_df = pd.DataFrame(index=df.index)
-    
-    signal_names = [f"{signal}_Signal" for signal in enabled_signals]
-    
-    # Collect all buy and sell signals
-    for signal in signal_names:
-        buy_signals_df[signal] = np.where(df[signal] == 1, df['Close'], np.nan)
-        sell_signals_df[signal] = np.where(df[signal] == -1, df['Close'], np.nan)
-    
-    # Add hover data
-    buy_hovers = []
-    for idx in buy_signals_df.index:
-        signals_on_day = [col.split('_')[0] for col in buy_signals_df.columns 
-                         if not pd.isna(buy_signals_df.loc[idx, col])]
-        if signals_on_day:
-            hover_text = f"Buy Signals: {', '.join(signals_on_day)}<br>Date: {idx.strftime('%Y-%m-%d')}<br>Price: ${df.loc[idx, 'Close']:.2f}"
-            buy_hovers.append((idx, df.loc[idx, 'Close'], hover_text))
-    
-    sell_hovers = []
-    for idx in sell_signals_df.index:
-        signals_on_day = [col.split('_')[0] for col in sell_signals_df.columns 
-                         if not pd.isna(sell_signals_df.loc[idx, col])]
-        if signals_on_day:
-            hover_text = f"Sell Signals: {', '.join(signals_on_day)}<br>Date: {idx.strftime('%Y-%m-%d')}<br>Price: ${df.loc[idx, 'Close']:.2f}"
-            sell_hovers.append((idx, df.loc[idx, 'Close'], hover_text))
-    
-    # Add buy signals (single trace for all buy signals)
-    if buy_hovers:
-        buy_x, buy_y, buy_texts = zip(*buy_hovers)
+        # Optionally plot Bollinger Bands (only if enabled AND toggle is on)
+        if show_bollinger and 'BB' in enabled_signals:
+            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
+            ))
+            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
+            ))
+
+        # Collect signals for markers
+        signal_cols = [col for col in df.columns if col.endswith('_Signal')]
+        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)
         fig.add_trace(go.Scatter(
-            x=buy_x, 
-            y=[y * 0.995 for y in buy_y],  # Position slightly below price for visibility
-            mode='markers', 
-            marker=dict(symbol='triangle-up', size=10, color='#00e676', line=dict(color='white', width=1)), 
+            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',
-            hovertext=buy_texts
+            hovertext=text,
+            showlegend=True
         ))
 
-    # Add sell signals (single trace for all sell signals)
-    if sell_hovers:
-        sell_x, sell_y, sell_texts = zip(*sell_hovers)
+    # Add sell markers
+    if sell_hovers_all:
+        x, y, text, colors = zip(*sell_hovers_all)
         fig.add_trace(go.Scatter(
-            x=sell_x, 
-            y=[y * 1.005 for y in sell_y],  # Position slightly above price for visibility
-            mode='markers', 
-            marker=dict(symbol='triangle-down', size=10, color='#ff5252', line=dict(color='white', width=1)), 
+            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',
-            hovertext=sell_texts
+            hovertext=text,
+            showlegend=True
         ))
 
-    # Improve the layout with larger dimensions
     fig.update_layout(
-        title=dict(
-            text=f'{ticker}: Technical Analysis & Trading Signals',
-            font=dict(size=24, color='white'),
-            x=0.5
-        ),
-        xaxis=dict(
-            title='Date',
-            gridcolor='rgba(255, 255, 255, 0.1)',
-            linecolor='rgba(255, 255, 255, 0.2)'
-        ),
-        yaxis=dict(
-            title='Price',
-            side='right',
-            gridcolor='rgba(255, 255, 255, 0.1)',
-            linecolor='rgba(255, 255, 255, 0.2)',
-            tickprefix='$'
-        ),
+        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'),
-        hovermode='closest',
         legend=dict(
-            bgcolor='rgba(30, 30, 30, 0.8)',
-            bordercolor='rgba(255, 255, 255, 0.2)',
-            borderwidth=1,
-            font=dict(color='white', size=10),
             orientation='h',
             yanchor='bottom',
             y=1.02,
             xanchor='center',
-            x=0.5
+            x=0.5,
+            bgcolor='rgba(30,30,30,0.8)'
         ),
-        margin=dict(l=50, r=50, b=100, t=100, pad=4),
-        height=800,  # Increased height
-        width=1200   # Increased width
+        height=800,
+        width=1200,
+        hovermode='closest'
     )
-    
-    # Add range selector for better time navigation
-    fig.update_xaxes(
-        rangeslider_visible=True,
-        rangeselector=dict(
-            buttons=list([
-                dict(count=1, label="1m", step="month", stepmode="backward"),
-                dict(count=3, label="3m", step="month", stepmode="backward"),
-                dict(count=6, label="6m", step="month", stepmode="backward"),
-                dict(count=1, label="YTD", step="year", stepmode="todate"),
-                dict(count=1, label="1y", step="year", stepmode="backward"),
-                dict(step="all")
-            ]),
-            bgcolor='rgba(30, 30, 30, 0.8)',
-            activecolor='#536dfe',
-            font=dict(color='white')
-        )
-    )
-    
+    fig.update_xaxes(rangeslider_visible=True)
     return fig
 
-def stock_analysis(ticker, start_date, end_date, 
-                  sensitivity,  # New simplified parameter
-                  use_sma, use_macd, use_rsi, use_bb, 
-                  use_stoch, use_cmf, use_cci):
+# ======================
+# Main Analysis Function
+# ======================
+
+def stock_analysis(
+    ticker,
+    start_date,
+    end_date,
+    rsi_lower,
+    rsi_upper,
+    bb_buffer,
+    stoch_lower,
+    stoch_upper,
+    cmf_threshold,
+    show_bollinger
+):
     try:
-        # Download stock data from Yahoo Finance
-        df = yf.download(ticker, start=start_date, end=end_date)
-        
-        # Check if data was retrieved
-        if df.empty:
-            fig = go.Figure()
-            fig.add_annotation(
-                text="No data found for this ticker and date range",
-                xref="paper", yref="paper", 
-                x=0.5, y=0.5, 
-                showarrow=False,
-                font=dict(color="white", size=16)
-            )
-            fig.update_layout(
-                plot_bgcolor='#1e1e1e',
-                paper_bgcolor='#1e1e1e',
-                height=800,
-                width=1200
-            )
-            return fig
-
-        # If the DataFrame has a MultiIndex for columns, handle it
-        if isinstance(df.columns, pd.MultiIndex):
-            df.columns = df.columns.droplevel(1) if len(df.columns.levels) > 1 else df.columns
-        
-        # Create list of enabled signals
-        enabled_signals = []
-        if use_sma: enabled_signals.append('SMA')
-        if use_macd: enabled_signals.append('MACD')
-        if use_rsi: enabled_signals.append('RSI')
-        if use_bb: enabled_signals.append('BB')
-        if use_stoch: enabled_signals.append('Stochastic')
-        if use_cmf: enabled_signals.append('CMF')
-        if use_cci: enabled_signals.append('CCI')
-        
-        # If no signals are enabled, enable all by default
-        if not enabled_signals:
-            enabled_signals = ['SMA', 'MACD', 'RSI', 'BB', 'Stochastic', 'CMF', 'CCI']
-        
-        # Get thresholds from sensitivity
-        thresholds = adjust_thresholds_by_sensitivity(sensitivity)
-        
-        # Generate signals
-        df = generate_trading_signals(df, thresholds, enabled_signals)
-        
-        # Last 360 days for plotting (or all data if less than 360 days)
-        df_last_360 = df.tail(min(360, len(df)))
-
-        # Plot simplified signals
-        fig = plot_simplified_signals(df_last_360, ticker, enabled_signals)
-        
-        return fig
-        
+        tickers = [t.strip().upper() for t in ticker.split(',') if t.strip()][:8]
+        if not tickers:
+            raise ValueError("No valid ticker provided")
+
+        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 = {}
+        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 data_dict:
+            raise ValueError("No data retrieved for any ticker")
+
+        return plot_multi_ticker_signals(data_dict, enabled_signals, show_bollinger)
+
     except Exception as e:
-        # Create error figure
         fig = go.Figure()
         fig.add_annotation(
             text=f"Error: {str(e)}",
-            xref="paper", yref="paper", 
-            x=0.5, y=0.5, 
+            x=0.5, y=0.5,
             showarrow=False,
-            font=dict(color="#ff5252", size=16)
+            font=dict(color="red", size=16)
         )
         fig.update_layout(
             plot_bgcolor='#1e1e1e',
             paper_bgcolor='#1e1e1e',
-            font=dict(color='white'),
             height=800,
             width=1200
         )
         return fig
 
-# Define Gradio interface with improved styling
+# ======================
+# Gradio Interface
+# ======================
+
 custom_theme = gr.themes.Monochrome(
     primary_hue="blue",
     secondary_hue="purple",
@@ -420,83 +264,58 @@ custom_theme = gr.themes.Monochrome(
 )
 
 with gr.Blocks(theme=custom_theme) as demo:
-    gr.Markdown("# Technical Analysis")
-    gr.Markdown("This app helps you analyze stocks with technical indicators and generates trading signals.")
+    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.Row():
         with gr.Column(scale=1):
             ticker_input = gr.Textbox(
-                label="Stock Ticker Symbol",
-                placeholder="e.g., AAPL, NVDA, MSFT",
-                value="NVDA"
-            )
-            start_date_input = gr.Textbox(
-                label="Start Date",
-                placeholder="YYYY-MM-DD",
-                value="2022-01-01"
-            )
-            end_date_input = gr.Textbox(
-                label="End Date",
-                placeholder="YYYY-MM-DD",
-                value="2026-01-01"  # Updated to current date
+                label="Tickers (comma-separated, max 8)",
+                placeholder="e.g., AAPL, MSFT, GOOGL, NVDA, TSLA, AMD, META, AMZN",
+                value="NVDA, AAPL, MSFT"
             )
-            
-            gr.Markdown("### Choose Indicators")
-            with gr.Row():
-                use_sma = gr.Checkbox(label="SMA", value=True)
-                use_macd = gr.Checkbox(label="MACD", value=True)
-                use_rsi = gr.Checkbox(label="RSI", value=True)
-                use_bb = gr.Checkbox(label="Bollinger", value=True)
-                use_stoch = gr.Checkbox(label="Stochastic", value=True)
-                use_cmf = gr.Checkbox(label="CMF", value=True)
-                use_cci = gr.Checkbox(label="CCI", value=True)
-            
-            gr.Markdown("### Signal Sensitivity")
-            with gr.Row():
-                sensitivity = gr.Slider(
-                    label="Signal Sensitivity", 
-                    minimum=1, 
-                    maximum=10, 
-                    step=1, 
-                    value=5, 
-                    info="1 = (sensitive), 10 = (strict)"
-                )
-            
-            # Create a submit button with styling
-            button = gr.Button("Analyze Stock", variant="primary")
-    
-    # Output: Signals plot with increased height
-    signals_output = gr.Plot(label="Technical Analysis & Trading Signals")
-
-    # Link button to function with updated parameters
-    button.click(
-        stock_analysis, 
+            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,
-            sensitivity,  # Single threshold parameter
-            use_sma, use_macd, use_rsi, use_bb, 
-            use_stoch, use_cmf, use_cci
-        ], 
-        outputs=[signals_output]
+            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
     )
 
     gr.Markdown("""
-    ## 📈 Trading Signals Legend
-    - **Green Triangle Up (▲)** indicates Buy signals
-    - **Red Triangle Down (▼)** indicates Sell signals
-    - Hover over signals to see which indicators triggered them
-    
-    ## 🔍 Signal Sensitivity Explained
-    - **Lower values (1-3)**: More frequent signals, good for short-term trading
-    - **Medium values (4-6)**: Balanced approach, moderate number of signals
-    - **Higher values (7-10)**: Fewer but potentially stronger signals, good for long-term investors
-    
-    ## 🛠️ Trading Strategy Tips
-    - **Day Trading**: Use lower sensitivity with multiple indicators
-    - **Swing Trading**: Use medium sensitivity with 3-4 indicators
-    - **Long-term Investing**: Use higher sensitivity focusing on trend indicators
-    - **Combine**: Using multiple indicators helps confirm signals and reduce false positives
+    ### 📌 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
     """)
 
-# Launch the interface
-demo.launch()
+# Launch
+if __name__ == "__main__":
+    demo.launch()