initial commit

README.md

@@ -1,12 +1,14 @@
 ---
-title: PN Dashboard
-emoji: 🏃
-colorFrom: red
-colorTo: pink
+title: CT Dashboard
+emoji: 📚
+colorFrom: indigo
+colorTo: green
 sdk: streamlit
-sdk_version: 1.31.1
+sdk_version: 1.17.0
 app_file: app.py
 pinned: false
+license: gpl
+fullWidth: true
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,599 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: light
+#       format_version: '1.5'
+#       jupytext_version: 1.14.2
+#   kernelspec:
+#     display_name: Python [conda env:bbytes] *
+#     language: python
+#     name: conda-env-bbytes-py
+# ---
+
+# +
+import csv 
+import pandas as pd
+from datetime import datetime, timedelta
+import numpy as np
+import datetime as dt
+import matplotlib.pyplot as plt
+from pathlib import Path
+import time
+import plotly.graph_objects as go
+import plotly.io as pio
+from PIL import Image
+
+import streamlit as st
+import plotly.express as px
+import altair as alt
+import dateutil.parser
+from  matplotlib.colors import LinearSegmentedColormap
+
+
+# +
+class color:
+    PURPLE = '\033[95m'
+    CYAN = '\033[96m'
+    DARKCYAN = '\033[36m'
+    BLUE = '\033[94m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+    END = '\033[0m'
+    
+@st.experimental_memo    
+def print_PL(amnt, thresh, extras = "" ):
+    if amnt > 0:
+        return color.BOLD + color.GREEN + str(amnt) + extras + color.END
+    elif amnt < 0:
+        return color.BOLD + color.RED + str(amnt)+ extras + color.END
+    elif np.isnan(amnt):
+        return str(np.nan)
+    else:
+        return str(amnt + extras)
+    
+@st.experimental_memo      
+def get_headers(logtype):
+    otimeheader = ""
+    cheader = ""
+    plheader = ""
+    fmat = '%Y-%m-%d %H:%M:%S'
+    
+    if logtype == "ByBit":
+        otimeheader = 'Create Time'
+        cheader = 'Contracts'
+        plheader = 'Closed P&L'
+        fmat = '%Y-%m-%d %H:%M:%S'
+        
+    if logtype == "BitGet":
+        otimeheader = 'Date'
+        cheader = 'Futures'
+        plheader = 'Realized P/L'
+        fmat = '%Y-%m-%d %H:%M:%S'  
+        
+    if logtype == "MEXC":
+        otimeheader = 'Trade time'
+        cheader = 'Futures'
+        plheader = 'closing position'
+        fmat = '%Y/%m/%d %H:%M'
+        
+    if logtype == "Binance":
+        otimeheader = 'Date'
+        cheader = 'Symbol'
+        plheader = 'Realized Profit'
+        fmat = '%Y-%m-%d %H:%M:%S'
+        
+    #if logtype == "Kucoin":
+    #    otimeheader = 'Time'
+    #    cheader = 'Contract'
+    #    plheader = ''
+    #    fmat = '%Y/%m/%d %H:%M:%S' 
+
+        
+    if logtype == "Kraken":
+        otimeheader = 'time'
+        cheader = 'asset'
+        plheader = 'amount'
+        fmat = '%Y-%m-%d %H:%M:%S.%f'  
+        
+    if logtype == "OkX":
+        otimeheader = '\ufeffOrder Time'
+        cheader = '\ufeffInstrument'
+        plheader = '\ufeffPL'
+        fmat = '%Y-%m-%d %H:%M:%S'        
+    
+    return otimeheader.lower(), cheader.lower(), plheader.lower(), fmat
+    
+@st.experimental_memo    
+def get_coin_info(df_coin, principal_balance,plheader):
+    numtrades = int(len(df_coin))
+    numwin = int(sum(df_coin[plheader] > 0))
+    numloss = int(sum(df_coin[plheader] < 0))
+    winrate = np.round(100*numwin/numtrades,2)
+    
+    grosswin = sum(df_coin[df_coin[plheader] > 0][plheader])
+    grossloss = sum(df_coin[df_coin[plheader] < 0][plheader])
+    if grossloss != 0:
+        pfactor = -1*np.round(grosswin/grossloss,2)
+    else: 
+        pfactor = np.nan
+    
+    cum_PL = np.round(sum(df_coin[plheader].values),2)
+    cum_PL_perc = np.round(100*cum_PL/principal_balance,2)
+    mean_PL = np.round(sum(df_coin[plheader].values/len(df_coin)),2)
+    mean_PL_perc = np.round(100*mean_PL/principal_balance,2)
+    
+    return numtrades, numwin, numloss, winrate, pfactor, cum_PL, cum_PL_perc, mean_PL, mean_PL_perc
+
+@st.experimental_memo
+def get_hist_info(df_coin, principal_balance,plheader):
+    numtrades = int(len(df_coin))
+    numwin = int(sum(df_coin[plheader] > 0))
+    numloss = int(sum(df_coin[plheader] < 0))
+    if numtrades != 0:
+        winrate = int(np.round(100*numwin/numtrades,2))
+    else: 
+        winrate = np.nan
+    
+    grosswin = sum(df_coin[df_coin[plheader] > 0][plheader])
+    grossloss = sum(df_coin[df_coin[plheader] < 0][plheader])
+    if grossloss != 0:
+        pfactor = -1*np.round(grosswin/grossloss,2)
+    else: 
+        pfactor = np.nan
+    return numtrades, numwin, numloss, winrate, pfactor
+
+@st.experimental_memo
+def get_rolling_stats(df, lev, otimeheader, days):
+    max_roll = (df[otimeheader].max() - df[otimeheader].min()).days
+    
+    if max_roll >= days:
+        rollend = df[otimeheader].max()-timedelta(days=days)
+        rolling_df = df[df[otimeheader] >= rollend]
+
+        if len(rolling_df) > 0:
+            rolling_perc = rolling_df['Return Per Trade'].dropna().cumprod().values[-1]-1
+        else: 
+            rolling_perc = np.nan
+    else:
+        rolling_perc = np.nan
+    return 100*rolling_perc
+@st.experimental_memo
+def cc_coding(row):
+    return ['background-color: lightgrey'] * len(row) if row['Exit Date'] <= datetime.strptime('2022-12-16 00:00:00','%Y-%m-%d %H:%M:%S').date() else [''] * len(row)
+def ctt_coding(row):
+    return ['background-color: lightgrey'] * len(row) if row['Exit Date'] <= datetime.strptime('2023-01-02 00:00:00','%Y-%m-%d %H:%M:%S').date() else [''] * len(row)
+
+@st.experimental_memo
+def my_style(v, props=''):
+    props = 'color:red' if v < 0 else 'color:green'
+    return props
+
+def filt_df(df, cheader, symbol_selections):
+    
+    df = df.copy()
+    df = df[df[cheader].isin(symbol_selections)]
+
+    return df
+def load_data(filename, account, exchange, otimeheader, fmat):
+    cols = ['id','datetime', 'exchange', 'subaccount', 'pair', 'side', 'action', 'amount', 'price']
+    df = pd.read_csv(filename, header = 0, names= cols)
+
+    filtdf = df[(df.exchange == exchange) & (df.subaccount == account)].dropna()
+    filtdf = filtdf.sort_values('datetime')
+    filtdf = filtdf.iloc[np.where(filtdf.action == 'open')[0][0]:, :] #get first open signal in dataframe
+
+    tnum = 0
+    dca = 0
+    newdf = pd.DataFrame([], columns=['Trade','Signal','Entry Date','Buy Price', 'Sell Price','Exit Date', 'P/L per token', 'P/L %'])
+    for index, row in filtdf.iterrows(): 
+        if row.action == 'open':
+            dca += 1 
+            tnum += 1 
+            sig = 'Long' if row.side == 'buy' else 'Short'
+            temp = pd.DataFrame({'Trade' :[tnum], 'Signal': [sig], 'Entry Date':[row.datetime],'Buy Price': [row.price], 'Sell Price': [np.nan],'Exit Date': [np.nan], 'P/L per token': [np.nan], 'P/L %': [np.nan], 'DCA': [dca]})
+            newdf = pd.concat([newdf,temp], ignore_index = True)
+        if row.action == 'close':
+            for j in np.arange(tnum-1, tnum-dca-1,-1):
+                newdf.loc[j,'Sell Price'] = row.price 
+                newdf.loc[j,'Exit Date'] = row.datetime
+            dca = 0 
+
+    newdf['Buy Price'] = pd.to_numeric(newdf['Buy Price'])
+    newdf['Sell Price'] = pd.to_numeric(newdf['Sell Price'])
+
+    newdf['P/L per token'] = newdf['Sell Price'] - newdf['Buy Price']
+    newdf['P/L %'] = 100*newdf['P/L per token']/newdf['Buy Price']
+    newdf = newdf.dropna()
+
+
+    dateheader = 'Date'
+    theader = 'Time'
+
+    newdf[dateheader] = [tradetimes.split(" ")[0] for tradetimes in newdf[otimeheader].values]
+    newdf[theader] = [tradetimes.split(" ")[1] for tradetimes in newdf[otimeheader].values]
+    
+    newdf[otimeheader] = pd.to_datetime(newdf[otimeheader])
+    newdf['Exit Date'] = pd.to_datetime(newdf['Exit Date'])
+    
+    newdf[dateheader] = [dateutil.parser.parse(date).date() for date in newdf[dateheader]]
+    newdf[theader] = [dateutil.parser.parse(time).time() for time in newdf[theader]]
+    
+    return newdf
+
+def get_sd_df(sd_df, sd, bot_selections, dca1, dca2, dca3, dca4, dca5, dca6, fees, lev, dollar_cap, principal_balance):
+    sd = 2*.00026
+    # ------ Standard Dev. Calculations. 
+    if bot_selections == "Cinnamon Toast":
+        dca_map = {1: dca1/100, 2: dca2/100, 3: dca3/100, 4: dca4/100, 1.1: dca5/100, 2.1: dca6/100}
+        sd_df['DCA %'] = sd_df['DCA'].map(dca_map)
+        sd_df['Calculated Return % (+)'] = df['Signal'].map(signal_map)*(df['DCA %'])*(1-fees)*((df['Sell Price']*(1+df['Signal'].map(signal_map)*sd) - df['Buy Price']*(1-df['Signal'].map(signal_map)*sd))/df['Buy Price']*(1-df['Signal'].map(signal_map)*sd) - fees) #accounts for fees on open and close of trade 
+        sd_df['Calculated Return % (-)'] = df['Signal'].map(signal_map)*(df['DCA %'])*(1-fees)*((df['Sell Price']*(1-df['Signal'].map(signal_map)*sd)-df['Buy Price']*(1+df['Signal'].map(signal_map)*sd))/df['Buy Price']*(1+df['Signal'].map(signal_map)*sd) - fees) #accounts for fees on open and close of trade 
+        sd_df['DCA'] = np.floor(sd_df['DCA'].values)
+
+        sd_df['Return Per Trade (+)'] = np.nan
+        sd_df['Return Per Trade (-)'] = np.nan
+        sd_df['Balance used in Trade (+)'] = np.nan
+        sd_df['Balance used in Trade (-)'] = np.nan
+        sd_df['New Balance (+)'] = np.nan
+        sd_df['New Balance (-)'] = np.nan
+
+        g1 = sd_df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return % (+)'].reset_index(name='Return Per Trade (+)')
+        g2 = sd_df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return % (-)'].reset_index(name='Return Per Trade (-)')
+        sd_df.loc[sd_df['DCA']==1.0,'Return Per Trade (+)'] = 1+lev*g1['Return Per Trade (+)'].values
+        sd_df.loc[sd_df['DCA']==1.0,'Return Per Trade (-)'] = 1+lev*g2['Return Per Trade (-)'].values
+
+        sd_df['Compounded Return (+)'] = sd_df['Return Per Trade (+)'].cumprod()
+        sd_df['Compounded Return (-)'] = sd_df['Return Per Trade (-)'].cumprod()
+        sd_df.loc[sd_df['DCA']==1.0,'New Balance (+)'] = [min(dollar_cap/lev, bal*principal_balance) for bal in sd_df.loc[sd_df['DCA']==1.0,'Compounded Return (+)']]
+        sd_df.loc[sd_df['DCA']==1.0,'Balance used in Trade (+)'] = np.concatenate([[principal_balance], sd_df.loc[sd_df['DCA']==1.0,'New Balance (+)'].values[:-1]])
+
+        sd_df.loc[sd_df['DCA']==1.0,'New Balance (-)'] = [min(dollar_cap/lev, bal*principal_balance) for bal in sd_df.loc[sd_df['DCA']==1.0,'Compounded Return (-)']]
+        sd_df.loc[sd_df['DCA']==1.0,'Balance used in Trade (-)'] = np.concatenate([[principal_balance], sd_df.loc[sd_df['DCA']==1.0,'New Balance (-)'].values[:-1]])
+    else: 
+        sd_df['Calculated Return % (+)'] = df['Signal'].map(signal_map)*(1-fees)*((df['Sell Price']*(1+df['Signal'].map(signal_map)*sd) - df['Buy Price']*(1-df['Signal'].map(signal_map)*sd))/df['Buy Price']*(1-df['Signal'].map(signal_map)*sd) - fees) #accounts for fees on open and close of trade 
+        sd_df['Calculated Return % (-)'] = df['Signal'].map(signal_map)*(1-fees)*((df['Sell Price']*(1-df['Signal'].map(signal_map)*sd)-df['Buy Price']*(1+df['Signal'].map(signal_map)*sd))/df['Buy Price']*(1+df['Signal'].map(signal_map)*sd) - fees) #accounts for fees on open and close of trade 
+        sd_df['Return Per Trade (+)'] = np.nan
+        sd_df['Return Per Trade (-)'] = np.nan
+
+        g1 = sd_df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return % (+)'].reset_index(name='Return Per Trade (+)')
+        g2 = sd_df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return % (-)'].reset_index(name='Return Per Trade (-)')
+        sd_df['Return Per Trade (+)'] = 1+lev*g1['Return Per Trade (+)'].values
+        sd_df['Return Per Trade (-)'] = 1+lev*g2['Return Per Trade (-)'].values
+
+        sd_df['Compounded Return (+)'] = sd_df['Return Per Trade (+)'].cumprod()
+        sd_df['Compounded Return (-)'] = sd_df['Return Per Trade (-)'].cumprod()
+        sd_df['New Balance (+)'] = [min(dollar_cap/lev, bal*principal_balance) for bal in sd_df['Compounded Return (+)']]
+        sd_df['Balance used in Trade (+)'] = np.concatenate([[principal_balance], sd_df['New Balance (+)'].values[:-1]])
+
+        sd_df['New Balance (-)'] = [min(dollar_cap/lev, bal*principal_balance) for bal in sd_df['Compounded Return (-)']]
+        sd_df['Balance used in Trade (-)'] = np.concatenate([[principal_balance], sd_df['New Balance (-)'].values[:-1]])
+
+    sd_df['Net P/L Per Trade (+)'] = (sd_df['Return Per Trade (+)']-1)*sd_df['Balance used in Trade (+)']
+    sd_df['Cumulative P/L (+)'] = sd_df['Net P/L Per Trade (+)'].cumsum()
+
+    sd_df['Net P/L Per Trade (-)'] = (sd_df['Return Per Trade (-)']-1)*sd_df['Balance used in Trade (-)']
+    sd_df['Cumulative P/L (-)'] = sd_df['Net P/L Per Trade (-)'].cumsum()
+    return sd_df
+
+def runapp() -> None:
+            bot_selections = "Pumpernickel"
+            otimeheader = 'Exit Date'
+            fmat = '%Y-%m-%d %H:%M:%S'
+            fees = .075/100
+    
+            #st.header(f"{bot_selections} Performance Dashboard :bread: :moneybag:")
+            no_errors = True
+            #st.write("Welcome to the Trading Bot Dashboard by BreadBytes! You can use this dashboard to track " +
+            #     "the performance of our trading bots.")
+
+            if bot_selections == "Pumpernickel":
+                lev_cap = 5
+                dollar_cap = 1000000000.00
+                data = load_data('history.csv', 'Pumpernickel Test', 'Bybit Futures', otimeheader, fmat)
+            
+            df = data.copy(deep=True)
+
+            dateheader = 'Date'
+            theader = 'Time'
+            
+            #st.subheader("Choose your settings:")
+            with st.form("user input", ):
+                if no_errors:
+                    with st.container():
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            try:
+                                startdate = st.date_input("Start Date", value=pd.to_datetime(df[otimeheader]).min())
+                            except:
+                                st.error("Please select your exchange or upload a supported trade log file.")
+                                no_errors = False 
+                        with col2:
+                            try:
+                                enddate = st.date_input("End Date", value=datetime.today())
+                            except:
+                                st.error("Please select your exchange or upload a supported trade log file.")
+                                no_errors = False 
+                        #st.sidebar.subheader("Customize your Dashboard")
+
+                        if no_errors and (enddate < startdate): 
+                            st.error("End Date must be later than Start date. Please try again.")
+                            no_errors = False 
+                    with st.container(): 
+                        col1,col2 = st.columns(2) 
+                        with col2:
+                            lev = st.number_input('Leverage', min_value=1, value=1, max_value= lev_cap, step=1)
+                        with col1:
+                            principal_balance = st.number_input('Starting Balance', min_value=0.00, value=1000.00, max_value= dollar_cap, step=.01)
+
+                #hack way to get button centered 
+                c = st.columns(9)
+                with c[4]: 
+                    submitted = st.form_submit_button("Get Cookin'!")           
+            signal_map = {'Long': 1, 'Short':-1}  
+            if submitted and principal_balance * lev > dollar_cap:
+                lev = np.floor(dollar_cap/principal_balance)
+                st.error(f"WARNING: (Starting Balance)*(Leverage) exceeds the ${dollar_cap} limit. Using maximum available leverage of {lev}")
+
+            df = df[(df[dateheader] >= startdate) & (df[dateheader] <= enddate)]
+
+            if submitted and len(df) == 0:
+                    st.error("There are no available trades matching your selections. Please try again!")
+                    no_errors = False
+
+            if no_errors:
+                if bot_selections == "Pumpernickel":
+                    dca_map = {1: 1/3, 2: 1/3, 3: 1/3}
+                    df['DCA %'] = df['DCA'].map(dca_map)
+                    df['Calculated Return %'] = df['Signal'].map(signal_map)*(df['DCA %'])*(1-fees)*((df['Sell Price']-df['Buy Price'])/df['Buy Price'] - fees) #accounts for fees on open and close of trade 
+                    df['DCA'] = np.floor(df['DCA'].values)
+
+                    df['Return Per Trade'] = np.nan
+                    df['Balance used in Trade'] = np.nan
+                    df['New Balance'] = np.nan
+
+                    g = df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return %'].reset_index(name='Return Per Trade')
+                    df.loc[df['DCA']==1.0,'Return Per Trade'] = 1+lev*g['Return Per Trade'].values
+
+                    df['Compounded Return'] = df['Return Per Trade'].cumprod()
+                    df.loc[df['DCA']==1.0,'New Balance'] = [min(dollar_cap/lev, bal*principal_balance) for bal in df.loc[df['DCA']==1.0,'Compounded Return']]
+                    df.loc[df['DCA']==1.0,'Balance used in Trade'] = np.concatenate([[principal_balance], df.loc[df['DCA']==1.0,'New Balance'].values[:-1]])
+                else: 
+                    df['Calculated Return %'] = df['Signal'].map(signal_map)*(1-fees)*((df['Sell Price']-df['Buy Price'])/df['Buy Price'] - fees) #accounts for fees on open and close of trade 
+                    df['Return Per Trade'] = np.nan
+                    g = df.groupby('Exit Date').sum(numeric_only=True)['Calculated Return %'].reset_index(name='Return Per Trade')
+                    df['Return Per Trade'] = 1+lev*g['Return Per Trade'].values
+
+                    df['Compounded Return'] = df['Return Per Trade'].cumprod()
+                    df['New Balance'] = [min(dollar_cap/lev, bal*principal_balance) for bal in df['Compounded Return']]
+                    df['Balance used in Trade'] = np.concatenate([[principal_balance], df['New Balance'].values[:-1]])
+                df['Net P/L Per Trade'] = (df['Return Per Trade']-1)*df['Balance used in Trade']
+                df['Cumulative P/L'] = df['Net P/L Per Trade'].cumsum()
+
+
+                cum_pl = df.loc[df.dropna().index[-1],'Cumulative P/L'] + principal_balance
+
+                effective_return = 100*((cum_pl - principal_balance)/principal_balance)
+                 
+                #st.header(f"{bot_selections} Results")
+                with st.container(): 
+
+                    if len(bot_selections) > 1:
+                        col1, col2 = st.columns(2)
+                        with col1: 
+                            st.metric(
+                                "Total Account Balance",
+                                f"${cum_pl:.2f}",
+                                f"{100*(cum_pl-principal_balance)/(principal_balance):.2f} %",
+                            )
+                                
+                dfdata = df.dropna()
+
+                # Create figure
+                fig = go.Figure()
+
+                pyLogo = Image.open("logo.png")
+
+#                     fig.add_traces(go.Scatter(x=sd_df['Exit Date'], y = sd_df['Cumulative P/L (+)'],line_shape='spline',
+#                              line = dict(smoothing = 1.3, color='rgba(31, 119, 200,0)'),  showlegend = False)
+#                                   )
+
+#                     fig.add_traces(go.Scatter(x=sd_df['Exit Date'], y = sd_df['Cumulative P/L (-)'],
+#                              line = dict(smoothing = 1.3, color='rgba(31, 119, 200,0)'), line_shape='spline',
+#                              fill='tonexty', 
+#                              fillcolor = 'rgba(31, 119, 200,.2)', name = '+/- Standard Deviation')
+#                                  )
+
+                # Add trace
+                fig.add_trace(
+                    go.Scatter(x=dfdata['Exit Date'], y=np.round(dfdata['Cumulative P/L'].values,2), line_shape='spline', 
+                               line = {'smoothing': .7, 'color' : 'rgba(90, 223, 137, 1)'},
+                               name='P/L')
+                )
+                buyhold  = (principal_balance/dfdata['Buy Price'][dfdata.index[0]])*(dfdata['Buy Price']-dfdata['Buy Price'][dfdata.index[0]])
+                fig.add_trace(go.Scatter(x=dfdata['Exit Date'], y=np.round(buyhold.values,2), line_shape='spline', 
+                                         line = {'smoothing': .7, 'color' :'rgba(33, 212, 225, 1)'}, name = 'Buy & Hold')
+                )
+
+                fig.add_layout_image(
+                        dict(
+                            source=pyLogo,
+                            xref="paper",
+                            yref="paper",
+                            x = 0.05, #dfdata['Exit Date'].astype('int64').min() // 10**9, 
+                            y = .95, #dfdata['Cumulative P/L'].max(),
+                            sizex= .9, #(dfdata['Exit Date'].astype('int64').max() - dfdata['Exit Date'].astype('int64').min()) // 10**9,
+                            sizey= .9, #(dfdata['Cumulative P/L'].max() - dfdata['Cumulative P/L'].min()),
+                            sizing="contain",
+                            opacity=0.5, 
+                        layer = "below")
+                )
+
+                #style layout 
+                fig.update_layout(
+                    height = 550,
+                    xaxis=dict(
+                        title="Exit Date", 
+                        tickmode='array',
+                        showgrid=False
+                    ),
+                    yaxis=dict(
+                        title="Cumulative P/L",
+                        showgrid=False
+                    ), 
+                    legend=dict(
+                    x=.85,
+                    y=0.15,
+                    traceorder="normal"
+                    ),
+                    plot_bgcolor = 'rgba(10, 10, 10, 1)'
+                ) 
+
+                st.plotly_chart(fig, theme=None, use_container_width=True, height=550)
+                st.write()
+                df['Per Trade Return Rate'] = df['Return Per Trade']-1
+
+                totals = pd.DataFrame([], columns = ['# of Trades', 'Wins', 'Losses', 'Win Rate', 'Profit Factor'])
+                data = get_hist_info(df.dropna(), principal_balance,'Per Trade Return Rate')
+                totals.loc[len(totals)] = list(i for i in data)
+
+                totals['Cum. P/L'] = cum_pl-principal_balance
+                totals['Cum. P/L (%)'] = 100*(cum_pl-principal_balance)/principal_balance
+
+                if df.empty:
+                    st.error("Oops! None of the data provided matches your selection(s). Please try again.")
+                else:
+                    with st.container():
+                        for row in totals.itertuples():
+                            col1, col2, col3, col4= st.columns(4)
+                            c1, c2, c3, c4 = st.columns(4)
+                            with col1:
+                                st.metric(
+                                    "Total Trades",
+                                    f"{row._1:.0f}",
+                                )
+                            with c1:
+                                st.metric(
+                                    "Profit Factor",
+                                    f"{row._5:.2f}",
+                                )
+                            with col2: 
+                                st.metric(
+                                    "Wins",
+                                    f"{row.Wins:.0f}",
+                                )
+                            with c2:
+                                st.metric(
+                                    "Cumulative P/L",
+                                    f"${row._6:.2f}",
+                                    f"{row._7:.2f} %",
+                                )
+                            with col3: 
+                                st.metric(
+                                    "Losses",
+                                    f"{row.Losses:.0f}",
+                                )
+                            with c3:
+                                st.metric(
+                                "Rolling 7 Days",
+                                    "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
+                                    f"{get_rolling_stats(df,lev, otimeheader, 7):.2f}%",
+                                )
+                                st.metric(
+                                "Rolling 30 Days",
+                                    "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
+                                    f"{get_rolling_stats(df,lev, otimeheader, 30):.2f}%",
+                                )
+
+                            with col4: 
+                                st.metric(
+                                    "Win Rate",
+                                    f"{row._4:.1f}%",
+                                )
+                            with c4:
+                                st.metric(
+                                "Rolling 90 Days",
+                                    "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
+                                    f"{get_rolling_stats(df,lev, otimeheader, 90):.2f}%",
+                                )
+                                st.metric(
+                                "Rolling 180 Days",
+                                    "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
+                                    f"{get_rolling_stats(df,lev, otimeheader, 180):.2f}%",
+                                )
+
+            if bot_selections == "Pumpernickel":
+                if submitted:                     
+                    grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
+                                             'Sell Price' : 'max',
+                                             'Net P/L Per Trade': 'mean', 
+                                             'Calculated Return %' : lambda x: np.round(100*lev*x.sum(),2), 
+                                             'DCA': lambda x: int(np.floor(x.max()))})
+                    grouped_df.index = range(1, len(grouped_df)+1)
+                    grouped_df.rename(columns={'DCA' : '# of DCAs', 'Buy Price':'Avg. Buy Price',
+                                               'Net P/L Per Trade':'Net P/L', 
+                                               'Calculated Return %':'P/L %'}, inplace=True)
+                else:
+
+                    grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
+                                             'Sell Price' : 'max',
+                                             'P/L per token': 'mean', 
+                                             'Calculated Return %' : lambda x: np.round(100*x.sum(),2), 
+                                             'DCA': lambda x: int(np.floor(x.max()))})
+                    grouped_df.index = range(1, len(grouped_df)+1)
+                    grouped_df.rename(columns={'DCA' : '# of DCAs', 'Buy Price':'Avg. Buy Price',
+                                               'Calculated Return %':'P/L %',
+                                               'P/L per token':'Net P/L'}, inplace=True)
+                
+            else: 
+                if submitted: 
+                    grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
+                                             'Sell Price' : 'max',
+                                             'Net P/L Per Trade': 'mean', 
+                                             'Calculated Return %' : lambda x: np.round(100*lev*x.sum(),2)})
+                    grouped_df.index = range(1, len(grouped_df)+1)
+                    grouped_df.rename(columns={'Buy Price':'Avg. Buy Price',
+                                               'Net P/L Per Trade':'Net P/L', 
+                                               'Calculated Return %':'P/L %'}, inplace=True)        
+                else: 
+                    grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
+                                             'Sell Price' : 'max',
+                                             'P/L per token': 'mean', 
+                                             'P/L %':'mean'})
+                    grouped_df.index = range(1, len(grouped_df)+1)
+                    grouped_df.rename(columns={'Buy Price':'Avg. Buy Price',
+                                               'P/L per token':'Net P/L'}, inplace=True)
+            st.subheader("Trade Logs")
+            grouped_df['Entry Date'] = pd.to_datetime(grouped_df['Entry Date'])
+            grouped_df['Exit Date'] = pd.to_datetime(grouped_df['Exit Date'])
+            if bot_selections == "Cosmic Cupcake" or bot_selections == "CT Toasted":
+                coding = cc_coding if bot_selections == "Cosmic Cupcake" else ctt_coding
+                st.dataframe(grouped_df.style.format({'Entry Date':'{:%m-%d-%Y %H:%M:%S}','Exit Date':'{:%m-%d-%Y %H:%M:%S}','Avg. Buy Price': '${:.2f}', 'Sell Price': '${:.2f}', 'Net P/L':'${:.2f}', 'P/L %':'{:.2f}%'})\
+                .apply(coding, axis=1)\
+                .applymap(my_style,subset=['Net P/L'])\
+                .applymap(my_style,subset=['P/L %']), use_container_width=True)
+                # new_title = '<div style="text-align: right;"><span style="background-color:lightgrey;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> Not Live Traded</div>'
+                # st.markdown(new_title, unsafe_allow_html=True)
+            else: 
+                st.dataframe(grouped_df.style.format({'Entry Date':'{:%m-%d-%Y %H:%M:%S}','Exit Date':'{:%m-%d-%Y %H:%M:%S}','Avg. Buy Price': '${:.2f}', 'Sell Price': '${:.2f}', 'Net P/L':'${:.2f}', 'P/L %':'{:.2f}%'})\
+                .applymap(my_style,subset=['Net P/L'])\
+                .applymap(my_style,subset=['P/L %']), use_container_width=True)
+                
+#             st.subheader("Checking Status")
+#             if submitted:
+#                 st.dataframe(sd_df)
+                                
+if __name__ == "__main__":
+    st.set_page_config(
+        "Trading Bot Dashboard", layout = 'wide'
+    )
+    runapp()
+# -
+
+
+
+

