deploy #1

requirements.txt

@@ -1,3 +1,5 @@
-altair
 pandas
+numpy
+matplotlib
+yfinance
 streamlit

src/.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.streamlit/
+config.toml

src/README.md

@@ -0,0 +1 @@
+# Placeholder for README.md

src/config.py

@@ -0,0 +1,6 @@
+# config.py
+STOCKS = ['RELIANCE.NS', 'TCS.NS', 'INFY.NS']
+START_DATE = '2014-02-01'
+RSI_PERIOD = 14
+SMA_SHORT = 20
+SMA_LONG = 50

src/indicators/ema.py

@@ -0,0 +1,9 @@
+# indicators/sma.py
+
+import pandas as pd
+
+def ema(df, period=20, column="Close"):
+    """
+    Calculates Exponential Moving Average (EMA)
+    """
+    return df[column].ewm(span=period, adjust=False).mean()

src/indicators/enhanced_features.py

@@ -0,0 +1,67 @@
+def create_volatility_features(df):
+    if 'return_1d' not in df.columns:
+        df['return_1d'] = df['Close'].pct_change()
+    
+    for period in [5, 10, 20, 30]:
+        df[f'volatility_{period}d'] = df['return_1d'].rolling(period).std()
+    
+    df['vol_ratio_5_20'] = df['volatility_5d'] / df['volatility_20d']
+    df['vol_ratio_10_20'] = df['volatility_10d'] / df['volatility_20d']
+    df['vol_rank_20'] = df['volatility_5d'].rolling(20).rank(pct=True)
+    df['vol_rank_50'] = df['volatility_5d'].rolling(50).rank(pct=True)
+    
+    return df
+
+def create_enhanced_lag_features(df):
+    for lag in [1, 2, 3, 5, 10]:
+        df[f'return_lag_{lag}'] = df['return_1d'].shift(lag)
+    
+    for lag in [1, 2, 3]:
+        if 'RSI14' in df.columns:
+            df[f'rsi_lag_{lag}'] = df['RSI14'].shift(lag)
+        if 'MACD' in df.columns:
+            df[f'macd_lag_{lag}'] = df['MACD'].shift(lag)
+    
+    if 'volume_ratio_20' in df.columns:
+        for lag in [1, 2]:
+            df[f'volume_ratio_lag_{lag}'] = df['volume_ratio_20'].shift(lag)
+    
+    return df
+
+def create_volume_features(df):
+    df['volume_sma_10'] = df['Volume'].rolling(10).mean()
+    df['volume_sma_20'] = df['Volume'].rolling(20).mean()
+    df['volume_sma_50'] = df['Volume'].rolling(50).mean()
+    
+    df['volume_ratio_10'] = df['Volume'] / df['volume_sma_10']
+    df['volume_ratio_20'] = df['Volume'] / df['volume_sma_20']
+    df['volume_ratio_50'] = df['Volume'] / df['volume_sma_50']
+    
+    df['price_volume'] = df['Close'] * df['Volume']
+    df['pv_sma_5'] = df['price_volume'].rolling(5).mean()
+    df['volume_momentum_5'] = df['Volume'] / df['Volume'].shift(5)
+    
+    return df
+
+def create_momentum_features(df):
+    for period in [3, 5, 10, 20]:
+        df[f'momentum_{period}d'] = df['Close'] / df['Close'].shift(period) - 1
+    
+    for period in [5, 10]:
+        df[f'roc_{period}d'] = (df['Close'] - df['Close'].shift(period)) / df['Close'].shift(period)
+    
+    return df
+
+def create_position_features(df):
+    for period in [10, 20, 50]:
+        df[f'high_{period}d'] = df['High'].rolling(period).max()
+        df[f'low_{period}d'] = df['Low'].rolling(period).min()
+        df[f'price_position_{period}'] = (df['Close'] - df[f'low_{period}d']) / (df[f'high_{period}d'] - df[f'low_{period}d'])
+    
+    if 'SMA20' in df.columns:
+        bb_std = df['Close'].rolling(20).std()
+        df['bb_upper'] = df['SMA20'] + (bb_std * 2)
+        df['bb_lower'] = df['SMA20'] - (bb_std * 2)
+        df['bb_position'] = (df['Close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])
+    
+    return df

src/indicators/macd.py

@@ -0,0 +1,17 @@
+
+# indicators/macd.py
+
+import pandas as pd
+
+def macd(df, fast_period=12, slow_period=26, signal_period=9, column="Close"):
+    """
+    Calculates MACD Line, Signal Line, and Histogram
+    """
+    ema_fast = df[column].ewm(span=fast_period, adjust=False).mean()
+    ema_slow = df[column].ewm(span=slow_period, adjust=False).mean()
+
+    macd_line = ema_fast - ema_slow
+    signal_line = macd_line.ewm(span=signal_period, adjust=False).mean()
+    histogram = macd_line - signal_line
+
+    return macd_line, signal_line, histogram

src/indicators/rsi.py

@@ -0,0 +1,19 @@
+# indicators/rsi.py
+
+import pandas as pd
+
+def rsi(df, period=14, column="Close"):
+    """
+    Calculates Relative Strength Index (RSI)
+    """
+    delta = df[column].diff()
+    gain = delta.clip(lower=0)
+    loss = -1 * delta.clip(upper=0)
+
+    avg_gain = gain.ewm(com=period-1, min_periods=period).mean()
+    avg_loss = loss.ewm(com=period-1, min_periods=period).mean()
+
+    rs = avg_gain / avg_loss
+    rsi = 100 - (100 / (1 + rs))
+
+    return rsi

src/indicators/sma.py

@@ -0,0 +1,18 @@
+# indicators/sma.py
+
+import pandas as pd
+
+def sma(df, period=20, column="Close"):
+    """
+    Calculates Simple Moving Average (SMA)
+    """
+    return df[column].rolling(window=period).mean()
+
+
+
+def ema(df, period=20, column="Close"):
+    """
+    Calculates Exponential Moving Average (EMA)
+    """
+    return df[column].ewm(span=period, adjust=False).mean()
+

src/logs/log_2025-08-03_22-03-43.log

@@ -0,0 +1,7 @@
+2025-08-03 22:03:43,463 [INFO] - Logger initialized.
+2025-08-03 22:03:43,463 [INFO] - Fetching data for RELIANCE.NS from 2024-02-01 to 2025-08-03 22:03:39.386764
+2025-08-03 22:03:49,344 [INFO] - Downloaded 372 rows for RELIANCE.NS
+2025-08-03 22:04:04,219 [INFO] - Fetching data for TCS.NS from 2024-02-01 to 2025-08-03 22:03:39.386764
+2025-08-03 22:04:04,496 [INFO] - Downloaded 372 rows for TCS.NS
+2025-08-03 22:04:08,637 [INFO] - Fetching data for INFY.NS from 2024-02-01 to 2025-08-03 22:03:39.386764
+2025-08-03 22:04:08,888 [INFO] - Downloaded 372 rows for INFY.NS

src/main.py

@@ -0,0 +1,64 @@
+# main.py
+
+from utils.logger import setup_logger
+from utils.data_loader import fetch_stock_data
+from indicators.rsi import rsi
+from indicators.sma import sma
+from indicators.ema import ema
+from indicators.macd import macd
+from strategy.rule_based_strategy import generate_signals
+from utils.backtester import backtest_signals
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# 1. Setup logging
+setup_logger()
+
+# 2. Define configuration
+stocks = ['RELIANCE.NS', 'TCS.NS', 'INFY.NS']
+start_date = '2024-02-01'
+rsi_period = 14
+sma_short = 20
+sma_long = 50
+ema_short = 20
+ema_long = 50
+
+for symbol in stocks:
+    print(f"\n--- Running for: {symbol} ---")
+
+    # 3. Fetch stock data
+    df = fetch_stock_data(symbol, start_date=start_date)
+
+    if df.empty:
+        print(f"No data for {symbol}, skipping...")
+        continue
+
+    # 4. Add indicators
+    df['RSI'] = rsi(df, period=rsi_period)
+    df['SMA20'] = sma(df, period=sma_short)
+    df['SMA50'] = sma(df, period=sma_long)
+    df['EMA20'] = ema(df, period=ema_short)
+    df['EMA50'] = ema(df, period=ema_long)
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = macd(df)
+
+    # 5. Generate buy/sell signals
+    df = generate_signals(df, rsi_col='RSI', sma_short_col='SMA20', sma_long_col='SMA50')
+
+    # 6. Backtest strategy
+    results = backtest_signals(df, signal_col='Signal')
+
+    # 7. Plot equity curve
+    plt.figure(figsize=(10, 5))
+    plt.plot(results['Total'], label='Equity Curve')
+    plt.title(f"{symbol} - Backtest Equity Curve")
+    plt.xlabel("Date")
+    plt.ylabel("Portfolio Value (₹)")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+    # 8. Print final portfolio value
+    final_value = results['Total'].iloc[-1]
+    print(f"Final portfolio value for {symbol}: ₹{final_value:,.2f}")

src/main.txt

@@ -0,0 +1,65 @@
+# main.py
+
+from utils.logger import setup_logger
+from utils.data_loader import fetch_stock_data
+from indicators.rsi import rsi
+from indicators.sma import sma
+from indicators.macd import macd
+from strategy.rule_based_strategy import generate_signals
+from utils.backtester import backtest_signals
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# ---------------------- Configuration ----------------------
+STOCK = 'RELIANCE.NS'
+START_DATE = '2024-02-01'
+
+# Indicator Parameters
+RSI_PERIOD = 14
+SMA_SHORT = 20
+SMA_LONG = 50
+
+# Backtest Settings
+INITIAL_CASH = 100000
+# -----------------------------------------------------------
+
+
+def main():
+    # Initialize Logger
+    setup_logger()
+
+    print(f"\nFetching data for {STOCK}...")
+    df = fetch_stock_data(STOCK, start_date=START_DATE)
+
+    if df.empty:
+        print("No data available. Exiting.")
+        return
+
+    print("Calculating indicators...")
+    df['RSI'] = rsi(df, period=RSI_PERIOD)
+    df['SMA20'] = sma(df, period=SMA_SHORT)
+    df['SMA50'] = sma(df, period=SMA_LONG)
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = macd(df)
+
+    print("Generating signals...")
+    df = generate_signals(df, rsi_col='RSI', sma_short_col='SMA20', sma_long_col='SMA50')
+
+    print("Backtesting strategy...")
+    results = backtest_signals(df, signal_col='Signal', price_col='Close', initial_cash=INITIAL_CASH)
+
+    final_equity = results['Total'].iloc[-1]
+    print(f"\n✅ Final Portfolio Value: ₹{final_equity:,.2f}")
+
+    # Plotting equity curve
+    plt.figure(figsize=(12, 6))
+    results['Total'].plot(label='Equity Curve', color='green')
+    results['Close'].plot(label='Close Price', secondary_y=True, alpha=0.3)
+    plt.title(f"Backtest Results for {STOCK}")
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

src/main_app.py

@@ -0,0 +1,663 @@
+# main_app.py
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from utils.data_loader import fetch_stock_data
+from indicators.rsi import rsi
+from indicators.sma import sma
+from indicators.ema import ema
+from indicators.macd import macd
+from strategy.rule_based_strategy import generate_signals_sma, generate_signals_ema
+from utils.backtester import backtest_signals
+
+# Function to display strategy results with Plotly
+def display_strategy_results(df, results, metrics, strategy_name, period_short, period_long, initial_cash, selected_stock):
+    """
+    Display comprehensive strategy results in Streamlit interface using Plotly
+    """
+    
+    # Performance metrics in columns
+    st.subheader("📊 Performance Overview")
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("💰 Final Value", metrics['Final Portfolio Value'])
+        st.metric("📈 Total Return", metrics['Total Return'])
+    
+    with col2:
+        st.metric("🎯 Buy & Hold Return", metrics['Buy & Hold Return'])
+        st.metric("📊 Total Trades", metrics['Total Trades'])
+    
+    with col3:
+        st.metric("🏆 Win Rate", metrics['Win Rate'])
+        st.metric("⚡ Sharpe Ratio", metrics['Sharpe Ratio'])
+    
+    with col4:
+        st.metric("📉 Max Drawdown", metrics['Maximum Drawdown'])
+        st.metric("🔥 Volatility", metrics['Volatility (Annual)'])
+
+    # Get signals for plotting
+    signal_col = f'{strategy_name}_Signal'
+    buy_signals = df[df[signal_col] == 1]
+    sell_signals = df[df[signal_col] == -1]
+    
+    # 1. Main price chart with signals and moving averages
+    st.subheader(f"📉 {selected_stock} Price Chart with {strategy_name} Strategy")
+    
+    fig_price = go.Figure()
+    
+    # Add price line
+    fig_price.add_trace(go.Scatter(
+        x=df.index,
+        y=df['Close'],
+        mode='lines',
+        name='Close Price',
+        line=dict(color='purple', width=2),
+        hovertemplate='<b>Price</b>: ₹%{y:.2f}<br><b>Date</b>: %{x}<extra></extra>'
+    ))
+    
+    # Add moving averages
+    fig_price.add_trace(go.Scatter(
+        x=df.index,
+        y=df[f'{strategy_name}{period_short}'],
+        mode='lines',
+        name=f'{strategy_name}{period_short}',
+        line=dict(color='blue', width=2),
+        hovertemplate=f'<b>{strategy_name}{period_short}</b>: ₹%{{y:.2f}}<br><b>Date</b>: %{{x}}<extra></extra>'
+    ))
+    
+    fig_price.add_trace(go.Scatter(
+        x=df.index,
+        y=df[f'{strategy_name}{period_long}'],
+        mode='lines',
+        name=f'{strategy_name}{period_long}',
+        line=dict(color='red', width=2),
+        hovertemplate=f'<b>{strategy_name}{period_long}</b>: ₹%{{y:.2f}}<br><b>Date</b>: %{{x}}<extra></extra>'
+    ))
+    
+    # Add buy signals
+    if not buy_signals.empty:
+        fig_price.add_trace(go.Scatter(
+            x=buy_signals.index,
+            y=buy_signals['Close'],
+            mode='markers',
+            name='Buy Signal',
+            marker=dict(
+                symbol='triangle-up',
+                size=12,
+                color='green',
+                line=dict(color='darkgreen', width=1)
+            ),
+            hovertemplate='<b>BUY</b><br><b>Price</b>: ₹%{y:.2f}<br><b>Date</b>: %{x}<extra></extra>'
+        ))
+    
+    # Add sell signals
+    if not sell_signals.empty:
+        fig_price.add_trace(go.Scatter(
+            x=sell_signals.index,
+            y=sell_signals['Close'],
+            mode='markers',
+            name='Sell Signal',
+            marker=dict(
+                symbol='triangle-down',
+                size=12,
+                color='red',
+                line=dict(color='darkred', width=1)
+            ),
+            hovertemplate='<b>SELL</b><br><b>Price</b>: ₹%{y:.2f}<br><b>Date</b>: %{x}<extra></extra>'
+        ))
+    
+    # Add trend zones
+    fig_price.add_trace(go.Scatter(
+        x=df.index,
+        y=df[f'{strategy_name}{period_short}'],
+        fill=None,
+        mode='lines',
+        line_color='rgba(0,0,0,0)',
+        showlegend=False
+    ))
+    
+    fig_price.add_trace(go.Scatter(
+        x=df.index,
+        y=df[f'{strategy_name}{period_long}'],
+        fill='tonexty',
+        mode='lines',
+        line_color='rgba(0,0,0,0)',
+        fillcolor='rgba(0,255,0,0.1)',
+        name='Bullish Zone',
+        showlegend=True
+    ))
+    
+    fig_price.update_layout(
+        title=f"{selected_stock} - {strategy_name} Strategy Signals",
+        xaxis_title="Date",
+        yaxis_title="Price (₹)",
+        height=600,
+        hovermode='x unified',
+        template='plotly_white'
+    )
+    
+    st.plotly_chart(fig_price, use_container_width=True)
+    
+    # 2. Portfolio performance comparison
+    st.subheader("📈 Portfolio Performance vs Buy & Hold")
+    
+    # Calculate buy & hold
+    buy_hold_value = initial_cash * (df['Close'] / df['Close'].iloc[0])
+    
+    fig_perf = go.Figure()
+    
+    fig_perf.add_trace(go.Scatter(
+        x=results.index,
+        y=results['Total'],
+        mode='lines',
+        name='Strategy Portfolio',
+        line=dict(color='green', width=3),
+        hovertemplate='<b>Strategy</b>: ₹%{y:,.0f}<br><b>Date</b>: %{x}<extra></extra>'
+    ))
+    
+    fig_perf.add_trace(go.Scatter(
+        x=df.index,
+        y=buy_hold_value,
+        mode='lines',
+        name='Buy & Hold',
+        line=dict(color='blue', width=2, dash='dash'),
+        hovertemplate='<b>Buy & Hold</b>: ₹%{y:,.0f}<br><b>Date</b>: %{x}<extra></extra>'
+    ))
+    
+    fig_perf.update_layout(
+        title="Strategy vs Buy & Hold Performance",
+        xaxis_title="Date",
+        yaxis_title="Portfolio Value (₹)",
+        height=500,
+        hovermode='x unified',
+        template='plotly_white'
+    )
+    
+    st.plotly_chart(fig_perf, use_container_width=True)
+    
+    # 3. Technical indicators in columns
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("💹 RSI Indicator")
+        
+        fig_rsi = go.Figure()
+        
+        # RSI line
+        fig_rsi.add_trace(go.Scatter(
+            x=df.index,
+            y=df['RSI'],
+            mode='lines',
+            name='RSI',
+            line=dict(color='purple', width=2),
+            hovertemplate='<b>RSI</b>: %{y:.1f}<br><b>Date</b>: %{x}<extra></extra>'
+        ))
+        
+        # Overbought/Oversold lines
+        fig_rsi.add_hline(y=70, line_dash="dash", line_color="red", 
+                         annotation_text="Overbought (70)")
+        fig_rsi.add_hline(y=30, line_dash="dash", line_color="green", 
+                         annotation_text="Oversold (30)")
+        fig_rsi.add_hline(y=50, line_dash="solid", line_color="gray", 
+                         annotation_text="Midline (50)", opacity=0.5)
+        
+        # Fill zones
+        fig_rsi.add_hrect(y0=0, y1=30, fillcolor="red", opacity=0.1, 
+                         line_width=0, annotation_text="Oversold Zone")
+        fig_rsi.add_hrect(y0=70, y1=100, fillcolor="green", opacity=0.1, 
+                         line_width=0, annotation_text="Overbought Zone")
+        
+        # Add buy/sell signals on RSI
+        if not buy_signals.empty:
+            fig_rsi.add_trace(go.Scatter(
+                x=buy_signals.index,
+                y=buy_signals['RSI'],
+                mode='markers',
+                name='Buy Signal',
+                marker=dict(symbol='triangle-up', size=10, color='green'),
+                showlegend=False
+            ))
+        
+        if not sell_signals.empty:
+            fig_rsi.add_trace(go.Scatter(
+                x=sell_signals.index,
+                y=sell_signals['RSI'],
+                mode='markers',
+                name='Sell Signal',
+                marker=dict(symbol='triangle-down', size=10, color='red'),
+                showlegend=False
+            ))
+        
+        fig_rsi.update_layout(
+            title="RSI with Trading Signals",
+            xaxis_title="Date",
+            yaxis_title="RSI Value",
+            height=400,
+            yaxis=dict(range=[0, 100]),
+            template='plotly_white'
+        )
+        
+        st.plotly_chart(fig_rsi, use_container_width=True)
+    
+    with col2:
+        st.subheader("📊 MACD Indicator")
+        
+        fig_macd = make_subplots(rows=2, cols=1, 
+                                shared_xaxes=True,
+                                vertical_spacing=0.05,
+                                row_width=[0.7, 0.3])
+        
+        # MACD line
+        fig_macd.add_trace(go.Scatter(
+            x=df.index,
+            y=df['MACD'],
+            mode='lines',
+            name='MACD',
+            line=dict(color='blue', width=2),
+            hovertemplate='<b>MACD</b>: %{y:.3f}<extra></extra>'
+        ), row=1, col=1)
+        
+        # Signal line
+        fig_macd.add_trace(go.Scatter(
+            x=df.index,
+            y=df['MACD_signal'],
+            mode='lines',
+            name='Signal Line',
+            line=dict(color='orange', width=2),
+            hovertemplate='<b>Signal</b>: %{y:.3f}<extra></extra>'
+        ), row=1, col=1)
+        
+        # Zero line
+        fig_macd.add_hline(y=0, line_dash="solid", line_color="pink", 
+                          opacity=0.5, row=1, col=1)
+        
+        # MACD histogram
+        colors = ['green' if val >= 0 else 'red' for val in df['MACD_hist']]
+        fig_macd.add_trace(go.Bar(
+            x=df.index,
+            y=df['MACD_hist'],
+            name='MACD Histogram',
+            marker_color=colors,
+            opacity=0.6,
+            hovertemplate='<b>Histogram</b>: %{y:.3f}<extra></extra>'
+        ), row=2, col=1)
+        
+        fig_macd.update_layout(
+            title="MACD Indicator",
+            height=500,
+            template='plotly_white',
+            showlegend=True
+        )
+        
+        fig_macd.update_xaxes(title_text="Date", row=2, col=1)
+        fig_macd.update_yaxes(title_text="MACD Value", row=1, col=1)
+        fig_macd.update_yaxes(title_text="Histogram", row=2, col=1)
+        
+        st.plotly_chart(fig_macd, use_container_width=True)
+    
+    # 4. Bollinger Bands
+    st.subheader("📈 Bollinger Bands")
+    
+    fig_bb = go.Figure()
+    
+    # Price line
+    fig_bb.add_trace(go.Scatter(
+        x=df.index,
+        y=df['Close'],
+        mode='lines',
+        name='Close Price',
+        line=dict(color='purple', width=2),
+        hovertemplate='<b>Price</b>: ₹%{y:.2f}<extra></extra>'
+    ))
+    
+    # 20-day SMA
+    fig_bb.add_trace(go.Scatter(
+        x=df.index,
+        y=df['SMA20'],
+        mode='lines',
+        name='20-day SMA',
+        line=dict(color='blue', width=1.5),
+        hovertemplate='<b>SMA20</b>: ₹%{y:.2f}<extra></extra>'
+    ))
+    
+    # Upper Band
+    fig_bb.add_trace(go.Scatter(
+        x=df.index,
+        y=df['Upper_Band'],
+        mode='lines',
+        name='Upper Band',
+        line=dict(color='red', dash='dash', width=1.5),
+        hovertemplate='<b>Upper Band</b>: ₹%{y:.2f}<extra></extra>'
+    ))
+    
+    # Lower Band with fill
+    fig_bb.add_trace(go.Scatter(
+        x=df.index,
+        y=df['Lower_Band'],
+        mode='lines',
+        name='Lower Band',
+        line=dict(color='green', dash='dash', width=1.5),
+        fill='tonexty',
+        fillcolor='rgba(128,128,128,0.2)',
+        hovertemplate='<b>Lower Band</b>: ₹%{y:.2f}<extra></extra>'
+    ))
+    
+    fig_bb.update_layout(
+        title="Bollinger Bands",
+        xaxis_title="Date",
+        yaxis_title="Price (₹)",
+        height=500,
+        template='plotly_white'
+    )
+    
+    st.plotly_chart(fig_bb, use_container_width=True)
+    
+    # 5. Drawdown Analysis
+    st.subheader("📉 Drawdown Analysis")
+    
+    # Calculate drawdown
+    returns = results['Total'].pct_change().fillna(0)
+    cumulative = (1 + returns).cumprod()
+    running_max = cumulative.expanding().max()
+    drawdown = (cumulative - running_max) / running_max
+    
+    fig_dd = go.Figure()
+    
+    fig_dd.add_trace(go.Scatter(
+        x=df.index,
+        y=drawdown * 100,
+        mode='lines',
+        name='Drawdown',
+        fill='tozeroy',
+        fillcolor='rgba(255,0,0,0.3)',
+        line=dict(color='red', width=1),
+        hovertemplate='<b>Drawdown</b>: %{y:.1f}%<extra></extra>'
+    ))
+    
+    fig_dd.update_layout(
+        title="Portfolio Drawdown Over Time",
+        xaxis_title="Date",
+        yaxis_title="Drawdown (%)",
+        height=400,
+        template='plotly_white'
+    )
+    
+    st.plotly_chart(fig_dd, use_container_width=True)
+    
+    # 6. Trade analysis
+    if not metrics['Trades DataFrame'].empty:
+        st.subheader("📋 Trade Analysis")
+        
+        trades_df = metrics['Trades DataFrame']
+        
+        # Trade statistics
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            avg_trade_duration = (pd.to_datetime(trades_df['exit_date']) - 
+                                pd.to_datetime(trades_df['entry_date'])).dt.days.mean()
+            st.metric("📅 Avg Trade Duration", f"{avg_trade_duration:.1f} days")
+            
+        with col2:
+            best_trade = trades_df['return_pct'].max()
+            st.metric("🚀 Best Trade", f"{best_trade:.2%}")
+            
+        with col3:
+            worst_trade = trades_df['return_pct'].min()
+            st.metric("💥 Worst Trade", f"{worst_trade:.2%}")
+        
+        # Trade returns distribution
+        st.subheader("📊 Trade Returns Distribution")
+        
+        returns_pct = trades_df['return_pct'] * 100
+        
+        fig_hist = px.histogram(
+            x=returns_pct,
+            nbins=20,
+            title="Distribution of Trade Returns",
+            labels={'x': 'Return (%)', 'y': 'Number of Trades'},
+            color_discrete_sequence=['steelblue']
+        )
+        
+        # Add vertical lines for mean and zero
+        fig_hist.add_vline(x=0, line_dash="dash", line_color="red", 
+                          annotation_text="Break Even")
+        fig_hist.add_vline(x=returns_pct.mean(), line_dash="solid", line_color="green", 
+                          annotation_text=f"Mean: {returns_pct.mean():.1f}%")
+        
+        fig_hist.update_layout(
+            height=400,
+            template='plotly_white',
+            showlegend=False
+        )
+        
+        st.plotly_chart(fig_hist, use_container_width=True)
+        
+        # Trade timeline
+        st.subheader("📅 Trade Timeline")
+        
+        fig_timeline = go.Figure()
+        
+        for i, trade in trades_df.iterrows():
+            color = 'green' if trade['return_pct'] > 0 else 'red'
+            fig_timeline.add_trace(go.Scatter(
+                x=[trade['entry_date'], trade['exit_date']],
+                y=[trade['entry_price'], trade['exit_price']],
+                mode='lines+markers',
+                name=f"Trade {i+1}",
+                line=dict(color=color, width=3),
+                marker=dict(size=8),
+                hovertemplate=f'<b>Trade {i+1}</b><br>' +
+                             f'Entry: ₹{trade["entry_price"]:.2f}<br>' +
+                             f'Exit: ₹{trade["exit_price"]:.2f}<br>' +
+                             f'Return: {trade["return_pct"]:.2%}<br>' +
+                             f'Duration: {(pd.to_datetime(trade["exit_date"]) - pd.to_datetime(trade["entry_date"])).days} days<extra></extra>',
+                showlegend=False
+            ))
+        
+        fig_timeline.update_layout(
+            title="Individual Trade Performance Timeline",
+            xaxis_title="Date",
+            yaxis_title="Price (₹)",
+            height=500,
+            template='plotly_white'
+        )
+        
+        st.plotly_chart(fig_timeline, use_container_width=True)
+        
+        # Trade history table
+        st.subheader("📊 Detailed Trade History")
+        display_trades = trades_df.copy()
+        display_trades['Entry Date'] = pd.to_datetime(display_trades['entry_date']).dt.strftime('%Y-%m-%d')
+        display_trades['Exit Date'] = pd.to_datetime(display_trades['exit_date']).dt.strftime('%Y-%m-%d')
+        display_trades['Entry Price'] = display_trades['entry_price'].apply(lambda x: f"₹{x:.2f}")
+        display_trades['Exit Price'] = display_trades['exit_price'].apply(lambda x: f"₹{x:.2f}")
+        display_trades['P&L (₹)'] = display_trades['profit_loss'].apply(lambda x: f"₹{x:,.2f}")
+        display_trades['Return %'] = display_trades['return_pct'].apply(lambda x: f"{x:.2%}")
+        display_trades['Duration'] = (pd.to_datetime(trades_df['exit_date']) - 
+                                    pd.to_datetime(trades_df['entry_date'])).dt.days
+        
+        trade_display = display_trades[['Entry Date', 'Exit Date', 'Entry Price', 'Exit Price', 
+                                      'P&L (₹)', 'Return %', 'Duration', 'exit_reason']].copy()
+        trade_display.columns = ['Entry Date', 'Exit Date', 'Entry Price', 'Exit Price', 
+                               'Profit/Loss', 'Return %', 'Days', 'Exit Reason']
+        
+        st.dataframe(trade_display, use_container_width=True)
+    
+    else:
+        st.info("📝 No trades were executed during this period with the current parameters.")
+    
+    # 7. Signal summary table
+    st.subheader("📋 Trading Signals Summary")
+    signal_summary = df[df[signal_col] != 0].copy()
+    
+    if not signal_summary.empty:
+        signal_summary['Signal Type'] = signal_summary[signal_col].map({1: '🟢 BUY', -1: '🔴 SELL'})
+        signal_summary['Price'] = signal_summary['Close'].apply(lambda x: f"₹{x:.2f}")
+        signal_summary['RSI'] = signal_summary['RSI'].apply(lambda x: f"{x:.1f}")
+        signal_summary[f'{strategy_name}{period_short}'] = signal_summary[f'{strategy_name}{period_short}'].apply(lambda x: f"₹{x:.2f}")
+        signal_summary[f'{strategy_name}{period_long}'] = signal_summary[f'{strategy_name}{period_long}'].apply(lambda x: f"₹{x:.2f}")
+        
+        display_signals = signal_summary[['Signal Type', 'Price', 'RSI', 
+                                        f'{strategy_name}{period_short}', 
+                                        f'{strategy_name}{period_long}']].copy()
+        display_signals.index = display_signals.index.strftime('%Y-%m-%d')
+        
+        st.dataframe(display_signals, use_container_width=True)
+    else:
+        st.info("📝 No trading signals were generated during this period with the current parameters.")
+
+# ---------------------------------------
+st.set_page_config(layout="wide", page_title="Algo Trading Dashboard", page_icon="📈")
+st.title("📈 Algo-Trading Dashboard: Technical Analysis & Backtesting")
+
+# Sidebar config
+st.sidebar.header("📊 Configuration")
+
+# Stock selection
+stocks = ['ADANIENT.NS', 'ADANIPORTS.NS', 'APOLLOHOSP.NS', 'ASIANPAINT.NS', 'AXISBANK.NS', 
+          'BAJAJ-AUTO.NS', 'BAJFINANCE.NS', 'BAJAJFINSV.NS', 'BEL.NS', 'BHARTIARTL.NS', 
+          'CIPLA.NS', 'COALINDIA.NS', 'DRREDDY.NS', 'EICHERMOT.NS', 'GRASIM.NS', 
+          'HCLTECH.NS', 'HDFCBANK.NS', 'HDFCLIFE.NS', 'HEROMOTOCO.NS', 'HINDALCO.NS', 
+          'HINDUNILVR.NS', 'ICICIBANK.NS', 'INDUSINDBK.NS', 'INFY.NS', 'ITC.NS', 
+          'JIOFIN.NS', 'JSWSTEEL.NS', 'KOTAKBANK.NS', 'LT.NS', 'M&M.NS', 'MARUTI.NS', 
+          'NESTLEIND.NS', 'NTPC.NS', 'ONGC.NS', 'POWERGRID.NS', 'RELIANCE.NS', 
+          'SBILIFE.NS', 'SHRIRAMFIN.NS', 'SBIN.NS', 'SUNPHARMA.NS', 'TATACONSUM.NS', 
+          'TCS.NS', 'TATAMOTORS.NS', 'TATASTEEL.NS', 'TECHM.NS', 'TITAN.NS', 
+          'TRENT.NS', 'ULTRACEMCO.NS', 'WIPRO.NS', 'ETERNAL.NS']
+
+selected_stock = st.sidebar.selectbox("Select Stock", stocks)
+start_date = st.sidebar.date_input("Start Date", pd.to_datetime("2024-01-01"))
+
+# Strategy selection
+strategy_type = st.sidebar.selectbox("Strategy Type", ["SMA-based", "EMA-based", "Both"])
+
+st.sidebar.subheader("📈 Technical Indicators")
+rsi_period = st.sidebar.slider("RSI Period", 5, 30, 14)
+sma_short = st.sidebar.slider("Short-term SMA", 5, 30, 20)
+sma_long = st.sidebar.slider("Long-term SMA", 30, 100, 50)
+ema_short = st.sidebar.slider("Short-term EMA", 5, 30, 20)
+ema_long = st.sidebar.slider("Long-term EMA", 30, 100, 50)
+
+st.sidebar.subheader("💰 Backtesting Parameters")
+initial_cash = st.sidebar.number_input("Initial Capital (₹)", min_value=10000, value=100000, step=10000)
+transaction_cost = st.sidebar.slider("Transaction Cost (%)", 0.0, 1.0, 0.1, step=0.05) / 100
+stop_loss = st.sidebar.slider("Stop Loss (%)", 0.0, 20.0, 5.0, step=1.0) / 100
+take_profit = st.sidebar.slider("Take Profit (%)", 0.0, 50.0, 15.0, step=5.0) / 100
+
+# Enable/disable risk management
+use_risk_mgmt = st.sidebar.checkbox("Enable Risk Management", value=True)
+
+# Load data with progress bar
+with st.spinner(f'Loading data for {selected_stock}...'):
+    df = fetch_stock_data(selected_stock, start_date=start_date.strftime("%Y-%m-%d"))
+
+st.subheader(f"📊 Stock Data for {selected_stock}")
+st.write(f"**Date Range:** {start_date.strftime('%Y-%m-%d')} to Present")
+st.write(f"**Total Records:** {len(df)} days")
+
+if df.empty:
+    st.error("❌ No data found for the selected stock and date range.")
+    st.stop()
+
+# Apply indicators
+with st.spinner('Calculating technical indicators...'):
+    df['RSI'] = rsi(df, period=rsi_period)
+    df['SMA20'] = sma(df, period=sma_short)
+    df['SMA50'] = sma(df, period=sma_long)
+    df['EMA20'] = ema(df, period=ema_short)
+    df['EMA50'] = ema(df, period=ema_long)
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = macd(df)
+    df['Upper_Band'] = df['SMA20'] + 2 * df['Close'].rolling(window=20).std()
+    df['Lower_Band'] = df['SMA20'] - 2 * df['Close'].rolling(window=20).std()
+
+# Apply strategies based on selection
+if strategy_type in ["SMA-based", "Both"]:
+    df = generate_signals_sma(df, rsi_col='RSI', sma_short_col='SMA20', sma_long_col='SMA50')
+
+if strategy_type in ["EMA-based", "Both"]:
+    df = generate_signals_ema(df, rsi_col='RSI', ema_short_col='EMA20', ema_long_col='EMA50')
+
+# Backtesting section
+st.header("🔍 Backtesting Results")
+
+# Create tabs for different strategies
+if strategy_type == "Both":
+    tab1, tab2 = st.tabs(["SMA Strategy", "EMA Strategy"])
+    
+    with tab1:
+        st.subheader("📊 SMA Strategy Results")
+        sma_results, sma_metrics = backtest_signals(
+            df, 
+            signal_col='SMA_Signal', 
+            price_col='Close', 
+            initial_cash=initial_cash,
+            transaction_cost=transaction_cost if use_risk_mgmt else 0,
+            stop_loss=stop_loss if use_risk_mgmt else None,
+            take_profit=take_profit if use_risk_mgmt else None
+        )
+        display_strategy_results(df, sma_results, sma_metrics, "SMA", sma_short, sma_long, initial_cash, selected_stock)
+    
+    with tab2:
+        st.subheader("📊 EMA Strategy Results")
+        ema_results, ema_metrics = backtest_signals(
+            df, 
+            signal_col='EMA_Signal', 
+            price_col='Close', 
+            initial_cash=initial_cash,
+            transaction_cost=transaction_cost if use_risk_mgmt else 0,
+            stop_loss=stop_loss if use_risk_mgmt else None,
+            take_profit=take_profit if use_risk_mgmt else None
+        )
+        display_strategy_results(df, ema_results, ema_metrics, "EMA", ema_short, ema_long, initial_cash, selected_stock)
+
+else:
+    # Single strategy
+    signal_col = 'SMA_Signal' if strategy_type == "SMA-based" else 'EMA_Signal'
+    strategy_name = strategy_type.split('-')[0]
+    
+    results, metrics = backtest_signals(
+        df, 
+        signal_col=signal_col, 
+        price_col='Close', 
+        initial_cash=initial_cash,
+        transaction_cost=transaction_cost if use_risk_mgmt else 0,
+        stop_loss=stop_loss if use_risk_mgmt else None,
+        take_profit=take_profit if use_risk_mgmt else None
+    )
+    
+    period_short = sma_short if strategy_type == "SMA-based" else ema_short
+    period_long = sma_long if strategy_type == "SMA-based" else ema_long
+    display_strategy_results(df, results, metrics, strategy_name, period_short, period_long, initial_cash, selected_stock)
+
+# Data download section
+st.subheader("💾 Download Data")
+col1, col2 = st.columns(2)
+
+with col1:
+    csv_data = df.to_csv(index=True)
+    st.download_button(
+        label="📁 Download Full Dataset (CSV)",
+        data=csv_data,
+        file_name=f"{selected_stock}_analysis_{start_date.strftime('%Y%m%d')}.csv",
+        mime="text/csv"
+    )
+
+with col2:
+    if 'results' in locals():
+        results_csv = results.to_csv(index=True)
+        st.download_button(
+            label="📊 Download Backtest Results (CSV)",
+            data=results_csv,
+            file_name=f"{selected_stock}_backtest_{start_date.strftime('%Y%m%d')}.csv",
+            mime="text/csv"
+        )
+
+# Footer
+st.markdown("---")
+st.markdown("Developed by Zane Vijay Falcao")

src/models/app.py

@@ -0,0 +1,440 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import pickle
+import plotly.graph_objects as go
+import plotly.express as px 
+from datetime import datetime, timedelta
+import warnings
+from curl_cffi import requests
+session = requests.Session(impersonate="chrome")
+warnings.filterwarnings('ignore')
+
+# Page config
+st.set_page_config(
+    page_title="Stock Price Prediction App",
+    page_icon="📈",
+    layout="wide"
+)
+
+# Title and description
+st.title("📈 Stock Price Prediction App")
+st.markdown("This app uses a trained Logistic Regression model to predict whether a stock will go **UP** ⬆️ or **DOWN** ⬇️ the next day.")
+
+# Sidebar for user inputs
+st.sidebar.header("🔧 Configuration")
+
+# Stock symbols from your model
+STOCK_SYMBOLS = [
+    'ADANIENT.NS', 'ADANIPORTS.NS', 'APOLLOHOSP.NS', 'ASIANPAINT.NS',
+    'AXISBANK.NS', 'BAJAJ-AUTO.NS', 'BAJFINANCE.NS', 'BAJAJFINSV.NS', 
+    'BEL.NS', 'BHARTIARTL.NS', 'CIPLA.NS', 'COALINDIA.NS', 'DRREDDY.NS', 
+    'EICHERMOT.NS', 'GRASIM.NS', 'HCLTECH.NS', 'HDFCBANK.NS', 'HDFCLIFE.NS', 
+    'HEROMOTOCO.NS', 'HINDALCO.NS', 'HINDUNILVR.NS', 'ICICIBANK.NS', 
+    'INDUSINDBK.NS', 'INFY.NS', 'ITC.NS', 'JIOFIN.NS', 'JSWSTEEL.NS', 
+    'KOTAKBANK.NS', 'LT.NS', 'M&M.NS', 'MARUTI.NS', 'NESTLEIND.NS', 
+    'NTPC.NS', 'ONGC.NS', 'POWERGRID.NS', 'RELIANCE.NS', 'SBILIFE.NS', 
+    'SHRIRAMFIN.NS', 'SBIN.NS', 'SUNPHARMA.NS', 'TATACONSUM.NS', 'TCS.NS',
+    'TATAMOTORS.NS', 'TATASTEEL.NS', 'TECHM.NS', 'TITAN.NS', 'TRENT.NS', 
+    'ULTRACEMCO.NS', 'WIPRO.NS', 'ETERNAL.NS'
+]
+
+# User inputs
+selected_stock = st.sidebar.selectbox("Select Stock Symbol", STOCK_SYMBOLS, index=35)  # Default to RELIANCE.NS
+start_date = st.sidebar.date_input("Start Date", value=datetime(2020, 1, 1))
+end_date = st.sidebar.date_input("End Date", value=datetime.now())
+prediction_mode = st.sidebar.button("Start Analysis")
+rsi_period = st.sidebar.slider("RSI Period", min_value=5, max_value=30, value=14, step=1)
+short_period = st.sidebar.slider("Short-term", min_value=5, max_value=50, value=20, step=1)
+long_period = st.sidebar.slider("Long-term", min_value=50, max_value=200, value=50, step=1)
+
+# Helper functions (same as in your original code)
+def SMA(series, period):
+    return series.rolling(window=period).mean()
+
+def EMA(series, period):
+    return series.ewm(span=period, adjust=False).mean()
+
+def MACD(series, fast=12, slow=26, signal=9):
+    ema_fast = EMA(series, fast)
+    ema_slow = EMA(series, slow)
+    macd = ema_fast - ema_slow
+    macd_signal = EMA(macd, signal)
+    macd_hist = macd - macd_signal
+    return macd, macd_signal, macd_hist
+
+def RSI(series, period=14):
+    delta = series.diff()
+    gain = (delta.where(delta > 0, 0)).ewm(alpha=1/period, min_periods=period).mean()
+    loss = (-delta.where(delta < 0, 0)).ewm(alpha=1/period, min_periods=period).mean()
+    RS = gain / loss
+    return 100 - (100 / (1 + RS))
+
+def create_volatility_features(df):
+    if 'return_1d' not in df.columns:
+        df['return_1d'] = df['Close'].pct_change()
+    
+    for period in [5, 10, 20, 30]:
+        df[f'volatility_{period}d'] = df['return_1d'].rolling(period).std()
+    
+    df['vol_ratio_5_20'] = df['volatility_5d'] / df['volatility_20d']
+    df['vol_ratio_10_20'] = df['volatility_10d'] / df['volatility_20d']
+    df['vol_rank_20'] = df['volatility_5d'].rolling(20).rank(pct=True)
+    df['vol_rank_50'] = df['volatility_5d'].rolling(50).rank(pct=True)
+    
+    return df
+
+def create_enhanced_lag_features(df):
+    for lag in [1, 2, 3, 5, 10]:
+        df[f'return_lag_{lag}'] = df['return_1d'].shift(lag)
+    
+    for lag in [1, 2, 3]:
+        if 'RSI14' in df.columns:
+            df[f'rsi_lag_{lag}'] = df['RSI14'].shift(lag)
+        if 'MACD' in df.columns:
+            df[f'macd_lag_{lag}'] = df['MACD'].shift(lag)
+    
+    if 'volume_ratio_20' in df.columns:
+        for lag in [1, 2]:
+            df[f'volume_ratio_lag_{lag}'] = df['volume_ratio_20'].shift(lag)
+    
+    return df
+
+def create_volume_features(df):
+    df['volume_sma_10'] = df['Volume'].rolling(10).mean()
+    df['volume_sma_20'] = df['Volume'].rolling(20).mean()
+    df['volume_sma_50'] = df['Volume'].rolling(50).mean()
+    
+    df['volume_ratio_10'] = df['Volume'] / df['volume_sma_10']
+    df['volume_ratio_20'] = df['Volume'] / df['volume_sma_20']
+    df['volume_ratio_50'] = df['Volume'] / df['volume_sma_50']
+    
+    df['price_volume'] = df['Close'] * df['Volume']
+    df['pv_sma_5'] = df['price_volume'].rolling(5).mean()
+    df['volume_momentum_5'] = df['Volume'] / df['Volume'].shift(5)
+    
+    return df
+
+def create_momentum_features(df):
+    for period in [3, 5, 10, 20]:
+        df[f'momentum_{period}d'] = df['Close'] / df['Close'].shift(period) - 1
+    
+    for period in [5, 10]:
+        df[f'roc_{period}d'] = (df['Close'] - df['Close'].shift(period)) / df['Close'].shift(period)
+    
+    return df
+
+def create_position_features(df):
+    for period in [10, 20, 50]:
+        df[f'high_{period}d'] = df['High'].rolling(period).max()
+        df[f'low_{period}d'] = df['Low'].rolling(period).min()
+        df[f'price_position_{period}'] = (df['Close'] - df[f'low_{period}d']) / (df[f'high_{period}d'] - df[f'low_{period}d'])
+    
+    if 'SMA20' in df.columns:
+        bb_std = df['Close'].rolling(20).std()
+        df['bb_upper'] = df['SMA20'] + (bb_std * 2)
+        df['bb_lower'] = df['SMA20'] - (bb_std * 2)
+        df['bb_position'] = (df['Close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])
+    
+    return df
+
+def process_stock_data(df):
+    """Process stock data to create all features"""
+    df = df.copy()
+    
+    # Basic technical indicators
+    df['SMA20'] = SMA(df['Close'], short_period)
+    df['SMA50'] = SMA(df['Close'], long_period)
+    df['EMA20'] = EMA(df['Close'], short_period)
+    df['EMA50'] = EMA(df['Close'], long_period)
+    df['RSI14'] = RSI(df['Close'], rsi_period)
+    df['RSI20'] = RSI(df['Close'], rsi_period + 6)  # Example for another RSI period
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = MACD(df['Close'])
+    
+    # Create feature sets
+    df = create_volatility_features(df)
+    df = create_enhanced_lag_features(df)
+    df = create_volume_features(df)
+    df = create_momentum_features(df)
+    df = create_position_features(df)
+    
+    # Additional features
+    df['SMA_crossover'] = (df['SMA20'] > df['SMA50']).astype(int)
+    df['RSI_oversold'] = (df['RSI14'] < 30).astype(int)
+    # Target: next-day up/down
+    df['next_close'] = df['Close'].shift(-1)
+    df['target'] = (df['next_close'] > df['Close']).astype(int)
+    
+    return df
+
+@st.cache_data
+def load_stock_data(symbol, start_date, end_date):
+    """Load stock data from Yahoo Finance"""
+    try:
+        data = yf.download(symbol, start=start_date, end=end_date,session=session)
+        # Flatten the MultiIndex columns
+        data.columns = [col[0] for col in data.columns]
+        return data
+    except Exception as e:
+        st.error(f"Error loading data: {e}")
+        return None
+
+# Feature list (same as in your model)
+FEATURES = [
+    'Close', 'Volume', 'SMA20', 'SMA50', 'EMA20', 'EMA50',
+    'RSI14', 'MACD', 'MACD_signal', 'MACD_hist',
+    'SMA_crossover', 'RSI_oversold',
+    'return_1d', 'volatility_5d', 'volatility_10d', 'volatility_20d',
+    'volatility_30d', 'vol_ratio_5_20', 'vol_ratio_10_20', 'vol_rank_20',
+    'vol_rank_50', 'return_lag_1', 'return_lag_2', 'return_lag_3',
+    'return_lag_5', 'return_lag_10', 'rsi_lag_1', 'macd_lag_1', 'rsi_lag_2',
+    'macd_lag_2', 'rsi_lag_3', 'macd_lag_3', 'volume_sma_10',
+    'volume_sma_20', 'volume_sma_50', 'volume_ratio_10', 'volume_ratio_20',
+    'volume_ratio_50', 'price_volume', 'pv_sma_5', 'volume_momentum_5',
+    'momentum_3d', 'momentum_5d', 'momentum_10d', 'momentum_20d', 'roc_5d',
+    'roc_10d', 'high_10d', 'low_10d', 'price_position_10', 'high_20d',
+    'low_20d', 'price_position_20', 'high_50d', 'low_50d',
+    'price_position_50', 'bb_upper', 'bb_lower', 'bb_position','target'
+]
+
+# Main app logic
+st.header(f"📊 Latest Data Prediction for {selected_stock}")
+    
+    
+with st.spinner("Loading stock data..."):
+    stock_data = load_stock_data(selected_stock, start_date, end_date)
+    
+    if stock_data is not None and not stock_data.empty:
+        # Process the data
+        processed_data = process_stock_data(stock_data)
+        processed_data = processed_data.dropna()
+        
+        
+        if len(processed_data) > 0:
+            # Get the latest row for prediction
+            latest_data = processed_data.iloc[-1]
+            
+            # Display current stock info
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Current Price", f"₹{latest_data['Close']:.2f}")
+            with col2:
+                daily_change = ((latest_data['Close'] - processed_data.iloc[-2]['Close']) / processed_data.iloc[-2]['Close']) * 100
+                st.metric("Daily Change", f"{daily_change:.2f}%")
+            with col3:
+                st.metric("Volume", f"{latest_data['Volume']:,.0f}")
+            with col4:
+                st.metric("RSI14", f"{latest_data['RSI14']:.2f}")
+            
+            # Create feature vector
+            feature_vector = latest_data[FEATURES].values.reshape(1, -1)
+            
+            # For demo purposes, create a mock prediction (since we don't have the actual model file)
+            # In real implementation, you would load your saved model:
+            model = pickle.load(open('logistic_regression_model.pkl', 'rb'))
+            scaler = pickle.load(open('scaler.pkl', 'rb'))  # You'd need to save this too
+            
+            
+            # Scale the features
+            feature_vector_scaled = scaler.transform(feature_vector)
+
+            # Make prediction
+            prediction = model.predict(feature_vector_scaled)[0]
+            probability = model.predict_proba(feature_vector_scaled)[0].max()
+            
+            # Display prediction
+            st.header("🔮 Prediction")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                if prediction == 1:
+                    st.success("📈 **PREDICTION: UP**")
+                    st.write(f"The model predicts the stock will go **UP** tomorrow with {probability:.1%} confidence.")
+                else:
+                    st.error("📉 **PREDICTION: DOWN**")
+                    st.write(f"The model predicts the stock will go **DOWN** tomorrow with {probability:.1%} confidence.")
+            
+            with col2:
+                # Confidence gauge
+                fig_gauge = go.Figure(go.Indicator(
+                    mode = "gauge+number",
+                    value = probability * 100,
+                    domain = {'x': [0, 1], 'y': [0, 1]},
+                    title = {'text': "Confidence %"},
+                    gauge = {
+                        'axis': {'range': [None, 100]},
+                        'bar': {'color': "darkgreen" if prediction == 1 else "darkred"},
+                        'steps': [
+                            {'range': [0, 50], 'color': "lightgray"},
+                            {'range': [50, 80], 'color': "yellow"},
+                            {'range': [80, 100], 'color': "lightgreen"}
+                        ],
+                        'threshold': {
+                            'line': {'color': "red", 'width': 4},
+                            'thickness': 0.75,
+                            'value': 90
+                        }
+                    }
+                ))
+                fig_gauge.update_layout(height=300)
+                st.plotly_chart(fig_gauge, use_container_width=True)
+            
+            # Technical indicators chart
+            st.header("📈 Technical Analysis")
+            
+            # Price and  Simple moving averages
+            fig_price = go.Figure()
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-60:], 
+                y=processed_data['Close'][-60:],
+                mode='lines',
+                name='Close Price',
+                line=dict(color='blue', width=2)
+            ))
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-60:], 
+                y=processed_data['SMA20'][-60:],
+                mode='lines',
+                name='SMA20',
+                line=dict(color='orange', width=1)
+            ))
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-60:], 
+                y=processed_data['SMA50'][-60:],
+                mode='lines',
+                name='SMA50',
+                line=dict(color='red', width=1)
+            ))
+            
+            fig_price.update_layout(
+                title=f"{selected_stock} - Price and Simple Moving Averages (Last 60 Days)",
+                xaxis_title="Date",
+                yaxis_title="Price (₹)",
+                height=400
+            )
+            st.plotly_chart(fig_price, use_container_width=True)
+            
+            # Price and Exponential moving averages
+            fig_price = go.Figure()
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-30:], 
+                y=processed_data['Close'][-30:],
+                mode='lines',
+                name='Close Price',
+                line=dict(color='blue', width=2)
+            ))
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-30:], 
+                y=processed_data['EMA20'][-30:],
+                mode='lines',
+                name='EMA20',
+                line=dict(color='orange', width=1)
+            ))
+            fig_price.add_trace(go.Scatter(
+                x=processed_data.index[-30:], 
+                y=processed_data['EMA50'][-30:],
+                mode='lines',
+                name='EMA50',
+                line=dict(color='red', width=1)
+            ))
+            
+            fig_price.update_layout(
+                title=f"{selected_stock} - Price and Exponential Moving Averages (Last 60 Days)",
+                xaxis_title="Date",
+                yaxis_title="Price (₹)",
+                height=400
+            )
+            st.plotly_chart(fig_price, use_container_width=True)
+            
+            # RSI chart
+            col1, col2 = st.columns(2)
+            with col1:
+                fig_rsi = go.Figure()
+                fig_rsi.add_trace(go.Scatter(
+                    x=processed_data.index[-30:], 
+                    y=processed_data['RSI14'][-30:],
+                    mode='lines',
+                    name='RSI14',
+                    line=dict(color='purple')
+                ))
+                fig_rsi.add_hline(y=70, line_dash="dash", line_color="red", annotation_text="Overbought")
+                fig_rsi.add_hline(y=30, line_dash="dash", line_color="green", annotation_text="Oversold")
+                fig_rsi.update_layout(
+                    title="RSI (14-day)",
+                    xaxis_title="Date",
+                    yaxis_title="RSI",
+                    height=300
+                )
+                st.plotly_chart(fig_rsi, use_container_width=True)
+            
+            with col2:
+                # MACD chart
+                fig_macd = go.Figure()
+                fig_macd.add_trace(go.Scatter(
+                    x=processed_data.index[-30:], 
+                    y=processed_data['MACD'][-30:],
+                    mode='lines',
+                    name='MACD',
+                    line=dict(color='blue')
+                ))
+                fig_macd.add_trace(go.Scatter(
+                    x=processed_data.index[-30:], 
+                    y=processed_data['MACD_signal'][-30:],
+                    mode='lines',
+                    name='Signal',
+                    line=dict(color='red')
+                ))
+                fig_macd.update_layout(
+                    title="MACD",
+                    xaxis_title="Date",
+                    yaxis_title="MACD",
+                    height=300
+                )
+                st.plotly_chart(fig_macd, use_container_width=True)
+            
+            # Feature importance (mock data for demo)
+            st.header("🎯 Key Factors")
+            st.write("Most important features affecting the prediction:")
+            
+            mock_features = ['RSI14', 'return_lag_1', 'volatility_5d', 'MACD', 'volume_ratio_20']
+            mock_importance = [0.15, 0.12, 0.10, 0.08, 0.07]
+            
+            fig_importance = px.bar(
+                x=mock_importance, 
+                y=mock_features,
+                orientation='h',
+                title="Feature Importance"
+            )
+            fig_importance.update_layout(height=300)
+            st.plotly_chart(fig_importance, use_container_width=True)
+            
+        else:
+            st.error("Not enough data to make a prediction. Please try a different stock or date range.")
+    else:
+        st.error("Unable to load stock data. Please check the symbol and try again.")
+
+
+
+# Sidebar information
+st.sidebar.markdown("---")
+st.sidebar.header("ℹ️ About")
+st.sidebar.write("""
+This app uses a Logistic Regression model trained on:
+- **50 Indian stocks** from NSE
+- **59 technical features** including RSI, MACD, moving averages, volatility measures, and lag features
+- **Historical data** for pattern recognition
+
+**Disclaimer**: This is for educational purposes only. Always do your own research before making investment decisions.
+""")
+
+st.sidebar.markdown("---")
+st.sidebar.write("**Model Performance:**")
+st.sidebar.write("• Accuracy: 55%")
+st.sidebar.write("• F1 Score: 0.4839")
+st.sidebar.write("• AUC: 0.5370")
+st.sidebar.write("Average Precision (AP): 0.5300")
+
+# Footer
+st.markdown("---")
+st.markdown("**⚠️ Disclaimer**: This prediction model is for research purposes only. Stock market investments are subject to market risks. Please consult with a financial advisor before making investment decisions.")

