src/streamlit_app.py

import os
import sys
import streamlit as st
import pandas as pd
import numpy as np
from io import BytesIO
import uuid

from huggingface_hub import snapshot_download

# Download files from the private space
private_repo = "kishan-1721/my_private_app"  # Replace with your private space's repo ID
cache_dir = "/data/private_space_cache"  # Updated to use writable /data directory
snapshot_download(
    repo_id=private_repo,
    repo_type="space",
    local_dir=cache_dir,
    token=os.getenv("HF_TOKEN")  # Assumes HF_TOKEN is set as a secret
)

# Add the downloaded files to the Python path
sys.path.append(cache_dir)

# --- Streamlit Page Configuration ---
st.set_page_config(page_title="Deep Stock Analyzer", layout="wide")

# Function to calculate streaks for a given DataFrame
def calculate_streaks(df):
    df['is_profit'] = df['Profit'] > 0
    df['streak_group'] = (df['is_profit'] != df['is_profit'].shift()).cumsum()
    streaks = df.groupby(['streak_group', 'is_profit']).apply(lambda x: pd.Series({
        'start_index': x.index[0],
        'end_index': x.index[-1],
        'start_date': x['Entry Date'].iloc[0],
        'end_date': x['Exit Date'].iloc[-1],
        'num_trades': len(x),
        'total_profit': x['Profit'].sum(),
        'total_percent_profit': x['% Profit'].sum()  # Added to calculate sum of % Profit
    }))
    return streaks

