Update app.py

app.py

@@ -1,22 +1,21 @@
 # %%
-# Install necessary packages if not already installed
-# pip install gradio yfinance prophet plotly matplotlib
-
+# %%
 import gradio as gr
 import pandas as pd
 import yfinance as yf
 from datetime import datetime
-import plotly.express as px
 import plotly.graph_objects as go
-import matplotlib.pyplot as plt
 import numpy as np
 
 # Functions for calculating indicators (SMA, RSI, etc.) and generating trading signals
-# (Reuse the code you've already written for technical indicators and forecasting)
 
 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()
@@ -24,6 +23,7 @@ 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,43 +45,81 @@ def calculate_stochastic_oscillator(df):
     slowd = slowk.rolling(window=3).mean()
     return slowk, slowd
 
-def generate_trading_signals(df):
+def calculate_atr(df, window=14):
+    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 = high_low.combine(high_close, max).combine(low_close, max)
+    atr = tr.rolling(window=window).mean()
+    return atr
+
+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
 
-    # Calculate Simple Moving Averages (SMA)
-    df['SMA_50'] = calculate_sma(df, 50)
-    df['SMA_200'] = calculate_sma(df, 200)
 
-    # Calculate other technical indicators
+
+
+
+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['ATR'] = calculate_atr(df)
+    df['CMF'] = calculate_cmf(df)
+    df['CCI'] = calculate_cci(df)
+
+    
 
     # Generate trading signals
-    df['SMA_Signal'] = np.where(df['SMA_50'] > df['SMA_200'], 1, 0)
+    df['SMA_Signal'] = np.where(df['SMA_30'] > df['SMA_100'], 1, 0)
     
     macd, signal = calculate_macd(df)
-    df['MACD_Signal'] = np.where((macd > signal.shift(1)) & (macd.shift(1) < signal), 1, 0)
+    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)
+
+
     
-    df['RSI_Signal'] = np.where(df['RSI'] < 30, 1, 0)
-    df['RSI_Signal'] = np.where(df['RSI'] > 70, -1, df['RSI_Signal'])
+    df['RSI_Signal'] = np.where(df['RSI'] < 20, 1, 0)
+    df['RSI_Signal'] = np.where(df['RSI'] > 90, -1, df['RSI_Signal'])
     
-    df['BB_Signal'] = np.where(df['Close'] < df['LowerBB'], 1, 0)
+    df['BB_Signal'] = np.where(df['Close'] < df['LowerBB'], 0, 0)
     df['BB_Signal'] = np.where(df['Close'] > df['UpperBB'], -1, df['BB_Signal'])
     
-    df['Stochastic_Signal'] = np.where((df['SlowK'] < 20) & (df['SlowD'] < 20), 1, 0)
-    df['Stochastic_Signal'] = np.where((df['SlowK'] > 80) & (df['SlowD'] > 80), -1, df['Stochastic_Signal'])
-
-    # Summing the values of each individual signal column
-    df['Combined_Signal'] = df[['SMA_Signal', 'MACD_Signal', 'RSI_Signal', 'BB_Signal', 'Stochastic_Signal']].sum(axis=1)
+    df['Stochastic_Signal'] = np.where((df['SlowK'] < 10) & (df['SlowD'] < 15), 1, 0)
+    df['Stochastic_Signal'] = np.where((df['SlowK'] > 90) & (df['SlowD'] > 85), -1, df['Stochastic_Signal'])
+    
+    df['CMF_Signal'] = np.where(df['CMF'] > 0.3, -1, np.where(df['CMF'] < -0.3, 1, 0))
 
+    
+    df['CCI_Signal'] = np.where(df['CCI'] < -180, 1, 0)
+    df['CCI_Signal'] = np.where(df['CCI'] > 150, -1, df['CCI_Signal'])
+    
 
 
+    # Combined signal for stronger buy/sell points
+    df['Combined_Signal'] = df[['RSI_Signal', 'BB_Signal', 
+                                  'Stochastic_Signal', 'CMF_Signal', 
+                                  'CCI_Signal']].sum(axis=1)
 
+    return df
 
 
 # %%
-import plotly.graph_objects as go
-
 def plot_combined_signals(df, ticker):
     # Create a figure
     fig = go.Figure()
@@ -104,7 +142,7 @@ def plot_combined_signals(df, ticker):
     ))
 
     # Add sell signals
-    sell_signals = df[df['Combined_Signal'] <= -2]
+    sell_signals = df[df['Combined_Signal'] <= -3]
     fig.add_trace(go.Scatter(
         x=sell_signals.index, y=sell_signals['Close'], 
         mode='markers', 
@@ -112,7 +150,7 @@ def plot_combined_signals(df, ticker):
         name='Sell Signal'
     ))
 