src/models/h2h_model.py

@@ -0,0 +1,491 @@
+# -*- coding: utf-8 -*-
+"""H2H model.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1uxbLGJ4l9i0bdWy43Oz4rgsyTdA5FTSd
+"""
+
+!pip install yfinance
+
+# Data and computation
+import pandas as pd
+import numpy as np
+
+# Plotting
+import matplotlib.pyplot as plt
+import seaborn as sns
+sns.set_style('whitegrid')
+plt.style.use("fivethirtyeight")
+
+# Yahoo Finance data import
+import yfinance as yf
+
+# Machine Learning
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_curve, auc
+from sklearn.preprocessing import StandardScaler, RobustScaler
+from sklearn.pipeline import Pipeline
+import scipy.stats as stats
+from sklearn.model_selection import GridSearchCV
+
+# Misc
+import warnings
+warnings.filterwarnings('ignore')
+
+# Select stocks and date range
+symbols = ['ADANIENT.NS',
+           'ADANIPORTS.NS', 'APOLLOHOSP.NS', 'ASIANPAINT.NS',
+           'AXISBANK.NS', 'BAJAJ-AUTO.NS', 'BAJFINANCE.NS', 'BAJAJFINSV.NS', 'BEL.NS', 'BHARTIARTL.NS', 'CIPLA.NS',
+           'COALINDIA.NS', 'DRREDDY.NS', 'EICHERMOT.NS', 'GRASIM.NS', 'HCLTECH.NS', 'HDFCBANK.NS',
+           'HDFCLIFE.NS', 'HEROMOTOCO.NS', 'HINDALCO.NS', 'HINDUNILVR.NS', 'ICICIBANK.NS', 'INDUSINDBK.NS',
+           'INFY.NS', 'ITC.NS', 'JIOFIN.NS', 'JSWSTEEL.NS', 'KOTAKBANK.NS', 'LT.NS', 'M&M.NS', 'MARUTI.NS',
+           'NESTLEIND.NS', 'NTPC.NS', 'ONGC.NS', 'POWERGRID.NS', 'RELIANCE.NS', 'SBILIFE.NS', 'SHRIRAMFIN.NS',
+           'SBIN.NS', 'SUNPHARMA.NS', 'TATACONSUM.NS', 'TCS.NS',
+           'TATAMOTORS.NS', 'TATASTEEL.NS', 'TECHM.NS',
+           'TITAN.NS', 'TRENT.NS', 'ULTRACEMCO.NS',
+           'WIPRO.NS',
+           'ETERNAL.NS']
+
+start_date = '2024-07-31'
+end_date = '2025-07-31'
+
+# Download daily close data for both stocks
+raw_data = yf.download(symbols, start=start_date, end=end_date)
+
+# Flatten MultiIndex columns
+raw_data.columns = ['_'.join(col).strip() for col in raw_data.columns.values]
+
+# For simplicity, stack to long format and process each stock similarly
+data = raw_data.copy()
+
+data
+
+# Helper functions
+
+def SMA(series, period):
+    return series.rolling(window=period).mean()
+
+def EMA(series, period):
+    return series.ewm(span=period, adjust=False).mean()
+
+def MACD(series, fast=12, slow=26, signal=9):
+    ema_fast = EMA(series, fast)
+    ema_slow = EMA(series, slow)
+    macd = ema_fast - ema_slow
+    macd_signal = EMA(macd, signal)
+    macd_hist = macd - macd_signal
+    return macd, macd_signal, macd_hist
+
+def RSI(series, period=14):
+    delta = series.diff()
+    gain = (delta.where(delta > 0, 0)).ewm(alpha=1/period, min_periods=period).mean()
+    loss = (-delta.where(delta < 0, 0)).ewm(alpha=1/period, min_periods=period).mean()
+    RS = gain / loss
+    return 100 - (100 / (1 + RS))
+
+def create_volatility_features(df):
+
+    # Calculate returns if not exists
+    if 'return_1d' not in df.columns:
+        df['return_1d'] = df['Close'].pct_change()
+
+    # Volatility features (crucial for logistic regression)
+    for period in [5, 10, 20, 30]:
+        df[f'volatility_{period}d'] = df['return_1d'].rolling(period).std()
+
+    # Volatility ratios
+    df['vol_ratio_5_20'] = df['volatility_5d'] / df['volatility_20d']
+    df['vol_ratio_10_20'] = df['volatility_10d'] / df['volatility_20d']
+
+    # Volatility rank (where current vol sits in historical range)
+    df['vol_rank_20'] = df['volatility_5d'].rolling(20).rank(pct=True)
+    df['vol_rank_50'] = df['volatility_5d'].rolling(50).rank(pct=True)
+
+    return df
+
+def create_enhanced_lag_features(df):
+    """Add comprehensive lag features - Critical for time series"""
+    #print("Adding enhanced lag features...")
+
+    # Price momentum lags
+    for lag in [1, 2, 3, 5, 10]:
+        df[f'return_lag_{lag}'] = df['return_1d'].shift(lag)
+
+    # Technical indicator lags
+    for lag in [1, 2, 3]:
+        if 'RSI14' in df.columns:
+            df[f'rsi_lag_{lag}'] = df['RSI14'].shift(lag)
+        if 'MACD' in df.columns:
+            df[f'macd_lag_{lag}'] = df['MACD'].shift(lag)
+
+    # Volume lags
+    if 'volume_ratio_20' in df.columns:
+        for lag in [1, 2]:
+            df[f'volume_ratio_lag_{lag}'] = df['volume_ratio_20'].shift(lag)
+
+    return df
+
+def create_volume_features(df):
+    """Enhanced volume features"""
+    #print("Adding volume features...")
+
+    # Volume moving averages
+    df['volume_sma_10'] = df['Volume'].rolling(10).mean()
+    df['volume_sma_20'] = df['Volume'].rolling(20).mean()
+    df['volume_sma_50'] = df['Volume'].rolling(50).mean()
+
+    # Volume ratios
+    df['volume_ratio_10'] = df['Volume'] / df['volume_sma_10']
+    df['volume_ratio_20'] = df['Volume'] / df['volume_sma_20']
+    df['volume_ratio_50'] = df['Volume'] / df['volume_sma_50']
+
+    # Price-volume features
+    df['price_volume'] = df['Close'] * df['Volume']
+    df['pv_sma_5'] = df['price_volume'].rolling(5).mean()
+
+    # Volume momentum
+    df['volume_momentum_5'] = df['Volume'] / df['Volume'].shift(5)
+
+    return df
+
+def create_momentum_features(df):
+    """Add momentum features"""
+    #print("Adding momentum features...")
+
+    # Price momentum
+    for period in [3, 5, 10, 20]:
+        df[f'momentum_{period}d'] = df['Close'] / df['Close'].shift(period) - 1
+
+    # Rate of change
+    for period in [5, 10]:
+        df[f'roc_{period}d'] = (df['Close'] - df['Close'].shift(period)) / df['Close'].shift(period)
+
+    return df
+
+def create_position_features(df):
+    """Add price position features"""
+    #print("Adding position features...")
+
+    # Price position in recent range
+    for period in [10, 20, 50]:
+        df[f'high_{period}d'] = df['High'].rolling(period).max()
+        df[f'low_{period}d'] = df['Low'].rolling(period).min()
+        df[f'price_position_{period}'] = (df['Close'] - df[f'low_{period}d']) / (df[f'high_{period}d'] - df[f'low_{period}d'])
+
+    # Bollinger Band position (if BB exists)
+    if 'SMA20' in df.columns:
+        bb_std = df['Close'].rolling(20).std()
+        df['bb_upper'] = df['SMA20'] + (bb_std * 2)
+        df['bb_lower'] = df['SMA20'] - (bb_std * 2)
+        df['bb_position'] = (df['Close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])
+
+    return df
+
+def create_rolling_stats(df):
+    """Add rolling statistical features"""
+    #print("Adding rolling statistics...")
+
+    # Rolling statistics of returns
+    for period in [5, 10]:
+        df[f'return_mean_{period}d'] = df['return_1d'].rolling(period).mean()
+        df[f'return_std_{period}d'] = df['return_1d'].rolling(period).std()
+        df[f'return_skew_{period}d'] = df['return_1d'].rolling(period).skew()
+        df[f'return_kurt_{period}d'] = df['return_1d'].rolling(period).kurt()
+
+    # Rolling statistics of RSI
+    if 'RSI14' in df.columns:
+        df['rsi_mean_5d'] = df['RSI14'].rolling(5).mean()
+        df['rsi_std_5d'] = df['RSI14'].rolling(5).std()
+
+    return df
+
+# Process each stock separately and then concatenate for ML
+all_ml_data = []
+
+for ticker in symbols:
+    df = pd.DataFrame({
+        'Open': data[f'Open_{ticker}'],
+        'High': data[f'High_{ticker}'],
+        'Low': data[f'Low_{ticker}'],
+        'Close': data[f'Close_{ticker}'],
+        'Volume': data[f'Volume_{ticker}']
+    })
+
+    df['SMA20']  = SMA(df['Close'], 20)
+    df['SMA50']  = SMA(df['Close'], 50)
+    df['EMA20']  = EMA(df['Close'], 20)
+    df['EMA50']  = EMA(df['Close'], 50)
+    df['RSI14']  = RSI(df['Close'], 14)
+    df['RSI20']  = RSI(df['Close'], 20)
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = MACD(df['Close'])
+    df = create_volatility_features(df)
+    df = create_enhanced_lag_features(df)
+    df = create_volume_features(df)
+    df = create_momentum_features(df)
+    df = create_position_features(df)
+
+    # Feature: SMA 20 above SMA 50 (bullish crossover)
+    df['SMA_crossover'] = (df['SMA20'] > df['SMA50']).astype(int)
+    # Feature: RSI oversold signal
+    df['RSI_oversold'] = (df['RSI14'] < 30).astype(int)
+    # Target: next-day up/down
+    df['next_close'] = df['Close'].shift(-1)
+    df['target'] = (df['next_close'] > df['Close']).astype(int)
+
+    df['ticker'] = ticker
+
+    # Drop rows with NaN (from indicator calculations)
+    df = df.dropna().copy()
+    all_ml_data.append(df)
+
+# Concatenate all stocks
+ml_data = pd.concat(all_ml_data)
+ml_data.reset_index(inplace=True)
+
+ml_data
+
+ml_data.columns
+
+for ticker in ml_data['ticker'].unique():
+    plt.figure(figsize=(20,12))
+    plt.plot(
+        ml_data[ml_data['ticker'] == ticker]['Date'],
+        ml_data[ml_data['ticker'] == ticker]['Close'],
+        label=f"{ticker}"
+    )
+    plt.title("Closing Price Over Time")
+    plt.xlabel("Date")
+    plt.ylabel("Close Price (USD)")
+    plt.legend(loc='upper left')
+
+    plt.show()
+
+sample = ml_data[ml_data['ticker'] == 'RELIANCE.NS'].copy()
+plt.figure(figsize=(14,7))
+plt.plot(sample['Date'], sample['Close'], label='Close')
+plt.plot(sample['Date'], sample['SMA20'], label='SMA20')
+plt.plot(sample['Date'], sample['SMA50'], label='SMA50')
+plt.title('RELIANCE: Close with SMA20 & SMA50')
+plt.legend()
+plt.show()
+
+plt.figure(figsize=(14,4))
+plt.plot(sample['Date'], sample['RSI14'], label='RSI14', color='green')
+plt.axhline(70, linestyle='--', color='r')
+plt.axhline(30, linestyle='--', color='b')
+plt.title('RELIANCE: RSI14 Time Series')
+plt.legend()
+plt.show()
+
+plt.figure(figsize=(14,4))
+plt.plot(sample['Date'], sample['MACD'], label='MACD')
+plt.plot(sample['Date'], sample['MACD_signal'], label='MACD Signal')
+plt.title('RELIANCE: MACD & Signal')
+plt.legend()
+plt.show()
+
+# Select features
+features = [
+    'Close', 'Volume', 'SMA20', 'SMA50', 'EMA20', 'EMA50',
+    'RSI14', 'MACD', 'MACD_signal', 'MACD_hist',
+    'SMA_crossover', 'RSI_oversold',
+    'return_1d', 'volatility_5d', 'volatility_10d', 'volatility_20d',
+       'volatility_30d', 'vol_ratio_5_20', 'vol_ratio_10_20', 'vol_rank_20',
+       'vol_rank_50', 'return_lag_1', 'return_lag_2', 'return_lag_3',
+       'return_lag_5', 'return_lag_10', 'rsi_lag_1', 'macd_lag_1', 'rsi_lag_2',
+       'macd_lag_2', 'rsi_lag_3', 'macd_lag_3', 'volume_sma_10',
+       'volume_sma_20', 'volume_sma_50', 'volume_ratio_10', 'volume_ratio_20',
+       'volume_ratio_50', 'price_volume', 'pv_sma_5', 'volume_momentum_5',
+       'momentum_3d', 'momentum_5d', 'momentum_10d', 'momentum_20d', 'roc_5d',
+       'roc_10d', 'high_10d', 'low_10d', 'price_position_10', 'high_20d',
+       'low_20d', 'price_position_20', 'high_50d', 'low_50d',
+       'price_position_50', 'bb_upper', 'bb_lower', 'bb_position',
+       'SMA_crossover', 'RSI_oversold', 'next_close'
+]
+target = 'target'
+
+# Standardize features (recommended for LR)
+X = ml_data[features]
+y = ml_data[target]
+
+scaler = RobustScaler()
+X_scaled = scaler.fit_transform(X)
+
+sns.countplot(x='target', data=ml_data)
+plt.title("Class Balance: Next-Day Up/Down Distribution")
+plt.xlabel("0 = Down, 1 = Up")
+plt.ylabel("Count")
+plt.show()
+
+# # Sort by date (if multi-stock, by ticker as well)
+# ml_data = ml_data.sort_values(['ticker', 'Date'])
+
+# # Chronological split: 80% train, 20% test
+# split_idx = int(0.8 * len(ml_data))
+# X_train, X_test = X_scaled[:split_idx], X_scaled[split_idx:]
+# y_train, y_test = y[:split_idx], y[split_idx:]
+
+from sklearn.model_selection import TimeSeriesSplit
+
+tscv = TimeSeriesSplit(n_splits=5)
+
+# Use only the last fold for final testing
+for train_index, test_index in tscv.split(X_scaled):
+    pass  # this will give you the last split
+
+X_train, X_test = X_scaled[train_index], X_scaled[test_index]
+y_train, y_test = y.iloc[train_index], y.iloc[test_index]
+
+# Hyperparameter tuning
+from sklearn.model_selection import GridSearchCV
+
+param_grid = {
+    'max_depth': [5, 7, 10, 15],
+    'min_samples_split': [2, 5, 10],
+    'min_samples_leaf': [1, 2, 4],
+    'criterion': ['gini', 'entropy']
+}
+
+# Decision Tree Classifier
+dt_model = GridSearchCV(DecisionTreeClassifier(random_state=42), param_grid, cv=tscv, n_jobs=-1)
+dt_model.fit(X_train, y_train)
+dt_preds = dt_model.predict(X_test)
+
+# Logistic Regression
+lr_model = LogisticRegression(random_state=42, max_iter=1000)
+lr_model.fit(X_train, y_train)
+lr_preds = lr_model.predict(X_test)
+
+# Performance
+def print_metrics(model_name, y_true, y_pred):
+    print(f"\n=== {model_name} ===")
+    print("Accuracy:", accuracy_score(y_true, y_pred))
+    print(classification_report(y_true, y_pred, target_names=['Down','Up']))
+
+print_metrics("Decision Tree", y_test, dt_preds)
+print_metrics("Logistic Regression", y_test, lr_preds)
+
+# Decision Tree feature importances
+importances = pd.Series(dt_model.best_index_, index=features)
+importances = importances.sort_values(ascending=False)
+print("\nTop Feature Importances (Decision Tree):")
+print(importances)
+
+plt.figure(figsize=(35,20))
+corr = ml_data[[
+    'Close', 'Volume', 'SMA20', 'SMA50', 'EMA20', 'EMA50',
+    'RSI14', 'MACD', 'MACD_signal', 'MACD_hist',
+    'SMA_crossover', 'RSI_oversold',
+    'return_1d', 'volatility_5d', 'volatility_10d', 'volatility_20d',
+    'volatility_30d', 'vol_ratio_5_20', 'vol_ratio_10_20', 'vol_rank_20',
+    'vol_rank_50', 'return_lag_1', 'return_lag_2', 'return_lag_3',
+    'return_lag_5', 'return_lag_10', 'rsi_lag_1', 'macd_lag_1', 'rsi_lag_2',
+]].corr()
+sns.heatmap(corr, annot=True, cmap='coolwarm', center=0)
+plt.title("Correlation Heatmap of Features")
+plt.show()
+
+from sklearn.metrics import confusion_matrix
+import seaborn as sns
+
+# Calculate the confusion matrix
+cm = confusion_matrix(y_test, lr_preds)
+
+# Display the confusion matrix using a heatmap
+plt.figure(figsize=(8, 6))
+sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Down', 'Up'], yticklabels=['Down', 'Up'])
+plt.xlabel('Predicted')
+plt.ylabel('Actual')
+plt.title('Confusion Matrix for LR model')
+plt.show()
+
+print("\n=======Confusion Matrix========\n")
+print(cm)
+
+from sklearn.metrics import precision_recall_curve, average_precision_score
+
+# Get predicted probabilities for the positive class
+y_scores = lr_model.predict_proba(X_test)[:, 1]
+
+# Calculate precision and recall for different thresholds
+precision, recall, _ = precision_recall_curve(y_test, y_scores)
+
+# Calculate the Average Precision (AP) score
+average_precision = average_precision_score(y_test, y_scores)
+
+# Plot the Precision-Recall curve
+plt.figure(figsize=(8, 6))
+plt.plot(recall, precision, color='red', lw=2, label='Precision-Recall curve (AP = %0.2f)' % average_precision)
+plt.xlabel('Recall')
+plt.ylabel('Precision')
+plt.title('Precision-Recall Curve')
+plt.ylim([0.0, 1.05])
+plt.xlim([0.0, 1.0])
+plt.legend(loc="lower left")
+plt.tight_layout()
+plt.show()
+
+print(f"\nAverage Precision (AP) for Logistic Regression: {average_precision:.4f}")
+
+from sklearn.metrics import roc_curve, auc
+
+# Calculate ROC curve
+fpr, tpr, thresholds = roc_curve(y_test, lr_model.predict_proba(X_test)[:,1])
+roc_auc = auc(fpr, tpr)
+
+# Plot ROC curve
+plt.figure(figsize=(8, 6))
+plt.plot(fpr, tpr, color='red', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
+plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
+plt.xlim([0.0, 1.0])
+plt.ylim([0.0, 1.05])
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver Operating Characteristic (ROC) Curve')
+plt.legend(loc="lower right")
+plt.show()
+
+print(f"\nAUC for Logistic Regression: {roc_auc:.4f}")
+
+from sklearn.metrics import f1_score, classification_report
+
+# Calculate F1 score
+f1 = f1_score(y_test, lr_preds)
+print(f"\nF1 Score for Logistic Regression: {f1:.4f}")
+
+# Print classification report
+print("\nClassification Report for Logistic Regression:")
+print(classification_report(y_test, lr_preds, target_names=['Down', 'Up']))
+
+# Calculate training accuracy for Logistic Regression
+lr_train_accuracy = lr_model.score(X_train, y_train)
+print(f"\nLogistic Regression Training Accuracy: {lr_train_accuracy:.4f}")
+print(f"Logistic Regression Test Accuracy: {accuracy_score(y_test, lr_preds):.4f}")
+
+import pickle
+
+# Save the Logistic Regression model
+filename = 'logistic_regression_model.pkl'
+pickle.dump(lr_model, open(filename, 'wb'))
+
+print(f"Logistic Regression model saved to {filename}")
+
+import pickle
+
+# Load the saved Logistic Regression model
+filename = 'logistic_regression_model.pkl'
+loaded_model = pickle.load(open(filename, 'rb'))
+
+print(f"Logistic Regression model loaded from {filename}")
+
+# Test the loaded model
+loaded_preds = loaded_model.predict(X_test)
+
+# Evaluate the loaded model's performance
+print("\n=== Loaded Logistic Regression Model Performance ===")
+print("\n Accuracy:", accuracy_score(y_test, loaded_preds)," \n")
+print(classification_report(y_test, loaded_preds, target_names=['Down','Up']))

src/models/logistic_regression_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:919c661816bdbe075897c7f6497a39463fc75a28d24fd9d61698578c0489f1a5
+size 1200

src/models/ml_model.py

@@ -0,0 +1 @@
+# Placeholder for ml_model.py

src/models/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04a408395df58f2d61dabfe3131509fe00170012806d34248a095b1446910404
+size 2254

src/requirements.txt

@@ -0,0 +1,12 @@
+# Placeholder for requirements.txt
+
+pandas
+numpy
+matplotlib
+yfinance
+streamlit
+
+gspread
+google-auth
+google-auth-oauthlib
+google-auth-httplib2

src/script.ps1

@@ -0,0 +1,51 @@
+# create_project_structure.ps1
+
+# Root directory
+$root = "src"
+
+# Define folders
+$folders = @(
+    "$root\data\historical",
+    "$root\indicators",
+    "$root\models",
+    "$root\strategy",
+    "$root\utils"
+)
+
+# Define files
+$files = @(
+    "$root\main.py",
+    "$root\config.py",
+    "$root\requirements.txt",
+    "$root\README.md",
+    "$root\indicators\sma.py",
+    "$root\indicators\ema.py",
+    "$root\indicators\rsi.py",
+    "$root\indicators\enhanced_features.py",
+    "$root\indicators\macd.py",
+    "$root\models\ml_model.py",
+    "$root\strategy\rule_based_strategy.py",
+    "$root\utils\data_loader.py",
+    "$root\utils\logger.py",
+    "$root\utils\backtester.py"
+)
+
+# Create folders
+foreach ($folder in $folders) {
+    if (-Not (Test-Path -Path $folder)) {
+        New-Item -ItemType Directory -Path $folder | Out-Null
+    }
+}
+
+# Create files with placeholder content
+foreach ($file in $files) {
+    if (-Not (Test-Path -Path $file)) {
+        New-Item -ItemType File -Path $file | Out-Null
+        Add-Content -Path $file -Value "# Placeholder for $([System.IO.Path]::GetFileName($file))"
+    }
+}
+
+Write-Host "Project structure created successfully under $root"
+# End of script
+# Save this script as create_project_structure.ps1 and run it in PowerShell to create the project structure.
+# Ensure you have the necessary permissions to create directories and files in the specified location.

src/strategy/rule_based_strategy.py

@@ -0,0 +1,51 @@
+# strategy/rule_based_strategy.py
+
+"""
+    Generates buy/sell signals based on:
+    - Buy when RSI < 30 and SMA20 crosses above SMA50
+    - Sell when RSI > 70 and SMA20 crosses below SMA50
+
+    Returns:
+        pd.DataFrame: DataFrame with new 'Signal' column: 1 = Buy, -1 = Sell, 0 = Hold
+"""
+
+import pandas as pd
+
+def generate_signals_sma(df, rsi_col='RSI', sma_short_col='SMA20', sma_long_col='SMA50'):
+    df = df.copy()
+    df['SMA_Signal'] = 0
+    
+    # Method 1: Use OR condition (either RSI or SMA crossover)
+    # Buy condition: RSI < 30 OR SMA20 crosses above SMA50
+    rsi_oversold = df[rsi_col] < 30
+    sma_bullish_cross = (df[sma_short_col].shift(1) < df[sma_long_col].shift(1)) & (df[sma_short_col] > df[sma_long_col])
+    buy_signal = rsi_oversold | sma_bullish_cross
+    df.loc[buy_signal, 'SMA_Signal'] = 1
+    
+    # Sell condition: RSI > 70 OR SMA20 crosses below SMA50
+    rsi_overbought = df[rsi_col] > 70
+    sma_bearish_cross = (df[sma_short_col].shift(1) > df[sma_long_col].shift(1)) & (df[sma_short_col] < df[sma_long_col])
+    sell_signal = rsi_overbought | sma_bearish_cross
+    df.loc[sell_signal, 'SMA_Signal'] = -1
+    
+    return df
+
+
+def generate_signals_ema(df, rsi_col='RSI', ema_short_col='EMA20', ema_long_col='EMA50'):
+    df = df.copy()
+    df['EMA_Signal'] = 0
+
+    # Method 1: Use OR condition (either RSI or EMA crossover)
+    # Buy condition: RSI < 30 OR EMA20 crosses above EMA50
+    rsi_oversold = df[rsi_col] < 30
+    ema_bullish_cross = (df[ema_short_col].shift(1) < df[ema_long_col].shift(1)) & (df[ema_short_col] > df[ema_long_col])
+    buy_signal = rsi_oversold | ema_bullish_cross
+    df.loc[buy_signal, 'EMA_Signal'] = 1
+
+    # Sell condition: RSI > 70 OR EMA20 crosses below EMA50
+    rsi_overbought = df[rsi_col] > 70
+    ema_bearish_cross = (df[ema_short_col].shift(1) > df[ema_long_col].shift(1)) & (df[ema_short_col] < df[ema_long_col])
+    sell_signal = rsi_overbought | ema_bearish_cross
+    df.loc[sell_signal, 'EMA_Signal'] = -1
+    
+    return df

src/streamlit_app.py

@@ -1,40 +1,808 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import yfinance as yf
+import pickle
+from datetime import datetime, timedelta
+import warnings
+from curl_cffi import requests
+session = requests.Session(impersonate="chrome")
+
+from indicators.rsi import rsi
+from indicators.sma import sma
+from indicators.ema import ema
+from indicators.macd import macd
+
+from strategy.rule_based_strategy import generate_signals_sma, generate_signals_ema
+from utils.backtester import backtest_signals
+ 
+from indicators.enhanced_features import (
+    create_volatility_features, create_enhanced_lag_features,
+    create_volume_features, create_momentum_features, create_position_features
+)
+
+# Suppress warnings
+warnings.filterwarnings('ignore')
+
+# Page config
+st.set_page_config(
+    page_title="Complete Stock Trading & Prediction Platform",
+    page_icon="📈",
+    layout="wide"
+)
+
+# Stock symbols
+STOCK_SYMBOLS = [
+    'ADANIENT.NS', 'ADANIPORTS.NS', 'APOLLOHOSP.NS', 'ASIANPAINT.NS',
+    'AXISBANK.NS', 'BAJAJ-AUTO.NS', 'BAJFINANCE.NS', 'BAJAJFINSV.NS', 
+    'BEL.NS', 'BHARTIARTL.NS', 'CIPLA.NS', 'COALINDIA.NS', 'DRREDDY.NS', 
+    'EICHERMOT.NS', 'GRASIM.NS', 'HCLTECH.NS', 'HDFCBANK.NS', 'HDFCLIFE.NS', 
+    'HEROMOTOCO.NS', 'HINDALCO.NS', 'HINDUNILVR.NS', 'ICICIBANK.NS', 
+    'INDUSINDBK.NS', 'INFY.NS', 'ITC.NS', 'JIOFIN.NS', 'JSWSTEEL.NS', 
+    'KOTAKBANK.NS', 'LT.NS', 'M&M.NS', 'MARUTI.NS', 'NESTLEIND.NS', 
+    'NTPC.NS', 'ONGC.NS', 'POWERGRID.NS', 'RELIANCE.NS', 'SBILIFE.NS', 
+    'SHRIRAMFIN.NS', 'SBIN.NS', 'SUNPHARMA.NS', 'TATACONSUM.NS', 'TCS.NS',
+    'TATAMOTORS.NS', 'TATASTEEL.NS', 'TECHM.NS', 'TITAN.NS', 'TRENT.NS', 
+    'ULTRACEMCO.NS', 'WIPRO.NS', 'ETERNAL.NS'
+]
+
+# Feature list for ML model
+FEATURES = [
+    'Close', 'Volume', 'SMA20', 'SMA50', 'EMA20', 'EMA50',
+    'RSI14', 'MACD', 'MACD_signal', 'MACD_hist',
+    'SMA_crossover', 'RSI_oversold',
+    'return_1d', 'volatility_5d', 'volatility_10d', 'volatility_20d',
+    'volatility_30d', 'vol_ratio_5_20', 'vol_ratio_10_20', 'vol_rank_20',
+    'vol_rank_50', 'return_lag_1', 'return_lag_2', 'return_lag_3',
+    'return_lag_5', 'return_lag_10', 'rsi_lag_1', 'macd_lag_1', 'rsi_lag_2',
+    'macd_lag_2', 'rsi_lag_3', 'macd_lag_3', 'volume_sma_10',
+    'volume_sma_20', 'volume_sma_50', 'volume_ratio_10', 'volume_ratio_20',
+    'volume_ratio_50', 'price_volume', 'pv_sma_5', 'volume_momentum_5',
+    'momentum_3d', 'momentum_5d', 'momentum_10d', 'momentum_20d', 'roc_5d',
+    'roc_10d', 'high_10d', 'low_10d', 'price_position_10', 'high_20d',
+    'low_20d', 'price_position_20', 'high_50d', 'low_50d',
+    'price_position_50', 'bb_upper', 'bb_lower', 'bb_position', 'target'
+]
+
+# ========================= SHARED FUNCTIONS =========================
+
+@st.cache_data
+def load_stock_data(symbol, start_date, end_date):
+    """Load stock data from Yahoo Finance"""
+    try:
+        data = yf.download(symbol, start=start_date, end=end_date, session=session)
+        # Flatten the MultiIndex columns
+        if data.columns.nlevels > 1:
+            data.columns = [col[0] for col in data.columns]
+        return data
+    except Exception as e:
+        st.error(f"Error loading data: {e}")
+        return None
+
+def process_stock_data(df, short_period, long_period, rsi_period):
+    """Process stock data to create all features"""
+    df = df.copy()
+    
+    # Basic technical indicators
+    df['SMA20'] = sma(df, short_period)
+    df['SMA50'] = sma(df, long_period)
+    df['EMA20'] = ema(df, short_period)
+    df['EMA50'] = ema(df, long_period)
+    df['RSI14'] = rsi(df, rsi_period)
+    df['RSI20'] = rsi(df, rsi_period + 6)
+    df['MACD'], df['MACD_signal'], df['MACD_hist'] = macd(df)
+    
+    # Bollinger Bands
+    df['Upper_Band'] = df['SMA20'] + 2 * df['Close'].rolling(window=20).std()
+    df['Lower_Band'] = df['SMA20'] - 2 * df['Close'].rolling(window=20).std()
+    
+    # Create feature sets
+    df = create_volatility_features(df)
+    df = create_enhanced_lag_features(df)
+    df = create_volume_features(df)
+    df = create_momentum_features(df)
+    df = create_position_features(df)
+    
+    # Additional features
+    df['SMA_crossover'] = (df['SMA20'] > df['SMA50']).astype(int)
+    df['RSI_oversold'] = (df['RSI14'] < 30).astype(int)
+    
+    # Target: next-day up/down
+    df['next_close'] = df['Close'].shift(-1)
+    df['target'] = (df['next_close'] > df['Close']).astype(int)
+    
+    return df
+
+# ========================= MAIN APPLICATION =========================
+
+# Main navigation
+st.title("📈 Stock Trading & Prediction Platform")
+
+# Navigation tabs
+tab1, tab2 = st.tabs(["🔮 Price Prediction", "📊 Trading Dashboard"])
+
+# ========================= SIDEBAR CONFIGURATION =========================
+
+st.sidebar.header("📊 Configuration")
+
+# Common inputs
+selected_stock = st.sidebar.selectbox("Select Stock Symbol", STOCK_SYMBOLS, index=35)
+start_date = st.sidebar.date_input("Start Date", value=datetime(2020, 1, 1))
+end_date = st.sidebar.date_input("End Date", value=datetime.now())
+
+st.sidebar.subheader("📈 Technical Indicators")
+rsi_period = st.sidebar.slider("RSI Period", min_value=5, max_value=30, value=14, step=1)
+short_period = st.sidebar.slider("Short-term Period", min_value=5, max_value=50, value=20, step=1)
+long_period = st.sidebar.slider("Long-term Period", min_value=50, max_value=200, value=50, step=1)
+
+# Strategy selection (for trading dashboard)
+strategy_type = st.sidebar.selectbox("Strategy Type", ["SMA-based", "EMA-based", "Both"])
+
+st.sidebar.subheader("💰 Backtesting Parameters")
+initial_cash = st.sidebar.number_input("Initial Capital (₹)", min_value=10000, value=100000, step=10000)
+transaction_cost = st.sidebar.slider("Transaction Cost (%)", 0.0, 1.0, 0.1, step=0.05) / 100
+stop_loss = st.sidebar.slider("Stop Loss (%)", 0.0, 20.0, 5.0, step=1.0) / 100
+take_profit = st.sidebar.slider("Take Profit (%)", 0.0, 50.0, 15.0, step=5.0) / 100
+use_risk_mgmt = st.sidebar.checkbox("Enable Risk Management", value=True)
+
+# ========================= PRICE PREDICTION TAB =========================
+
+with tab1:
+    st.header(f"🔮 Price Prediction for {selected_stock}")
+    
+    with st.spinner("Loading stock data..."):
+        stock_data = load_stock_data(selected_stock, start_date, end_date)
+        
+        if stock_data is not None and not stock_data.empty:
+            # Display sample data
+            st.subheader("📊 Latest Stock Data")
+            st.dataframe(stock_data.tail(10), use_container_width=True)
+            
+            # Process the data
+            processed_data = process_stock_data(stock_data, short_period, long_period, rsi_period)
+            processed_data = processed_data.dropna()
+            
+            if len(processed_data) > 0:
+                # Get the latest row for prediction
+                latest_data = processed_data.iloc[-1]
+                
+                # Display current stock info
+                col1, col2, col3, col4 = st.columns(4)
+                with col1:
+                    st.metric("Current Price", f"₹{latest_data['Close']:.2f}")
+                with col2:
+                    daily_change = ((latest_data['Close'] - processed_data.iloc[-2]['Close']) / processed_data.iloc[-2]['Close']) * 100
+                    st.metric("Daily Change", f"{daily_change:.2f}%")
+                with col3:
+                    st.metric("Volume", f"{latest_data['Volume']:,.0f}")
+                with col4:
+                    st.metric("RSI14", f"{latest_data['RSI14']:.2f}")
+                
+                
+                model = pickle.load(open('models/logistic_regression_model.pkl', 'rb'))
+                scaler = pickle.load(open('models/scaler.pkl', 'rb'))
+                    
+                # Create feature vector
+                feature_vector = latest_data[FEATURES].values.reshape(1, -1)
+                feature_vector_scaled = scaler.transform(feature_vector)
+                    
+                # Make prediction
+                prediction = model.predict(feature_vector_scaled)[0]
+                probability = model.predict_proba(feature_vector_scaled)[0].max()
+            
+                
+                # Display prediction
+                st.header("🔮 Prediction Results")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    if prediction == 1:
+                        st.success("📈 **PREDICTION: UP**")
+                        st.write(f"The model predicts the stock will go **UP** tomorrow with {probability:.1%} confidence.")
+                    else:
+                        st.error("📉 **PREDICTION: DOWN**")
+                        st.write(f"The model predicts the stock will go **DOWN** tomorrow with {probability:.1%} confidence.")
+                
+                with col2:
+                    # Confidence gauge
+                    fig_gauge = go.Figure(go.Indicator(
+                        mode = "gauge+number",
+                        value = probability * 100,
+                        domain = {'x': [0, 1], 'y': [0, 1]},
+                        title = {'text': "Confidence %"},
+                        gauge = {
+                            'axis': {'range': [None, 100]},
+                            'bar': {'color': "darkgreen" if prediction == 1 else "darkred"},
+                            'steps': [
+                                {'range': [0, 50], 'color': "lightgray"},
+                                {'range': [50, 80], 'color': "yellow"},
+                                {'range': [80, 100], 'color': "lightgreen"}
+                            ],
+                            'threshold': {
+                                'line': {'color': "red", 'width': 4},
+                                'thickness': 0.75,
+                                'value': 90
+                            }
+                        }
+                    ))
+                    fig_gauge.update_layout(height=300)
+                    st.plotly_chart(fig_gauge, use_container_width=True)
+                
+                # Technical Analysis Charts
+                st.header("📈 Technical Analysis")
+                
+                # Price charts
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    # SMA Chart
+                    fig_sma = go.Figure()
+                    fig_sma.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['Close'][-60:],
+                                               mode='lines', name='Close Price', line=dict(color='blue', width=2)))
+                    fig_sma.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['SMA20'][-60:],
+                                               mode='lines', name='SMA20', line=dict(color='orange', width=1)))
+                    fig_sma.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['SMA50'][-60:],
+                                               mode='lines', name='SMA50', line=dict(color='red', width=1)))
+                    fig_sma.update_layout(title=f"{selected_stock} - Simple Moving Averages", height=400)
+                    st.plotly_chart(fig_sma, use_container_width=True)
+                
+                with col2:
+                    # EMA Chart
+                    fig_ema = go.Figure()
+                    fig_ema.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['Close'][-60:],
+                                               mode='lines', name='Close Price', line=dict(color='blue', width=2)))
+                    fig_ema.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['EMA20'][-60:],
+                                               mode='lines', name='EMA20', line=dict(color='orange', width=1)))
+                    fig_ema.add_trace(go.Scatter(x=processed_data.index[-60:], y=processed_data['EMA50'][-60:],
+                                               mode='lines', name='EMA50', line=dict(color='red', width=1)))
+                    fig_ema.update_layout(title=f"{selected_stock} - Exponential Moving Averages", height=400)
+                    st.plotly_chart(fig_ema, use_container_width=True)
+                
+                # RSI and MACD
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    fig_rsi = go.Figure()
+                    fig_rsi.add_trace(go.Scatter(x=processed_data.index[-30:], y=processed_data['RSI14'][-30:],
+                                               mode='lines', name='RSI14', line=dict(color='purple')))
+                    fig_rsi.add_hline(y=70, line_dash="dash", line_color="red", annotation_text="Overbought")
+                    fig_rsi.add_hline(y=30, line_dash="dash", line_color="green", annotation_text="Oversold")
+                    fig_rsi.update_layout(title=f"RSI ({rsi_period}-day)", height=300)
+                    st.plotly_chart(fig_rsi, use_container_width=True)
+                
+                with col2:
+                    fig_macd = go.Figure()
+                    fig_macd.add_trace(go.Scatter(x=processed_data.index[-30:], y=processed_data['MACD'][-30:],
+                                                mode='lines', name='MACD', line=dict(color='blue')))
+                    fig_macd.add_trace(go.Scatter(x=processed_data.index[-30:], y=processed_data['MACD_signal'][-30:],
+                                                mode='lines', name='Signal', line=dict(color='red')))
+                    fig_macd.update_layout(title="MACD", height=300)
+                    st.plotly_chart(fig_macd, use_container_width=True)
+            
+            else:
+                st.error("Not enough data to make a prediction.")
+        else:
+            st.error("Unable to load stock data.")
+
+# ========================= TRADING DASHBOARD TAB =========================
+
+with tab2:
+    st.header("📊 Trading Dashboard")
+    
+    with st.spinner(f'Loading data for {selected_stock}...'):
+        df = load_stock_data(selected_stock, start_date, end_date)
+    
+    if df is not None and not df.empty:
+        st.subheader(f"📊 Stock Data for {selected_stock}")
+        st.write(f"**Date Range:** {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+        st.write(f"**Total Records:** {len(df)} days")
+        
+        # Process data for trading
+        df = process_stock_data(df, short_period, long_period, rsi_period)
+        df = df.dropna()
+        
+        # Generate trading signals
+        if strategy_type in ["SMA-based", "Both"]:
+            df = generate_signals_sma(df, rsi_col='RSI14', sma_short_col='SMA20', sma_long_col='SMA50')
+        
+        if strategy_type in ["EMA-based", "Both"]:
+            df = generate_signals_ema(df, rsi_col='RSI14', ema_short_col='EMA20', ema_long_col='EMA50')
+        
+        # Initialize variables to avoid NameError
+        results = None
+        metrics = None
+        signal_col = None
+        strategy_name = None
+        
+        # Backtesting section
+        st.header("🔍 Backtesting Results")
+        
+        if strategy_type == "Both":
+            tab_sma, tab_ema = st.tabs(["SMA Strategy", "EMA Strategy"])
+            
+            with tab_sma:
+                st.subheader("📊 SMA Strategy Results")
+                sma_results, sma_metrics = backtest_signals(
+                    df, signal_col='SMA_Signal', price_col='Close', 
+                    initial_cash=initial_cash, transaction_cost=transaction_cost if use_risk_mgmt else 0
+                )
+                
+                # Set variables for common sections
+                results = sma_results
+                metrics = sma_metrics
+                signal_col = 'SMA_Signal'
+                strategy_name = 'SMA'
+                
+                # Display metrics
+                col1, col2, col3, col4 = st.columns(4)
+                with col1:
+                    st.metric("💰 Final Value", sma_metrics['Final Portfolio Value'])
+                    st.metric("📈 Total Return", sma_metrics['Total Return'])
+                with col2:
+                    st.metric("🎯 Buy & Hold Return", sma_metrics['Buy & Hold Return'])
+                    st.metric("📊 Total Trades", sma_metrics['Total Trades'])
+                with col3:
+                    st.metric("🏆 Win Rate", sma_metrics['Win Rate'])
+                    st.metric("⚡ Sharpe Ratio", sma_metrics['Sharpe Ratio'])
+                with col4:
+                    st.metric("📉 Max Drawdown", sma_metrics['Maximum Drawdown'])
+                    st.metric("🔥 Volatility", sma_metrics['Volatility (Annual)'])
+                
+                # SMA Price Chart with Signals
+                fig_sma_signals = go.Figure()
+                fig_sma_signals.add_trace(go.Scatter(x=df.index, y=df['Close'], mode='lines', 
+                                                   name='Close Price', line=dict(color='purple', width=2)))
+                fig_sma_signals.add_trace(go.Scatter(x=df.index, y=df['SMA20'], mode='lines', 
+                                                   name='SMA20', line=dict(color='blue', width=2)))
+                fig_sma_signals.add_trace(go.Scatter(x=df.index, y=df['SMA50'], mode='lines', 
+                                                   name='SMA50', line=dict(color='red', width=2)))
+                
+                # Add buy/sell signals
+                buy_signals = df[df['SMA_Signal'] == 1]
+                sell_signals = df[df['SMA_Signal'] == -1]
+                
+                if not buy_signals.empty:
+                    fig_sma_signals.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'],
+                                                       mode='markers', name='Buy Signal',
+                                                       marker=dict(symbol='triangle-up', size=12, color='green')))
+                
+                if not sell_signals.empty:
+                    fig_sma_signals.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'],
+                                                       mode='markers', name='Sell Signal',
+                                                       marker=dict(symbol='triangle-down', size=12, color='red')))
+                
+                fig_sma_signals.update_layout(title=f"{selected_stock} - SMA Strategy Signals", height=500)
+                st.plotly_chart(fig_sma_signals, use_container_width=True)
+                
+                # Portfolio Performance
+                buy_hold_value = initial_cash * (df['Close'] / df['Close'].iloc[0])
+                fig_perf_sma = go.Figure()
+                fig_perf_sma.add_trace(go.Scatter(x=sma_results.index, y=sma_results['Total'],
+                                                mode='lines', name='SMA Strategy', line=dict(color='green', width=3)))
+                fig_perf_sma.add_trace(go.Scatter(x=df.index, y=buy_hold_value,
+                                                mode='lines', name='Buy & Hold', line=dict(color='blue', width=2, dash='dash')))
+                fig_perf_sma.update_layout(title="SMA Strategy vs Buy & Hold Performance", height=400)
+                st.plotly_chart(fig_perf_sma, use_container_width=True)
+            
+            with tab_ema:
+                st.subheader("📊 EMA Strategy Results")
+                ema_results, ema_metrics = backtest_signals(
+                    df, signal_col='EMA_Signal', price_col='Close', 
+                    initial_cash=initial_cash, transaction_cost=transaction_cost if use_risk_mgmt else 0
+                )
+                
+                # Set variables for common sections  
+                results = ema_results
+                metrics = ema_metrics
+                signal_col = 'EMA_Signal'
+                strategy_name = 'EMA'
+                
+                # Display metrics
+                col1, col2, col3, col4 = st.columns(4)
+                with col1:
+                    st.metric("💰 Final Value", ema_metrics['Final Portfolio Value'])
+                    st.metric("📈 Total Return", ema_metrics['Total Return'])
+                with col2:
+                    st.metric("🎯 Buy & Hold Return", ema_metrics['Buy & Hold Return'])
+                    st.metric("📊 Total Trades", ema_metrics['Total Trades'])
+                with col3:
+                    st.metric("🏆 Win Rate", ema_metrics['Win Rate'])
+                    st.metric("⚡ Sharpe Ratio", ema_metrics['Sharpe Ratio'])
+                with col4:
+                    st.metric("📉 Max Drawdown", ema_metrics['Maximum Drawdown'])
+                    st.metric("🔥 Volatility", ema_metrics['Volatility (Annual)'])
+                
+                # EMA Price Chart with Signals
+                fig_ema_signals = go.Figure()
+                fig_ema_signals.add_trace(go.Scatter(x=df.index, y=df['Close'], mode='lines', 
+                                                   name='Close Price', line=dict(color='purple', width=2)))
+                fig_ema_signals.add_trace(go.Scatter(x=df.index, y=df['EMA20'], mode='lines', 
+                                                   name='EMA20', line=dict(color='blue', width=2)))
+                fig_ema_signals.add_trace(go.Scatter(x=df.index, y=df['EMA50'], mode='lines', 
+                                                   name='EMA50', line=dict(color='red', width=2)))
+                
+                # Add buy/sell signals
+                buy_signals = df[df['EMA_Signal'] == 1]
+                sell_signals = df[df['EMA_Signal'] == -1]
+                
+                if not buy_signals.empty:
+                    fig_ema_signals.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'],
+                                                       mode='markers', name='Buy Signal',
+                                                       marker=dict(symbol='triangle-up', size=12, color='green')))
+                
+                if not sell_signals.empty:
+                    fig_ema_signals.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'],
+                                                       mode='markers', name='Sell Signal',
+                                                       marker=dict(symbol='triangle-down', size=12, color='red')))
+                
+                fig_ema_signals.update_layout(title=f"{selected_stock} - EMA Strategy Signals", height=500)
+                st.plotly_chart(fig_ema_signals, use_container_width=True)
+                
+                # Portfolio Performance
+                buy_hold_value = initial_cash * (df['Close'] / df['Close'].iloc[0])
+                fig_perf_ema = go.Figure()
+                fig_perf_ema.add_trace(go.Scatter(x=ema_results.index, y=ema_results['Total'],
+                                                mode='lines', name='EMA Strategy', line=dict(color='green', width=3)))
+                fig_perf_ema.add_trace(go.Scatter(x=df.index, y=buy_hold_value,
+                                                mode='lines', name='Buy & Hold', line=dict(color='blue', width=2, dash='dash')))
+                fig_perf_ema.update_layout(title="EMA Strategy vs Buy & Hold Performance", height=400)
+                st.plotly_chart(fig_perf_ema, use_container_width=True)
+        
+        else:
+            # Single strategy
+            signal_col = 'SMA_Signal' if strategy_type == "SMA-based" else 'EMA_Signal'
+            strategy_name = strategy_type.split('-')[0]
+            
+            results, metrics = backtest_signals(
+                df, signal_col=signal_col, price_col='Close', 
+                initial_cash=initial_cash, transaction_cost=transaction_cost if use_risk_mgmt else 0
+            )
+            
+            # Display metrics
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("💰 Final Value", metrics['Final Portfolio Value'])
+                st.metric("📈 Total Return", metrics['Total Return'])
+            with col2:
+                st.metric("🎯 Buy & Hold Return", metrics['Buy & Hold Return'])
+                st.metric("📊 Total Trades", metrics['Total Trades'])
+            with col3:
+                st.metric("🏆 Win Rate", metrics['Win Rate'])
+                st.metric("⚡ Sharpe Ratio", metrics['Sharpe Ratio'])
+            with col4:
+                st.metric("📉 Max Drawdown", metrics['Maximum Drawdown'])
+                st.metric("🔥 Volatility", metrics['Volatility (Annual)'])
+            
+            # Price Chart with Signals
+            fig_signals = go.Figure()
+            fig_signals.add_trace(go.Scatter(x=df.index, y=df['Close'], mode='lines', 
+                                           name='Close Price', line=dict(color='purple', width=2)))
+            
+            if strategy_name == 'SMA':
+                fig_signals.add_trace(go.Scatter(x=df.index, y=df['SMA20'], mode='lines', 
+                                               name='SMA20', line=dict(color='blue', width=2)))
+                fig_signals.add_trace(go.Scatter(x=df.index, y=df['SMA50'], mode='lines', 
+                                               name='SMA50', line=dict(color='red', width=2)))
+            else:
+                fig_signals.add_trace(go.Scatter(x=df.index, y=df['EMA20'], mode='lines', 
+                                               name='EMA20', line=dict(color='blue', width=2)))
+                fig_signals.add_trace(go.Scatter(x=df.index, y=df['EMA50'], mode='lines', 
+                                               name='EMA50', line=dict(color='red', width=2)))
+            
+            # Add buy/sell signals
+            buy_signals = df[df[signal_col] == 1]
+            sell_signals = df[df[signal_col] == -1]
+            
+            if not buy_signals.empty:
+                fig_signals.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'],
+                                               mode='markers', name='Buy Signal',
+                                               marker=dict(symbol='triangle-up', size=12, color='green')))
+            
+            if not sell_signals.empty:
+                fig_signals.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'],
+                                               mode='markers', name='Sell Signal',
+                                               marker=dict(symbol='triangle-down', size=12, color='red')))
+            
+            fig_signals.update_layout(title=f"{selected_stock} - {strategy_name} Strategy Signals", height=500)
+            st.plotly_chart(fig_signals, use_container_width=True)
+            
+            # Portfolio Performance
+            buy_hold_value = initial_cash * (df['Close'] / df['Close'].iloc[0])
+            fig_perf = go.Figure()
+            fig_perf.add_trace(go.Scatter(x=results.index, y=results['Total'],
+                                        mode='lines', name=f'{strategy_name} Strategy', line=dict(color='green', width=3)))
+            fig_perf.add_trace(go.Scatter(x=df.index, y=buy_hold_value,
+                                        mode='lines', name='Buy & Hold', line=dict(color='blue', width=2, dash='dash')))
+            fig_perf.update_layout(title=f"{strategy_name} Strategy vs Buy & Hold Performance", height=400)
+            st.plotly_chart(fig_perf, use_container_width=True)
+        
+        # Additional Technical Analysis Charts (only show if we have results)
+        if results is not None:
+            st.header("📈 Additional Technical Analysis")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # RSI Chart
+                fig_rsi = go.Figure()
+                fig_rsi.add_trace(go.Scatter(x=df.index, y=df['RSI14'], mode='lines', 
+                                           name='RSI14', line=dict(color='purple', width=2)))
+                
+                # Add buy/sell signals on RSI if available
+                if not buy_signals.empty:
+                    fig_rsi.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['RSI14'],
+                                               mode='markers', name='Buy Signal',
+                                               marker=dict(symbol='triangle-up', size=10, color='green'),
+                                               showlegend=False))
+                
+                if not sell_signals.empty:
+                    fig_rsi.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['RSI14'],
+                                               mode='markers', name='Sell Signal',
+                                               marker=dict(symbol='triangle-down', size=10, color='red'),
+                                               showlegend=False))
+                
+                fig_rsi.add_hline(y=70, line_dash="dash", line_color="red", annotation_text="Overbought (70)")
+                fig_rsi.add_hline(y=30, line_dash="dash", line_color="green", annotation_text="Oversold (30)")
+                fig_rsi.add_hline(y=50, line_dash="solid", line_color="gray", annotation_text="Midline (50)", opacity=0.5)
+                
+                fig_rsi.update_layout(title="RSI with Trading Signals", yaxis=dict(range=[0, 100]), height=400)
+                st.plotly_chart(fig_rsi, use_container_width=True)
+            
+            with col2:
+                # MACD Chart
+                fig_macd = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.05, row_heights=[0.7, 0.3])
+                
+                # MACD line
+                fig_macd.add_trace(go.Scatter(x=df.index, y=df['MACD'], mode='lines', name='MACD',
+                                            line=dict(color='blue', width=2)), row=1, col=1)
+                
+                # Signal line
+                fig_macd.add_trace(go.Scatter(x=df.index, y=df['MACD_signal'], mode='lines', name='Signal Line',
+                                            line=dict(color='orange', width=2)), row=1, col=1)
+                
+                # Zero line
+                fig_macd.add_hline(y=0, line_dash="solid", line_color="pink", opacity=0.5, row=1, col=1)
+                
+                # MACD histogram
+                colors = ['green' if val >= 0 else 'red' for val in df['MACD_hist']]
+                fig_macd.add_trace(go.Bar(x=df.index, y=df['MACD_hist'], name='MACD Histogram',
+                                        marker_color=colors, opacity=0.6), row=2, col=1)
+                
+                fig_macd.update_layout(title="MACD Indicator", height=400, showlegend=True)
+                fig_macd.update_xaxes(title_text="Date", row=2, col=1)
+                fig_macd.update_yaxes(title_text="MACD Value", row=1, col=1)
+                fig_macd.update_yaxes(title_text="Histogram", row=2, col=1)
+                
+                st.plotly_chart(fig_macd, use_container_width=True)
+            
+            # Bollinger Bands
+            st.subheader("📈 Bollinger Bands")
+            fig_bb = go.Figure()
+            
+            fig_bb.add_trace(go.Scatter(x=df.index, y=df['Close'], mode='lines', name='Close Price',
+                                      line=dict(color='purple', width=2)))
+            fig_bb.add_trace(go.Scatter(x=df.index, y=df['SMA20'], mode='lines', name='20-day SMA',
+                                      line=dict(color='blue', width=1.5)))
+            fig_bb.add_trace(go.Scatter(x=df.index, y=df['Upper_Band'], mode='lines', name='Upper Band',
+                                      line=dict(color='red', dash='dash', width=1.5)))
+            fig_bb.add_trace(go.Scatter(x=df.index, y=df['Lower_Band'], mode='lines', name='Lower Band',
+                                      line=dict(color='green', dash='dash', width=1.5),
+                                      fill='tonexty', fillcolor='rgba(128,128,128,0.2)'))
+            
+            fig_bb.update_layout(title="Bollinger Bands", height=500)
+            st.plotly_chart(fig_bb, use_container_width=True)
+
+            # Drawdown Analysis
+            st.subheader("📉 Drawdown Analysis")
+            
+            # Calculate drawdown
+            returns = results['Total'].pct_change().fillna(0)
+            cumulative = (1 + returns).cumprod()
+            running_max = cumulative.expanding().max()
+            drawdown = (cumulative - running_max) / running_max
+            
+            fig_dd = go.Figure()
+            
+            fig_dd.add_trace(go.Scatter(
+                x=df.index,
+                y=drawdown * 100,
+                mode='lines',
+                name='Drawdown',
+                fill='tozeroy',
+                fillcolor='rgba(255,0,0,0.3)',
+                line=dict(color='red', width=1),
+                hovertemplate='<b>Drawdown</b>: %{y:.1f}%<extra></extra>'
+            ))
+            
+            fig_dd.update_layout(
+                title="Portfolio Drawdown Over Time",
+                xaxis_title="Date",
+                yaxis_title="Drawdown (%)",
+                height=400,
+                template='plotly_white'
+            )
+            
+            st.plotly_chart(fig_dd, use_container_width=True)
+            
+            # Trade analysis
+            if metrics is not None and not metrics['Trades DataFrame'].empty:
+                st.subheader("📋 Trade Analysis")
+                
+                trades_df = metrics['Trades DataFrame']
+                
+                # Trade statistics
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    avg_trade_duration = (pd.to_datetime(trades_df['exit_date']) - 
+                                        pd.to_datetime(trades_df['entry_date'])).dt.days.mean()
+                    st.metric("📅 Avg Trade Duration", f"{avg_trade_duration:.1f} days")
+                    
+                with col2:
+                    best_trade = trades_df['return_pct'].max()
+                    st.metric("🚀 Best Trade", f"{best_trade:.2%}")
+                    
+                with col3:
+                    worst_trade = trades_df['return_pct'].min()
+                    st.metric("💥 Worst Trade", f"{worst_trade:.2%}")
+                
+                # Trade returns distribution
+                st.subheader("📊 Trade Returns Distribution")
+                
+                returns_pct = trades_df['return_pct'] * 100
+                
+                fig_hist = px.histogram(
+                    x=returns_pct,
+                    nbins=20,
+                    title="Distribution of Trade Returns",
+                    labels={'x': 'Return (%)', 'y': 'Number of Trades'},
+                    color_discrete_sequence=['steelblue']
+                )
+                
+                # Add vertical lines for mean and zero
+                fig_hist.add_vline(x=0, line_dash="dash", line_color="red", 
+                                annotation_text="Break Even")
+                fig_hist.add_vline(x=returns_pct.mean(), line_dash="solid", line_color="green", 
+                                annotation_text=f"Mean: {returns_pct.mean():.1f}%")
+                
+                fig_hist.update_layout(
+                    height=400,
+                    template='plotly_white',
+                    showlegend=False
+                )
+                
+                st.plotly_chart(fig_hist, use_container_width=True)
+                
+                # Trade timeline
+                st.subheader("📅 Trade Timeline")
+                
+                fig_timeline = go.Figure()
+                
+                for i, trade in trades_df.iterrows():
+                    color = 'green' if trade['return_pct'] > 0 else 'red'
+                    fig_timeline.add_trace(go.Scatter(
+                        x=[trade['entry_date'], trade['exit_date']],
+                        y=[trade['entry_price'], trade['exit_price']],
+                        mode='lines+markers',
+                        name=f"Trade {i+1}",
+                        line=dict(color=color, width=3),
+                        marker=dict(size=8),
+                        hovertemplate=f'<b>Trade {i+1}</b><br>' +
+                                    f'Entry: ₹{trade["entry_price"]:.2f}<br>' +
+                                    f'Exit: ₹{trade["exit_price"]:.2f}<br>' +
+                                    f'Return: {trade["return_pct"]:.2%}<br>' +
+                                    f'Duration: {(pd.to_datetime(trade["exit_date"]) - pd.to_datetime(trade["entry_date"])).days} days<extra></extra>',
+                        showlegend=False
+                    ))
+                
+                fig_timeline.update_layout(
+                    title="Individual Trade Performance Timeline",
+                    xaxis_title="Date",
+                    yaxis_title="Price (₹)",
+                    height=500,
+                    template='plotly_white'
+                )
+                
+                st.plotly_chart(fig_timeline, use_container_width=True)
+                
+                # Trade history table
+                st.subheader("📊 Detailed Trade History")
+                display_trades = trades_df.copy()
+                display_trades['Entry Date'] = pd.to_datetime(display_trades['entry_date']).dt.strftime('%Y-%m-%d')
+                display_trades['Exit Date'] = pd.to_datetime(display_trades['exit_date']).dt.strftime('%Y-%m-%d')
+                display_trades['Entry Price'] = display_trades['entry_price'].apply(lambda x: f"₹{x:.2f}")
+                display_trades['Exit Price'] = display_trades['exit_price'].apply(lambda x: f"₹{x:.2f}")
+                display_trades['P&L (₹)'] = display_trades['profit_loss'].apply(lambda x: f"₹{x:,.2f}")
+                display_trades['Return %'] = display_trades['return_pct'].apply(lambda x: f"{x:.2%}")
+                display_trades['Duration'] = (pd.to_datetime(trades_df['exit_date']) - 
+                                            pd.to_datetime(trades_df['entry_date'])).dt.days
+                
+                trade_display = display_trades[['Entry Date', 'Exit Date', 'Entry Price', 'Exit Price', 
+                                            'P&L (₹)', 'Return %', 'Duration', 'exit_reason']].copy()
+                trade_display.columns = ['Entry Date', 'Exit Date', 'Entry Price', 'Exit Price', 
+                                    'Profit/Loss', 'Return %', 'Days', 'Exit Reason']
+                
+                st.dataframe(trade_display, use_container_width=True)
+            
+            else:
+                st.info("📝 No trades were executed during this period with the current parameters.")
+            
+            # Signal summary table
+            if signal_col is not None:
+                st.subheader("📋 Trading Signals Summary")
+                signal_summary = df[df[signal_col] != 0].copy()
+                
+                if not signal_summary.empty:
+                    signal_summary['Signal Type'] = signal_summary[signal_col].map({1: '🟢 BUY', -1: '🔴 SELL'})
+                    signal_summary['Price'] = signal_summary['Close'].apply(lambda x: f"₹{x:.2f}")
+                    signal_summary['RSI'] = signal_summary['RSI14'].apply(lambda x: f"{x:.1f}")
+                    signal_summary[f'{strategy_name}{short_period}'] = signal_summary[f'{strategy_name}{short_period}'].apply(lambda x: f"₹{x:.2f}")
+                    signal_summary[f'{strategy_name}{long_period}'] = signal_summary[f'{strategy_name}{long_period}'].apply(lambda x: f"₹{x:.2f}")
+                    
+                    display_signals = signal_summary[['Signal Type', 'Price', 'RSI', 
+                                                    f'{strategy_name}{short_period}', 
+                                                    f'{strategy_name}{long_period}']].copy()
+                    display_signals.index = display_signals.index.strftime('%Y-%m-%d')
+                    
+                    st.dataframe(display_signals, use_container_width=True)
+                else:
+                    st.info("📝 No trading signals were generated during this period with the current parameters.")
+        
+        # Data Download Section
+        st.subheader("💾 Download Data")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            csv_data = df.to_csv(index=True)
+            st.download_button(
+                label="📁 Download Full Dataset (CSV)",
+                data=csv_data,
+                file_name=f"{selected_stock}_analysis_{start_date.strftime('%Y%m%d')}.csv",
+                mime="text/csv"
+            )
+        
+        with col2:
+            if results is not None:
+                results_csv = results.to_csv(index=True)
+                st.download_button(
+                    label="📊 Download Backtest Results (CSV)",
+                    data=results_csv,
+                    file_name=f"{selected_stock}_backtest_{start_date.strftime('%Y%m%d')}.csv",
+                    mime="text/csv"
+                )
+    
+    else:
+        st.error("❌ No data found for the selected stock and date range.")
+
+# ========================= SIDEBAR INFORMATION =========================
+
+st.sidebar.markdown("---")
+st.sidebar.header("ℹ️ About")
+st.sidebar.write("""
+**Price Prediction Features:**
+- Logistic Regression model for next-day prediction
+- 59+ technical features including volatility, momentum, and lag features
+- Confidence gauge and feature importance analysis
+
+**Trading Dashboard Features:**
+- SMA and EMA-based strategies
+- Comprehensive backtesting with risk management
+- Detailed performance metrics and trade analysis
+- Interactive visualizations with Plotly
+
+**Disclaimer**: This is for educational purposes only. Always do your own research before making investment decisions.
+""")
+
+st.sidebar.markdown("---")
+st.sidebar.write("**Model Performance:**")
+st.sidebar.write("• Accuracy: 55%")
+st.sidebar.write("• F1 Score: 0.4839")
+st.sidebar.write("• AUC: 0.5370")
+st.sidebar.write("• Average Precision: 0.5300")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Footer
+st.markdown("---")
+st.markdown("**⚠️ Disclaimer**: This platform is for research and educational purposes only. Stock market investments are subject to market risks. Please consult with a financial advisor before making investment decisions.")
+st.markdown("**Developed by**: Zane Vijay Falcao")

