Update app.py

app.py

@@ -1,21 +1,16 @@
-# %%
-# %%
 import gradio as gr
 import pandas as pd
 import yfinance as yf
-from datetime import datetime
 import plotly.graph_objects as go
 import numpy as np
 
-# Functions for calculating indicators (SMA, RSI, etc.) and generating trading signals
-
+# Functions for calculating indicators (keeping these unchanged)
 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()
@@ -23,7 +18,6 @@ def calculate_macd(df):
     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()
@@ -45,23 +39,18 @@ def calculate_stochastic_oscillator(df):
     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
 
-
-
 def generate_trading_signals(df):
     # Calculate various indicators
     df['SMA_30'] = calculate_sma(df, 30)
@@ -74,228 +63,332 @@ def generate_trading_signals(df):
     df['CMF'] = calculate_cmf(df)
     df['CCI'] = calculate_cci(df)
 
-    
-
-    # Generate trading signals
-    df['SMA_Signal'] = np.where(df['SMA_30'] > df['SMA_100'], 1, 0)
+    # Generate trading signals with stricter SMA threshold
+    # Making SMA threshold stricter - require 3% difference between SMAs
+    df['SMA_Diff_Pct'] = (df['SMA_30'] - df['SMA_100']) / df['SMA_100'] * 100
+    df['SMA_Signal'] = np.where(df['SMA_Diff_Pct'] > 30, 1, 0)  # Buy when SMA_30 is 30% above SMA_100
+    df['SMA_Signal'] = np.where(df['SMA_Diff_Pct'] < -30, -1, df['SMA_Signal'])  # Sell when SMA_30 is 30% below SMA_100
     
     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)
-
-
-    # Modified RSI Signals (tighter thresholds)
-    df['RSI_Signal'] = np.where(df['RSI'] < 12, 1, 0)  # Changed from 20 to 15
-    df['RSI_Signal'] = np.where(df['RSI'] > 95, -1, df['RSI_Signal'])  # Changed from 90 to 95
+                                   (macd < signal) & (macd.shift(1) >= signal.shift(1))], [1, -1], default=0)
 
+    # RSI Signals
+    df['RSI_Signal'] = np.where(df['RSI'] < 12, 1, 0)
+    df['RSI_Signal'] = np.where(df['RSI'] > 95, -1, df['RSI_Signal'])
     
-    # Modified Bollinger Bands (require confirmation)
-
+    # Bollinger Bands with buffer
     buffer_percentage = 0.01  # 1% buffer
-
-    # Buy signal: Price below LowerBB for 2 consecutive periods with buffer
     df['BB_Signal'] = np.where(
         (df['Close'] < df['LowerBB'] * (1 - buffer_percentage)) & 
         (df['Close'].shift(1) < df['LowerBB'].shift(1) * (1 - buffer_percentage)) & 
         (df['Close'].shift(2) < df['LowerBB'].shift(2) * (1 - buffer_percentage)), 1, 0
     )
-    
-    # Sell signal: Price above UpperBB for 2 consecutive periods with buffer
     df['BB_Signal'] = np.where(
         (df['Close'] > df['UpperBB'] * (1 + buffer_percentage)) & 
         (df['Close'].shift(1) > df['UpperBB'].shift(1) * (1 + buffer_percentage)) & 
         (df['Close'].shift(2) > df['UpperBB'].shift(2) * (1 + buffer_percentage)), -1, df['BB_Signal']
     )
-
     
-    # Modified Stochastic (tighter thresholds)
+    # Stochastic signals
     df['Stochastic_Signal'] = np.where((df['SlowK'] < 5) & (df['SlowD'] < 5), 1, 0)
     df['Stochastic_Signal'] = np.where((df['SlowK'] > 99) & (df['SlowD'] > 95), -1, df['Stochastic_Signal'])
 
-    # Modified CMF Signals
-    df['CMF_Signal'] = np.where(df['CMF'] > 0.4, -1, np.where(df['CMF'] < -0.4, 1, 0))  # Changed from 0.3 to 0.4
+    # CMF Signals
+    df['CMF_Signal'] = np.where(df['CMF'] > 0.4, -1, np.where(df['CMF'] < -0.4, 1, 0))
 
-    # Modified CCI Signals
-    df['CCI_Signal'] = np.where(df['CCI'] < -195, 1, 0)  # Changed from -180
-    df['CCI_Signal'] = np.where(df['CCI'] > 195, -1, df['CCI_Signal'])  # Changed from 150
+    # CCI Signals
+    df['CCI_Signal'] = np.where(df['CCI'] < -195, 1, 0)
+    df['CCI_Signal'] = np.where(df['CCI'] > 195, -1, df['CCI_Signal'])
 
-    # Include SMA and MACD in combined signals
+    # Combined signal (keeping for reference but not used in the output)
     df['Combined_Signal'] = df[['RSI_Signal', 'BB_Signal', 
                                'Stochastic_Signal', 'CMF_Signal', 
                                'CCI_Signal', 'MACD_Signal']].sum(axis=1)
 
     return df
 