history.csv

@@ -0,0 +1,104 @@
+,id,datetime,exchange,subaccount,pair,side,action,amount,price
+0,1,2024-02-12 19:05:48,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 315, in webhook
+    dec = f_key.decrypt(enc).decode()
+  File ""/usr/local/lib/python3.10/site-packages/cryptography/fernet.py"", line 83, in decrypt
+    t"
+1,2,2024-02-12 19:10:57,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 315, in webhook
+    f_key = bytes(f_key, ""utf-8"")
+UnboundLocalError: local variable 'f_key' referenced before assignment
+
+local variable 'f_key' referen"
+2,3,2024-02-12 19:12:50,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 316, in webhook
+    f_key = bytes(f_key, ""utf-8"")
+UnboundLocalError: local variable 'f_key' referenced before assignment
+
+local variable 'f_key' referen"
+3,4,2024-02-12 19:17:01,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 316, in webhook
+    dec = f_key.decrypt(enc).decode()
+  File ""/usr/local/lib/python3.10/site-packages/cryptography/fernet.py"", line 83, in decrypt
+    t"
+4,5,2024-02-12 19:18:27,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 315, in webhook
+    dec = bytes(f_key, ""utf-8"").decrypt(enc).decode()
+TypeError: encoding without a string argument
+
+encoding without a string argument"
+5,6,2024-02-12 19:28:00,,,,,,,"Webhook error:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/flask_app.py"", line 315, in webhook
+    dec = f_key.decrypt(enc) #.decode()
+  File ""/usr/local/lib/python3.10/site-packages/cryptography/fernet.py"", line 83, in decrypt
+   "
+6,7,2024-02-12 19:32:09,Bybit Futures,test1,BTCUSDT,buy,open,0.001,49881.5
+7,8,2024-02-12 19:40:29,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+8,9,2024-02-12 19:40:38,Bybit Futures,test1,BTCUSDT,sell,close,0.001,49736.9
+9,10,2024-02-12 19:40:39,Bybit Futures,test1,BTCUSDT,sell,open,0.001,49736.9
+10,11,2024-02-12 19:40:43,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+11,12,2024-02-12 19:40:50,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+12,13,2024-02-12 19:41:26,Bybit Futures,test1,BTCUSDT,buy,close,0.001,49733.3
+13,14,2024-02-12 19:41:31,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+14,15,2024-02-12 19:42:16,Bybit Futures,test1,BTCUSDT,buy,open,0.003,49749.5
+15,16,2024-02-12 19:42:28,Bybit Futures,test1,BTCUSDT,buy,open,0.003,49737.1
+16,17,2024-02-12 19:42:36,Bybit Futures,test1,BTCUSDT,sell,close,0.006,49726.4
+17,18,2024-02-12 19:42:37,Bybit Futures,test1,BTCUSDT,sell,open,0.003,49738
+18,19,2024-02-12 19:42:43,Bybit Futures,test1,BTCUSDT,sell,open,0.003,49731
+19,20,2024-02-12 19:43:01,Bybit Futures,test1,BTCUSDT,buy,close,0.006,49752.4
+20,21,2024-02-12 19:51:14,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+21,22,2024-02-12 19:51:38,Bybit Futures,test1,,,,,"Error: Get active positions:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/bybitUniFuturesClient.py"", line 236, in get_position
+    position = self.client.get_positions(category= ""linear"", symbol= pair)['result']['list'][0]
+  File ""/"
+22,23,2024-02-13 00:16:03,Bybit Futures,Pure Bread Test,ETHUSDT,sell,open,0.33,2679.29
+23,24,2024-02-13 03:11:33,Bybit Futures,Pure Bread Test,ETHUSDT,buy,close,0.33,2653.47
+24,25,2024-02-13 03:38:01,Bybit Futures,Pure Bread Test,ETHUSDT,buy,open,0.34,2642.86
+25,26,2024-02-13 09:01:02,Bybit Futures,Pure Bread Test,ETHUSDT,sell,close,0.34,2662.12
+26,27,2024-02-13 09:01:03,Bybit Futures,Pure Bread Test,ETHUSDT,sell,open,0.34,2662.12
+27,28,2024-02-13 10:26:43,Bybit Futures,Pumpernickel Test,,,,,Order size (0.0) is less than minimum size (0.1) for ATOMUSDT.
+28,29,2024-02-13 11:56:56,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+29,30,2024-02-13 11:57:12,Bybit Futures,test1,BTCUSDT,buy,open,0.001,50013.9
+30,31,2024-02-13 11:57:16,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+31,32,2024-02-13 11:57:39,Bybit Futures,test1,BTCUSDT,sell,close,0.001,50016.1
+32,33,2024-02-13 11:57:40,Bybit Futures,test1,BTCUSDT,sell,open,0.001,50016.1
+33,34,2024-02-13 11:58:13,Bybit Futures,test1,BTCUSDT,buy,close,0.001,49970.9
+34,35,2024-02-13 11:58:22,Bybit Futures,test1,,,,,No need to place order for BTCUSDT.
+35,36,2024-02-13 11:58:40,Bybit Futures,test1,BTCUSDT,buy,open,0.009,49985.9
+36,37,2024-02-13 11:58:50,Bybit Futures,test1,BTCUSDT,buy,open,0.009,49982.1
+37,38,2024-02-13 11:59:10,Bybit Futures,test1,BTCUSDT,sell,close,0.018,49974.5
+38,39,2024-02-13 11:59:58,Bybit Futures,test1,,,,,"Error: Get active positions:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/bybitUniFuturesClient.py"", line 236, in get_position
+    position = self.client.get_positions(category= ""linear"", symbol= pair)['result']['list'][0]
+  File ""/"
+39,40,2024-02-13 12:45:32,Bybit Futures,Pumpernickel Test,,,,,Order size (0.0) is less than minimum size (0.1) for ATOMUSDT.
+40,41,2024-02-13 13:37:01,Bybit Futures,Pure Bread Test,,,,,No need to place order for ETHUSDT.
+41,42,2024-02-13 15:15:05,Bybit Futures,Pumpernickel Test,ATOMUSDT,buy,open,19.9,9.983
+42,43,2024-02-13 15:28:34,Bybit Futures,Pumpernickel Test,ATOMUSDT,sell,close,19.9,10.095
+43,44,2024-02-13 15:28:35,Bybit Futures,Pumpernickel Test,ATOMUSDT,sell,open,19.8,10.097
+44,45,2024-02-13 16:41:32,Bybit Futures,Pumpernickel Test,ATOMUSDT,buy,close,19.8,9.974
+45,46,2024-02-13 16:41:33,Bybit Futures,Pumpernickel Test,ATOMUSDT,buy,open,20.2,9.97471782
+46,47,2024-02-13 16:58:37,Bybit Futures,Pumpernickel Test,ATOMUSDT,buy,open,20.2,9.93472772
+47,48,2024-02-13 19:08:03,Bybit Futures,Pumpernickel Test,ATOMUSDT,sell,close,40.4,10.104
+48,49,2024-02-13 19:08:04,Bybit Futures,Pumpernickel Test,ATOMUSDT,sell,open,20.3,10.104
+49,50,2024-02-13 19:29:04,Bybit Futures,Pumpernickel Test,ATOMUSDT,sell,open,20.1,10.186
+50,51,2024-02-13 19:58:20,Bybit Futures,test1,,,,,"Error: Get active positions:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/bybitUniFuturesClient.py"", line 236, in get_position
+    position = self.client.get_positions(category= ""linear"", symbol= pair)['result']['list'][0]
+  File ""/"
+51,52,2024-02-13 20:01:33,Bybit Futures,test1,BTCUSDT,buy,open,0.001,49052.6
+52,53,2024-02-13 14:02:46,Bybit Futures,test1,BTCUSDT,buy,open,0.001,49089.5
+53,54,2024-02-13 20:10:03,Bybit Futures,Pumpernickel Test,,,,,"Error: Get active positions:
+Traceback (most recent call last):
+  File ""/home/doukaslewis/mysite/bybitUniFuturesClient.py"", line 157, in get_position
+    position = self.client.get_positions(category= ""linear"", symbol= pair)['result']['list'][0]
+  File ""/"

requirements.txt

@@ -0,0 +1,9 @@
+pandas==1.5.2
+datetime
+numpy
+matplotlib
+pathlib
+plotly
+altair
+streamlit
+altair<5