src/utils/backtester.py

@@ -0,0 +1,186 @@
+# utils/backtester.py
+
+import pandas as pd
+import numpy as np
+
+def backtest_signals(df, signal_col='Signal', price_col='Close', initial_cash=100000, 
+                    transaction_cost=0.001, stop_loss=None, take_profit=None):
+    """
+    Enhanced backtest strategy using buy/sell signals.
+
+    Parameters:
+        df (pd.DataFrame): DataFrame with signal and price columns
+        signal_col (str): Name of the signal column (1 = Buy, -1 = Sell)
+        price_col (str): Name of the price column to use for trading
+        initial_cash (float): Starting cash for the backtest
+        transaction_cost (float): Transaction cost as percentage (0.001 = 0.1%)
+        stop_loss (float): Stop loss percentage (0.05 = 5%)
+        take_profit (float): Take profit percentage (0.10 = 10%)
+
+    Returns:
+        tuple: (results_df, performance_metrics)
+    """
+    df = df.copy()
+    df['Position'] = 0  # 1 if holding, 0 otherwise
+    df['Cash'] = initial_cash
+    df['Holdings_Value'] = 0
+    df['Total'] = initial_cash
+    df['Returns'] = 0
+    df['Trade_Action'] = ''
+
+    position = 0  # Whether we hold a stock
+    cash = initial_cash
+    shares = 0
+    entry_price = 0
+    trades = []
+    
+    for i in range(len(df)):
+        current_price = df[price_col].iloc[i]
+        signal = df[signal_col].iloc[i]
+        
+        # Check stop loss and take profit if holding position
+        if position == 1 and shares > 0:
+            price_change = (current_price - entry_price) / entry_price
+            
+            # Stop loss check
+            if stop_loss and price_change <= -stop_loss:
+                # Force sell due to stop loss
+                cash = shares * current_price * (1 - transaction_cost)
+                trades.append({
+                    'entry_date': entry_date,
+                    'exit_date': df.index[i],
+                    'entry_price': entry_price,
+                    'exit_price': current_price,
+                    'shares': shares,
+                    'profit_loss': cash - (shares * entry_price),
+                    'return_pct': price_change,
+                    'exit_reason': 'Stop Loss'
+                })
+                shares = 0
+                position = 0
+                df.at[df.index[i], 'Trade_Action'] = 'STOP_LOSS'
+                
+            # Take profit check
+            elif take_profit and price_change >= take_profit:
+                # Force sell due to take profit
+                cash = shares * current_price * (1 - transaction_cost)
+                trades.append({
+                    'entry_date': entry_date,
+                    'exit_date': df.index[i],
+                    'entry_price': entry_price,
+                    'exit_price': current_price,
+                    'shares': shares,
+                    'profit_loss': cash - (shares * entry_price),
+                    'return_pct': price_change,
+                    'exit_reason': 'Take Profit'
+                })
+                shares = 0
+                position = 0
+                df.at[df.index[i], 'Trade_Action'] = 'TAKE_PROFIT'
+
+        # Process regular buy/sell signals
+        if signal == 1 and position == 0 and cash > 0:
+            # Buy signal
+            cost_with_fees = cash * (1 + transaction_cost)
+            if cost_with_fees <= cash:
+                shares = cash / (current_price * (1 + transaction_cost))
+                cash = 0
+                position = 1
+                entry_price = current_price
+                entry_date = df.index[i]
+                df.at[df.index[i], 'Trade_Action'] = 'BUY'
+
+        elif signal == -1 and position == 1 and shares > 0:
+            # Sell signal
+            cash = shares * current_price * (1 - transaction_cost)
+            
+            # Record trade
+            price_change = (current_price - entry_price) / entry_price
+            trades.append({
+                'entry_date': entry_date,
+                'exit_date': df.index[i],
+                'entry_price': entry_price,
+                'exit_price': current_price,
+                'shares': shares,
+                'profit_loss': cash - (shares * entry_price),
+                'return_pct': price_change,
+                'exit_reason': 'Signal'
+            })
+            
+            shares = 0
+            position = 0
+            df.at[df.index[i], 'Trade_Action'] = 'SELL'
+
+        # Update portfolio values
+        holdings_value = shares * current_price if shares > 0 else 0
+        total_value = cash + holdings_value
+        
+        df.at[df.index[i], 'Position'] = position
+        df.at[df.index[i], 'Cash'] = cash
+        df.at[df.index[i], 'Holdings_Value'] = holdings_value
+        df.at[df.index[i], 'Total'] = total_value
+        
+        # Calculate daily returns
+        if i > 0:
+            prev_total = df['Total'].iloc[i-1]
+            df.at[df.index[i], 'Returns'] = (total_value - prev_total) / prev_total
+
+    # Calculate performance metrics
+    performance_metrics = calculate_performance_metrics(df, trades, initial_cash)
+    
+    return df[['Close', signal_col, 'Position', 'Cash', 'Holdings_Value', 'Total', 
+              'Returns', 'Trade_Action']], performance_metrics
+
+
+def calculate_performance_metrics(df, trades, initial_cash):
+    """Calculate comprehensive performance metrics"""
+    final_value = df['Total'].iloc[-1]
+    total_return = (final_value - initial_cash) / initial_cash
+    
+    # Calculate buy and hold return for comparison
+    buy_hold_return = (df['Close'].iloc[-1] - df['Close'].iloc[0]) / df['Close'].iloc[0]
+    
+    # Risk metrics
+    returns = df['Returns'].dropna()
+    if len(returns) > 0:
+        volatility = returns.std() * np.sqrt(252)  # Annualized volatility
+        sharpe_ratio = (returns.mean() * 252) / volatility if volatility > 0 else 0
+        
+        # Maximum drawdown
+        cumulative = (1 + returns).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdown = (cumulative - running_max) / running_max
+        max_drawdown = drawdown.min()
+    else:
+        volatility = 0
+        sharpe_ratio = 0
+        max_drawdown = 0
+    
+    # Trade statistics
+    if trades:
+        trades_df = pd.DataFrame(trades)
+        win_rate = len(trades_df[trades_df['return_pct'] > 0]) / len(trades_df)
+        avg_win = trades_df[trades_df['return_pct'] > 0]['return_pct'].mean() if len(trades_df[trades_df['return_pct'] > 0]) > 0 else 0
+        avg_loss = trades_df[trades_df['return_pct'] < 0]['return_pct'].mean() if len(trades_df[trades_df['return_pct'] < 0]) > 0 else 0
+        profit_factor = abs(avg_win / avg_loss) if avg_loss != 0 else float('inf')
+    else:
+        win_rate = 0
+        avg_win = 0
+        avg_loss = 0
+        profit_factor = 0
+    
+    return {
+        'Total Return': f"{total_return:.2%}",
+        'Buy & Hold Return': f"{buy_hold_return:.2%}",
+        'Final Portfolio Value': f"₹{final_value:,.2f}",
+        'Total Trades': len(trades),
+        'Win Rate': f"{win_rate:.2%}",
+        'Average Win': f"{avg_win:.2%}",
+        'Average Loss': f"{avg_loss:.2%}",
+        'Profit Factor': f"{profit_factor:.2f}",
+        'Volatility (Annual)': f"{volatility:.2%}",
+        'Sharpe Ratio': f"{sharpe_ratio:.2f}",
+        'Maximum Drawdown': f"{max_drawdown:.2%}",
+        'Trades DataFrame': pd.DataFrame(trades) if trades else pd.DataFrame()
+    }
+    