# --- Main Application ---
def main():
    st.title("Deep Stock Analyzer")

    # Settings
    with st.container():
        col1, col2, col3, col4, col5, col6 = st.columns(6)
        with col1:
            global sideways_threshold
            sideways_threshold = st.slider("Sideways Threshold", min_value=0.0, max_value=2.0, value=0.00, step=0.01, format="%.2f") / 100
        with col2:
            global buffer
            buffer = st.slider("Buffer", min_value=0.0, max_value=2.0, value=0.0, step=0.01, format="%.2f") / 100
        with col3:
            global intra_sl_value
            intra_sl_value = st.slider("Intra SL Value", min_value=0.0, max_value=10.0, value=1.5, step=0.1, format="%.1f") / 100
        with col4:

            global interest_rate
            interest_rate = st.number_input(label="Funding Cost Per Day",step=0.01,value=0.04 ,format="%.4f")

            # genre = st.radio(
            #     "Want to find out Best Configuration ?",
            #     ["YES", "NO"],
            #     # index=1  # Set "NO" as the default, uncomment if needed
            # )
        with col5:
            Trailing_Value = st.radio(
                "Set your Trailing Value ?",
                ["Close", "High - Low"],
                index=0
            )
        with col6:
            selected_script = st.radio(
                "Select Your Script",
                ["Old", "New Maxloss 5%"],
                index=0
            )

    with st.container():
        col1, col2, col3, col4, col5 = st.columns([1,1,1,1,2])

        with col1:
            global brokerages
            brokerages = st.number_input(label="Brokerages",step=0.01,value=0.2644 ,format="%.4f")

        with col2:
            global MTF_Exposure
            MTF_Exposure = st.slider("MTF Exposure", min_value=2.00, max_value=8.00, value=3.00, step=0.1, format="%.2f")

        with col3:

            Exchange = st.radio(
                "Select your Exchange ?",
                ["Indian", "Crypto"],
                index=0
            )

            if intra_sl_value <= 0.0:
                st.text("IntraBar is Set to Previous Top - Bottom")
                
        with col4:
            global max_loss_sl
            max_loss_sl = st.slider("MaxLoss SL Value", min_value=0.0, max_value=10.0, value=3.0, step=0.1, format="%.1f") / 100

        with col5:
            # File uploader
            uploaded_file = st.file_uploader("Upload your CSV file", type=["csv"])

    if selected_script == "Old":
        from main4 import get_buy_signal, parse_date, get_sell_signal, year_wise_analysis, calculate_yearly_returns, calculate_mtf_returns, crypto_year_wise_analysis, crypto_calculate_mtf_returns, crypto_calculate_yearly_returns, find_sequences, generate_trade_signals
    else:
        from main6 import get_buy_signal, parse_date, get_sell_signal, year_wise_analysis, calculate_yearly_returns, calculate_mtf_returns, crypto_year_wise_analysis, crypto_calculate_mtf_returns, crypto_calculate_yearly_returns, find_sequences, generate_trade_signals

    if uploaded_file is not None:
        df = pd.read_csv(uploaded_file)
        try:
            df = df[['Date','Open','High', 'Low', 'Close']]
        except:
            df = df[['Date','Open','High', 'Low', 'Price']]

        if st.button("Start Analysis"):
            # Data preprocessing
            df.columns = df.columns.str.strip()
            df['Date'] = parse_date(df['Date'])
            df.sort_values('Date', inplace=True)

            if 'Price' in df.columns:
                df = df.rename(columns={'Price': 'Close'})
            df['%Change'] = df['Close'].pct_change().fillna(0) * 100
            df["Direction"] = df["%Change"].apply(lambda x: "📈" if x > 0 else "📉")
            df['Side Ways'] = df['%Change'].apply(lambda x: abs(x / 100) < sideways_threshold)

            # Define ranges for trailOffset and target_SL to test
            trailOffset_values = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06]
            
            if Exchange == 'Crypto':
                target_SL_values = [0.0 , 0.02, 0.04, 0.06, 0.08, 0.09, 0.10, 0.11, 0.12, 0.13, 0.14, 0.15]
                # target_SL_values = [0.0 , 0.02, 0.04, 0.06, 0.08]
                
            else:
                target_SL_values = [0.0 , 0.02, 0.04, 0.06, 0.08]
                
            initial_investment_main = 100000

            mtf_investment = initial_investment_main / MTF_Exposure

            # Function to calculate Compound Annual Growth Rate (CAGR)
            def calculate_cagr(total_profit, initial_investment, num_years):
                """Calculate CAGR given total profit, initial investment, and number of years."""
                if num_years == 0:
                    return 0
                return round(((((total_profit + initial_investment) / initial_investment) ** (1 / num_years)) - 1) * 100, 2)

            # Initialize lists to store analysis results for all trades and BUY trades
            all_year_analysis = []
            all_year_analysis_BUY = []

            # Iterate over all combinations of trailOffset and target_SL
            for trailOffset in trailOffset_values:
                for target_SL in target_SL_values:
                    # Generate trade signals with current parameters
                    
                    if selected_script == "Old":
                        result = generate_trade_signals(df, trailOffset, target_SL, Trailing_Value, buffer, intra_sl_value)
                    else:
                        result = generate_trade_signals(df, trailOffset, target_SL, Trailing_Value, buffer, intra_sl_value, max_loss_sl)
                        
                    final_df = result[1]  # Extract trades DataFrame from result

                    # Calculate percentage profit for each trade
                    final_df['% Profit'] = final_df['Profit'] / final_df['Entry Price'] * 100

                    # Assign 'Year' column based on date fields
                    df = df.assign(Year=df['Date'].dt.year)
                    final_df = final_df.assign(Year=final_df['Entry Date'].dt.year)

                    total_years = final_df['Year'].unique()

                    # Filter trades to get only BUY trades
                    buy_trades_df = final_df[final_df['Trade Type'] == 'BUY']

                    # Calculate Multi-Time Frame (MTF) returns with compounding
                    if Exchange == 'Indian':

                        system_mtf_with_compound, system_mtf_yearly_with_compound = calculate_mtf_returns(
                            df, final_df, MTF_Exposure, True, brokerages
                        )
                        buy_trades_mtf_returns_compound, buy_trades_mtf_yearly_compound = calculate_mtf_returns(
                            df, buy_trades_df, MTF_Exposure, True, brokerages
                        )

                    else:
                        system_mtf_with_compound, system_mtf_yearly_with_compound = crypto_calculate_mtf_returns(
                            df, final_df, MTF_Exposure, True, brokerages, interest_rate
                        )

                        buy_trades_mtf_returns_compound, buy_trades_mtf_yearly_compound = crypto_calculate_mtf_returns(
                            df, buy_trades_df, MTF_Exposure, True, brokerages, interest_rate
                        )

                    ################################## Risk Reward Ratio ##################################
                    def risk_reward(df):
                        p_trades = len(df[df['Profit'] > 0])
                        N_trades = len(df[df['Profit'] <= 0])

                        p_profit_ = df[df['Profit'] > 0]['Profit'].sum()
                        N_profit_ = df[df['Profit'] <= 0]['Profit'].sum()

                        ratio_risk_reward = round(abs((p_profit_ / p_trades) / ( N_profit_ / N_trades)), 3)
                        
                        return ratio_risk_reward

                    # Add parameter values to yearly results
                    system_mtf_yearly_with_compound['trailOffset'] = trailOffset * 100
                    system_mtf_yearly_with_compound['target_SL'] = target_SL * 100
                    system_mtf_yearly_with_compound['Winning Ratio'] = round((len(system_mtf_with_compound[system_mtf_with_compound['Profit'] > 0]) / len(system_mtf_with_compound)) * 100, 2)
                    system_mtf_yearly_with_compound['Risk/Reward Ratio'] = risk_reward(system_mtf_with_compound)
                    
                    buy_trades_mtf_yearly_compound['trailOffset'] = trailOffset * 100
                    buy_trades_mtf_yearly_compound['target_SL'] = target_SL * 100
                    buy_trades_mtf_yearly_compound['Winning Ratio'] = round((len(buy_trades_mtf_returns_compound[buy_trades_mtf_returns_compound['Profit'] > 0]) / len(buy_trades_mtf_returns_compound)) * 100, 2)
                    buy_trades_mtf_yearly_compound['Risk/Reward Ratio'] =  risk_reward(buy_trades_mtf_returns_compound)

                    # Calculate CAGR for overall system
                    total_profit_system = system_mtf_yearly_with_compound['Final Profit After All'].sum()
                    num_years_system = len(system_mtf_yearly_with_compound)
                    system_cagr = calculate_cagr(total_profit_system, mtf_investment, num_years_system)
                    system_mtf_yearly_with_compound['CAGR'] = system_cagr
                    system_mtf_yearly_with_compound['Last 10'] = system_mtf_yearly_with_compound.tail(10)['System Gain'].mean()
                    system_mtf_yearly_with_compound['Last 5'] = system_mtf_yearly_with_compound.tail(5)['System Gain'].mean()
                    system_mtf_yearly_with_compound['Last 3'] = system_mtf_yearly_with_compound.tail(3)['System Gain'].mean()
                    system_mtf_yearly_with_compound['Last 2'] = system_mtf_yearly_with_compound.tail(2)['System Gain'].mean()
                    system_mtf_yearly_with_compound['Last 1'] = system_mtf_yearly_with_compound.tail(1)['System Gain'].mean()

                    # Calculate CAGR for BUY trades
                    total_profit_buy = buy_trades_mtf_yearly_compound['Final Profit After All'].sum()
                    num_years_buy = len(buy_trades_mtf_yearly_compound)
                    buy_cagr = calculate_cagr(total_profit_buy, mtf_investment, num_years_buy)
                    buy_trades_mtf_yearly_compound['CAGR'] = buy_cagr
                    buy_trades_mtf_yearly_compound['Last 10'] = buy_trades_mtf_yearly_compound.tail(10)['System Gain'].mean()
                    buy_trades_mtf_yearly_compound['Last 5'] = buy_trades_mtf_yearly_compound.tail(5)['System Gain'].mean()
                    buy_trades_mtf_yearly_compound['Last 3'] = buy_trades_mtf_yearly_compound.tail(3)['System Gain'].mean()
                    buy_trades_mtf_yearly_compound['Last 2'] = buy_trades_mtf_yearly_compound.tail(2)['System Gain'].mean()
                    buy_trades_mtf_yearly_compound['Last 1'] = buy_trades_mtf_yearly_compound.tail(1)['System Gain'].mean()

                    # Store results
                    all_year_analysis.append(system_mtf_yearly_with_compound)
                    all_year_analysis_BUY.append(buy_trades_mtf_yearly_compound)

            # Combine all yearly results into single DataFrames
            final_year_analysis = pd.concat(all_year_analysis, ignore_index=True)
            final_year_analysis_BUY = pd.concat(all_year_analysis_BUY, ignore_index=True)

            # Define columns to keep in the final output
            selected_columns = [
                'trailOffset', 'target_SL', 'Year', 'Start_Price', 'End_Price', 'System Gain','Last 10','Last 5','Last 3',
                'Last 2','Last 1','CAGR', 'Index Gain', 'Difference', 'Final Profit After All', 'Winning Ratio','Risk/Reward Ratio',
                'Total_Trades', 'Total BUY Trades', 'Total SELL Trades'
            ]

            # Filter DataFrames to selected columns
            final_year_analysis = final_year_analysis[selected_columns]
            final_year_analysis_BUY = final_year_analysis_BUY[selected_columns]

            # Aggregate results by trailOffset and target_SL
            result = final_year_analysis.groupby(['trailOffset', 'target_SL']).agg({
                'Final Profit After All': 'sum',  # Total profit across years
                'CAGR': 'mean',                   # CAGR (same for each year in a combination)
                'System Gain': 'mean',            # Average yearly system gain
                'Last 10' : 'mean',
                'Last 5' : 'mean',
                'Last 3' : 'mean',
                'Last 2' : 'mean',
                'Last 1' : 'mean',
                'Winning Ratio' : 'mean',   # Winning Ratio
                'Risk/Reward Ratio' : 'mean',
                'Total_Trades': 'mean',           # Average trades per year
                'Total BUY Trades': 'mean',       # Average BUY trades per year
                'Total SELL Trades': 'mean'       # Average SELL trades per year
            }).reset_index()

            result_BUY = final_year_analysis_BUY.groupby(['trailOffset', 'target_SL']).agg({
                'Final Profit After All': 'sum',
                'CAGR': 'mean',
                'System Gain': 'mean',
                'Last 10' : 'mean',
                'Last 5' : 'mean',
                'Last 3' : 'mean',
                'Last 2' : 'mean',
                'Last 1' : 'mean',
                'Winning Ratio' : 'mean',   # Winning Ratio
                'Risk/Reward Ratio' : 'mean',
                'Total_Trades': 'mean',
                'Total BUY Trades': 'mean',
                'Total SELL Trades': 'mean'
            }).reset_index()

            # Convert trade count columns to integers after rounding
            trade_count_columns = ['Total_Trades', 'Total BUY Trades', 'Total SELL Trades']
            result[trade_count_columns] = result[trade_count_columns].round().astype(int)
            result = result.sort_values("CAGR", ascending = False).reset_index(drop = True)

            result_BUY[trade_count_columns] = result_BUY[trade_count_columns].round().astype(int)
            result_BUY = result_BUY.sort_values("CAGR", ascending = False).reset_index(drop = True)

            rename_columns = {'trailOffset' : 'Trailing SL', 'target_SL' : 'Target', 'Total_Trades':'Avg_Trades', 'Total BUY Trades': 'Avg BUY Trades', 'Total SELL Trades': 'Avg SELL Trades'}
            result.rename(columns=rename_columns, inplace= True)
            result_BUY.rename(columns=rename_columns, inplace= True)

            # Display results in Streamlit
            st.write(f"Total Years : {len(total_years)}")
            st.write(f"High - Low Average: {round(final_df['change %'].mean(), 2)}")
            st.write(f"Initial Investment : {mtf_investment}")
            
            st.subheader("📈 System Best Combination Performance", divider=True)
            st.dataframe(result)

            st.subheader("📈 Buy System Best Combination Performance", divider=True)
            st.dataframe(result_BUY)

if __name__ == "__main__":
    main()