app.py

import pandas as pd
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
import dash_table

from sqlalchemy import create_engine

engine = create_engine('postgresql://fncalderong:Fncalderon91G@strategy.c1kvaa1zefdl.us-east-2.rds.amazonaws.com/strategy')
df = pd.read_sql("SELECT * from trades", engine.connect())
df['Trade type']=df['Trade type'].str.strip()
df['Exposure']=df['Exposure'].str.strip()
df['Exchange']=df['Exchange'].str.strip()
df['YearMonth'] = df['Entry time'].dt.strftime('%Y-%m')
# df = pd.read_csv('aggr.csv', parse_dates=['Entry time'])


def filter_df(d_frame, exchange, margin, start_date, end_date):
    df_aux = d_frame[(d_frame['Exchange'] == exchange) & (d_frame['Margin'] == margin) & (d_frame['Entry time'] >= start_date) & (d_frame['Entry time'] <= end_date)]
    return df_aux



def calc_returns_over_month(dff):
    out = []
    for name, group in dff.groupby('YearMonth'):
        exit_balance = group.head(1)['Exit balance'].values[0]
        entry_balance = group.tail(1)['Entry balance'].values[0]
        monthly_return = (exit_balance * 100 / entry_balance) - 100
        out.append({
            'month': name,
            'entry': entry_balance,
            'exit': exit_balance,
            'monthly_return': monthly_return
        })
    return out


def calc_btc_returns(dff):
    btc_start_value = dff.tail(1)['BTC Price'].values[0]
    btc_end_value = dff.head(1)['BTC Price'].values[0]
    btc_returns = (btc_end_value * 100 / btc_start_value) - 100
    return btc_returns


def calc_strat_returns(dff):
    start_value = dff.tail(1)['Exit balance'].values[0]
    end_value = dff.head(1)['Entry balance'].values[0]
    returns = (end_value * 100 / start_value) - 100
    return returns




# df['yymm'] = df['Entry time'].dt.strftime('%Y-%m')
#
#
# import plotly.graph_objects as go
#
# import pandas as pd
# from datetime import datetime
#
# df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/finance-charts-apple.csv')
# df
# fig = go.Figure(data=[go.Candlestick(x=df['Date'],
#                 open=df['AAPL.Open'],
#                 high=df['AAPL.High'],
#                 low=df['AAPL.Low'],
#                 close=df['AAPL.Close'])])
#
# fig.show()
#
app = dash.Dash(__name__, external_stylesheets=['https://codepen.io/uditagarwal/pen/oNvwKNP.css', 'https://codepen.io/uditagarwal/pen/YzKbqyV.css'])



app.layout = html.Div(children=[
    html.Div(
            children=[
                html.H2(children="Bitcoin Leveraged Trading Backtest Analysis", className='h2-title'),
            ],
            className='study-browser-banner row'
    ),
    html.Div(
        className="row app-body",
        children=[
            html.Div(
                className="twelve columns card",
                children=[
                    html.Div(
                        className="padding row",
                        children=[
                            html.Div(
                                className="two columns card",
                                children=[
                                    html.H6("Select Exchange",),
                                    dcc.RadioItems(
                                        id="exchange-select",
                                        options=[
                                            {'label': label, 'value': label} for label in df['Exchange'].unique()
                                        ],
                                        value='Bitmex',
                                        labelStyle={'display': 'inline-block'}
                                    )
                                ]
                            ),
                            # Leverage Selector
                            html.Div(
                                className="two columns card",
                                children=[
                                    html.H6("Select Leverage"),
                                    dcc.RadioItems(
                                        id="leverage-select",
                                        options=[
                                            {'label': int(label), 'value': int(label)} for label in df['Margin'].unique()
                                        ],
                                        value=1,
                                        labelStyle={'display': 'inline-block'}
                                    ),
                                ]
                            ),
                            html.Div(
                                className="three columns card",
                                children=[
                                    html.H6("Select a Date Range"),
                                    dcc.DatePickerRange(
                                        id="date-range",
                                        display_format="MMM YY",
                                        start_date=df['Entry time'].min(),
                                        end_date=df['Entry time'].max()
                                    ),
                                ]
                            ),
                            html.Div(
                                id="strat-returns-div",
                                className="two columns indicator pretty_container",
                                children=[
                                    html.P(id="strat-returns", className="indicator_value"),
                                    html.P('Strategy Returns', className="twelve columns indicator_text"),
                                ]
                            ),
                            html.Div(
                                id="market-returns-div",
                                className="two columns indicator pretty_container",
                                children=[
                                    html.P(id="market-vs-returns", className="indicator_value"),
                                    html.P('Market Returns', className="twelve columns indicator_text"),
                                ]
                            ),
                            html.Div(
                                id="strat-vs-market-div",
                                className="two columns indicator pretty_container",
                                children=[
                                    html.P(id="strat-vs-market", className="indicator_value"),
                                    html.P('Strategy vs. Market Returns', className="twelve columns indicator_text"),
                                ]
                            ),
                        ]
                )
        ]),
        html.Div(
            className="twelve columns card",
            children=[
                dcc.Graph(
                    id="monthly-chart",
                    figure={
                        'data': []
                    }
                )
            ]
        ),
        html.Div(
                className="padding row",
                children=[
                    html.Div(
                        className="six columns card",
                        children=[
                            dash_table.DataTable(
                                id='table',
                                columns=[
                                    {'name': 'Number', 'id': 'Number'},
                                    {'name': 'Trade type', 'id': 'Trade type'},
                                    {'name': 'Exposure', 'id': 'Exposure'},
                                    {'name': 'Entry balance', 'id': 'Entry balance'},
                                    {'name': 'Exit balance', 'id': 'Exit balance'},
                                    {'name': 'Pnl (incl fees)', 'id': 'Pnl (incl fees)'},
                                ],
                                style_cell={'width': '50px'},
                                style_table={
                                    'maxHeight': '450px',
                                    'overflowY': 'scroll'
                                },
                            )
                        ]
                    ),
                    dcc.Graph(
                        id="pnl-types",
                        className="six columns",
                        figure={}
                    )
                    ]
        ),
                    html.Div(
                        className="padding row",
                        children=[
                            dcc.Graph(
                                id="daily-btc",
                                className="six columns card",
                                style={'height':'450px'},
                                figure={}
                            ),
                            dcc.Graph(
                                id="balance",
                                className="six columns card",
                                style={'height':'450px'},
                                figure={}
                            )
                        ]
                    )
                ]
        )
        ])