src/utils/data_loader.py

@@ -0,0 +1,41 @@
+# utils/data_loader.py
+
+import yfinance as yf
+import pandas as pd
+from datetime import datetime
+import logging
+
+from curl_cffi import requests
+session = requests.Session(impersonate="chrome")
+
+today = datetime.today()
+
+def fetch_stock_data(symbol, start_date="2023-01-01", end_date=today, interval="1d"):
+    """
+    Fetch historical stock data from Yahoo Finance.
+
+    Parameters:
+        symbol (str): Ticker symbol (e.g., "RELIANCE.NS")
+        start_date (str): Start date in "YYYY-MM-DD"
+        end_date (str): End date (default is today)
+        interval (str): Data interval ("1d", "1h", etc.)
+
+    Returns:
+        pd.DataFrame: Historical OHLCV stock data
+    """
+    try:
+        logging.info(f"Fetching data for {symbol} from {start_date} to {end_date or 'today'}")
+        df = yf.download(symbol, start=start_date, end=end_date, interval=interval, progress=False, session=session, auto_adjust=True, threads=True)
+        # Flatten the MultiIndex columns
+        df.columns = [col[0] for col in df.columns]
+
+        if df.empty:
+            logging.warning(f"No data found for {symbol}")
+        else:
+            logging.info(f"Downloaded {len(df)} rows for {symbol}")
+        return df
+
+    except Exception as e:
+        logging.error(f"Failed to fetch data for {symbol}: {e}")
+        return pd.DataFrame()
+