-    # Add combined signal trace
+    # Combined signal trace
     fig.add_trace(go.Scatter(
         x=df.index, y=df['Combined_Signal'], 
         mode='lines', 
@@ -121,41 +159,126 @@ def plot_combined_signals(df, ticker):
         yaxis='y2'
     ))
 
-    # Update layout for secondary y-axis
+    # Update layout
     fig.update_layout(
         title=f'{ticker}: Stock Price and Combined Trading Signal (Last 60 Days)',
-        xaxis=dict(title='Date', gridcolor='gray', gridwidth=0.5),
-        yaxis=dict(title='Price', side='left', gridcolor='gray', gridwidth=0.5),
+        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'),
-        legend=dict(x=0.01, y=0.99, bgcolor='rgba(0,0,0,0)'),
-        hovermode='x unified'
+        font=dict(color='white')
     )
 
     return fig
 
-
 # %%
 def stock_analysis(ticker, start_date, end_date):
     # Download stock data from Yahoo Finance
     df = yf.download(ticker, start=start_date, end=end_date)
     
-    # Run your existing trading signals and indicators here
+    # Generate signals
     generate_trading_signals(df)
     
     # Last 60 days
     df_last_60 = df.tail(60)
     
-    # Plot trading signals using the improved function
+    # Plot signals
     fig_signals = plot_combined_signals(df_last_60, ticker)
     
-    
-    # Combine the figures into HTML output
     return fig_signals
 
 
+
+
+# %%
+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='lightcoral', width=2)
+    ))
+
+    # Add buy/sell signals for each indicator
+    signal_names = ['RSI_Signal', 'BB_Signal', 
+                    'Stochastic_Signal', 'CMF_Signal', 
+                    'CCI_Signal']
+
+    for signal in signal_names:
+        buy_signals = df[df[signal] == 1]
+        sell_signals = df[df[signal] == -1]
+        
+        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=f'{signal} Buy Signal'
+        ))
+
+        fig.add_trace(go.Scatter(
+            x=sell_signals.index, y=sell_signals['Close'], 
+            mode='markers', 
+            marker=dict(symbol='triangle-down', size=10, color='lightsalmon'), 
+            name=f'{signal} Sell Signal'
+        ))
+
+    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')
+    )
+
+    return fig
+
+
+def display_signals(df):
+    # Create a signals DataFrame
+    signals_df = df[['Close', 'SMA_Signal', 'MACD_Signal', 'RSI_Signal', 
+                      'BB_Signal', 'Stochastic_Signal', 'ATR_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'}
+        )
+
+    return signals_df
+
+def stock_analysis(ticker, start_date, end_date):
+    # Download stock data from Yahoo Finance
+    df = yf.download(ticker, start=start_date, end=end_date)
+
+    # Generate signals
+    df = generate_trading_signals(df)
+    
+    # Last 60 days for plotting
+    df_last_60 = df.tail(60)
+
+    # Plot combined signals
+    fig_signals = plot_combined_signals(df_last_60, ticker)
+
+    # Plot individual signals
+    fig_individual_signals = plot_individual_signals(df_last_60, ticker)
+
+    # Display signals DataFrame
+    signals_df = df_last_60[['Close', 'SMA_Signal', 'MACD_Signal', 'RSI_Signal', 'BB_Signal', 
+                              'Stochastic_Signal', 'ATR_Signal', 'CMF_Signal', 
+                              'CCI_Signal']]
+
+    return fig_signals, fig_individual_signals
+
+
+
 # %%
 # Define Gradio interface
 with gr.Blocks() as demo:
@@ -169,12 +292,16 @@ with gr.Blocks() as demo:
     button = gr.Button("Analyze Stock")
     
     # Outputs: Display results, charts
-    signals_output = gr.Plot(label="Trading Signals")
+    combined_signals_output = gr.Plot(label="Combined Trading Signals")
+    individual_signals_output = gr.Plot(label="Individual Trading Signals")
+    #signals_df_output = gr.Dataframe(label="Buy/Sell Signals")
 
     # Link button to function
-    button.click(stock_analysis, inputs=[ticker_input, start_date_input, end_date_input], outputs=[signals_output])
+    button.click(stock_analysis, inputs=[ticker_input, start_date_input, end_date_input], 
+                  outputs=[combined_signals_output, individual_signals_output])
 
 # Launch the interface
 demo.launch()
 
 
+