@app.callback(
    [
        dash.dependencies.Output('date-range', 'start_date'),
        dash.dependencies.Output('date-range', 'end_date')
    ],
    [
        dash.dependencies.Input('exchange-select', 'value')
    ]
)

def exchangechange(exchange):
    df_aux = df[df['Exchange'] == exchange]['Entry time']
    new_star_date = df_aux.min().date()
    new_end_date = df_aux.max().date()
    return [new_star_date, new_end_date]



@app.callback(
    [
        dash.dependencies.Output('monthly-chart', 'figure'),
        dash.dependencies.Output('market-vs-returns', 'children'),
        dash.dependencies.Output('strat-returns', 'children'),
        dash.dependencies.Output('strat-vs-market', 'children'),
    ],
    (
            dash.dependencies.Input('exchange-select', 'value'),
            dash.dependencies.Input('leverage-select', 'value'),
            dash.dependencies.Input('date-range', 'start_date'),
            dash.dependencies.Input('date-range', 'end_date'),

    )
)
def update_monthly(exchange, leverage, start_date, end_date):
    dff = filter_df(df, exchange, leverage, start_date, end_date)
    data = calc_returns_over_month(dff)
    btc_returns = calc_btc_returns(dff)
    strat_returns = calc_strat_returns(dff)
    strat_vs_market = strat_returns - btc_returns

    return {
               'data': [
                   go.Candlestick(
                       open=[each['entry'] for each in data],
                       close=[each['exit'] for each in data],
                       x=[each['month'] for each in data],
                       low=[each['entry'] for each in data],
                       high=[each['exit'] for each in data]
                   )
               ],
               'layout': {
                   'title': 'Overview of Monthly performance'
               }
           }, f'{btc_returns:0.2f}%', f'{strat_returns:0.2f}%', f'{strat_vs_market:0.2f}%'

@app.callback(
    dash.dependencies.Output('table', 'data'),
    (
        dash.dependencies.Input('exchange-select', 'value'),
        dash.dependencies.Input('leverage-select', 'value'),
        dash.dependencies.Input('date-range', 'start_date'),
        dash.dependencies.Input('date-range', 'end_date'),
    )
)
def update_table(exchange, leverage, start_date, end_date):
    dff = filter_df(df, exchange, leverage, start_date, end_date)
    return dff.to_dict('records')

@app.callback(
    dash.dependencies.Output('pnl-types', 'figure'),
    (
        dash.dependencies.Input('exchange-select', 'value'),
        dash.dependencies.Input('leverage-select', 'value'),
        dash.dependencies.Input('date-range', 'start_date'),
        dash.dependencies.Input('date-range', 'end_date'),
    )
)
def update_bar(exchange, leverage, start_date, end_date):
    dff = filter_df(df, exchange, leverage, start_date, end_date)
    dff_Short = dff[dff['Trade type']=="Short"]
    dff_Long = dff[dff['Trade type'] == "Long"]
    data = []
    data.append(go.Bar(
        x=dff_Short['Entry time'], y=dff_Short['Pnl (incl fees)'], name='Short'
    ))
    data.append(go.Bar(
        x=dff_Long['Entry time'], y=dff_Long['Pnl (incl fees)'], name='Long'
    ))
    return {
            'data': data, 'layout': {'barmode': 'group','title':'PNL'}
        }


@app.callback(
    [
        dash.dependencies.Output('daily-btc', 'figure'),
        dash.dependencies.Output('balance', 'figure')
    ],
    (
        dash.dependencies.Input('exchange-select', 'value'),
        dash.dependencies.Input('leverage-select', 'value'),
        dash.dependencies.Input('date-range', 'start_date'),
        dash.dependencies.Input('date-range', 'end_date'),
    )
)

def update_line(exchange, leverage, start_date, end_date):
    dff = filter_df(df, exchange, leverage, start_date, end_date)
    data1 = []
    data1.append(go.Scatter(
            x=dff['Entry time'], y=dff['BTC Price'], name="BTC"
        ))
    data2 = []
    data2.append(go.Scatter(
        x=dff['Entry time'], y=dff['Entry balance'], name="Balance"
    ))
    return {
        'data': data1,
        'layout': go.Layout(
            margin={'t': 50, 'r': 50, },
            title="Daily BTC Price"
        )
    },{
        'data': data2,
        'layout': go.Layout(
            margin={'t': 50, 'r': 50, },
            title="Balance Over Time"
        )
    }



if __name__ == "__main__":
    app.run_server(debug=True, host='0.0.0.0')