-# %%
-def plot_combined_signals(df, ticker):
-    # Create a figure
+def plot_simplified_signals(df, ticker):
+    # Create a figure with improved styling
     fig = go.Figure()
-
-    # Add closing price trace
+    
+    # Use a line chart instead of candlestick for simplicity
     fig.add_trace(go.Scatter(
-        x=df.index, y=df['Close'], 
+        x=df.index, 
+        y=df['Close'],
         mode='lines', 
-        name='Closing Price', 
-        line=dict(color='indigo', width=2)
+        name='Price', 
+        line=dict(color='#26a69a', width=2),
+        opacity=0.9
     ))
-
-    # Add buy signals
-    buy_signals = df[df['Combined_Signal'] >= 3]
+    
+    # Add SMA lines
     fig.add_trace(go.Scatter(
-        x=buy_signals.index, y=buy_signals['Close'], 
-        mode='markers', 
-        marker=dict(symbol='triangle-up', size=10, color='lightgreen'), 
-        name='Buy Signal'
+        x=df.index, y=df['SMA_30'], 
+        mode='lines', 
+        name='SMA 30', 
+        line=dict(color='#42a5f5', width=1.5, dash='dot')
     ))
-
-    # Add sell signals
-    sell_signals = df[df['Combined_Signal'] <= -2]
+    
     fig.add_trace(go.Scatter(
-        x=sell_signals.index, y=sell_signals['Close'], 
-        mode='markers', 
-        marker=dict(symbol='triangle-down', size=10, color='red'), 
-        name='Sell Signal'
+        x=df.index, y=df['SMA_100'], 
+        mode='lines', 
+        name='SMA 100', 
+        line=dict(color='#5e35b1', width=1.5, dash='dot')
     ))
 
-    # Combined signal trace
+    # Add bollinger bands with lighter appearance
     fig.add_trace(go.Scatter(
-        x=df.index, y=df['Combined_Signal'], 
-        mode='lines', 
-        name='Combined Signal', 
-        line=dict(color='lightgreen', width=0.5), 
-        yaxis='y2'
+        x=df.index, y=df['UpperBB'],
+        mode='lines',
+        name='Upper BB',
+        line=dict(color='rgba(250, 250, 250, 0.3)', width=1),
+        showlegend=True
     ))
-
-    # Update layout
-    fig.update_layout(
-        title=f'{ticker}: 360 Stock Price and Combined Trading Signal',
-        xaxis=dict(title='Date'),
-        yaxis=dict(title='Price', side='left'),
-        yaxis2=dict(title='Combined Signal', overlaying='y', side='right', showgrid=False),
-        plot_bgcolor='black',
-        paper_bgcolor='black',
-        font=dict(color='white')
-    )
-
-    return fig
-
-
-
-
-# %%
-def plot_individual_signals(df, ticker):
-    # Create a figure
-    fig = go.Figure()
+    
     fig.add_trace(go.Scatter(
-        x=df.index, y=df['Close'], 
-        mode='lines', 
-        name='Closing Price', 
-        line=dict(color='lightgreen', width=2)
+        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
     ))
 
-    # Add buy/sell signals for each indicator
-    signal_names = ['RSI_Signal', 'BB_Signal', 
-                    'Stochastic_Signal', 'CMF_Signal', 
-                    'CCI_Signal']
-
+    # 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 = ['RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 
+                   'CMF_Signal', 'CCI_Signal', 'MACD_Signal', 'SMA_Signal']
+    
+    # Collect all buy and sell signals
     for signal in signal_names:
-        buy_signals = df[df[signal] == 1]
-        sell_signals = df[df[signal] == -1]
-        
+        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)
         fig.add_trace(go.Scatter(
-            x=buy_signals.index, y=buy_signals['Close'], 
+            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='blackblue'), 
-            name=f'{signal} Buy Signal'
+            marker=dict(symbol='triangle-up', size=10, color='#00e676', line=dict(color='white', width=1)), 
+            name='Buy Signals',
+            hoverinfo='text',
+            hovertext=buy_texts
         ))
 
+    # Add sell signals (single trace for all sell signals)
+    if sell_hovers:
+        sell_x, sell_y, sell_texts = zip(*sell_hovers)
         fig.add_trace(go.Scatter(
-            x=sell_signals.index, y=sell_signals['Close'], 
+            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='red'), 
-            name=f'{signal} Sell Signal'
+            marker=dict(symbol='triangle-down', size=10, color='#ff5252', line=dict(color='white', width=1)), 
+            name='Sell Signals',
+            hoverinfo='text',
+            hovertext=sell_texts
         ))
 
+    # Improve the layout
     fig.update_layout(
-        title=f'{ticker}: Individual Trading Signals',
-        xaxis=dict(title='Date'),
-        yaxis=dict(title='Price', side='left'),
-        plot_bgcolor='black',
-        paper_bgcolor='black',
-        font=dict(color='white')
+        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='$'
+        ),
+        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
+        ),
+        margin=dict(l=50, r=50, b=100, t=100, pad=4)
     )
