Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,557 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+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="Stock Market Analyzer", layout="wide")
+
+# --- Main Application ---
+def main():
+    st.title("Stock Market Analyzer")
+
+    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.0, 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 target_sl
+            target_sl = st.slider("Target SL Value", min_value=0.0, max_value=15.0, value=0.0, step=0.1, format="%.1f") / 100
+        with col5:
+            global trail_offset
+            trail_offset = st.slider("Trailing SL %", min_value=0.0, max_value=10.0, value=3.0, step=0.1, format="%.1f") / 100
+        with col6:
+            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 st.container():
+        col1, col2, col4, col3  = st.columns([1,1,1,2])
+
+        with col1:
+            Trailing_Value = st.radio(
+                "Set your Trailing Value ?",
+                ["Close", "High - Low"],
+                index=1
+            )
+
+            Exchange = st.radio(
+                "Select your Exchange ?",
+                ["Indian", "Crypto"],
+                index=0
+            )
+
+        with col2:
+            global brokerages
+            brokerages = st.number_input(label="Brokerages",step=0.01,value=0.2644 ,format="%.4f")
+
+            global interest_rate
+            interest_rate = st.number_input(label="Funding Cost Per Day",step=0.01,value=0.04 ,format="%.4f")
+
+            if intra_sl_value <= 0.0:
+                st.text("IntraBar is Set to Previous Top - Bottom")
+            if target_sl <= 0.0:
+                st.text("No Target is Set")
+            if trail_offset <= 0.0:
+                st.text("No Trailing Stop-loss")
+
+        with col4:
+            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")
+
+            selected_script  = st.radio(
+                "Select Your Script",
+                ["Old", "New Maxloss 5%"],
+                index=0
+            )
+
+        with col3:
+            # 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
+    
+    # st.divider()
+    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)
+
+            # Generate signals and trades
+            # result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value)
+            
+            if selected_script == "Old":
+                result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value, buffer, intra_sl_value)
+            else:    
+                result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value, buffer, intra_sl_value, max_loss_sl)
+                
+            final_df = result[1]
+            final_df['Gap Loss 2%'] = final_df.apply(lambda x: True if x['Gap_UP_Down Trade'] == True and x['Profit %'] < -2 else False, axis=1)
+            final_df['Gap Exit'] = np.where(final_df['Gap_UP_Down Trade'].shift(-1).eq(True), True, False)
+            final_df['Gap Exit Loss % 2'] = np.where(final_df['Gap_UP_Down Trade'].shift(-1).eq(True) & (final_df['Profit %'] < -2), True, False)
+
+            col1, col2 = st.columns(2)
+
+            # with col1:
+            #     st.subheader("📶 Processed Signal Data", divider=True)
+            #     st.dataframe(final_df)
+
+            df = df.assign(Year=df['Date'].dt.year)
+            final_df = final_df.assign(Year=final_df['Entry Date'].dt.year)
+
+            if Exchange == 'Indian':
+
+    ################################################### Performing Analysis ###################################################
+
+                system_returns_no_compound, system_yearly_no_compound = calculate_yearly_returns(df,final_df, False, brokerages)
+
+                system_returns_with_compound, system_yearly_with_compound = calculate_yearly_returns(df,final_df, True, brokerages)
+
+                system_mtf_no_compound, system_mtf_yearly_no_compound = calculate_mtf_returns(df,final_df, MTF_Exposure, False, brokerages)
+                            
+                system_mtf_with_compound, system_mtf_yearly_with_compound = calculate_mtf_returns(df,final_df, MTF_Exposure, True, brokerages)
+                
+    ################################################### BUY Trade Performing Analysis ###################################################
+
+                buy_trades_df = final_df[final_df['Trade Type'] == 'BUY']
+
+                buy_trades_no_compound, buy_trades_yearly_no_compound = calculate_yearly_returns(df,buy_trades_df, False, brokerages)
+
+                buy_trades_compound, buy_trades_yearly_compound = calculate_yearly_returns(df,buy_trades_df, True, brokerages)
+
+                buy_trades_mtf_no_compound, buy_trades_mtf_yearly_no_compound = calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, False, brokerages)
+
+                buy_trades_mtf_returns_compound, buy_trades_mtf_yearly_compound = calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, True, brokerages)
+
+            else:
+    ################################################### Crypto Performing Analysis ###################################################
+
+    ################################################### Performing Analysis ###################################################
+
+                system_returns_no_compound, system_yearly_no_compound = crypto_calculate_yearly_returns(df,final_df, False, brokerages)
+
+                system_returns_with_compound, system_yearly_with_compound = crypto_calculate_yearly_returns(df,final_df, True, brokerages)
+
+                system_mtf_no_compound, system_mtf_yearly_no_compound = crypto_calculate_mtf_returns(df,final_df, MTF_Exposure, False, brokerages, interest_rate)
+                            
+                system_mtf_with_compound, system_mtf_yearly_with_compound = crypto_calculate_mtf_returns(df,final_df, MTF_Exposure, True, brokerages, interest_rate)
+                
+    ################################################### BUY Trade Performing Analysis ###################################################
+
+                buy_trades_df = final_df[final_df['Trade Type'] == 'BUY']
+
+                buy_trades_no_compound, buy_trades_yearly_no_compound = crypto_calculate_yearly_returns(df,buy_trades_df, False, brokerages)
+
+                buy_trades_compound, buy_trades_yearly_compound = crypto_calculate_yearly_returns(df,buy_trades_df, True, brokerages)
+
+                buy_trades_mtf_no_compound, buy_trades_mtf_yearly_no_compound = crypto_calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, False, 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)
+
+            # system_yearly_analysis = year_wise_analysis(df, system_returns_no_compound)
+            # System_Gain_Com = year_wise_analysis(df, system_returns_with_compound)
+            # year_analysis_ = year_wise_analysis(df, system_mtf_with_compound)
+
+            System_Gain_Com = system_mtf_yearly_no_compound
+            # year_analysis_ = system_mtf_yearly_with_compound
+
+            initial_investment_amount = 100000
+
+            with col1:
+                st.subheader("📆 Year-Wise Performance", divider=True)
+                st.dataframe(system_yearly_no_compound)
+
+            with col2:
+                st.subheader("📶 Compounding Year-Wise Performance", divider=True)
+                st.dataframe(System_Gain_Com)
+
+
+            pcol1, pcol2, pcol3 = st.columns(3)
+            
+            with pcol1:
+                st.subheader("📊 Performance Overview", divider=True)
+                
+                container = st.container(border=True)
+                container.text(f"Average Trades : {round(system_yearly_no_compound['Total_Trades'].mean(), 0)}")
+                container.text(f"Average BUY Trades : {round(system_yearly_no_compound['Total BUY Trades'].mean(), 0)}")
+                container.text(f"Average SELL Trades : {round(system_yearly_no_compound['Total SELL Trades'].mean(), 0)}")
+
+                container = st.container(border=True)
+                container.text(f"Start Price {system_yearly_no_compound['Start_Price'].iloc[0]}, End Price : {system_yearly_no_compound['End_Price'].iloc[-1]}")
+                container.text(f"Average Index Gain %: {round(system_yearly_no_compound['Index Gain'].sum() / len(system_yearly_no_compound), 2)}")
+                container.text(f"Index CAGR = {round(((system_yearly_no_compound['End_Price'].iloc[-1] / system_yearly_no_compound['Start_Price'].iloc[0]) ** (1 / len(system_yearly_no_compound)) - 1) * 100, 2) } ")
+
+                # container.text(f"Average System Gain %: {round(system_yearly_no_compound['System Gain'].sum() / len(system_yearly_no_compound), 2)}")
+                # container.text(f"Difference: {round(system_yearly_no_compound['Difference'].sum() / len(system_yearly_no_compound) , 2) }")
+
+            with pcol2:
+                st.subheader("📊 Trade Overview", divider=True)
+
+                container = st.container(border=True)               
+                container.text(f"Total Years : {len(system_yearly_no_compound)}")
+                container.text(f"Total Trades: {len(final_df)}")
+                container.text(f"Profitable Trades {round(len(final_df[final_df['Profit'] > 0]))}")
+                container.text(f"Total Target Hit: {len(final_df[final_df['Exit Condition'] == 'Target Hit'])}")
+                container.text(f"Total Trailing Hit: {len(final_df[final_df['Exit Condition'] == 'Trailing Hit'])}")
+                container.text(f"Total IntraBar Hit: {len(final_df[final_df['Exit Condition'] == 'IntraBar Hit'])}")
+                container.text(f"High - Low Average: {round(final_df['change %'].mean(), 2)}")
+                # container.text(f"High - Low Average Number new: {round(np.percentile(final_df['change %'], 60), 2)}")
+                container.text(f"% Winning Ratio {round((len(final_df[final_df['Profit'] > 0]) / len(final_df)) * 100, 2)} %")
+
+            with pcol3:
+                st.subheader("📊 Gap Up & Down Overview", divider=True)
+
+                container = st.container(border=True)               
+                container.text(f"Total Gap_UP_Down Trades: {final_df['Gap_UP_Down Trade'].sum()}")
+                container.text(f"Total Gap_UP_Down Exit Trades: {final_df['Gap Exit'].sum()}")
+                container.text(f"Loss More than 2 % in Gap_UP_Down Trades: {final_df['Gap Loss 2%'].sum()}")
+                container.text(f"Loss More than 2 % in Gap_UP_Down Exit Trades: {final_df['Gap Exit Loss % 2'].sum()}")
+
+
+                ################################## Risk Reward Ratio ##################################
+                container = st.container(border=True)               
+                
+                p_trades = len(final_df[final_df['Profit'] > 0])
+                N_trades = len(final_df[final_df['Profit'] < 0])
+
+                p_profit_ = final_df[final_df['Profit'] > 0]['Profit'].sum()
+                N_profit_ = final_df[final_df['Profit'] < 0]['Profit'].sum()
+
+                p_profit_avg = final_df[final_df['Profit'] > 0]['Profit %'].mean()
+                N_profit_avg = final_df[final_df['Profit'] < 0]['Profit %'].mean()
+                
+                # container.text(f" (p_profit = {p_profit_} / p_trades = {p_trades}) / (N_profit_ = {N_profit_} / N_trades = {N_trades})")
+
+                ratio = abs((p_profit_ / p_trades) / ( N_profit_ / N_trades))
+
+                container.text(f"% Risk Reward Ratio: {round(ratio, 3 )} %")
+                container.text(f"% Profit Avg: {round(p_profit_avg, 4 )} %")
+                container.text(f"% Loss Avg: {round(N_profit_avg, 4 )} ")
+
+                if Exchange != 'Indian':
+                    container.text(f"Max Holding Days: {System_Gain_Com['HOLDING DAYS'].max()}")
+                
+
+            st.divider()
+################################################### Performance Analysis ###################################################
+
+            pcol1, pcol2, pcol3 = st.columns(3)
+
+            with pcol1:
+                st.subheader("📈 System Performance", divider=True)
+
+                total_profit_ = round(system_yearly_no_compound['Final Profit After All'].sum(), 2)
+                total_profit_AVG = round(system_yearly_no_compound['System Gain'].sum() / len(system_yearly_no_compound), 2)
+
+                buy_profit = round(buy_trades_yearly_no_compound['Final Profit After All'].sum(), 2)
+                buy_profit_AVG = round(buy_trades_yearly_no_compound['System Gain'].sum() / len(buy_trades_yearly_no_compound), 2)
+
+                sell_profit = round(total_profit_ - buy_profit, 2)
+                sell_profit_avg = round(total_profit_AVG - buy_profit_AVG, 2)
+
+                container = st.container(border=True)
+                container.write(f"**Total Profit : {total_profit_} (AVG : {total_profit_AVG} %)**")
+                container.write(f"**Buy Profit : {buy_profit} (AVG : {buy_profit_AVG} %)**")
+                container.write(f"**SELL Profit : {sell_profit} (AVG : {sell_profit_avg} %)**")
+                container.text(f"Total Years : {len(system_yearly_no_compound)}")
+
+                # container.write(f"**Total BUY Profit : {round(system_yearly_no_compound['BUY_Profit'].sum(), 2)} ({round((system_yearly_no_compound['BUY_Profit'].sum() * 100)/system_yearly_no_compound['Profit'].sum(), 2)} %) (AVG : {round(system_yearly_no_compound['BUY_Gain'].mean(), 2)} %)**")
+                # container.write(f"**Total SELL Profit : {round(system_yearly_no_compound['SELL_Profit'].sum(), 2)} ({round((system_yearly_no_compound['SELL_Profit'].sum() * 100)/system_yearly_no_compound['Profit'].sum(), 2)} %)**")
+                
+                container.markdown("---") 
+                ten_years = system_yearly_no_compound.tail(10)
+                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")
+
+                ten_years = buy_trades_yearly_no_compound.tail(10)
+                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                
+                container.markdown("---") 
+                five_years = system_yearly_no_compound.tail(5)
+                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                five_years = buy_trades_yearly_no_compound.tail(5)
+                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+                
+                container.markdown("---") 
+                three_years = system_yearly_no_compound.tail(3)
+                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                three_years = buy_trades_yearly_no_compound.tail(3)
+                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+
+                container.markdown("---") 
+                two_years = system_yearly_no_compound.tail(2)
+                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                two_years = buy_trades_yearly_no_compound.tail(2)
+                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+
+                container.markdown("---") 
+                one_years = system_yearly_no_compound.tail(1)
+                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                one_years = buy_trades_yearly_no_compound.tail(1)
+                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+
+            with pcol2:
+                st.subheader("📈 Compounding Performance", divider=True)
+
+                compund_system_cagr = round((((((system_yearly_with_compound['Final Profit After All'].sum()) + 100000) / 100000 ) ** (1 / len(system_yearly_with_compound))) -1 ) * 100 , 2)
+                buy_compund_system_cagr = round((((((buy_trades_yearly_compound['Final Profit After All'].sum()) + 100000) / 100000) ** (1 / len(buy_trades_yearly_compound))) -1 ) * 100 , 2)
+
+                container = st.container(border=True)
+                container.write(f"**Total Profit : {round(system_yearly_with_compound['Final Profit After All'].sum(), 2)} (AVG : {round(system_yearly_with_compound['System Gain'].sum() / len(system_yearly_with_compound), 2)} %) (C:{compund_system_cagr} %)**")
+                container.write(f"**Buy Profit : {round(buy_trades_yearly_compound['Final Profit After All'].sum(), 2)} (AVG : {round(buy_trades_yearly_compound['System Gain'].sum() / len(buy_trades_yearly_compound), 2)} %) (C:{buy_compund_system_cagr} %)**")
+                container.write(f"Initial Investment : {initial_investment_amount}")
+
+                # container.write(f"**Total BUY Profit : {round(system_yearly_with_compound['BUY_Profit'].sum(), 2)} ({round((system_yearly_with_compound['BUY_Profit'].sum() * 100)/system_yearly_with_compound['Profit'].sum(), 2)} %) (AVG : {round(system_yearly_with_compound['BUY_Gain'].mean(), 2)} %)**")
+                # container.write(f"**Total SELL Profit : {round(system_yearly_with_compound['SELL_Profit'].sum(), 2)} ({round((system_yearly_with_compound['SELL_Profit'].sum() * 100)/system_yearly_with_compound['Profit'].sum(), 2)} %)**")
+                
+                container.markdown("---") 
+                ten_years = system_yearly_with_compound.tail(10)
+                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")
+
+                ten_years = buy_trades_yearly_compound.tail(10)
+                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                
+                container.markdown("---") 
+                five_years = system_yearly_with_compound.tail(5)
+                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+                
+                five_years = buy_trades_yearly_compound.tail(5)
+                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+
+                container.markdown("---") 
+                three_years = system_yearly_with_compound.tail(3)
+                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+                
+                three_years = buy_trades_yearly_compound.tail(3)
+                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+
+                container.markdown("---") 
+                two_years = system_yearly_with_compound.tail(2)
+                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+                
+                two_years = buy_trades_yearly_compound.tail(2)
+                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+
+                container.markdown("---") 
+                one_years = system_yearly_with_compound.tail(1)
+                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+                
+                one_years = buy_trades_yearly_compound.tail(1)
+                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+
+            with pcol3:
+                st.subheader("📈 MTF Compounding Gain", divider=True)
+
+                mtf_investment = initial_investment_amount / MTF_Exposure 
+
+                compund_system_cagr = round((((((system_mtf_yearly_with_compound['Final Profit After All'].sum()) + mtf_investment) / mtf_investment) ** (1 / len(system_mtf_yearly_with_compound))) -1 ) * 100 , 2)
+                buy_compund_system_cagr = round((((((buy_trades_mtf_yearly_compound['Final Profit After All'].sum()) + mtf_investment) / mtf_investment) ** (1 / len(buy_trades_mtf_yearly_compound))) -1 ) * 100 , 2)
+
+                container = st.container(border=True)
+                container.write(f"**Total Profit : {round(system_mtf_yearly_with_compound['Final Profit After All'].sum(), 2)} (AVG : {round(system_mtf_yearly_with_compound['System Gain'].sum() / len(system_mtf_yearly_with_compound), 2)} %) (C:{compund_system_cagr} %)**")
+                container.write(f"**Buy Profit : {round(buy_trades_mtf_yearly_compound['Final Profit After All'].sum(), 2)} (AVG : {round(buy_trades_mtf_yearly_compound['System Gain'].sum() / len(buy_trades_mtf_yearly_compound), 2)} %) (C:{buy_compund_system_cagr} %)**")
+                container.write(f"Initial Investment : {mtf_investment}")
+
+                # container.write(f"**Total BUY Profit : {round(system_mtf_yearly_with_compound['BUY_Profit'].sum(), 2)} ({round((system_mtf_yearly_with_compound['BUY_Profit'].sum() * 100)/system_mtf_yearly_with_compound['Profit'].sum(), 2)} %) (AVG : {round(system_mtf_yearly_with_compound['BUY_Gain'].mean(), 2)} %)**")
+                # container.write(f"**Total SELL Profit : {round(system_mtf_yearly_with_compound['SELL_Profit'].sum(), 2)} ({round((system_mtf_yearly_with_compound['SELL_Profit'].sum() * 100)/system_mtf_yearly_with_compound['Profit'].sum(), 2)} %)**")
+                
+                container.markdown("---") 
+                ten_years = system_mtf_yearly_with_compound.tail(10)
+                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")
+
+                ten_years = buy_trades_mtf_yearly_compound.tail(10)
+                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
+                
+                container.markdown("---") 
+                five_years = system_mtf_yearly_with_compound.tail(5)
+                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                five_years = buy_trades_mtf_yearly_compound.tail(5)
+                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
+
+                container.markdown("---") 
+                three_years = system_mtf_yearly_with_compound.tail(3)
+                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                three_years = buy_trades_mtf_yearly_compound.tail(3)
+                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
+
+                container.markdown("---") 
+                two_years = system_mtf_yearly_with_compound.tail(2)
+                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                two_years = buy_trades_mtf_yearly_compound.tail(2)
+                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
+           
+                container.markdown("---") 
+                one_years = system_mtf_yearly_with_compound.tail(1)
+                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
+
+                one_years = buy_trades_mtf_yearly_compound.tail(1)
+                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
+           
+            temp = final_df[['Entry Date', 'Trade Type', 'Gap_UP_Down Trade', 'GAP_P', 'Entry Price', 'Exit Date', 'Exit Condition', 'Exit Price', 'Profit', 'Profit %', 'Gap Loss 2%','Year']]
+            temp.rename(columns={'Trade Type' : 'Trade', 'Gap_UP_Down Trade' : 'GAP', 'Entry Price' : 'Entry', 'Exit Price' : 'Exit', 'Gap Loss 2%' : 'Gap Loss %'}, inplace = True)
+            
+            # Filter out rows where '% Profit' is NaN and sort by 'Entry Date'
+            def max_Profit_loss(final_df):
+                filtered_df = final_df[final_df['Profit %'].notna()].sort_values('Entry Date')
+
+                # Define conditions for profit and loss sequences
+                profit_condition = lambda row: row['Profit %'] >= 0
+                loss_condition = lambda row: row['Profit %'] <= 0
+
+                # Find profit and loss sequences
+                profit_sequences = find_sequences(filtered_df, profit_condition)
+                loss_sequences = find_sequences(filtered_df, loss_condition)
+
+                # Convert sequences to DataFrames
+                profit_df = pd.DataFrame(profit_sequences)
+                loss_df = pd.DataFrame(loss_sequences)
+
+                # Get top 20 sequences
+                # Top 20 profit sequences (highest total % profit)
+                top_profit_df = profit_df.sort_values('Total %', ascending=False).head(20)
+                # Top 20 loss sequences (most negative total % loss)
+                top_loss_df = loss_df.sort_values('Total %', ascending=True).head(20)
+
+                # Add 'Type' column to distinguish between profit and loss
+                top_profit_df['Type'] = 'Profit'
+                top_loss_df['Type'] = 'Loss'
+
+                top_profit_df.reset_index(drop=True, inplace=True)
+                top_loss_df.reset_index(drop=True, inplace=True)
+
+                data = {
+                    'Year_L': top_loss_df['Start Date'].apply(lambda x: x.year),
+                    # 'End Date_Loss': top_loss_df['End Date'],
+                    '%_Loss': top_loss_df['Total %'],
+                    
+                    'Year_P': top_profit_df['Start Date'].apply(lambda x: x.year),
+                    # 'End Date_Profit': top_profit_df['End Date'],
+                    '%_Profit': top_profit_df['Total %']
+                }
+                return pd.DataFrame(data)
+                
+            st.divider()
+            
+            st.subheader("Detail Analysis of Maximum Profit 📈 and Loss 📉", divider=True)
+            pcol1, pcol2, pcol3 = st.columns([1,1,2])
+
+            with pcol1:
+                st.text("General Analysis")
+                profit_loss_all = max_Profit_loss(final_df)
+                st.dataframe(profit_loss_all)
+
+            with pcol2:
+                st.text("Only in BUY Trades")
+                profit_loss_all_BUY = max_Profit_loss(buy_trades_df)
+                st.dataframe(profit_loss_all_BUY)
+            
+            with pcol3:
+                st.text("Gap Up & Down Loss 📉")
+                st.dataframe(final_df[final_df['Gap Exit Loss % 2'] == True].reset_index())
+
+            # Save to Excel
+            excel_buffer = BytesIO()
+            with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
+                final_df.to_excel(writer, sheet_name='Trades Analysis', index=False)
+                # temp.to_excel(writer, sheet_name='Full Analysis', index=False)
+                system_returns_no_compound.to_excel(writer, sheet_name='System Analysis', index=False)
+                system_yearly_no_compound.to_excel(writer, sheet_name='System Yearly', index=False)
+
+                profit_loss_all.to_excel(writer, sheet_name='Profit-Loss Analysis', index=False)
+
+                system_returns_with_compound.to_excel(writer, sheet_name='System Compounding', index=False)
+                system_yearly_with_compound.to_excel(writer, sheet_name='System Compounding Yearly', index=False)
+
+                system_mtf_no_compound.to_excel(writer, sheet_name='MTF System Analysis', index=False)
+                system_mtf_yearly_no_compound.to_excel(writer, sheet_name='MTF System Yearly', index=False)
+
+                system_mtf_with_compound.to_excel(writer, sheet_name='CMP MTF System', index=False)
+                system_mtf_yearly_with_compound.to_excel(writer, sheet_name='CMP MTF Yearly', index=False)
+
+                buy_trades_no_compound.to_excel(writer, sheet_name='BUY Analysis', index=False)
+                buy_trades_yearly_no_compound.to_excel(writer, sheet_name='BUY Yearly', index=False)
+
+                buy_trades_compound.to_excel(writer, sheet_name='BUY Compound', index=False)
+                buy_trades_yearly_compound.to_excel(writer, sheet_name='BUY Compound Yearly', index=False)
+
+                buy_trades_mtf_no_compound.to_excel(writer, sheet_name='BUY MTF', index=False)
+                buy_trades_mtf_yearly_no_compound.to_excel(writer, sheet_name='BUY MTF Yearly', index=False)
+                
+                buy_trades_mtf_returns_compound.to_excel(writer, sheet_name='BUY MTF CMP', index=False)
+                buy_trades_mtf_yearly_compound.to_excel(writer, sheet_name='BUY MTF CMP Yearly', index=False)
+
+
+            file_name_ = f"{uploaded_file.name} Trailing {trail_offset} Target {target_sl}"
+
+            excel_buffer.seek(0)
+            st.download_button(
+                label="Download Excel File",
+                data=excel_buffer,
+                file_name=f"Analysis of {file_name_}.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
 
-"""
-# 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])),
-    ))
+if __name__ == "__main__":
+    main()