src/utils/google_sheets.py

@@ -0,0 +1,426 @@
+# utils/google_sheets.py
+
+import gspread
+from google.oauth2.service_account import Credentials
+import pandas as pd
+from datetime import datetime
+import streamlit as st
+import json
+
+class TradingGoogleSheets:
+    def __init__(self, credentials_json_path=None, credentials_dict=None, sheet_name="Trading_Log"):
+        """
+        Initialize Google Sheets connection
+        
+        Parameters:
+            credentials_json_path (str): Path to service account JSON file
+            credentials_dict (dict): Service account credentials as dictionary (for Streamlit secrets)
+            sheet_name (str): Name of the Google Sheet to create/use
+        """
+        self.sheet_name = sheet_name
+        self.scope = [
+            "https://spreadsheets.google.com/feeds",
+            "https://www.googleapis.com/auth/drive"
+        ]
+        
+        # Initialize credentials
+        if credentials_dict:
+            # For Streamlit deployment with secrets
+            self.creds = Credentials.from_service_account_info(credentials_dict, scopes=self.scope)
+        elif credentials_json_path:
+            # For local development with JSON file
+            self.creds = Credentials.from_service_account_file(credentials_json_path, scopes=self.scope)
+        else:
+            raise ValueError("Either credentials_json_path or credentials_dict must be provided")
+        
+        self.client = gspread.authorize(self.creds)
+        self.spreadsheet = None
+        
+    def create_or_get_spreadsheet(self):
+        """Create a new spreadsheet or get existing one"""
+        try:
+            # Try to open existing spreadsheet
+            self.spreadsheet = self.client.open(self.sheet_name)
+            print(f"Opened existing spreadsheet: {self.sheet_name}")
+        except gspread.SpreadsheetNotFound:
+            # Create new spreadsheet
+            self.spreadsheet = self.client.create(self.sheet_name)
+            print(f"Created new spreadsheet: {self.sheet_name}")
+            
+            # Share with your email (replace with your email)
+            # self.spreadsheet.share('your-email@gmail.com', perm_type='user', role='writer')
+        
+        # Create the three required worksheets
+        self.setup_worksheets()
+        return self.spreadsheet
+    
+    def setup_worksheets(self):
+        """Setup the required worksheets with headers"""
+        worksheets_config = {
+            "Trade_Log": [
+                "Timestamp", "Stock", "Strategy", "Signal_Type", "Price", "RSI", 
+                "MA_Short", "MA_Long", "Entry_Date", "Exit_Date", "Entry_Price", 
+                "Exit_Price", "Shares", "Profit_Loss", "Return_Pct", "Exit_Reason", "Duration_Days"
+            ],
+            "Summary_PL": [
+                "Date", "Stock", "Strategy", "Total_Trades", "Winning_Trades", 
+                "Losing_Trades", "Win_Rate", "Total_PL", "Best_Trade", "Worst_Trade", 
+                "Avg_Win", "Avg_Loss", "Profit_Factor", "Max_Drawdown", "Sharpe_Ratio", 
+                "Final_Portfolio_Value", "Total_Return"
+            ],
+            "Performance_Metrics": [
+                "Date", "Stock", "Strategy", "Initial_Capital", "Final_Value", 
+                "Total_Return", "Buy_Hold_Return", "Alpha", "Volatility", 
+                "Sharpe_Ratio", "Max_Drawdown", "Total_Trades", "Win_Rate", 
+                "Avg_Trade_Duration", "Transaction_Cost", "Notes"
+            ]
+        }
+        
+        existing_sheets = [ws.title for ws in self.spreadsheet.worksheets()]
+        
+        for sheet_name, headers in worksheets_config.items():
+            if sheet_name not in existing_sheets:
+                # Create new worksheet
+                worksheet = self.spreadsheet.add_worksheet(title=sheet_name, rows=1000, cols=len(headers))
+                worksheet.append_row(headers)
+                print(f"Created worksheet: {sheet_name}")
+            else:
+                print(f"Worksheet already exists: {sheet_name}")
+    
+    def log_trade_signals(self, df, strategy_name, stock_symbol):
+        """Log all trade signals to Trade_Log worksheet"""
+        try:
+            worksheet = self.spreadsheet.worksheet("Trade_Log")
+            
+            # Get signals from dataframe
+            signal_col = f'{strategy_name}_Signal'
+            signals_df = df[df[signal_col] != 0].copy()
+            
+            if signals_df.empty:
+                print("No signals to log")
+                return
+            
+            # Prepare data for logging
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            
+            rows_to_add = []
+            for idx, row in signals_df.iterrows():
+                signal_type = "BUY" if row[signal_col] == 1 else "SELL"
+                
+                row_data = [
+                    current_time,  # Timestamp
+                    stock_symbol,  # Stock
+                    strategy_name,  # Strategy
+                    signal_type,  # Signal_Type
+                    round(row['Close'], 2),  # Price
+                    round(row['RSI'], 2),  # RSI
+                    round(row[f'{strategy_name}20'], 2),  # MA_Short
+                    round(row[f'{strategy_name}50'], 2),  # MA_Long
+                    "",  # Entry_Date (filled when trade completes)
+                    "",  # Exit_Date
+                    "",  # Entry_Price
+                    "",  # Exit_Price
+                    "",  # Shares
+                    "",  # Profit_Loss
+                    "",  # Return_Pct
+                    "",  # Exit_Reason
+                    ""   # Duration_Days
+                ]
+                rows_to_add.append(row_data)
+            
+            # Add all rows at once
+            if rows_to_add:
+                worksheet.append_rows(rows_to_add)
+                print(f"Logged {len(rows_to_add)} signals to Trade_Log")
+                
+        except Exception as e:
+            print(f"Error logging trade signals: {e}")
+    
+    def log_completed_trades(self, trades_df, strategy_name, stock_symbol):
+        """Log completed trades to Trade_Log worksheet"""
+        try:
+            worksheet = self.spreadsheet.worksheet("Trade_Log")
+            
+            if trades_df.empty:
+                print("No completed trades to log")
+                return
+            
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            
+            rows_to_add = []
+            for _, trade in trades_df.iterrows():
+                row_data = [
+                    current_time,  # Timestamp
+                    stock_symbol,  # Stock
+                    strategy_name,  # Strategy
+                    "COMPLETED_TRADE",  # Signal_Type
+                    round(trade['exit_price'], 2),  # Price (exit price)
+                    "",  # RSI
+                    "",  # MA_Short
+                    "",  # MA_Long
+                    trade['entry_date'],  # Entry_Date
+                    trade['exit_date'],  # Exit_Date
+                    round(trade['entry_price'], 2),  # Entry_Price
+                    round(trade['exit_price'], 2),  # Exit_Price
+                    round(trade['shares'], 4),  # Shares
+                    round(trade['profit_loss'], 2),  # Profit_Loss
+                    round(trade['return_pct'] * 100, 2),  # Return_Pct
+                    trade['exit_reason'],  # Exit_Reason
+                    (pd.to_datetime(trade['exit_date']) - pd.to_datetime(trade['entry_date'])).days  # Duration_Days
+                ]
+                rows_to_add.append(row_data)
+            
+            if rows_to_add:
+                worksheet.append_rows(rows_to_add)
+                print(f"Logged {len(rows_to_add)} completed trades to Trade_Log")
+                
+        except Exception as e:
+            print(f"Error logging completed trades: {e}")
+    
+    def log_summary_pl(self, metrics, strategy_name, stock_symbol, trades_df):
+        """Log summary P&L to Summary_PL worksheet"""
+        try:
+            worksheet = self.spreadsheet.worksheet("Summary_PL")
+            
+            current_date = datetime.now().strftime("%Y-%m-%d")
+            
+            # Calculate additional metrics
+            total_trades = len(trades_df) if not trades_df.empty else 0
+            winning_trades = len(trades_df[trades_df['return_pct'] > 0]) if not trades_df.empty else 0
+            losing_trades = len(trades_df[trades_df['return_pct'] < 0]) if not trades_df.empty else 0
+            
+            # Extract numeric values from metrics
+            win_rate = float(metrics['Win Rate'].strip('%')) if metrics['Win Rate'] != '0.00%' else 0
+            total_pl = float(metrics['Final Portfolio Value'].replace('₹', '').replace(',', '')) - 100000  # Assuming 100k initial
+            best_trade = trades_df['return_pct'].max() * 100 if not trades_df.empty else 0
+            worst_trade = trades_df['return_pct'].min() * 100 if not trades_df.empty else 0
+            avg_win = float(metrics['Average Win'].strip('%')) if metrics['Average Win'] != '0.00%' else 0
+            avg_loss = float(metrics['Average Loss'].strip('%')) if metrics['Average Loss'] != '0.00%' else 0
+            profit_factor = float(metrics['Profit Factor']) if metrics['Profit Factor'] != '0.00' else 0
+            max_drawdown = float(metrics['Maximum Drawdown'].strip('%'))
+            sharpe_ratio = float(metrics['Sharpe Ratio'])
+            final_value = float(metrics['Final Portfolio Value'].replace('₹', '').replace(',', ''))
+            total_return = float(metrics['Total Return'].strip('%'))
+            
+            row_data = [
+                current_date,  # Date
+                stock_symbol,  # Stock
+                strategy_name,  # Strategy
+                total_trades,  # Total_Trades
+                winning_trades,  # Winning_Trades
+                losing_trades,  # Losing_Trades
+                round(win_rate, 2),  # Win_Rate
+                round(total_pl, 2),  # Total_PL
+                round(best_trade, 2),  # Best_Trade
+                round(worst_trade, 2),  # Worst_Trade
+                round(avg_win, 2),  # Avg_Win
+                round(avg_loss, 2),  # Avg_Loss
+                round(profit_factor, 2),  # Profit_Factor
+                round(max_drawdown, 2),  # Max_Drawdown
+                round(sharpe_ratio, 2),  # Sharpe_Ratio
+                round(final_value, 2),  # Final_Portfolio_Value
+                round(total_return, 2)  # Total_Return
+            ]
+            
+            worksheet.append_row(row_data)
+            print("Logged summary P&L to Summary_PL")
+            
+        except Exception as e:
+            print(f"Error logging summary P&L: {e}")
+    
+    def log_performance_metrics(self, metrics, strategy_name, stock_symbol, initial_capital, 
+                              transaction_cost, notes=""):
+        """Log performance metrics to Performance_Metrics worksheet"""
+        try:
+            worksheet = self.spreadsheet.worksheet("Performance_Metrics")
+            
+            current_date = datetime.now().strftime("%Y-%m-%d")
+            
+            # Extract and clean numeric values
+            final_value = float(metrics['Final Portfolio Value'].replace('₹', '').replace(',', ''))
+            total_return = float(metrics['Total Return'].strip('%'))
+            buy_hold_return = float(metrics['Buy & Hold Return'].strip('%'))
+            alpha = total_return - buy_hold_return
+            volatility = float(metrics['Volatility (Annual)'].strip('%'))
+            sharpe_ratio = float(metrics['Sharpe Ratio'])
+            max_drawdown = float(metrics['Maximum Drawdown'].strip('%'))
+            total_trades = metrics['Total Trades']
+            win_rate = float(metrics['Win Rate'].strip('%'))
+            
+            # Calculate average trade duration (you might need to pass this from trades_df)
+            avg_trade_duration = 0  # You can calculate this from trades_df if needed
+            
+            row_data = [
+                current_date,  # Date
+                stock_symbol,  # Stock
+                strategy_name,  # Strategy
+                initial_capital,  # Initial_Capital
+                round(final_value, 2),  # Final_Value
+                round(total_return, 2),  # Total_Return
+                round(buy_hold_return, 2),  # Buy_Hold_Return
+                round(alpha, 2),  # Alpha
+                round(volatility, 2),  # Volatility
+                round(sharpe_ratio, 2),  # Sharpe_Ratio
+                round(max_drawdown, 2),  # Max_Drawdown
+                total_trades,  # Total_Trades
+                round(win_rate, 2),  # Win_Rate
+                avg_trade_duration,  # Avg_Trade_Duration
+                transaction_cost * 100,  # Transaction_Cost (as percentage)
+                notes  # Notes
+            ]
+            
+            worksheet.append_row(row_data)
+            print("Logged performance metrics to Performance_Metrics")
+            
+        except Exception as e:
+            print(f"Error logging performance metrics: {e}")
+    
+    def get_sheet_url(self):
+        """Get the URL of the Google Sheet"""
+        if self.spreadsheet:
+            return self.spreadsheet.url
+        return None
+    
+    def clear_worksheet(self, worksheet_name):
+        """Clear all data from a worksheet (except headers)"""
+        try:
+            worksheet = self.spreadsheet.worksheet(worksheet_name)
+            worksheet.clear()
+            # Re-add headers based on the worksheet
+            if worksheet_name == "Trade_Log":
+                headers = ["Timestamp", "Stock", "Strategy", "Signal_Type", "Price", "RSI", 
+                          "MA_Short", "MA_Long", "Entry_Date", "Exit_Date", "Entry_Price", 
+                          "Exit_Price", "Shares", "Profit_Loss", "Return_Pct", "Exit_Reason", "Duration_Days"]
+            elif worksheet_name == "Summary_PL":
+                headers = ["Date", "Stock", "Strategy", "Total_Trades", "Winning_Trades", 
+                          "Losing_Trades", "Win_Rate", "Total_PL", "Best_Trade", "Worst_Trade", 
+                          "Avg_Win", "Avg_Loss", "Profit_Factor", "Max_Drawdown", "Sharpe_Ratio", 
+                          "Final_Portfolio_Value", "Total_Return"]
+            elif worksheet_name == "Performance_Metrics":
+                headers = ["Date", "Stock", "Strategy", "Initial_Capital", "Final_Value", 
+                          "Total_Return", "Buy_Hold_Return", "Alpha", "Volatility", 
+                          "Sharpe_Ratio", "Max_Drawdown", "Total_Trades", "Win_Rate", 
+                          "Avg_Trade_Duration", "Transaction_Cost", "Notes"]
+            
+            worksheet.append_row(headers)
+            print(f"Cleared and reset worksheet: {worksheet_name}")
+            
+        except Exception as e:
+            print(f"Error clearing worksheet {worksheet_name}: {e}")
+
+
+# Integration function for your Streamlit app
+def log_to_google_sheets(df, results, metrics, strategy_name, stock_symbol, 
+                        initial_cash, transaction_cost, credentials_dict=None, 
+                        credentials_json_path=None):
+    """
+    Main function to log all data to Google Sheets
+    
+    Parameters:
+        df: DataFrame with signals and indicators
+        results: Backtest results DataFrame
+        metrics: Performance metrics dictionary
+        strategy_name: Name of the strategy (SMA/EMA)
+        stock_symbol: Stock symbol
+        initial_cash: Initial capital
+        transaction_cost: Transaction cost percentage
+        credentials_dict: Google service account credentials (for Streamlit)
+        credentials_json_path: Path to JSON credentials file (for local)
+    """
+    try:
+        # Initialize Google Sheets connection
+        sheets_logger = TradingGoogleSheets(
+            credentials_dict=credentials_dict,
+            credentials_json_path=credentials_json_path,
+            sheet_name=f"Trading_Log_{stock_symbol}"
+        )
+        
+        # Create or get spreadsheet
+        spreadsheet = sheets_logger.create_or_get_spreadsheet()
+        
+        # Log trade signals
+        sheets_logger.log_trade_signals(df, strategy_name, stock_symbol)
+        
+        # Log completed trades if available
+        if not metrics['Trades DataFrame'].empty:
+            sheets_logger.log_completed_trades(metrics['Trades DataFrame'], strategy_name, stock_symbol)
+        
+        # Log summary P&L
+        trades_df = metrics['Trades DataFrame'] if not metrics['Trades DataFrame'].empty else pd.DataFrame()
+        sheets_logger.log_summary_pl(metrics, strategy_name, stock_symbol, trades_df)
+        
+        # Log performance metrics
+        sheets_logger.log_performance_metrics(
+            metrics, strategy_name, stock_symbol, initial_cash, transaction_cost
+        )
+        
+        return sheets_logger.get_sheet_url()
+        
+    except Exception as e:
+        print(f"Error in log_to_google_sheets: {e}")
+        return None
+
+
+# # Streamlit integration function
+# def add_google_sheets_to_streamlit(df, results, metrics, strategy_name, stock_symbol, 
+#                                  initial_cash, transaction_cost):
+#     """Add Google Sheets logging functionality to your Streamlit app"""
+    
+#     st.subheader("📊 Google Sheets Integration")
+    
+#     # Check if credentials are configured
+#     if 'google_sheets_credentials' in st.secrets:
+#         col1, col2 = st.columns([2, 1])
+        
+#         with col1:
+#             if st.button("📤 Log to Google Sheets", type="primary"):
+#                 with st.spinner("Logging data to Google Sheets..."):
+#                     sheet_url = log_to_google_sheets(
+#                         df=df,
+#                         results=results, 
+#                         metrics=metrics,
+#                         strategy_name=strategy_name,
+#                         stock_symbol=stock_symbol,
+#                         initial_cash=initial_cash,
+#                         transaction_cost=transaction_cost,
+#                         credentials_dict=dict(st.secrets.google_sheets_credentials)
+#                     )
+                    
+#                     if sheet_url:
+#                         st.success("✅ Data logged successfully!")
+#                         st.markdown(f"🔗 [View Google Sheet]({sheet_url})")
+#                     else:
+#                         st.error("❌ Failed to log data to Google Sheets")
+        
+#         with col2:
+#             st.info("💡 **Auto-logging enabled**\n\nData will be saved to:\n- Trade signals\n- P&L summary\n- Performance metrics")
+    
+#     else:
+#         st.warning("⚠️ Google Sheets credentials not configured. Add your service account credentials to Streamlit secrets to enable logging.")
+        
+#         with st.expander("📋 Setup Instructions"):
+#             st.markdown("""
+#             **To enable Google Sheets integration:**
+            
+#             1. **Create a Google Cloud Project**
+#             2. **Enable Google Sheets & Drive APIs**
+#             3. **Create a Service Account**
+#             4. **Download the JSON credentials**
+#             5. **Add credentials to Streamlit secrets**
+            
+#             **In your `.streamlit/secrets.toml` file:**
+#             ```toml
+#             [google_sheets_credentials]
+#             type = "service_account"
+#             project_id = "your-project-id"
+#             private_key_id = "your-private-key-id"
+#             private_key = "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
+#             client_email = "your-service-account@your-project.iam.gserviceaccount.com"
+#             client_id = "your-client-id"
+#             auth_uri = "https://accounts.google.com/o/oauth2/auth"
+#             token_uri = "https://oauth2.googleapis.com/token"
+#             auth_provider_x509_cert_url = "https://www.googleapis.com/oauth2/v1/certs"
+#             client_x509_cert_url = "https://www.googleapis.com/robot/v1/metadata/x509/your-service-account%40your-project.iam.gserviceaccount.com"
+#             universe_domain = "googleapis.com"
+#             ```
+#             """)

src/utils/logger.py

@@ -0,0 +1,24 @@
+# utils/logger.py
+
+import logging
+import os
+from datetime import datetime
+
+def setup_logger(log_dir="logs", log_level=logging.INFO):
+    """
+    Sets up a logger that writes to both console and a timestamped log file.
+    """
+    os.makedirs(log_dir, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    log_file = os.path.join(log_dir, f"log_{timestamp}.log")
+
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s [%(levelname)s] - %(message)s",
+        handlers=[
+            logging.FileHandler(log_file),
+            logging.StreamHandler()
+        ]
+    )
+    logging.info("Logger initialized.")
+