-
-    return fig
-
-
-def display_signals(df):
-    # Create a signals DataFrame
-    signals_df = df[['Close', 'SMA_Signal', 'MACD_Signal', 'RSI_Signal', 
-                      'BB_Signal', 'Stochastic_Signal', 
-                      'CMF_Signal', 'CCI_Signal']].copy()
-
-    # The Date is the index, so we don't need to add it as a column
-    signals_df.index.name = 'Date'  # Name the index for better readability
-
-    # Replace signal values with 'Buy', 'Sell', or 'Hold'
-    for column in signals_df.columns:
-        signals_df[column] = signals_df[column].replace(
-            {1: 'Buy', -1: 'Sell', 0: 'Hold'}
+    
+    # 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')
         )
+    )
+    
+    return fig
 
-    return signals_df
-
-# Define the stock analysis function (keep only one version)
 def stock_analysis(ticker, start_date, end_date):
-    # Download stock data from Yahoo Finance
-    df = yf.download(ticker, start=start_date, end=end_date)
-
-    # If the DataFrame has a MultiIndex for columns, handle it
-    if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.droplevel(1)
-    
-    # Generate signals
-    df = generate_trading_signals(df)
-    
-    # Last 360 days for plotting
-    df_last_360 = df.tail(360)
+    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'
+            )
+            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
+        
+        # Generate signals
+        df = generate_trading_signals(df)
+        
+        # Last 360 days for plotting (or all data if less than 360 days)
+        df_last_360 = df.tail(min(360, len(df)))
 
-    # Plot combined signals
-    fig_signals = plot_combined_signals(df_last_360, ticker)
+        # Plot simplified signals
+        fig_individual = plot_simplified_signals(df_last_360, ticker)
+        
+        return fig_individual
+        
+    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, 
+            showarrow=False,
+            font=dict(color="#ff5252", size=16)
+        )
+        fig.update_layout(
+            plot_bgcolor='#1e1e1e',
+            paper_bgcolor='#1e1e1e',
+            font=dict(color='white')
+        )
+        return fig
+
+# Define Gradio interface with improved styling
+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("# Simplified Stock Market Signal Analysis")
+    gr.Markdown("This app analyzes stock data and visualizes trading signals based on multiple technical indicators with a clean, simplified display.")
+
+    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"
+            )
+            
+            # Create a submit button with styling
+            button = gr.Button("Analyze Stock", variant="primary")
     
-    # Plot individual signals
-    fig_individual_signals = plot_individual_signals(df_last_360, ticker)
+    # Output: Signals plot
+    signals_output = gr.Plot(label="Technical Analysis & Trading Signals")
+
+    # Link button to function
+    button.click(
+        stock_analysis, 
+        inputs=[ticker_input, start_date_input, end_date_input], 
+        outputs=[signals_output]
+    )
 
-    # Create signals DataFrame for display
-    signals_df = df_last_360[['Close', 'SMA_Signal', 'MACD_Signal', 'RSI_Signal', 
-                             'BB_Signal', 'Stochastic_Signal', 'CMF_Signal', 
-                             'CCI_Signal']].copy()
+    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
     
-    # Format signals for display
-    for column in signals_df.columns[1:]:  # Skip 'Close'
-        signals_df[column] = signals_df[column].replace({1: 'Buy', -1: 'Sell', 0: 'Hold'})
-
-    return fig_individual_signals, signals_df
-
-# Define Gradio interface
-with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("## 360 Stock Market Analysis")
-
-    ticker_input = gr.Textbox(label="Enter Stock Ticker (e.g., AAPL, NVDA)", value="NVDA")
-    start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", value="2022-01-01")
-    end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", value="2023-01-01")  # Fixed end date
-
-    # Create a submit button that runs the stock analysis function
-    button = gr.Button("Analyze Stock")
+    ## 🔍 Indicators & Thresholds
+    - **SMA**: Simple Moving Average (30 & 100 days) - 30% threshold
+    - **MACD**: Moving Average Convergence Divergence (12, 26, 9)
+    - **RSI**: Relative Strength Index (Buy < 12, Sell > 95)
+    - **BB**: Bollinger Bands (with 1% buffer)
+    - **Stochastic**: Stochastic Oscillator (Buy < 5, Sell > 99)
+    - **CMF**: Chaikin Money Flow (Buy < -0.4, Sell > 0.4)
+    - **CCI**: Commodity Channel Index (Buy < -195, Sell > 195)
     
-    # Outputs: Display results, charts
-    individual_signals_output = gr.Plot(label="Trading Signals")
-    signals_df_output = gr.Dataframe(label="Buy/Sell Signals")
-
-    # Link button to function with both outputs
-    button.click(stock_analysis, 
-                inputs=[ticker_input, start_date_input, end_date_input], 
-                outputs=[individual_signals_output,signals_df_output])
+    ## 💡 Visualization Improvements
+    - Simple line chart for price
+    - Consolidated buy/sell signals
+    - Reduced visual clutter
+    - Enhanced hover information
+    - Interactive time range selection
+    """)
 
 # Launch the interface
-demo.launch()
+demo.launch()