# Main Plot dcc.Graph(id='main-graph') ]) ################################################################################ ################################### CALLBACK ################################### ################################################################################ # Tells output and input # If only using one input it still needs to be a list # Value is what's associated with teh dropdown, and is constantly being changed/updated @app.callback( Output('main-graph', 'figure'), [Input('graph-dropdown-1', 'value'), Input('graph-dropdown-2', 'value')]) def graph_maker(col1, col2): ''' Returns the figure dict for main plot ''' data = [] # markers for target in range(3): trace = go.Scatter( x=df[df['target'] == target][col1], y=df[df['target'] == target][col2], mode='markers', ) data.append(trace)
all_options = { 'Emotion_final.csv': ['all', 'sadness', 'anger', 'love', 'surprise', 'fear', 'happy'], 'text_emotion.csv': [u'all', 'empty', 'sadness', 'enthusiasm', 'neutral', 'worry', 'surprise', 'love', 'fun', 'hate', 'happy', 'boredom', 'relief', 'anger'] } ############################################################################# ############################### PAGE HOME ################################### ############################################################################# @app.callback( Output("modal_Home", "is_open"), [Input("open-centered", "n_clicks"), Input("close-centered", "n_clicks")], [State("modal_Home", "is_open")], ) def toggle_modal(n1, n2, is_open): if n1 or n2: return not is_open return is_open @app.callback( Output('app-home-display-value', 'children'), Input('app-home-dropdown', 'value')) def display_value(value): return 'You have selected "{}"'.format(value) @app.callback( Output('output_container', 'children'),
os.remove(f) def subCallback(stream_id,data,state,log,crtl): #store data locally in some file fileName = 'data'+str(stream_id)+'.csv' df = pd.DataFrame([data]) with open(fileName,'a') as f: df.to_csv(f,mode='a',header=not f.tell(),index=False) return state @app.callback(Output('subTime','data'), Input('keyValues','modified_timestamp'), State('keyValues','data'),State('subTime','data')) def start_sub(n,streamList,subscribed): if streamList is None: #too early raise PreventUpdate try: for stream in streamList: sub.subscribe(stream ,callback = subCallback) return time.time() except Exception as e: logger.exception("Ran into error subscribing to streams in index.py") return False @app.callback(Output('streamID','data'),
app = dash.Dash() server = app.server app.config['suppress_callback_exceptions'] = True app.layout = html.Div([ html.H1('Dash Tabs component demo'), dcc.Tabs(id="tabs-example", value='tab-1-example', children=[ dcc.Tab(label='Tab One', value='tab-1-example'), dcc.Tab(label='Tab Two', value='tab-2-example'), ]), html.Div(id='tabs-content-example') ]) @app.callback(Output('tabs-content-example', 'children'), [Input('tabs-example', 'value')]) def render_content(tab): if tab == 'tab-1-example': return tab_1.tab_1_layout elif tab == 'tab-2-example': return tab_2.tab_2_layout # Tab 1 callback @app.callback(dash.dependencies.Output('page-1-content', 'children'), [dash.dependencies.Input('page-1-dropdown', 'value')]) def page_1_dropdown(value): return 'You have selected "{}"'.format(value) # Tab 2 callback @app.callback(Output('page-2-content', 'children'), [Input('page-2-radios', 'value')])
dcc.Graph(id='pie_chart', config={'displayModeBar': 'hover'}), ], className="create_container2 six columns"), ], className="row flex-display"), ], id="mainContainer", style={ "display": "flex", "flex-direction": "column" }) @app.callback(Output('pie_chart', 'figure'), [Input('select_country', 'value')], [Input('date_range', 'start_date')], [Input('date_range', 'end_date')]) def update_graph(select_country, start_date, end_date): covid1 = covid.groupby(['Date', 'Country/Region' ])[['Confirmed', 'Deaths', 'Recovered', 'Active']].sum().reset_index() covid2 = covid1[covid1['Country/Region'] == select_country][[ 'Country/Region', 'Date', 'Confirmed' ]].reset_index() covid2[ 'daily confirmed'] = covid2['Confirmed'] - covid2['Confirmed'].shift(1) covid2.fillna(0, inplace=True) daily_confirmed = covid2[(covid2['Country/Region'] == select_country) & (covid2['Date'].between(start_date, end_date) )]['daily confirmed'].sum()
def callbacks(app): # pylint: disable=redefined-outer-name @app.callback(Output('mol3d-data-info', 'children'), [Input('dropdown-demostr', 'value')]) def show_data(molecule_selected): if molecule_selected in data_info.keys(): mol = data_info[molecule_selected] return [ html.H4(mol['name']), mol['description'], html.A('(source)', href=mol['link']) ] return '' @app.callback(Output('dropdown-demostr', 'value'), [Input('mol3d-upload-data', 'contents')], [State('dropdown-demostr', 'value')]) def reset_dropdown(upload_content, dem): if upload_content is not None: return None return dem # Callback for updating dropdown options @app.callback(Output('mol3d-coloring-key', 'options'), [Input('dropdown-style-color', 'value')]) def update_color_options(mol_style): color_dict_keys = { 'atom': list(sparser.ATOM_COLOR_DICT.keys()), 'residue': list(sparser.RESIDUE_COLOR_DICT.keys()), 'residue_type': list(sparser.RESIDUE_TYPE_COLOR_DICT.keys()), 'chain': list(sparser.CHAIN_COLOR_DICT.keys()) } options = [{ 'label': k.upper(), 'value': k } for k in color_dict_keys[mol_style]] return options @app.callback(Output('mol3d-color-storage', 'data'), [ Input('mol3d-coloring-value', 'value'), Input('dropdown-style-color', 'value') ], state=[ State('mol3d-coloring-key', 'value'), State('mol3d-color-storage', 'data') ]) def update_color_dict(color_value, color_style, color_key, current): if color_style is None: return {} if color_key is None or color_value is None: return current # clear the dict if the color style has changed if '{}_colors'.format(color_style) not in current.keys(): current = {'{}_colors'.format(color_style): {}} # finally update the dict current['{}_colors'.format( color_style)][color_key] = color_value['hex'] return current # Callback for molecule visualization based on uploaded PDB file @app.callback( Output('mol3d-biomolecule-viewer', 'children'), [ Input('mol3d-upload-data', 'contents'), Input('dropdown-demostr', 'value'), Input('dropdown-styles', 'value'), Input('dropdown-style-color', 'value'), Input('mol3d-color-storage', 'modified_timestamp') ], [State('mol3d-color-storage', 'data')], ) def use_upload(contents, demostr, mol_style, color_style, mt, custom_colors): if demostr is not None: copy2(demostr, './str.pdb') fname = './str.pdb' elif contents is not None and demostr is None: try: content_type, content_string = str(contents).split(',') decoded_contents = base64.b64decode(content_string).decode( "UTF-8") f = tempfile.NamedTemporaryFile(suffix=".pdb", delete=False, mode='w+') f.write(decoded_contents) fname = f.name f.close() except AttributeError: pass else: return 'demostr and contents are none' # Create the model data from the decoded contents modata = parser.create_data(fname) fmodel = files_data_style(modata) with open(fmodel) as fm: mdata = json.load(fm) # Create the cartoon style from the decoded contents datstyle = sparser.create_style(fname, mol_style, color_style, **custom_colors) fstyle = files_data_style(datstyle) with open(fstyle) as sf: data_style = json.load(sf) # Delete all the temporary files that were created for x in [fname, fmodel, fstyle]: if os.path.isfile(x): os.unlink(x) else: pass # Return the new molecule visualization container return dash_bio.Molecule3dViewer( id='mol-3d', selectionType='atom', modelData=mdata, styles=data_style, selectedAtomIds=[], backgroundOpacity='0', atomLabelsShown=False, ) # Callback to print details of each selected atom of the biomolecule @app.callback( Output("mol3d-selection-output", "children"), [Input("mol-3d", "selectedAtomIds"), Input("mol-3d", "modelData")]) def selout(selected_atom_ids, model_data): residue_summary = [] for atom_id in selected_atom_ids: res_info = model_data['atoms'][atom_id] residues = { "residue": res_info['residue_name'], "atom": res_info['name'], "chain": res_info['chain'], "xyz": res_info['positions'] } residue_summary += [ html.P('{}: {}'.format(key, str(residues[key]))) for key in residues ] residue_summary.append(html.Br()) if len(residue_summary) == 0: residue_summary.append("No atoms have been selected. Click \ on an atom to select it.") return html.Div(residue_summary)
children=dcc.Graph( id="volume-chart", config={"displayModeBar": False}, ), className="card", ), ], className="wrapper", ), ] ) @app.callback( [Output("price-chart", "figure"), Output("volume-chart", "figure")], [ Input("region-filter", "value"), Input("type-filter", "value"), Input("date-range", "start_date"), Input("date-range", "end_date"), ], ) def update_charts(region, avocado_type, start_date, end_date): mask = ( (data.region == region) & (data.type == avocado_type) & (data.Date >= start_date) & (data.Date <= end_date) ) filtered_data = data.loc[mask, :] price_chart_figure = { "data": [
def get_backtesting_report_dash_app(backtesting_result: dict, dash_app=None): # global app if dash_app is not None: app = dash_app else: app = app_ app.layout = html.Div( [ html.H2('Backtesting Result'), dcc.Location(id='url', refresh=False), dcc.Link('Index', href='/'), html.Br(), dcc.Link('General Performance', href='/btPerformance'), # dcc.Tab(), html.Br(), dcc.Link('Monthly Analysis', href='/monthlyAnalysis'), html.Br(), # todo holding position question dcc.Link('Entry and exit Detail', href='/details'), html.Br(), dcc.Link('Trading history', href='/history'), html.Br(), # dcc.Tabs(id='tabs', value='tab', children=[ # dcc.Tab(label='General Performance', value='tab-1'), # dcc.Tab(label='Monthly Analysis', value='tab-2'), # dcc.Tab(label='Entry and exit Detail', value='tab-3'), # dcc.Tab(label='Trading history', value='tab-4'), # # dcc.Tab(label='Tab two', value='tab-2'), # ]), html.Div(id='page-content'), ], style={'margin': '30px'}) profile = json.dumps(backtesting_result['strategy_profile'], indent=2) index_page = html.Div([ html.Pre(profile), # todo 行情profile # benchmark # each stock # each time frame # strategy basic information # name # todo 回测类型 # ]), # --------------- index page callback --------------- @app.callback(Output('page-content', 'children'), [Input('url', 'pathname')]) def display_page(pathname): if pathname == '/btPerformance': return dash_report.get_layout(backtesting_result) elif pathname == '/monthlyAnalysis': return monthly_analysis.get_layout(backtesting_result) elif pathname == '/details': return entry_exit_analysis.get_layout(backtesting_result) elif pathname == '/history': return trading_history.get_layout(backtesting_result) else: return index_page # --------------- general page callback --------------- @app.callback( [Output('general_markdown', 'children')], [Input('risk-free-rate', 'value'), Input('annul-factor', 'value')]) def update_general_performance(risk_free_rate, annulizaed_factor): strategy_net_value = backtesting_result['net_value'] returns = backtesting_result['rate of return'] risk_free_rate = float(risk_free_rate) annulizaed_factor = int(annulizaed_factor) general_performance = { 'Initial capital': "{:.2f}".format(strategy_net_value[0]), 'End capital': "{:.2f}".format(strategy_net_value[-1]), 'Cumulative Return %': "{:.2f} %".format(100 * backtesting_result['cumulative_return']), 'CAGR %': "{:.2f} %".format(100 * backtesting_result['cagr']), 'First traded': backtesting_result['first_traded'], 'Last traded': backtesting_result['last_traded'], 'Num of trade': backtesting_result['num_trade'], 'Win rate %': "{:.2f} %".format(100 * backtesting_result['win_rate']), # type: float 'Avg win': "{:.2f}".format(backtesting_result['avg_win']), 'Avg loss': "{:.2f}".format(backtesting_result['avg_loss']), 'Payoff ratio': "{:.2f}".format(backtesting_result['payoff_ratio']), # returns statistics 'Volatility %': "{:.2f} %".format(100 * backtesting_result['volatility']), 'Skew': "{:.2f}".format(backtesting_result['skew']), 'Kurtosis': "{:.2f}".format(backtesting_result['Kurtosis']), 'Sharpe': "{:.2f}".format( sharpe_ratio(returns, risk_free_rate, annulizaed_factor)), 'Sortino': "{:.2f}".format(sortino(returns, risk_free_rate, annulizaed_factor)), } general_ss = pd.Series(general_performance, name='Performance') return general_ss.to_markdown(), @app.callback([ Output('top-k-markdown', 'children'), Output('top-max-drawdown', 'figure') ], [Input('top-k-drawdown', 'value')]) def update_top_drawdown(top_k): top_k = int(top_k) strategy_net_value = backtesting_result['net_value'] table = backtesting_result['drawdown_detail'].sort_values( by='max drawdown')[:min(top_k, len(backtesting_result['drawdown_detail']) )] # type: pd.DataFrame table['max drawdown'] = table['max drawdown'].apply( lambda x: "{:.2f} %".format(100 * x)) # table['99% max drawdown'] = table['99% max drawdown'].apply(lambda x: "{:.2f} %".format(100 *x)) table.reset_index(inplace=True) table.drop(columns=['99% max drawdown', 'index'], inplace=True) fig = net_value_plot(strategy_net_value) red_color = [ '#CE0000', '#EA0000', '#FF0000', '#FF2D2D', '#FF2D2D', '#FF5151', '#FF7575', '#FF9797', '#FFB5B5', '#FFD2D2' ] shapes = [ dict( type="rect", # x-reference is assigned to the x-values xref="x", # y-reference is assigned to the plot paper [0,1] yref="paper", x0=row['start'].replace('-', '/'), y0=0, x1=row['end'].replace('-', '/'), y1=1, fillcolor=red_color[idx], opacity=0.5, layer="below", line_width=0, ) for idx, row in table.iterrows() ] fig.update_layout(shapes=shapes) return table.to_markdown(), fig # --------------- monthly page callback --------------- @app.callback([ Output('title', 'children'), Output('return-heatmap', 'figure'), Output('returns-distribution', 'figure'), Output('key_period', 'children') ], [Input('dropdown', 'value')]) def change_selection(value): if value == 'D': agg_ret = aggregate_returns(backtesting_result['rate of return'], 'day') # type: pd.Series # todo trade statistics # trade_group = backtesting_result['trade_list'].groupby('order_time') heatmap = aggregate_returns_heatmap(agg_ret, 'day') displot = returns_distribution_plot(agg_ret) consec_win = agg_ret.groupby((agg_ret > 0).cumsum()) consec_loss = agg_ret.groupby((agg_ret < 0).cumsum()) period_performance = { 'Best Day': agg_ret.index[agg_ret.argmax()].date(), 'Best Day Return': "{:.2f} %".format(100 * agg_ret.max()), 'Worst Day': agg_ret.index[agg_ret.argmin()].date(), 'Worst Day Return': "{:.2f} %".format(100 * agg_ret.min()), 'Days of Consecutive Win': consec_win.cumcount().max(), 'Days of Consecutive Losses': consec_loss.cumcount().max(), 'Avg Daily Return %': "{:.2f} %".format(100 * agg_ret.mean()), 'Daily Return Vol %': "{:.2f} %".format(100 * agg_ret.std()), 'Daily Return Skew': "{:.2f} ".format(agg_ret.skew()), 'Daily Return Kurt': "{:.2f} ".format(agg_ret.kurt()), } return 'Daily Analysis', heatmap, displot, pd.Series( period_performance, name='Daily Key Performance').to_markdown() elif value == 'W': agg_ret = aggregate_returns(backtesting_result['rate of return'], 'week') heatmap = aggregate_returns_heatmap(agg_ret, 'week') displot = returns_distribution_plot(agg_ret) consec_win = agg_ret.groupby((agg_ret > 0).cumsum()) consec_loss = agg_ret.groupby((agg_ret < 0).cumsum()) period_performance = { 'Best Week': agg_ret.index[agg_ret.argmax()].date(), 'Best Week Return': "{:.2f} %".format(100 * agg_ret.max()), 'Worst Week': agg_ret.index[agg_ret.argmin()].date(), 'Worst Week Return': "{:.2f} %".format(100 * agg_ret.min()), 'Weeks of Consecutive Win': consec_win.cumcount().max(), 'Weeks of Consecutive Losses': consec_loss.cumcount().max(), 'Avg Weekly Return %': "{:.2f} %".format(100 * agg_ret.mean()), 'Weekly Return Vol %': "{:.2f} %".format(100 * agg_ret.std()), 'Weekly Return Skew': "{:.2f} ".format(agg_ret.skew()), 'Weekly Return Kurt': "{:.2f} ".format(agg_ret.kurt()), } return 'Weekly Analysis', heatmap, displot, pd.Series( period_performance, name='Week Key Performance').to_markdown() elif value == 'M': agg_ret = aggregate_returns(backtesting_result['rate of return'], 'month') heatmap = aggregate_returns_heatmap(agg_ret, 'month') displot = returns_distribution_plot(agg_ret) consec_win = agg_ret.groupby((agg_ret > 0).cumsum()) consec_loss = agg_ret.groupby((agg_ret < 0).cumsum()) period_performance = { 'Best Month': agg_ret.index[agg_ret.argmax()].date(), 'Best Month Return': "{:.2f} %".format(100 * agg_ret.max()), 'Worst Month': agg_ret.index[agg_ret.argmin()].date(), 'Worst Month Return': "{:.2f} %".format(100 * agg_ret.min()), 'Months of Consecutive Win': consec_win.cumcount().max(), 'Months of Consecutive Losses': consec_loss.cumcount().max(), 'Avg Monthly Return %': "{:.2f} %".format(100 * agg_ret.mean()), 'Monthly Return Vol %': "{:.2f} %".format(100 * agg_ret.std()), 'Monthly Return Skew': "{:.2f} ".format(agg_ret.skew()), 'Monthly Return Kurt': "{:.2f} ".format(agg_ret.kurt()), } return 'Monthly Analysis', heatmap, displot, pd.Series( period_performance, name='Monthly Key Performance').to_markdown() elif value == 'Q': agg_ret = aggregate_returns(backtesting_result['rate of return'], 'quarter') heatmap = aggregate_returns_heatmap(agg_ret, 'quarter') displot = returns_distribution_plot(agg_ret) consec_win = agg_ret.groupby((agg_ret > 0).cumsum()) consec_loss = agg_ret.groupby((agg_ret < 0).cumsum()) period_performance = { 'Best Quarter': agg_ret.index[agg_ret.argmax()].date(), 'Best Quarter Return': "{:.2f} %".format(100 * agg_ret.max()), 'Worst Quarter': agg_ret.index[agg_ret.argmin()].date(), 'Worst Quarter Return': "{:.2f} %".format(100 * agg_ret.min()), 'Quarters of Consecutive Win': consec_win.cumcount().max(), 'Quarters of Consecutive Losses': consec_loss.cumcount().max(), 'Avg Quarterly Return %': "{:.2f} %".format(100 * agg_ret.mean()), 'Quarterly Return Vol %': "{:.2f} %".format(100 * agg_ret.std()), 'Quarterly Return Skew': "{:.2f} ".format(agg_ret.skew()), 'Quarterly Return Kurt': "{:.2f} ".format(agg_ret.kurt()), } return 'Quarter Analysis', heatmap, displot, pd.Series( period_performance, name='Quarterly Key Performance').to_markdown() elif value == 'Y': agg_ret = aggregate_returns(backtesting_result['rate of return'], 'year') heatmap = aggregate_returns_heatmap(agg_ret, 'year') displot = returns_distribution_plot(agg_ret) consec_win = agg_ret.groupby((agg_ret > 0).cumsum()) consec_loss = agg_ret.groupby((agg_ret < 0).cumsum()) period_performance = { 'Best Year': agg_ret.index[agg_ret.argmax()].date(), 'Best Year Return': "{:.2f} %".format(100 * agg_ret.max()), 'Worst Year': agg_ret.index[agg_ret.argmin()].date(), 'Worst Year Return': "{:.2f} %".format(100 * agg_ret.min()), 'Years of Consecutive Win': consec_win.cumcount().max(), 'Years of Consecutive Losses': consec_loss.cumcount().max(), 'Avg Yearly Return %': "{:.2f} %".format(100 * agg_ret.mean()), 'Yearly Return Vol %': "{:.2f} %".format(100 * agg_ret.std()), 'Yearly Return Skew': "{:.2f} ".format(agg_ret.skew()), 'Yearly Return Kurt': "{:.2f} ".format(agg_ret.kurt()), } return 'Year Analysis', heatmap, displot, pd.Series( period_performance, name='Yearly Key Performance').to_markdown() # --------------- entry exit page callback --------------- @app.callback(Output('timeframe', 'options'), [Input('asset-selection', 'value')]) def change_display(value): return [{ 'label': i, 'value': i } for i in backtesting_result['data'][value].keys()] @app.callback([ Output('entry-exit', 'figure'), Output('trade_table', 'data'), Output('trade_table', 'style_data_conditional') ], [Input('submit', 'n_clicks'), Input('trade_table', 'selected_rows')], [ State('ta-list', 'children'), State('my-date-picker-range', 'start_date'), State('my-date-picker-range', 'end_date'), State('asset-selection', 'value'), State('timeframe', 'value'), State('ohlc-line', 'value'), State('entrust', 'value'), ]) def update_entry_exit(n_clicks, selected_rows, ta_dict, start_date, end_date, symbol, timeframe, line, entrust): data = backtesting_result['data'][symbol][ timeframe] # type: pd.DataFrame data = data[(data.index >= pd.to_datetime(start_date)) & (data.index <= pd.to_datetime(end_date))] trade = backtesting_result['trade_list'] trade = trade[(trade['order_time'] >= pd.to_datetime(start_date)) & (trade['order_time'] <= pd.to_datetime(end_date))] ohlc_graph = True # print(entrust) if len(selected_rows) > 0: trade_graph = trade.iloc[selected_rows] selected_cond = [{ 'if': { 'row_index': i }, 'background_color': '#D2F3FF' } for i in selected_rows] else: trade_graph = trade selected_cond = [] if line == 'line': ohlc_graph = False e = False if entrust is None or len(entrust) == 0: e = False else: e = True ta = json.loads(ta_dict) return entry_and_exit_plot(data, trade_graph, symbol, ohlc_graph, entrust=e, ta_dict=ta), \ trade.to_dict('records'), selected_cond @app.callback(Output('indicator-name', 'options'), [Input('indicator-category', 'value')]) def update_ta(category): l = [] if category == 'customization': l = customization.__func__ elif category == 'momentum': l = momentum.__func__ elif category == 'volatility': l = volatility.__func__ elif category == 'overlap': l = overlap.__func__ elif category == 'volume': l = volume.__func__ elif category == 'pattern': l = pattern.__func__ return [{'label': i, 'value': i} for i in l] @app.callback(Output('parameter', 'children'), [Input('indicator-name', 'value')]) def update_ta_parameter(ta_name): if ta_name is None: return None func = eval(str(ta_name)) para_dict = inspect.signature(func).parameters children = [] for k, v in para_dict.items(): if k == 'inputs': continue else: # todo can it possible to make it a line? children.append(html.H6(k, style={'displace': 'inline-block'})) if isinstance(v.default, MA_Type): value = v.default.name children.append( dcc.Dropdown( id=k, options=[{ 'label': label, 'value': label } for label, value_ in v.default._member_map_.items()], value=value, )) else: value = v.default children.append(dcc.Input(id=k, value=value, debounce=True)) return children @app.callback( [Output('ta-list', 'children'), Output('remove-name', 'options')], [ Input( 'add-indicator', 'n_clicks', ), Input('remove-indicator', 'n_clicks') ], [ State('indicator-name', 'value'), State('parameter', 'children'), State('overlap', 'value'), State('remove-name', 'value'), State('ta-list', 'children') ]) def update_ta_list(add_clicks, remove_clicks, indicator, parameters, overlap, remove, ta_list): if ta_list is None: ta_dict = {} else: ta_dict = json.loads(ta_list) if indicator is not None: indicator_str = '' indicator_str += indicator indicator_str += '(inputs, ' for p in parameters: if p['type'] == 'Input': if p['props']['value'] == '' or p['props']['value'] is None: continue indicator_str += p['props']['id'] try: value = str(int(p['props']['value'])) except ValueError: try: value = str(float(p['props']['value'])) except ValueError: value = "'" + p['props']['value'] + "'" indicator_str += "=" + value + ',' elif p['type'] == 'Dropdown': indicator_str += p['props']['id'] + '=MA_Type.' + p[ 'props']['value'] + ',' indicator_str += ')' ta_dict[indicator_str] = True if 'overlap' in overlap else False if remove is not None: try: del ta_dict[remove] except: remove = None options = [{'label': i, 'value': i} for i in ta_dict.keys()] return json.dumps(ta_dict), options else: if remove is not None: try: del ta_dict[remove] except: remove = None options = [{'label': i, 'value': i} for i in ta_dict.keys()] return json.dumps(ta_dict), options # --------------- trade list page callback --------------- @app.callback(Output('table', 'data'), [ Input('date-picker-range', 'start_date'), Input('date-picker-range', 'end_date') ]) def update_output(date_from, date_to): if date_to is None or date_from is None: return df = backtesting_result['trade_list'] df_ = df[(df['order_time'] >= pd.to_datetime(date_from)) & (df['order_time'] <= pd.to_datetime(date_to))] return df_.to_dict('records') return app
]), width=4 ) ) columns.append( dbc.Col( dbc.FormGroup([ dbc.Label('Learning rate'), html.Button(id='add-lr', type='submit', children='add learning rate'), html.Div( id='learning-rates' ) ]), width=4 ) ) return dbc.Row( columns ) """ Adds one text input box for the learning rate parameter """ @app.callback( Output('learning-rates', 'children'), [Input('add-lr', 'n_clicks')] ) def add_learning_rates(clicks): if clicks is None: return [dcc.Input(id={'type':'lr', 'index':0}, type='number', min=0, max=1)] inputs = [] for i in range (clicks): inputs.append(dcc.Input(id={'type':'lr', 'index':i}, type='number', min=0, max=1)) return inputs """ filters out trace options trace files available for generating graphs are determined by the chosen dataset ('dataset' checklist component in 'build' config menu tab) """
]), dcc.Graph(id='indicator-graphic'), dcc.Slider(id='year--slider', min=df['Year'].min(), max=df['Year'].max(), value=df['Year'].max(), marks={str(year): str(year) for year in df['Year'].unique()}, step=None) ]) print({str(year): str(year) for year in df['Year'].unique()}) @app.callback(Output('indicator-graphic', 'figure'), [ Input('xaxis-column', 'value'), Input('yaxis-column', 'value'), Input('xaxis-type', 'value'), Input('yaxis-type', 'value'), Input('year--slider', 'value') ]) def update_graph(xaxis_column_name, yaxis_column_name, xaxis_type, yaxis_type, year_value): dff = df[df['Year'] == year_value] return { 'data': [ dict(x=dff[dff['Indicator Name'] == xaxis_column_name]['Value'], y=dff[dff['Indicator Name'] == yaxis_column_name]['Value'], text=dff[dff['Indicator Name'] == yaxis_column_name] ['Country Name'],
]) # figure loading figdict = {'tc':'tccrop.jpg','pca':'pccrop.jpg','veg':'vfccrop.jpg','heat':'hfccrop.jpg'} figpath = 'assets/images/' titledict = { 'tc':'True Color', 'pca':'Spectral Principal Components', 'veg':'Near Infrared (Vegetation=Red)', 'heat':'Shortwave Infrared' } @app.callback( [Output('leftgraph', 'figure'), Output('lefttitle', 'children')], [Input('leftbutton', 'value')] ) def update_left_figure(button): array = io.imread(figpath+figdict[button]) fig = px.imshow(array) fig.update_layout(width=780, height=900, margin={'l':5,'r':5,'b':5,'t':5}) return fig, titledict[button] @app.callback( [Output('rightgraph', 'figure'), Output('righttitle', 'children')], [Input('rightbutton', 'value')] ) def update_right_figure(button): array = io.imread(figpath+figdict[button]) fig = px.imshow(array)
]) ], width={ "size": 6, "offset": 3 }, ), ]), ], fluid=True, ) @APP.callback( Output("memory_custom_dimensions", "data"), Input("sample_definition_custom_dimensions", "value"), ) def _get_memory_custom_dimensions(sample_definition): return load_feather( f"correlation_between_accelerated_aging_dimensions/custom_dimensions_{sample_definition}.feather" ).to_dict() @APP.callback( Output("memory_scores_custom_dimensions", "data"), Input("sample_definition_custom_dimensions", "value"), ) def _modify_store_custom_dimensions(sample_definition): score_sample_definition = sample_definition if sample_definition == "all_samples_when_possible_otherwise_average": score_sample_definition = "all_samples_per_participant"
html.Div(id='page-content')]) options = html.Div([ html.H3('Dashboard Options'), html.Div(id='operation-display-value'), dcc.Link('Go to Operation', href='/publisher-dashboard/operation'), html.Div(id='performance-display-value'), dcc.Link('Go to Performance', href='/publisher-dashboard/performance'), html.Div(id='orbiting-display-value'), dcc.Link('Go to Orbiting', href='/publisher-dashboard/orbiting'), html.Div(id='positioning-display-value'), dcc.Link('Go to Positioning', href='/publisher-dashboard/positioning'), ]) @app.callback(Output('page-content', 'children'), [Input('url', 'pathname')]) def display_page(pathname): if pathname == '/publisher-dashboard/operation': return operation.layout elif pathname == '/publisher-dashboard/performance': return performance.layout elif pathname == '/publisher-dashboard/orbiting': return orbiting.layout elif pathname == '/publisher-dashboard/positioning': return positioning.layout else: return options if __name__ == '__main__': app.run_server(debug=DEBUG_MODE, host=SERVER_HOST, port=SERVER_PORT)
]) return layout ################################################################## # CALLBACKS ################################################################## #Toggle winners map if selected target @app.callback( Output('alert_target_not_selected_gsom', 'is_open'), Output('collapse_winnersmap_gsom', 'is_open'), Output('dropdown_target_selection_gsom', 'value'), Input('info_table_gsom', 'children'), #udpate on load Input('dropdown_target_selection_gsom', 'value'), ) def toggle_winners_gsom(info_table, target_value): ctx = dash.callback_context trigger_id = ctx.triggered[0]["prop_id"].split(".")[0] preselected_target = session_data.get_target_name() if (trigger_id == 'info_table_gsom'): #init call if (preselected_target is None): return False, True, None else: return False, True, preselected_target
}, content_style={ 'fontFamily': 'Arial', 'borderBottom': '1px solid #d6d6d6', 'borderLeft': '1px solid #d6d6d6', 'borderRight': '1px solid #d6d6d6', 'padding': '44px' }) ], style={ 'maxWidth': '1200px', 'margin': '0 auto' }) @app.callback( Output(component_id='categoricalPlot', component_property='figure'), [Input(component_id='jenisPlot', component_property='value'), Input(component_id='jenisDiamond', component_property='value')] ) def update_graph_categorical(jenisPlot,jenisDiamond): return { 'data': getPlot(jenisPlot,jenisDiamond), 'layout': go.Layout( xaxis={'title':jenisDiamond}, yaxis={'title':'price'}, margin={'l':40,'b':40,'t':10,'r':10}, # legend={'x':0, 'y':1}, hovermode='closest',boxmode='group',violinmode='group' ) } @app.callback(
chart_df = chart_df.groupby( "iyear")[chart_dp_value].value_counts().reset_index( name="count") if chart_df.shape[0]: pass else: chart_df = pd.DataFrame(columns=['iyear', 'count', chart_dp_value]) chart_df.loc[0] = [0, 0, "No data"] fig = px.area(chart_df, x="iyear", y="count", color=chart_dp_value) return dcc.Graph(figure=fig) @app.callback(Output("date", "options"), [Input("month", "value")]) def update_date(month): option = [] if month: option = [{"label": m, "value": m} for m in date_list] return option @app.callback([ Output("region-dropdown", "value"), Output("region-dropdown", "disabled"), Output("country-dropdown", "value"), Output("country-dropdown", "disabled") ], [Input("subtabs", "value")]) def update_r(tab): region = None
className='six columns u-full-width', style={"border":'1px solid White'}), html.Div([ html.Img(id='wordcloud', className='u-full-width')], className='six columns')], className="row")], className="container u-full-width") # html.Div( # [html.Div(id='time-log')], # className="container") ], className='container') @app.callback( Output('search-grid', 'children'), [Input('search-method','value')]) def update_search_method(search_method): """ Update search method depending on user choices """ if search_method == 'choice': return DROPDOWN_ITEM return INPUT_ITEM @app.callback( Output('job-id', 'children'), [Input('button', 'n_clicks')], state=[State('keyword', 'value'), State('sourcechoice', 'values')]) def submit_query(n_click, keyword, sourcechoice): """
), ], className="row flex-display", ), html.Div( [dcc.Graph(id="prarameter_table")], id="tables-container", className="twelve columns", ), html.Div(id='intermediate-value', style={'display': 'none'}) ]) @app.callback( [Output("opening_text", "children"),Output("closing_text", "children"),Output("pnl_text", "children"),Output("pnl_percent_text", "children")], [Input("strategy_name","value"), Input('intermediate-value', 'children')], ) def update_text(strategy_name,json_strategy_report): try: df_strategy_report = pd.read_json(json_strategy_report, orient='split') open_balance = 10000 for strat_index in df_strategy_report.index: if(df_strategy_report['stratgy_name'][strat_index] == strategy_name): break close_balance = df_strategy_report['value_at_end'][strat_index] pnl = df_strategy_report['profit_loss'][strat_index] pnl_percentage = df_strategy_report['roe'][strat_index] return "₹" + str(open_balance), "₹" + str(close_balance), "₹" + str(pnl), str(pnl_percentage) + "%" except:
import dash_html_components as html from dash.dependencies import Input, Output import plotly.graph_objs as go import squarify import pandas as pd app = dash.Dash() server = app.server app.config.supress_callback_exceptions = True rfm = pd.read_csv('rfm.csv') rfm['Counts'] = rfm.groupby(['Segment'])['CustomerID'].transform('count') app.layout = html.Div([dcc.Graph(id='treemap')]) @app.callback(Output('treemap', 'figure'), [Input('treemap', 'value')]) def treemap(value): #values = [500, 433, 78, 25, 25, 7] values = rfm['Segment'].value_counts().values index = rfm['Segment'].value_counts().index parents_segment = rfm['Segment'].head(20).values childs = rfm['CustomerID'].head(20).values segment_counts = rfm['Counts'].head(20).values # Choose colors from http://colorbrewer2.org/ under "Export" trace = go.Sunburst(ids=childs, labels=parents_segment, values=segment_counts, outsidetextfont={
'scrollZoom': True, 'showTips': True }) ]) ], fluid=True) ], fluid=True) @app.callback([ Output('basic-interactions', 'figure'), Output('infected', 'children'), Output('basic-interactions2', 'figure') ], [ Input('pop', 'value'), Input('recDays', 'value'), Input('avgInfections', 'value'), Input('initialInfections', 'value'), Input('worlds', 'value') ]) def runModel(Pop, recDays, avgInfections, initialInfections, worlds): if recDays and Pop and avgInfections and initialInfections: def runRegular(recDays, Pop, avgInfections, initialInfections): global fig, stringy # Number of people self-isolating selfIsolating = Pop # Number of people susceptible S_0 = Pop - initialInfections # Number of people infected
# simulate expensive query print('Computing value with {}'.format(value)) time.sleep(5) return df[df['category'] == value] def generate_figure(value, figure): fig = copy.deepcopy(figure) filtered_dataframe = global_store(value) fig['data'][0]['x'] = filtered_dataframe['x'] fig['data'][0]['y'] = filtered_dataframe['y'] fig['layout'] = {'margin': {'l': 20, 'r': 10, 'b': 20, 't': 10}} return fig @app.callback(Output('signal', 'children'), [Input('dropdown', 'value')]) def compute_value(value): # compute value and send a signal when done global_store(value) return value @app.callback(Output('graph-1', 'figure'), [Input('signal', 'children')]) def update_graph_1(value): # generate_figure gets data from `global_store`. # the data in `global_store` has already been computed # by the `compute_value` callback and the result is stored # in the global redis cached return generate_figure( value, { 'data': [{
# ] # ), html.Div(id='add-node-signal', children="", hidden=True), dcc.Location(id='url', refresh=False), ], fluid=True, className="m-0 p-0") @app.callback( [ Output("cytoscape-net", "layout"), Output("layout-algo-select", "label"), ], [ Input("layout-algo-select-circle", "n_clicks"), Input('layout-algo-select-random', "n_clicks"), Input('layout-algo-select-grid', "n_clicks"), Input('layout-algo-select-concentric', "n_clicks"), Input('layout-algo-select-breadthfirst', "n_clicks"), #Input('layout-algo-select-fcose',"n_clicks"), Input('layout-algo-select-cose', "n_clicks"), Input('layout-algo-select-cose-bilkent', "n_clicks"), Input('layout-algo-select-dagre', "n_clicks"), Input('layout-algo-select-cola', "n_clicks"), Input('layout-algo-select-klay', "n_clicks"), Input('layout-algo-select-spread', "n_clicks"), Input('layout-algo-select-euler', "n_clicks"), ], [State("cytoscape-net", "layout"), State("layout-algo-select", "label")])
n_clicks=0) ]), html.Div(children=[ html.H2(children=lang['wanna_know_more']), html.Button("", id='change-info', n_clicks=0), html.Div(id='div-info-pipotron', children="") ]) ]) ##################################################################### # CALLBACKS : @app.callback(Output('real-review', 'children'), [Input('change-real-review', 'n_clicks')]) def update_real_review(n_clicks): return S_pipotron_reviews.sample(1) @app.callback( Output('fake-review', 'children'), [Input('change-fake-review', 'n_clicks'), Input('color-choice', 'value')]) def update_fake_review(n_clicks, color): return get_fake_review(color) @app.callback([ Output('div-info-pipotron', 'children'), Output('change-info', 'children')
import dash import dash_core_components as dcc import dash_html_components as html from dash.dependencies import Input, Output import plotly.graph_objs as go import numpy as np import pandas as pd df = pd.read_csv('OldFaithful.csv') colors = {'background': '#111111', 'text': '#7FDBFF'} app = dash.Dash() app.layout = html.Div([ dcc.Input(id='my-id', value='Initial Text', type='text'), html.Div(id='my-div') ]) @app.callback(Output(component_id='my-div', component_property='children'), [Input(component_id='my-id', component_property='value')]) def update_output_div(input_value): return "You entered : {}".format(input_value) if __name__ == '__main__': app.run_server()
'value': 'Category' }, { 'label': 'Resolution', 'value': 'Resolution' }], value='Resolution', placeholder="Select by your choice", )), html.Div(html.Div(dcc.Graph(id='Sankey-with-dropdown'))) ]) ]) @app.callback( Output('histogram-with-slider', 'figure'), [Input('xaxis-column', 'value'), Input('DayOfWeek-slider', 'value')]) def update_figure(xaxis_column_name, selected_DayOfWeek): mapp = { 1: 'Monday', 2: 'Tuesday', 3: 'Wednesday', 4: 'Thursday', 5: 'Friday', 6: 'Saturday', 7: 'Sunday' } filtered_df = df[df.DayOfWeek == mapp[selected_DayOfWeek]] #crime_category = filtered_df['Descript'] fig = px.histogram(filtered_df, x=filtered_df[xaxis_column_name],
def register_flow_callbacks(app, cache): @app.callback( Output("flowplot", "figure"), [ Input("url", "pathname"), Input("metric", "value"), Input("tasktype", "value"), Input("parameter", "value"), ], ) @cache.memoize(timeout=TIMEOUT) def update_flow_plots(pathname, metric, tasktype, parameter): """ :param pathname: url path :param metric: dropdown to choose function/metric :param tasktype:drop down to choose task type :param parameter: dropdown to choose parameter :return: """ if pathname is not None and "/dashboard/flow" in pathname: flow_id = int(re.search(r"flow/(\d+)", pathname).group(1)) else: return [] # Get all tasks of selected task type task_type_enum = [ TaskType.SUPERVISED_CLASSIFICATION, TaskType.SUPERVISED_REGRESSION, TaskType.LEARNING_CURVE, TaskType.SUPERVISED_DATASTREAM_CLASSIFICATION, TaskType.SUPERVISED_DATASTREAM_CLASSIFICATION, TaskType.CLUSTERING, TaskType.MACHINE_LEARNING_CHALLENGE, TaskType.SURVIVAL_ANALYSIS, TaskType.SUBGROUP_DISCOVERY, ] task_types = [ "Supervised classification", "Supervised regression", "Learning curve", "Supervised data stream classification", "Clustering", "Machine Learning Challenge", "Survival Analysis", "Subgroup Discovery", ] t_list = tasks.list_tasks( task_type=task_type_enum[task_types.index(tasktype)]) task_id = [value["tid"] for key, value in t_list.items()] # Get all evaluations of selected metric and flow import time start = time.time() df = evaluations.list_evaluations_setups( function=metric, flows=[flow_id], size=1000, output_format="dataframe", sort_order="desc", ) end = time.time() print("list flow evals took ", end - start, " sec") if df.empty: return go.Figure() # Filter type of task df = df[df["task_id"].isin(task_id)] run_link = [] tick_text = [] # Set clickable labels for run_id in df["run_id"].values: link = '<a href="https://www.openml.org/r/' + str(run_id) + '/"> ' run_link.append(link) for data_id in df["data_id"].values: link = '<a href="https://www.openml.org/d/' + str(data_id) + '/">' tick_text.append(link) hover_text = [] if parameter == "None": color = [1] * len(df["data_name"]) hover_text = df["value"] marker = dict( opacity=0.8, symbol="diamond", color=color, # set color equal to a variable colorscale="Jet", ) else: color = [] for param_dict in df.parameters: values = [ value for key, value in param_dict.items() if parameter == key ] if not values: color.append("0") else: color.append(values[0]) hover_text.append(values[0]) if color[0].isdigit(): color = list(map(int, color)) else: color = pd.DataFrame(color)[0].astype("category").cat.codes marker = dict( opacity=0.8, symbol="diamond", color=color, # set color equal to a variable colorscale="Jet", colorbar=dict(title="Colorbar"), ) data = [ go.Scatter( x=df["value"], y=df["data_name"], mode="text+markers", text=run_link, hovertext=hover_text, hoverlabel=dict(bgcolor="white", bordercolor="black"), marker=marker, ) ] layout = go.Layout( hovermode="closest", title="Every point is a run, click for details <br>" "Every y label is a dataset, click for details <br>" "Top 1000 runs shown", font=dict(size=11), autosize=True, height=500 + 15 * df["data_name"].nunique(), xaxis=go.layout.XAxis(showgrid=False), yaxis=go.layout.YAxis( showgrid=True, ticktext=tick_text + df["data_name"], tickvals=df["data_name"], showticklabels=True, ), ) fig = go.Figure(data, layout) return fig
print("\n #17 ", list_of_radio_items_id,"\n"), #// itemx_state = State('radioitem_12_4','value'), #// print("\n #12 Printing state :\n", itemx_state) print("\n #22 START: Printing list_of_row_column_pair:"), print(list_of_row_column_pair), print("\n #22 END \n"), print("#29 END: Loading layout"), print("#35 Printing the latest dataframe [post_cleansing_df]..."), print(post_cleansing_df) ]) @app.callback( Output('output-container-button', 'children'), [Input('apply_btn', 'n_clicks')], callback_loop_radioitem_id() #// callback_loop(), ) def update_output(n_clicks, *radio_item_value_id): if n_clicks is None: raise PreventUpdate else: print("\n -> #3 update_output_div()\n \"Apply\" button has been pressed ") returnx = "" # Print Debug: print("#13 START printing value:") print(radio_item_value_id) print("#13 END \n")
def autoencoder(app, model, dataset, latent_options, paths, pre_process=None, prefix=""): prefix += '-ae-' header = dbc.Row([ html.Div(html.H5("Auto Encoder"), className="col-md-6"), dbc.Row([ html.Div("Model: ", className="col-4 text-right m-auto pr-0"), html.Div(dcc.Dropdown(id=prefix + 'selected-model', options=[{ "label": k, "value": v } for k, v in paths.items()], value=paths[next(iter(paths.keys()))], searchable=False), className="col-5 pl-0 "), html.Div(dbc.Button('reload', color="info", id=prefix + 'reload-model', className="col"), className="col-3 pl-0") ], className="col-md-6 tools") ]) input_div = dbc.Col( dbc.Card([ dbc.CardHeader([ "Input", dbc.Button('sample', color="info", id=prefix + 'sample-input', className="mr-1 float-right", n_clicks=0), ]), dbc.CardBody([ html.Div(children=[], id=prefix + 'input-content'), html.Span(children="", id=prefix + 'input-content-id', className='d-none'), ], className="d-flex justify-content-center"), ])) latent_size = latent_options['n'] latent_space = [] # just used to fill initial space in the html init_hidden_space = ",".join( [str(latent_options['min']) for _ in range(latent_size)]) for _ in range(latent_size): id = prefix + 'latent-slider-' + str(_) latent_space.append( dcc.Slider(min=latent_options['min'], max=latent_options['max'], step=latent_options['step'], updatemode='drag', id=id, value=latent_options['min'], className="mt-3 mb-3")) latent_div = dbc.Col( dbc.Card([ dbc.CardHeader("Latent Space"), html.Span(id=prefix + "hidden-latent-space", children=init_hidden_space, className='d-none'), dbc.CardBody( [html.Div(children=latent_space, id=prefix + 'output-latent')]), ])) output_div = dbc.Col( dbc.Card([ dbc.CardHeader("Output"), dbc.CardBody([ html.Div(children=[], id=prefix + 'output-content'), ], className="d-flex justify-content-center"), ])) @app.callback([ Output(component_id=prefix + 'input-content-id', component_property='children'), Output(component_id=prefix + 'input-content', component_property='children'), Output(component_id=prefix + "hidden-latent-space", component_property='children') ], [ Input(component_id=prefix + 'sample-input', component_property='n_clicks') ]) def sample_input(n_clicks): input_id = random.randint(0, len(dataset) - 1) # img, _ = dataset[input_id] img = dataset[input_id] # hx = model.encoder(img.view(-1)) hx = model.encode(Variable(torch.FloatTensor(img).unsqueeze(0))) hx = [ round(_, len(str(latent_options['step']).split('.')[-1])) for _ in hx[0].cpu().data.numpy().tolist() ] # pre-process to get PIL image if pre_process is not None: disp_img = pre_process(img) else: disp_img = img disp_img = _img_resize(disp_img) # convert to byte code image output = BytesIO() disp_img.save(output, format='PNG') output.seek(0) encoded_image = base64.b64encode(output.read()) html_img = html.Img( src='data:image/png;base64,{}'.format(str(encoded_image)[2:-1])) hx = ','.join([str(_) for _ in hx]) return str(input_id), html_img, hx for slider_id in range(latent_size): @app.callback( Output(component_id=prefix + 'latent-slider-' + str(slider_id), component_property="value"), [ Input(component_id=prefix + "hidden-latent-space", component_property='children') ], [ State(component_id=prefix + 'latent-slider-' + str(slider_id), component_property="id") ]) def set_latent_slider(latent_space, slider_id): slider_id = int(slider_id.split("-")[-1]) return float(latent_space.split(",")[slider_id]) @app.callback( Output(component_id=prefix + 'output-content', component_property='children'), [ Input(component_id=prefix + 'latent-slider-' + str(slider_id), component_property='value') for slider_id in range(latent_size) ]) def predicted_output(*latent_space): output = model.decode( Variable(torch.FloatTensor(latent_space).unsqueeze(0))) # pre-process to get numpy image if pre_process is not None: # img = pre_process(output.reshape(dataset[0].shape)) img = pre_process(output) img = _img_resize(img) # convert to img output = BytesIO() img.save(output, format='PNG') output.seek(0) encoded_image = base64.b64encode(output.read()) html_img = html.Img( src='data:image/png;base64,{}'.format(str(encoded_image)[2:-1])) return html_img @app.callback( Output(component_id=prefix + 'sample-input', component_property='n_clicks'), [ Input(component_id=prefix + 'selected-model', component_property='value'), Input(component_id=prefix + 'reload-model', component_property='n_clicks') ], [ State(component_id=prefix + 'sample-input', component_property='n_clicks') ]) def refresh_model(model_path, reload, n_clicks): model.load_state_dict(torch.load(model_path, map_location='cpu')) return int(n_clicks) + 1 ae_div = dbc.Card([ dbc.CardHeader(header), dbc.CardBody( dbc.Row([input_div, latent_div, output_div], className='m-2')) ], className="mt-4 mb-4 border-secondary autoencoder-box") return ae_div
autofill=True, margin=dict(t=75, r=50, b=100, l=50), ), ), ), ], ), ], ), ], ) @app.callback( Output("county-choropleth", "figure"), [Input("years-slider", "value")], [State("county-choropleth", "figure")], ) def display_map(year, figure): cm = dict(zip(BINS, DEFAULT_COLORSCALE)) data = [ dict( lat=df_lat_lon["Latitude "], lon=df_lat_lon["Longitude"], text=df_lat_lon["Hover"], type="scattermapbox", hoverinfo="text", marker=dict(size=5, color="white", opacity=0), ) ]
dbc.Collapse( dbc.Nav([search_bar], className="ml-auto", navbar=True), id="navbar-collapse", navbar=True, ), ], fluid=True, ), color="#2c6693", dark=True, ) @app.callback( Output("navbar-collapse", "is_open"), [Input("navbar-toggler", "n_clicks")], [State("navbar-collapse", "is_open")], ) def toggle_navbar_collapse(n, is_open): if n: return not is_open return is_open # the style arguments for the sidebar. We use position:fixed and a fixed width SIDEBAR_STYLE = { "position": "fixed", "top": 120, "left": 0, "bottom": 0, "width": "16rem",