def build_results_page(ticker_symbol, from_date, to_date): ticker_analysis = tsa.TimeSeriesAnalyzer(ticker_symbol, from_date, to_date) historical_prices = get_historic_prices_graph(ticker_analysis, ticker_symbol) stats = get_statistic_results(ticker_analysis) distplot_daily_returns = get_distplot_daily_returns(ticker_analysis) vol_price_evolution = get_vol_price_evolution(ticker_analysis) return [ dbc.Row( dbc.Col(dcc.Graph(id='historical_prices', figure=historical_prices), width=12)), dbc.Row([ dbc.Col([ dcc.Graph(id='distplot_daily_returns', figure=distplot_daily_returns), dcc.Graph(id='vol_price_evolution', figure=vol_price_evolution) ], width=8), dbc.Col([ html.H5('Estadísticos del análisis', style=statisticResultsTitles), html.Div(children=stats) ], width=3) ]) ]
def render_content(tab): if tab == "tab-1-example": return html.Div( [ html.H3("Tab content 1"), dcc.Graph( id="graph-1-tabs", figure={ "data": [{"x": [1, 2, 3], "y": [3, 1, 2], "type": "bar"}] }, ), ] ) elif tab == "tab-2-example": return html.Div( [ html.H3("Tab content 2"), dcc.Graph( id="graph-2-tabs", figure={ "data": [{"x": [1, 2, 3], "y": [5, 10, 6], "type": "bar"}] }, ), ] )
def update_output(value): if value == 'C': return dcc.Graph(id='case_fig', figure=case_fig) elif value == 'H': return dcc.Graph(id='hos_hos_ts_fig', figure=hos_hos_ts_fig) elif value == 'D': return dcc.Graph(id='death_fig', figure=death_fig)
def _add_plotting_col(self) -> dbc.Col: """Add column with plots and tables. It is placed on the right side. """ return dbc.Col( id="col-plotting-area", children=[ dbc.Row( # Passed / failed tests id="row-graph-passed", class_name="g-0 p-2", children=[ dcc.Loading(children=[ dcc.Graph(id="graph-passed", figure=self._default_fig_passed) ]) ]), dbc.Row( # Duration id="row-graph-duration", class_name="g-0 p-2", children=[ dcc.Loading(children=[ dcc.Graph(id="graph-duration", figure=self._default_fig_duration) ]) ]), dbc.Row( class_name="g-0 p-2", align="center", justify="start", children=[ dbc.Col( # Download width=2, children=[ dcc.Loading(children=[ dbc.Button(id="btn-download-data", children=self._show_tooltip( "help-download", "Download Data"), class_name="me-1", color="info"), dcc.Download(id="download-data") ]), ]), dbc.Col( # Show URL width=10, children=[ dbc.Card(id="card-url", body=True, class_name="gy-2 p-0", children=[]), ]) ]) ], width=9, )
def UpdateGraph(lap_ids: List[int], point_values: List[Text]) -> List[dcc.Graph]: if not isinstance(point_values, list): point_values = [point_values] if lap_ids: graphs = [] laps_data = queries.GetLapsData(lap_ids, point_values) for point_value in point_values: figure_data = laps_data title = point_value # Copied so that time_delta can redefine without breaking other graphs. if point_value == 'time_delta': figure_data = laps_data.copy() if point_value == 'racing_line': graph_type = 'map' fig = px.line_geo( laps_data, title=title, lat='lat', lon='lon', color='lap_id', fitbounds='locations', ) else: if point_value == 'time_delta': if len(lap_ids) < 2: continue # Need at least two laps to make a comparison. figure_data = queries.GetTimeDelta(lap_ids) title = 'time_delta vs first selected lap (lap_id: %s)' % lap_ids[ 0] graph_type = 'graph' fig = px.line(figure_data, title=title, x='elapsed_distance_m', y=point_value, color='lap_id', hover_data=['lap_id', 'lap_number', point_value]) fig.update_xaxes(showspikes=True) fig.update_yaxes(fixedrange=True) fig.update_layout(hovermode='x unified') graph = dcc.Graph( { 'type': graph_type, 'index': point_values.index(point_value) }, figure=fig, style={ 'display': 'inline-grid', 'width': '50%' }) graphs.append(graph) return graphs # Empty line when no rows have been selected. return [dcc.Graph(figure=px.line())]
def get_layout(**kwargs): return html.Div([ dcc.Markdown( dedent(""" # Research Analysis """)), dcc.Dropdown(id="app-option", options=[{ 'label': i, 'value': i } for i in get_app_options()], value=get_app_options()[0]), dcc.Dropdown(id="balance-option", options=[{ 'label': i, 'value': i } for i in get_balancing_options()], value="Combined"), dcc.Loading(id="loading-icon", type="circle", children=[ html.Div( children=[dcc.Graph(id="latency_vs_price")], style={'margin': 'auto'}, ), ]), dcc.Loading(id="loading-icon", type="circle", children=[ html.Div(dcc.Graph(id="price_cdf_koss_weights")), ]), dcc.Loading(id="loading-icon", type="circle", children=[ html.Div(dcc.Graph(id="price_cdf_algo_comparison")), ]), dcc.Loading(id="loading-icon", type="circle", children=[ html.Div(dcc.Graph(id="latency_cdf_koss_weights")), ]), dcc.Loading(id="loading-icon", type="circle", children=[ html.Div(dcc.Graph(id="latency_cdf_algo_comparison")), ]), # dcc.Loading( # id = "loading-icon", # type="circle", # children=[html.Div(dcc.Graph(id="latecy-to-price-graph"))] # ), ])
def render_tab_content(active_tab, data): """ This callback takes the 'active_tab' property as input, as well as the stored graphs, and renders the tab content depending on what the value of 'active_tab' is. """ if active_tab and data is not None: if active_tab == "scatter": return dcc.Graph(figure=data["scatter"]) elif active_tab == "histogram": return dbc.Row([ dbc.Col(dcc.Graph(figure=data["hist_1"]), width=6), dbc.Col(dcc.Graph(figure=data["hist_2"]), width=6), ]) return "No tab selected"
def test_grbs001_graph_without_ids(dash_dcc, is_eager): app = Dash(__name__, eager_loading=is_eager) app.layout = html.Div([ dcc.Graph(className="graph-no-id-1"), dcc.Graph(className="graph-no-id-2") ]) dash_dcc.start_server(app) assert not dash_dcc.wait_for_element(".graph-no-id-1").get_attribute( "id"), "the graph should contain no more auto-generated id" assert not dash_dcc.wait_for_element(".graph-no-id-2").get_attribute( "id"), "the graph should contain no more auto-generated id" assert dash_dcc.get_logs() == []
def test_grbs004_graph_loading_state_updates(dash_dcc): lock = Lock() app = Dash(__name__, suppress_callback_exceptions=True) app.layout = html.Div( [ html.H1(id="title", children="loading state updates"), dcc.Graph(id="my-graph"), ] ) @app.callback(Output("my-graph", "figure"), [Input("title", "n_clicks")]) def update_graph(n_clicks): values = [0, n_clicks] ranges = [0, n_clicks] with lock: return { "data": [{"x": ranges, "y": values, "line": {"shape": "spline"}}], } dash_dcc.start_server(app) dash_dcc.wait_for_element("#my-graph:not([data-dash-is-loading])") with lock: title = dash_dcc.wait_for_element("#title") title.click() dash_dcc.wait_for_element('#my-graph[data-dash-is-loading="true"]') dash_dcc.wait_for_element("#my-graph:not([data-dash-is-loading])") assert dash_dcc.get_logs() == []
def updateDismissalMethods(table_data, player, season, match_type, discipline, inter_tav_type): if discipline != "Batting": return None if not player: return None df_batting = pd.DataFrame(table_data)#getBattingDataframe() player_name = df_batting.iloc[player[0]]["name"]#df_batting[df_batting['name'] == player] df_batting = getBattingDataframe() df_player = getBattingPlayer(df_batting, player_name, inter_tav_type, season, match_type) if df_player.empty: return None counter=collections.Counter(df_player['dismissal'].tolist()) most_common = counter.most_common(6) mods = [] weights = [] for mod in most_common: mods.append(mod[0]) weights.append(mod[1]) return dcc.Graph(figure=getBarChart(mods,weights,bg_colour=True), config={'displayModeBar': False}, id='bat-m-graph')
def updateBowlingDismissalMethods(table_data, player, season, match_type, discipline, inter_tav_type): if discipline != "Bowling": return None if not player: return None df_bowling = pd.DataFrame(table_data) player_name = df_bowling.iloc[player[0]]["name"] df_bowling = getBowlingDataframe() df_player = getBowlingPlayer(df_bowling, player_name, inter_tav_type, season, match_type) if df_player.empty: return None dis_types_df = df_player['dismissal_types'].dropna() #print (dis_types) mod_list = [item for sublist in dis_types_df.tolist() for item in sublist] counter=collections.Counter(mod_list) most_common = counter.most_common(6) mods = [] weights = [] for mod in most_common: mods.append(mod[0]) weights.append(mod[1]) return dcc.Graph(figure=getBarChart(mods,weights,bg_colour=True), config={'displayModeBar': False}, id='bowl-m-graph')
def test_grva003_empty_graph(dash_dcc, is_eager): app = Dash(__name__, eager_loading=is_eager) app.layout = html.Div([ html.Button(id="click", children="Click me"), dcc.Graph( id="graph", figure={"data": [dict(x=[1, 2, 3], y=[1, 2, 3], type="scatter")]}, ), ]) @app.callback( Output("graph", "figure"), [Input("click", "n_clicks")], [State("graph", "figure")], ) def render_content(click, prev_graph): if click: return {} return prev_graph dash_dcc.start_server(app) button = dash_dcc.wait_for_element("#click") button.click() time.sleep(2) # Wait for graph to re-render dash_dcc.percy_snapshot( "render-empty-graph ({})".format("eager" if is_eager else "lazy")) assert dash_dcc.get_logs() == []
def line_plot_multiIndex(df: DataFrame) -> dcc.Graph: """ Returns a line plot for a dataframe with a MultiIndex. It is assumed that the first-level index is the real index, and that data should be grouped using the second-level one. Parameters ---------- df : DataFrame Dataframe to plot. It is a multiIndex dataframe. Returns ------- g : dcc.Graph """ fig = go.Figure() for region in df.index.get_level_values(1).unique(): fig.add_trace( go.Scatter(x=df.index.get_level_values(0).unique(), y=df.loc[(df.index.get_level_values(1) == region), df.columns[0]], name=region)) fig.update_layout(title=_('Line plot'), xaxis_title=df.index.get_level_values(0).name, yaxis_title=df.columns[0]) g = dcc.Graph(figure=fig) return g
def generate_funding_chart_progress(funding_data): data = json.loads(funding_data)['plans_funding'] if len(data['plans']) == 0: return '' trace1 = go.Bar(y=data['total_funded'], x=data['plans'], text=data['percentages'], marker=dict(color='rgb(49,130,189)', line=dict(color='rgb(8,48,107)', width=1.5)), opacity=1, name='Total Funded') trace2 = go.Bar(y=data['required'], x=data['plans'], marker=dict(color='#92a8d1', line=dict(color='rgb(8,48,107)', width=1.5)), opacity=0.25, name='Total Required') return dcc.Graph( id='chart-progress', figure={ 'data': [trace1, trace2], 'layout': go.Layout( barmode='overlay', title= 'Funding progress for the country\'s emergency plans (Nutrition)' ) })
def cell_clicked(active_cell): if active_cell is None: return no_update row = active_cell["row_id"] print(f"row id: {row}") country = df.at[row, "country"] print(country) col = active_cell["column_id"] print(f"column id: {col}") print("---------------------") y = col if col in ["pop", "gdpPercap"] else "lifeExp" fig = px.line(df[df["country"] == country], x="year", y=y, title=" ".join([country, y])) fig.update_layout(title={"font_size": 20}, title_x=0.5, margin=dict(t=190, r=15, l=5, b=5)) fig.update_traces(line=dict(color=color[y])) return dcc.Graph(figure=fig)
def get_app2(): app = dash.Dash(__name__) app.layout = html.Div([ html.Button("i=20", id="button", n_clicks=0), DataTable( id="table", page_size=5, columns=[{ "name": "i", "id": "i" }, { "name": "square", "id": "square" }], data=[{ "i": i, "square": i**2 } for i in range(50 + 1)], page_current=5, ), dcc.Graph(), ]) @app.callback(Output("table", "data"), Input("button", "n_clicks")) def update_table_data(n): return ([{ "i": i, "square": i**2 } for i in range(20 + 1)] if n > 0 else dash.no_update) return app
def test_dvui002_disable_ui_config(dash_duo): app = Dash(__name__) app.layout = html.Div( [ html.P(id="tcid", children="Hello Disable UI"), dcc.Graph(id="broken", animate=3), # error ignored by disable ] ) dash_duo.start_server( app, debug=True, use_reloader=False, use_debugger=True, dev_tools_hot_reload=False, dev_tools_ui=False, ) dash_duo.wait_for_text_to_equal("#tcid", "Hello Disable UI") logs = str(wait.until(dash_duo.get_logs, timeout=1)) assert ( "Invalid argument `animate` passed into Graph" in logs ), "the error should present in the console without DEV tools UI" assert not dash_duo.find_elements( ".dash-debug-menu" ), "the debug menu icon should NOT show up" dash_duo.percy_snapshot("devtools - disable dev tools UI - no debug menu")
def test_grva011_without_mathjax(dash_dcc, is_eager): app = Dash(__name__, eager_loading=is_eager, assets_folder="../../assets") app.layout = html.Div([ dcc.Graph( id="output", figure={ "data": [{ "y": [3, 1, 2] }], "layout": { "title": { "text": "Apple: $2, Orange: $3" } }, }, ) ]) dash_dcc.start_server(app) assert dash_dcc.wait_for_element(".gtitle").text == "Apple: $2, Orange: $3" assert not dash_dcc.driver.execute_script("return !!window.MathJax") assert dash_dcc.get_logs() == []
def update_fig(data, column_option, figure_option): if column_option == "Term": _df = pd.DataFrame(data).groupby(column_option).agg( {"Enrolled": "sum"}) str_title = "Enrollment per {:s}".format(column_option) else: _df = pd.DataFrame(data).groupby(column_option).agg( {"Enrolled": "mean"}) str_title = "Average Enrollment per {:s}".format(column_option) if figure_option == 'line': fig = (px.line( _df, y=["Enrolled"], title=str_title, ).update_xaxes(showticklabels=True).update_yaxes( rangemode="tozero").update_layout( showlegend=False, xaxis_type="category", yaxis_title="Enrolled", barmode="overlay", )) else: fig = (px.bar( _df, y=["Enrolled"], title=str_title, ).update_xaxes(showticklabels=True).update_layout( showlegend=False, xaxis_type="category", yaxis_title="Enrolled", barmode="overlay", )) return [dcc.Graph(figure=fig)]
def test_grva012_with_mathjax(dash_dcc, is_eager): app = Dash(__name__, eager_loading=is_eager, assets_folder="../../assets") app.layout = html.Div([ dcc.Graph( mathjax=True, id="output", figure={ "data": [{ "y": [3, 1, 2] }], "layout": { "title": { "text": "Equation: $E=mc^2$" } }, }, ) ]) dash_dcc.start_server(app) dash_dcc.wait_for_element(".gtitle-math") assert dash_dcc.driver.execute_script("return !!window.MathJax") assert dash_dcc.get_logs() == []
def test_dvui001_disable_props_check_config(dash_duo): app = Dash(__name__) app.layout = html.Div( [ html.P(id="tcid", children="Hello Props Check"), dcc.Graph(id="broken", animate=3), # error ignored by disable ] ) dash_duo.start_server( app, debug=True, use_reloader=False, use_debugger=True, dev_tools_hot_reload=False, dev_tools_props_check=False, ) dash_duo.wait_for_text_to_equal("#tcid", "Hello Props Check") assert dash_duo.find_elements("#broken svg.main-svg"), "graph should be rendered" # open the debug menu so we see the "hot reload off" indicator dash_duo.find_element(".dash-debug-menu").click() sleep(1) # wait for debug menu opening animation dash_duo.percy_snapshot("devtools - disable props check - Graph should render")
def forecast(n, n_days, val): if n == None: return [""] if val == None: raise PreventUpdate fig = prediction(val, int(n_days) + 1) return [dcc.Graph(figure=fig)]
def get_regional_emissions_comparison(): return html.Div( dbc.Col( [ html.Br(), html.Br(), html.H2( [ "Emissions Across Regions in ", html.Strong( id="country_name", style={ "fontWeight": "normal", "color": "green" }, ), ], style={ "textAlign": "center", "marginLeft": "12%" }, ), dcc.Graph(id="regional_emissions_comparison_choropleth"), ], id="regional_emissions_comparison_component", ), style={"marginLeft": "-12%"}, )
def display_selected_drive_charts(value): filtered_df = auto_data[auto_data['drive-wheels']==value].groupby(['drive-wheels','body-style'],as_index=False). \ mean() filtered_df = filtered_df fig1 = px.pie(filtered_df, values='price', names='body-style', title="Pie Chart") fig2 = px.bar(filtered_df, x='body-style', y='price', title='Bar Chart') return [dcc.Graph(figure=fig1), dcc.Graph(figure=fig2)]
def update_graph(figure): if figure is None: raise PreventUpdate elif figure == "error": search_error = (MessageContainer( [ MessageBody( dcc.Markdown( "Plotting is only available for phase diagrams containing 2-4 components." )) ], kind="warning", ), ) return search_error else: plot = [ dcc.Graph( figure=figure, config={ "displayModeBar": False, "displaylogo": False }, ) ] return plot
def test_dveh003_validation_errors_in_place(dash_duo): app = Dash(__name__) app.layout = html.Div([ html.Button(id="button", children="update-graph", n_clicks=0), dcc.Graph(id="output", figure={"data": [{ "y": [3, 1, 2] }]}), ]) # animate is a bool property @app.callback(Output("output", "animate"), [Input("button", "n_clicks")]) def update_output(n_clicks): if n_clicks == 1: return n_clicks dash_duo.start_server( app, debug=True, use_reloader=False, use_debugger=True, dev_tools_hot_reload=False, ) dash_duo.wait_for_element(".js-plotly-plot .main-svg") dash_duo.find_element("#button").click() dash_duo.wait_for_text_to_equal(dash_duo.devtools_error_count_locator, "1") dash_duo.percy_snapshot("devtools - validation exception - closed") dash_duo.find_element(".test-devtools-error-toggle").click() dash_duo.percy_snapshot("devtools - validation exception - open")
def get_funding_chart_by_orga(iso_code, organization): data = fts_api.get_country_funding_for_organization(iso_code, organization) if len(data['funding_source']) == 0: return '' labels = [] values = [] for orga in data['funding_source']: labels.append(orga['name']) values.append(orga['totalFunding']) trace = go.Pie(labels=labels, values=values, hole=0.4, hoverinfo='label+value', showlegend=False, textinfo='percent', marker=dict(line=dict(color='#000000', width=2))) return dcc.Graph( id=organization + '-chart-progress', figure={ 'data': [trace], 'layout': go.Layout(title='Who is funding {0} (for Nutrition)'.format( organization.upper())) })
def update_output(n_clicks): if n_clicks == 1: return dcc.Graph(id="output", animate=0, figure={"data": [{ "y": [3, 1, 2] }]})
def plot(test_passed, show_opt, jsonified_data, y_type, x_type, plot_scale, prev_show_opt): if test_passed is True: # Load and shape the data df_x, df_y, to_plot_list, x_tag, y_label = shape_reso_df_to_output( x_type=x_type, y_type=y_type, show_opt=show_opt, jsonified_data=jsonified_data, prev_show_opt=prev_show_opt, to_csv=False) df_to_plot = df_y[to_plot_list] df_to_plot.insert(loc=0, column=x_tag, value=df_x[x_tag]) jsonized_plot_df = df_to_plot.to_json(orient='split', date_format='iso') # Plot in matplotlib fig = plt.figure() ax1 = fig.add_subplot(111) try: ax1 = df_to_plot.set_index(keys=x_tag).plot(legend=False, ax=ax1) except TypeError: pass ax1.set_ylabel(y_label) # Convert to plotly and format layout plotly_fig = shape_matplot_to_plotly(fig=fig, y_type=y_type, plot_scale=plot_scale) return html.Div([ dcc.Graph(figure=plotly_fig, id=app_id_dict['plot_fig_id']) ]), [json.dumps(jsonized_plot_df)] else: return plot_loading, [None]
def line_plot(df: DataFrame) -> dcc.Graph: """ Create and return the line plot for a dataframe. Parameters ---------- df : DataFrame Dataframe to plot. Returns ------- g : dcc.Graph Dash object containing the line plot. Examples -------- Get the `figure` attribute if you want to display this in a Jupyter notebook. >>> line_plot = line_plot(timeseries_container.timeseries_data).figure >>> line_plot.show() """ fig = go.Figure( data=go.Scatter(x=df.index, y=df.iloc[:, 0], mode='lines+markers')) fig.update_layout(title=_('Line plot'), xaxis_title=df.index.name, yaxis_title=df.columns[0]) g = dcc.Graph(figure=fig) return g