def main_function(self, mode): external_stylesheets = [ 'https://raw.githubusercontent.com/rab657/explainx/master/explainx.css', dbc.themes.BOOTSTRAP, { 'href': 'https://fonts.googleapis.com/css?family=Montserrat', 'rel': 'stylesheet' } ] local = JupyterDash(__name__, external_stylesheets=external_stylesheets, suppress_callback_exceptions=True) local.title = "explainX.ai - Feature Interaction" local.layout = feature_interaction.layout_interaction( self.data, self.df_with_shap, local) if mode == None: import random port = random.randint(5000, 6000) return local.run_server(port=port) else: import random port = random.randint(5000, 6000) return local.run_server(mode='inline', port=port)
def main_function(self, mode): external_stylesheets = [ 'https://raw.githubusercontent.com/rab657/explainx/master/explainx.css', dbc.themes.BOOTSTRAP, { 'href': 'https://fonts.googleapis.com/css?family=Montserrat', 'rel': 'stylesheet' } ] local = JupyterDash(__name__, external_stylesheets=external_stylesheets, suppress_callback_exceptions=True) local.title = "explainX.ai - Local Level Explanation" local.layout = local_explanation.layout_local(self.shapley_values, self.data, self.df_with_shap, local) debug_value = False if mode is None: import random port = random.randint(6000, 7000) return local.run_server(port=port, debug=debug_value, dev_tools_ui=debug_value, dev_tools_props_check=debug_value, dev_tools_silence_routes_logging=True, dev_tools_hot_reload=True) else: import random port = random.randint(6000, 7000) return local.run_server(mode='inline', port=port, debug=debug_value, dev_tools_ui=debug_value, dev_tools_props_check=debug_value, dev_tools_silence_routes_logging=True, dev_tools_hot_reload=True)
def main_function(self, mode): external_stylesheets = [ 'https://raw.githubusercontent.com/rab657/explainx/master/explainx.css', dbc.themes.BOOTSTRAP, { 'href': 'https://fonts.googleapis.com/css?family=Montserrat', 'rel': 'stylesheet' } ] cohort = JupyterDash(__name__, external_stylesheets=external_stylesheets, suppress_callback_exceptions=True) cohort.title = "explainX.ai - Model Performance Analysis" cohort.layout = cohort_app.test_func(self.data, self.model, cohort) debug_value = False if mode == None: import random port = random.randint(4000, 5000) return cohort.run_server(port=port, debug=debug_value, dev_tools_ui=debug_value, dev_tools_props_check=debug_value, dev_tools_silence_routes_logging=True, dev_tools_hot_reload=True) else: import random port = random.randint(4000, 5000) return cohort.run_server(mode='inline', port=port, debug=debug_value, dev_tools_ui=debug_value, dev_tools_props_check=debug_value, dev_tools_silence_routes_logging=True, dev_tools_hot_reload=True)
def run_app(df): app = JupyterDash(__name__, external_stylesheets=external_stylesheets,suppress_callback_exceptions=True) app.config.suppress_callback_exceptions = True app.layout = html.Div([ dcc.Location(id = 'url', refresh = False), html.Div(id = 'page-content')]) try: @app.callback(Output('page-content', 'children'),[Input('url', 'pathname')]) def display_page(pathname): if pathname == '/plot': return App(df) elif pathname == '/data-exploration': return dataexploration(df) else: return Homepage(df) @app.callback(Output('hist_plot','children'),[Input('hist_col_dropdown','value'),Input('theme_dropdown','value')]) def update_data_distribution(col_list,theme): children = plot_distributions(df,col_list,theme) return children @app.callback([Output('corr','children'),Output('heatmap','style'),Output('heatmap-figure','children')], [Input('col1','value'),Input('col2','value'),Input('asso_type','value'),Input('show-more','n_clicks')]) def update_association(col1,col2,asso_type,n): heat_map_style={'display':'none'} heat_map_child=[] try: corr_child=association(df,asso_type,col1,col2) except (TypeError): corr_child=[html.P('Please select numeric columns', style={'color':'red'})] if n is not None: if n%2==1: heat_map_style=_params() if asso_type=='Predictive Power Score': pps_fig = go.Figure(data=go.Heatmap(z=get_pps_array(df), x=df.columns,y=df.columns)) pps_fig.update_layout(title='Heat Map for Predicted Power Score') heat_map_child=[dcc.Graph(figure=pps_fig)] if asso_type=='Correlation': corr_arr=get_corr_array(df) corr_fig=go.Figure(data=go.Heatmap(z=corr_arr, x=corr_arr.index,y=corr_arr.columns)) corr_fig.update_layout(title='Heat Map for Correlation') heat_map_child=[dcc.Graph(figure=corr_fig)] return corr_child,heat_map_style,heat_map_child @app.callback([Output('output_plots','children'),Output('add-parameter-drop','options'),Output('color_div','style'), Output('facet_col_div','style'),Output('margin_x_div','style'),Output('margin_y_div','style'),Output('trendline_div','style'), Output('size_div','style'),Output('animation_div','style'),Output('opacity_div','style'),Output('barmode_div','style'), Output('boxmode_div','style'),Output('q_div','style'),Output('points_div','style')], [Input('charttype','value'), Input('xaxis','value'), Input('yaxis','value'), Input('theme_dropdown','value'), Input('add-parameter-drop','value'),Input('color','value'),Input('facet_col','value'),Input('margin-x','value'), Input('margin-y','value'),Input('trendline','value'),Input('size','value'),Input('animation','value'),Input('opacity','value'), Input('barmode','value'), Input('boxmode','value'),Input('q','value'),Input('points','value')]) def update_plots(chart_type,x,y,theme,added_params,color,facet_col,margin_x,margin_y,trendline,size,animation,opacity,barmode,boxmode,q,points): color_style = {'display': 'none'} facet_col_style = {'display': 'none'} margin_x_style = {'display': 'none'} margin_y_style = {'display': 'none'} trendline_style={'display':'none'} size_style = {'display':'none'} animation_style = {'display':'none'} opacity_style={'display': 'none'} barmode_style = {'display': 'none'} boxmode_style = {'display': 'none'} q_style={'display': 'none'} points_style={'display': 'none'} facet_col_val,color_val, margin_x_val,margin_y_val,trendline_val,size_val,animation_val,opacity_val,barmode_val,boxmode_val,q_val,points_val,notched_val=None,None,None,None,None,None,None,1,'relative','group','linear','outliers',False box_val=False log_x = False log_y = False for param in added_params: if param == 'log_x': log_x=True if param=='log_y': log_y=True if param=='color': color_style = _params() color_val=color if param=='facet_col': facet_col_style = _params() facet_col_val=facet_col if param == 'marginal_x': margin_x_style= _params() margin_x_val = margin_x if param == 'marginal_y': margin_y_style=_params() margin_y_val=margin_y if param=='trendline': trendline_style=_params() trendline_val=trendline if param=='size': size_style = _params() size_val=size if param == 'animation_frame': animation_style=_params() animation_val = animation if param == 'opacity': opacity_style=_params() opacity_val=opacity if param == 'barmode': barmode_style=_params() barmode_val=barmode if param == 'mode': boxmode_style=_params() boxmode_val=boxmode if param == 'quartilemethod': q_style=_params() q_val=q if param == 'points': points_style=_params() points_val=points if param == 'notched': notched_val=True if param == 'box': box_val=True options = add_parameters(chart_type) plot_children = plot_graph(plot_type=chart_type,df=df,x=x,y=y,theme=theme,color=color_val,facet_col=facet_col_val, marginal_x=margin_x_val,marginal_y=margin_y_val,trendline=trendline_val,log_x=log_x,log_y=log_y,size=size_val, animation_frame =animation_val,opacity=opacity_val,barmode=barmode_val,boxmode=boxmode_val, quartilemethod=q_val,points=points_val,notched=notched_val,box=box_val) return plot_children, options, color_style, facet_col_style , margin_x_style, margin_y_style, trendline_style , size_style ,animation_style, opacity_style, barmode_style, boxmode_style,q_style,points_style app.run_server(mode='inline',width=WIDTH,port=12345) except: app.run_server(mode='inline',width=WIDTH,port=12345)
# REVIEW6: Return dcc.Graph component to the empty division return [dcc.Graph(figure=tree_fig), dcc.Graph(figure=pie_fig), dcc.Graph(figure=map_fig), dcc.Graph(figure=bar_fig), dcc.Graph(figure=line_fig) ] else: # REVIEW7: This covers chart type 2 and we have completed this exercise under Flight Delay Time Statistics Dashboard section # Compute required information for creating graph from the data avg_car, avg_weather, avg_NAS, avg_sec, avg_late = compute_data_choice_2(df) # Create graph carrier_fig = px.line(avg_car, x='Month', y='CarrierDelay', color='Reporting_Airline', title='Average carrrier delay time (minutes) by airline') weather_fig = px.line(avg_weather, x='Month', y='WeatherDelay', color='Reporting_Airline', title='Average weather delay time (minutes) by airline') nas_fig = px.line(avg_NAS, x='Month', y='NASDelay', color='Reporting_Airline', title='Average NAS delay time (minutes) by airline') sec_fig = px.line(avg_sec, x='Month', y='SecurityDelay', color='Reporting_Airline', title='Average security delay time (minutes) by airline') late_fig = px.line(avg_late, x='Month', y='LateAircraftDelay', color='Reporting_Airline', title='Average late aircraft delay time (minutes) by airline') return[dcc.Graph(figure=carrier_fig), dcc.Graph(figure=weather_fig), dcc.Graph(figure=nas_fig), dcc.Graph(figure=sec_fig), dcc.Graph(figure=late_fig)] # Run the app if __name__ == '__main__': # REVIEW8: Adding dev_tools_ui=False, dev_tools_props_check=False can prevent error appearing before calling callback function app.run_server(mode="inline", host="localhost", debug=False, dev_tools_ui=False, dev_tools_props_check=False)
html.Hr(), content_row ], style=CONTENT_STYLE) app = JupyterDash(external_stylesheets=[dbc.themes.BOOTSTRAP]) app.layout = html.Div([sidebar, content]) @app.callback(Output( component_id='bee_data_table', component_property='data'), [ Input(component_id='submit_button', component_property='n_clicks'), State(component_id='state_dropdown', component_property='value'), State(component_id='range_slider', component_property='value') ]) def update_dash_table(n_clicks, state, date_range): dash_table_data = (grouped_df.loc[grouped_df["State"] == state].loc[ grouped_df["Year"] >= date_range[0]].loc[ grouped_df["Year"] <= date_range[1]].to_dict('records')) return dash_table_data @app.callback( dash.dependencies.Output('output-container-range-slider', 'children'), [dash.dependencies.Input('range_slider', 'value')]) def update_slideroutput(value): return 'You have selected {} to {} inclusive'.format(value[0], value[1]) if __name__ == '__main__': app.run_server()
def show_task(jeditaskid, verbose=False, mode='inline'): # get task task = queryPandaMonUtils.query_tasks(23518002, verbose=False)[-1][0] # get tasks of the user tasks = queryPandaMonUtils.query_tasks(username=task['username'], verbose=False)[-1] tids = set([x['jeditaskid'] for x in tasks]) tids.add(jeditaskid) # Build App app = JupyterDash(__name__) app.layout = html.Div([ html.Div([ html.H2("TaskID: "), dcc.Dropdown( id='dropdown_taskid', options=[{'label': i, 'value': i} for i in tids], value=jeditaskid ),], style={'display': 'inline-block', 'width': '20%'} ), html.Div([ html.Div([ html.H2('Task Attributes'), dash_table.DataTable(id='00_table', columns=[{'id': 'attribute', 'name': 'attribute'}, {'id': 'value', 'name': 'value'}], page_action='none', style_table={'height': '330px', 'overflowY': 'auto'}, style_cell_conditional=[ { 'if': {'column_id': 'value'}, 'textAlign': 'left' }, ]),], style={'display': 'inline-block', 'width': '49%', 'float': 'left', 'padding-top': '30px'} ), html.Div([ dcc.Graph(id='01_graph'),], style={'display': 'inline-block', 'width': '49%'} ), ],), html.Div([ html.Div([ dcc.Graph(id='10_graph')], style={'display': 'inline-block', 'width': '49%'}), html.Div([ dcc.Graph(id='11_graph')], style={'display': 'inline-block', 'width': '49%'}) ],), ]) # Run app and display result inline in the notebook app.run_server(mode=mode) @app.callback( Output('00_table', 'data'), Output('01_graph', 'figure'), Output('10_graph', 'figure'), Output('11_graph', 'figure'), Input('dropdown_taskid', "value") ) def make_elements(jeditaskid): verbose = False task = queryPandaMonUtils.query_tasks(jeditaskid, verbose=verbose)[-1][0] jobs = queryPandaMonUtils.query_jobs(jeditaskid, drop=False, verbose=verbose)[-1]['jobs'] jobs = pd.DataFrame(jobs) # task data task_data = [{'attribute': k, 'value': task[k]} for k in task if isinstance(task[k], (str, type(None)))] # figures site_fig = px.histogram(jobs, x="computingsite", color="jobstatus") ram_fig = px.histogram(jobs, x="maxrss") exectime_fig = go.Figure() legend_set = set() for d in jobs.itertuples(index=False): if d.jobstatus == 'finished': t_color = 'green' elif d.jobstatus == 'failed': t_color = 'red' else: t_color = 'orange' if d.jobstatus not in legend_set: show_legend = True legend_set.add(d.jobstatus) exectime_fig.add_trace( go.Scatter( x=[d.creationtime, d.creationtime], y=[d.pandaid, d.pandaid], mode="lines", line=go.scatter.Line(color=t_color), showlegend=True, legendgroup=d.jobstatus, name=d.jobstatus, hoverinfo='skip' ) ) exectime_fig.add_trace( go.Scatter( x=[d.creationtime, d.endtime], y=[d.pandaid, d.pandaid], mode="lines", line=go.scatter.Line(color=t_color), showlegend=False, legendgroup=d.jobstatus, name="", hovertemplate="PandaID: %{y:d}") ) exectime_fig.update_xaxes(range=[jobs['creationtime'].min(), jobs['endtime'].max()], title_text='Job Lifetime') exectime_fig.update_yaxes(range=[jobs['pandaid'].min() * 0.999, jobs['pandaid'].max() * 1.001], title_text='PandaID') return task_data, site_fig, ram_fig, exectime_fig
df_new = df2.loc[df2['loc'] == col][[ 'date', 'temperature' ]].set_index('date', drop=True).rename(columns={'temperature': col}) df3 = df_new.copy() #df3 = df3.cumsum()#.tail(1000) fig = df3.plot(template='plotly_dark') #fig.show() colors = px.colors.qualitative.Plotly for i, col in enumerate(df3.columns): fig.add_annotation(x=df3.index[-1], y=df3[col].iloc[-1], text=str(df3[col].iloc[-1])[:4], align="right", arrowcolor='rgba(0,0,0,0)', ax=25, ay=0, yanchor='middle', font=dict(color=colors[i])) return (fig) app.run_server( mode='external', host='0.0.0.0', port=8069, dev_tools_ui=True, #debug=True, dev_tools_hot_reload=True, threaded=True)
def DashBoard(self, pos): #creating web app name app = JupyterDash(__name__) #colors and style colors = {'background': "darkslategrey", 'text': "cyan"} style = {'textAlign': 'right', 'color': "cyan"} app.layout = html.Div( style={'backgroundColor': colors['background']}, children=[ html.H1( children="Backtesting Forex Strategy", #header style={ 'textAlign': 'center', 'color': colors['text'] }), html.Div([ #division for plotting html.Label(['Forex strategy type'], style=style), dcc.Dropdown( # dropdown method id='my_dropdown', options=[ { 'label': 'Long only', 'value': 'P&L_Buy' }, #dropdown labels { 'label': 'Short only', 'value': 'P&L_Sell' }, { 'label': 'Long-Short', 'value': 'P&L' }, ], value='P&L', multi=False, clearable=False, style={"width": "50%"}), ]), html.Div([ html.Label( ["Strategy Report"], #label for the each division style=style), html.Label(["P&L for the strategy"], style=style), dcc.Graph(id='the_graph') ]), #we plot here by taking the id of that plot ]) @app.callback( #callback function for chnage in input of dropdown Output(component_id='the_graph', component_property='figure'), [Input(component_id='my_dropdown', component_property='value')]) def update_graph(my_dropdown): if (my_dropdown == "P&L"): df = pos fig_ = go.Figure() fig_.add_traces(data=go.Scatter(y=pos['P&L'], name="P&L_")) fig_.update_layout(title="P&L from both long and short", title_x=0.5, plot_bgcolor=colors['background'], paper_bgcolor=colors['text'], xaxis_title="Toatal Data", yaxis_title="Profit", width=1300, height=500, xaxis={'showgrid': False}, yaxis={'showgrid': False}) elif (my_dropdown == "P&L_Buy"): df = pos fig_ = go.Figure() fig_.add_traces(data=go.Scatter(y=pos['P&L'].loc[pos.loc[ pos['Pred'] == 1].index], name="P&L_")) fig_.update_layout(title="P&L from long only", title_x=0.5, plot_bgcolor=colors['background'], paper_bgcolor=colors['text'], xaxis_title="Total Data", yaxis_title="Profit", width=1300, height=500, xaxis={'showgrid': False}, yaxis={'showgrid': False}) elif (my_dropdown == "P&L_Sell"): df = pos fig_ = go.Figure() fig_.add_traces(data=go.Scatter(y=pos['P&L'].loc[pos.loc[ pos['Pred'] == 0].index], name="P&L_")) fig_.update_layout(title="P&L from short only", title_x=0.5, plot_bgcolor=colors['background'], paper_bgcolor=colors['text'], xaxis_title="Total Data", yaxis_title="Profit", width=1300, height=500, xaxis={'showgrid': False}, yaxis={'showgrid': False}) return (fig_) app.run_server(mode='external', port=9181) return
dff = dff.rename(columns={"Happiness Score 2019": 'Happiness Score'}) # Plotly Express to show a map of the world with colored regions for the happiness score fig = px.choropleth(data_frame=dff, locations=dff["ISO3"], color=dff['Happiness Score'], hover_data=dff[['Country', 'Happiness Score']], color_continuous_scale=px.colors.sequential.Plasma) return container, fig # ### Prints the map figure # In[15]: app.run_server(mode='inline') # ## Investigating the top 5 and bottom 5 happiness scores # ### Creates a Dataframe that pulls the Top 10 Happiest Countries based on the 2015 Rank # ### Originally wanted to use this to look at the happiness score, but it didn't work # ### Saving the code now in case useful somewhere else # In[16]: Top102015List = (df[(df['Rank 2015'] < 11) & (df['Happiness Score 2015'] > 5)][['Country']]) print("Top 10 countries in 2015 Rank") print(Top102015List) # ### Creating dataframes with only top/bottom 5 for each year
import dash import dash_html_components as html import dash_core_components as dcc from jupyter_dash import JupyterDash # Create a dash application app = JupyterDash(__name__) JupyterDash.infer_jupyter_proxy_config() # Get the layout of the application and adjust it. # Create an outer division using html.Div and add title to the dashboard using html.H1 component # Add description about the graph using HTML P (paragraph) component # Finally, add graph component. app.layout = html.Div(children=[ html.H1('Airline Dashboard', style={ 'textAlign': 'center', 'color': '#503D36', 'font-size': 40 }), html. P('Proportion of distance group (250 mile distance interval group) by month (month indicated by numbers).', style={ 'textAlign': 'center', 'color': '#F57241' }), dcc.Graph(figure=fig), ]) if __name__ == '__main__': app.run_server(mode="inline", host="localhost")
app = JupyterDash(__name__, external_stylesheets=external_stylesheets) styles = { 'pre': { 'border': 'thin lightgrey solid', 'overflowX': 'scroll' } } app.layout = html.Div(children=[ html.H1(children='HDB resale data by sector'), filter_buttons, plot_buttons, dcc.Graph(id='choropleth_element', figure=chorofig, style={'width': '60%', 'display': 'inline-block'}), dcc.Graph(id='timeseries_element', figure=tsfig, style={'width': '38%','display': 'inline-block'}), ]) if __name__ == '__main__': app.run_server(debug=True, host='0.0.0.0', port='8050') # %% [markdown] # ## Configure callback # # Callback determines how a figure changes when user input changes. Any function can be designated as a callback function using the decorator `@app.callback`. The argumernts and outputs of the function should match the inputs, states and outputs of the decorator as we discuess below. Note that each output callback can only be linked to a single function, i.e. Dash does not allow multiple callback functions to share the same output. # # `Input` triggers the callback function whenever it detects a change in a target element property. `State` on the other hand 'stores' the changes, but does not trigger the callback. `Output` write the output of the function to a target HTML element. `Output`, `Input` and `State` accepts two arguments, the first is 'id' element, and the second is a property of the element to read or write from. The number of arguments in the callback function should be the sum of `Input` and `State` in the same order, no more no less. The equality must hold even if we don't use the values (such as `'n_clicks'` from buttons) from the inputs. Likewise, the number of values returned by the function should equal the number of `Output` in the callback. # # # For callback functions with multiple inputs, it may be necessary to identify the input that triggered the callback. We can use dash.callback_context to identify the specific input element and property that triggered the most recent callback, and tailor the response accordingly. # # In the app, clicking buttons `btn1`-`btn6` triggers a callback that replots the graphs with different sets of data. When users change the filter selections, the changes are stored in `State`. These changes are propagated to the graph only when the buttons are pressed. # # For cross selectivity, the choropleth and timeseries plots are linked such that selecting particular sectors in either graph updates the selection in the other graph. The callback function essentially looks for changes to the selectedData of the choropleth, or changes to restyleData in the time series. Once the changes have been identified, update `'selectedpoints'` in the choropleth, and `'visible'` in the traces of the time series. Note that `'selectedpoints'` is a set of index that depends on `tsfig[]` #
def main(): # collect stocks ticks = [] while True: boof = input('Add stock to portfolio: ') if boof: ticks.append(boof) else: break # create portfolio object port = Portfolio(ticks) W, R, V, S, K = port.build(port.coskew(), port.cokurt()) #make a dataframe weights = pd.DataFrame({ticks[i] : W[:,i] for i in range(len(ticks))}) stats = pd.DataFrame({'Return':R, 'Volatility':V, 'Skew':S, 'Kurtosis':K}) df = weights.join(stats) #create a graph object graph = port.graph(R, V, S, K) # initialize app app = JupyterDash(__name__, external_stylesheets=[dbc.themes.FLATLY]) PLOTLY_LOGO = 'https://images.plot.ly/logo/new-branding/plotly-logomark.png' percent = FormatTemplate.percentage(2) decimal = Format(precision=2, scheme=Scheme.fixed) app.layout = html.Div([ html.Div([ html.Img( src=PLOTLY_LOGO, style={ 'width':'40px', 'margin-right':'auto' } ) ], style={ 'grid-area':'nav', 'background':'#58d5f6', 'padding':'10px', 'display':'flex', 'align-items':'center', 'justify-content':'flex-end' } ), html.Div([ dcc.Graph( id='graph', figure=graph ) ], style={ 'grid-area':'scatter', 'background':'#236fc8', 'padding':'10px', 'color':'white' } ), html.Div([ DataTable( id='table', data=df.to_dict('records'), columns=[ {'id':i, 'name':i, 'type':'numeric', 'hideable':True, 'format':decimal} if i == 'Skew' or i == 'Kurtosis' else {'id':i, 'name':i, 'type':'numeric', 'hideable':True, 'format':percent} for i in df.columns ], filter_action='native', sort_action='native', page_current=0, page_size=10, cell_selectable=False, style_as_list_view=True, style_table={'overflowX': 'auto'}, style_header={ # header style 'backgroundColor': 'rgb(230, 230, 230, 0.15)', 'fontWeight': 'bold' }, style_filter={ # header filter 'backgroundColor': 'rgb(230, 230, 230, 0)' }, style_cell={ # style each individual cell 'minWidth': '65px', 'color':'white' }, style_data={ # same as above, exclude header and filter cells 'whiteSpace': 'normal', 'backgroundColor': 'rgb(248, 248, 248, 0)', 'height': 'auto' }, style_data_conditional=[{ 'if': {'row_index': 'even'}, 'backgroundColor': 'rgb(248, 248, 248, 0.15)' }] ) ], style={ 'grid-area':'datatable', 'background':'#236fc8', 'padding':'10px', } ) ], style={ # main wrapper 'height':'100vh', 'width':'97%', 'margin':'0 auto', 'display':'grid', 'grid-gap':'5px', 'grid-template-columns':'5fr 2fr', 'grid-template-rows':'1fr 12fr', 'grid-template-areas':'"nav nav"\ "datatable scatter"' } ) app.run_server(mode='external', debug=True, port=140)
title='Average NAS delay time (minutes) by airline') sec_fig = px.line( avg_sec, x='Month', y='SecurityDelay', color='Reporting_Airline', title='Average security delay time (minutes) by airline') late_fig = px.line( avg_late, x='Month', y='LateAircraftDelay', color='Reporting_Airline', title='Average late aircraft delay time (minutes) by airline') return [ dcc.Graph(figure=carrier_fig), dcc.Graph(figure=weather_fig), dcc.Graph(figure=nas_fig), dcc.Graph(figure=sec_fig), dcc.Graph(figure=late_fig) ] # Run the app if __name__ == '__main__': app.run_server(mode="jupyterlab", host="localhost", debug=False, dev_tools_ui=False, dev_tools_props_check=False)
if clicks is not None: if input_value is not None and input_value != '': count = 0 for i in df['title']: if i == input_value: count += 1 if (count == 0): return ( 'Sorry, no movie recommendations available :(. Please enter another movie name!' ) else: movie = input_value movie_user_ratings = moviemat[movie] similar_to_movie = moviemat.corrwith(movie_user_ratings) corr_movie = pd.DataFrame(similar_to_movie, columns=['Correlation']) corr_movie.dropna(inplace=True) corr_movie = corr_movie.join(ratings['num of ratings']) a = corr_movie[corr_movie['num of ratings'] > 100].sort_values( 'Correlation', ascending=False).head() return ('If you enjoyed ' + movie + ', you would also enjoy ' + a.reset_index()["title"][1] + ', ' + a.reset_index()["title"][2] + ', and ' + a.reset_index()["title"][3] + '!') return ('Please enter valid input') app.run_server(mode='external', port=8061) # In[ ]:
CalcResults(structure=defect_structure, energy=0.5, **common)] de_common = dict(name="Va_O1", structure=defect_structure, site_symmetry="1", perturbed_structure=defect_structure, defect_center=[[0]*3]) defect_entries = [DefectEntry(charge=0, **de_common), DefectEntry(charge=1, **de_common)] corrections = [ManualCorrection(correction_energy=1.0), ManualCorrection(correction_energy=1.0)] cpd_e_component = CpdEnergyComponent(cpd_plot_info, perfect, defects, defect_entries, corrections, unitcell_vbm=0.0, unitcell_cbm=1.0) my_layout = html.Div([Column(cpd_e_component.layout)]) ctc.register_crystal_toolkit(app=app, layout=my_layout, cache=None) # In[5]: app.run_server(port=8099) #app.run_server(mode='inline', port=8096)
return [dcc.Graph(figure=tree_fig), dcc.Graph(figure=pie_fig), dcc.Graph(figure=map_fig), dcc.Graph(figure=bar_fig), dcc.Graph(figure=line_fig)] else: # REVIEW7: This covers chart type 2 and we have completed this exercise under Flight Delay Time Statistics Dashboard section # Compute required information for creating graph from the data avg_car, avg_weather, avg_NAS, avg_sec, avg_late = compute_data_choice_2(df) # Create graph carrier_fig = px.line(avg_car, x='Month', y='CarrierDelay', color='Reporting_Airline', title='Average carrrier delay time (minutes) by airline') weather_fig = px.line(avg_weather, x='Month', y='WeatherDelay', color='Reporting_Airline', title='Average weather delay time (minutes) by airline') nas_fig = px.line(avg_NAS, x='Month', y='NASDelay', color='Reporting_Airline', title='Average NAS delay time (minutes) by airline') sec_fig = px.line(avg_sec, x='Month', y='SecurityDelay', color='Reporting_Airline', title='Average security delay time (minutes) by airline') late_fig = px.line(avg_late, x='Month', y='LateAircraftDelay', color='Reporting_Airline', title='Average late aircraft delay time (minutes) by airline') return[dcc.Graph(figure=carrier_fig), dcc.Graph(figure=weather_fig), dcc.Graph(figure=nas_fig), dcc.Graph(figure=sec_fig), dcc.Graph(figure=late_fig)] JupyterDash.infer_jupyter_proxy_config() # Run the app if __name__ == '__main__': app.run_server(mode='inline', host='localhost', debug=False)
# REVIEW6: Return dcc.Graph component to the empty division return [dcc.Graph(figure=tree_fig), dcc.Graph(figure=pie_fig), dcc.Graph(figure=map_fig), dcc.Graph(figure=bar_fig), dcc.Graph(figure=line_fig) ] else: # REVIEW7: This covers chart type 2 and we have completed this exercise under Flight Delay Time Statistics Dashboard section # Compute required information for creating graph from the data avg_car, avg_weather, avg_NAS, avg_sec, avg_late = compute_data_choice_2(df) # Create graph carrier_fig = px.line(avg_car, x='Month', y='CarrierDelay', color='Reporting_Airline', title='Average carrrier delay time (minutes) by airline') weather_fig = px.line(avg_weather, x='Month', y='WeatherDelay', color='Reporting_Airline', title='Average weather delay time (minutes) by airline') nas_fig = px.line(avg_NAS, x='Month', y='NASDelay', color='Reporting_Airline', title='Average NAS delay time (minutes) by airline') sec_fig = px.line(avg_sec, x='Month', y='SecurityDelay', color='Reporting_Airline', title='Average security delay time (minutes) by airline') late_fig = px.line(avg_late, x='Month', y='LateAircraftDelay', color='Reporting_Airline', title='Average late aircraft delay time (minutes) by airline') return[dcc.Graph(figure=carrier_fig), dcc.Graph(figure=weather_fig), dcc.Graph(figure=nas_fig), dcc.Graph(figure=sec_fig), dcc.Graph(figure=late_fig)] # Run the app if __name__ == '__main__': # REVIEW8: Adding dev_tools_ui=False, dev_tools_props_check=False can prevent error appearing before calling callback function app.run_server( port=8002, host="127.0.0.1", debug=False, dev_tools_ui=False, dev_tools_props_check=False)
# , external_stylesheets =[dbc.themes.BOOTSTRAP] else: app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP]) except NameError: app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP]) app.layout = layout # app.layout = html.Div([layout]) register_callbacks(app) app.config.suppress_callback_exceptions = True if __name__ == '__main__': if os.environ.get("USERNAME") == 'john': # app.run_server(host="127.0.0.1", debug=False, port=int(os.environ['CDSW_APP_PORT'])) # app.run_server(host="127.0.0.1", debug=False, port=int(os.environ['CDSW_APP_PORT'])) # app.run_server(host="0.0.0.0", debug=False, port=int(os.environ['CDSW_APP_PORT'])) app.run_server(host="127.0.0.1", port='8052', debug=True) # app.run_server(debug=True) else: ##### Only do Google Analytics if hosted online ##### app.scripts.config.serve_locally = False app.scripts.append_script({ "external_url": "https://www.googletagmanager.com/gtag/js?id=G-XS013W81ZD" }) app.scripts.append_script( {'external_url': 'http://www.vacquishcovid19.com/assets/gtag.js'}) app.run_server(port='8052', debug=False)
def graph(G, mode="external", **kwargs): """ G: a multidirectional graph kwargs are passed to the Jupyter_Dash.run_server() function. Some usefull arguments are: mode: "inline" to run app inside the jupyter nodebook, default is external debug: True or False, Usefull to catch errors during development. """ import dash from jupyter_dash import JupyterDash import dash_cytoscape as cyto from dash.dependencies import Output, Input import dash_html_components as html import dash_core_components as dcc import dash_table import networkx as nx import scConnect as cn import plotly.graph_objs as go import plotly.io as pio import pandas as pd import numpy as np import json import matplotlib import matplotlib.pyplot as plt pio.templates.default = "plotly_white" cyto.load_extra_layouts() JupyterDash.infer_jupyter_proxy_config() app = JupyterDash(__name__) server = app.server # Add a modified index string to change the title to scConnect app.index_string = ''' <!DOCTYPE html> <html> <head> {%metas%} <title>scConnect</title> {%favicon%} {%css%} </head> <body> {%app_entry%} <footer> {%config%} {%scripts%} {%renderer%} </body> </html> ''' # Add colors to each node nodes = pd.Categorical(G.nodes()) # make a list of RGBA tuples, one for each node colors = plt.cm.tab20c(nodes.codes / len(nodes.codes), bytes=True) # zip node to color color_map_nodes = dict(zip(nodes, colors)) # add these colors to original graph for node, color in color_map_nodes.items(): G.nodes[node]["color"] = color[0:3] # Save only RGB # Add colors to edges(source node color) for G for u, v, k in G.edges(keys=True): G.edges[u, v, k]["color"] = color_map_nodes[u][0:3] # load graph into used formes def G_to_flat(G, weight): G_flat = cn.graph.flatten_graph(G, weight=weight, log=True) # Add colors to edges(source node color) for G_flat for u, v, in G_flat.edges(): G_flat.edges[u, v]["color"] = color_map_nodes[u][0:3] return G_flat # produce full graph variante to extract metadata G_flat = G_to_flat(G, weight="score") G_split = cn.graph.split_graph(G) # find and sort all found interactions interactions = list(G_split.keys()) interactions.sort() G_cyto = nx.cytoscape_data(G_flat) # get min and max weight for all edges for flat and normal graph #weights = [d["weight"] for u, v, d in G_flat.edges(data=True)] scores = [d["score"] for u, v, d in G.edges(data=True)] cent = [d["centrality"] for n, d in G.nodes(data=True)] # prepare data for network graph nodes = G_cyto["elements"]["nodes"] elements = [] # collect all available genes genes = list(nodes[0]["data"]["genes"].keys()) # Styling parameters font_size = 20 # Style for network graph default_stylesheet = [{ 'selector': 'node', 'style': { 'background-color': 'data(color)', 'label': 'data(id)', 'shape': 'ellipse', 'opacity': 1, 'font-size': f'{font_size}', 'font-weight': 'bold', 'text-wrap': 'wrap', 'text-max-width': "100px", 'text-opacity': 1, 'text-outline-color': "white", 'text-outline-opacity': 1, 'text-outline-width': 2 } }, { 'selector': 'node:selected', 'style': { 'background-color': 'data(color)', 'label': 'data(id)', 'shape': 'ellipse', 'opacity': 1, 'border-color': "black", 'border-width': "5" } }, { 'selector': 'edge', 'style': { 'line-color': 'data(color)', "opacity": 0.7, "curve-style": "unbundled-bezier", "width": "data(weight)", "target-arrow-shape": "vee", "target-arrow-color": "black", 'z-index': 1, 'font-size': f'{font_size}' } }, { 'selector': 'edge:selected', 'style': { 'line-color': 'red', 'line-style': "dashed", 'opacity': 1, 'z-index': 10, } }] app.layout = html.Div( className="wrapper", children=[ # wrapper html.Div( className="header", children=[ # header html.Img(src="assets/logo.png", alt="scConnect logo"), html.Div( className="graph-info", id="graph-stat", children=[ html. H3(f'Loaded graph with {len(G.nodes())} nodes and {len(G.edges())} edges' ) ]) ]), html.Div( className="network-settings", children=[ # network settings html.H2("Network settings", style={"text-align": "center"}), html.Label("Interactions"), dcc.Dropdown(id="network-interaction", options=[{ 'label': "all interactions", 'value': "all" }] + [{ 'label': interaction, 'value': interaction } for interaction in interactions], value="all"), # select if only significant ligands and receptors should be shown html.Label("Graph weight:"), dcc.RadioItems(id="weight-select", options=[{ "label": "Score", "value": "score" }, { "label": "Log score", "value": "log_score" }, { "label": "Specificity", "value": "specificity" }, { "label": "Importance", "value": "importance" }], value="importance", labelStyle={ 'display': 'block', "margin-left": "50px" }, style={ "padding": "10px", "margin": "auto" }), html.Label("Graph Layout"), dcc.Dropdown( id="network-layout", options=[{ 'label': name.capitalize(), 'value': name } for name in [ 'grid', 'random', 'circle', 'cose', 'concentric', 'breadthfirst', 'cose-bilkent', 'cola', 'euler', 'spread', 'dagre', 'klay' ]], value="circle", clearable=False), html.Label("Weight Filter", style={ "paddingBottom": 500, "paddingTop": 500 }), dcc. Slider( # min, max and value are set dynamically via a callback id="network-filter", step=0.001, updatemode="drag", tooltip={ "always_visible": True, "placement": "right" }, ), html.Label("Node size"), dcc.RangeSlider(id="node-size", value=[10, 50], min=0, max=100, updatemode="drag"), html.Label("Select gene"), dcc.Dropdown( id="gene_dropdown", options=[{ "label": gene, "value": gene } for gene in genes], clearable=True, placeholder="Color by gene expression", ), # Store node colors "hidden" for gene expresison html.Div(id="node-colors", style={"display": "none"}, children=[""]), html.Div(id="min-max", children=[]), # Click to download image of network graph html.Button(children="Download current view", id="download-network-graph", style={"margin": "10px"}) ]), # end network settings html.Div( id="network-graph", className="network-graph", children=[ # network graph html.H2("Network graph", style={"text-align": "center"}), cyto.Cytoscape(id="cyto-graph", style={ 'width': '100%', 'height': '80vh' }, stylesheet=default_stylesheet, elements=elements, autoRefreshLayout=True, zoomingEnabled=False) ]), # end network graph html.Div( className="sankey-settings", children=[ # network settings html.H2("Sankey Settings", style={"text-align": "center"}), html.Label("Weight Filter"), dcc.Slider(id="sankey-filter", min=min(scores), max=max(scores), value=0.75, step=0.001, updatemode="drag", tooltip={ "always_visible": True, "placement": "right" }), html.Label("Toggle weighted"), dcc.RadioItems(id="sankey-toggle", options=[{ "label": "Score", "value": "score" }, { "label": "Log score", "value": "log_score" }, { "label": "Specificity", "value": "specificity" }, { "label": "Importance", "value": "importance" }], value="importance", labelStyle={"display": "block"}) ]), # end network settings html.Div( className="sankey", id="sankey", children=[ # sankey graph html.H2("Sankey graph", style={"text-align": "center"}), dcc.Graph(id="sankey-graph") ]), # end sankey graph html.Div( className="interaction-list", children=[ # interaction list html.Div(id="selection", children=[ html.H2("Interactions", style={"text-align": "center"}), html.H3(id="edge-info", style={"text-align": "center"}), dcc.Graph(id="interaction-scatter"), html.Div(id="interaction-selection", style={"display": "none"}, children=[""]) ]), html.Div(children=[ dash_table.DataTable( id="edge-selection", page_size=20, style_table={ "overflowX": "scroll", "overflowY": "scroll", "height": "50vh", "width": "95%" }, style_cell_conditional=[{ "if": { "column_id": "interaction" }, "textAlign": "left" }, { "if": { "column_id": "receptorfamily" }, "textAlign": "left" }, { "if": { "column_id": "pubmedid" }, "textAlign": "left" }], style_header={ "fontWeight": "bold", "maxWidth": "200px", "minWidth": "70px" }, style_data={ "maxWidth": "200px", "minWidth": "70px", "textOverflow": "ellipsis" }, sort_action="native", fixed_rows={ 'headers': True, 'data': 0 }) ]) ]), # end interaction list html.Div( className="L-R-scores", children=[ # ligand and receptor lists html.H2("Ligand and receptors", style={"text-align": "center"}), html.Div(children=[ html.H3( id="selected-node", style={"text-align": "center"}, children=["Select a node in the notwork graph"]), html.Label("Search for ligands and receptors:", style={"margin-right": "10px"}), dcc.Input(id="filter_l_r", type="search", value="", placeholder="Search") ]), dcc.Tabs([ dcc.Tab(label="Ligands", children=[ dcc.Graph(id="ligand-graph", config=dict(autosizable=True, responsive=True)), dash_table.DataTable( id="ligand-table", page_size=20, style_table={ "overflowX": "scroll", "overflowY": "scroll", "height": "50vh", "width": "95%" }, style_cell_conditional=[{ "if": { "column_id": "Ligand" }, "textAlign": "left" }], style_header={ "fontWeight": "bold", "maxWidth": "200px", "minWidth": "70px" }, style_data={ "maxWidth": "200px", "minWidth": "70px", "textOverflow": "ellipsis" }, sort_action="native", fixed_rows={ 'headers': True, 'data': 0 }) ]), dcc.Tab(label="Receptors", children=[ dcc.Graph(id="receptor-graph", config=dict(autosizable=True, responsive=True)), dash_table.DataTable( id="receptor-table", page_size=20, style_table={ "overflowX": "scroll", "overflowY": "scroll", "height": "50vh", "width": "95%" }, style_cell_conditional=[{ "if": { "column_id": "Receptor" }, "textAlign": "left" }], style_header={ "fontWeight": "bold", "maxWidth": "200px", "minWidth": "70px" }, style_data={ "maxWidth": "200px", "minWidth": "70px", "textOverflow": "ellipsis" }, sort_action="native", fixed_rows={ 'headers': True, 'data': 0 }) ]) ]) ]) # end ligand receptor list ]) # end wrapper # Instantiate the graph and produce the bounderies for filters @app.callback([ Output("cyto-graph", "elements"), Output("network-filter", "min"), Output("network-filter", "max"), Output("network-filter", "value") ], [ Input("network-interaction", "value"), Input("weight-select", "value") ]) def make_graph(interaction, score): G_flat = G_to_flat(G, score) if interaction == "all": # if no interaction is selected, use full graph G_cyto = nx.cytoscape_data(G_flat) weights = [d["weight"] for u, v, d in G_flat.edges(data=True)] # prepare data for network graph nodes = G_cyto["elements"]["nodes"] edges = G_cyto["elements"]["edges"] elements = nodes + edges return elements, min(weights), max(weights), np.mean(weights) else: # an interaction is selected, select only that interaction G_split = cn.graph.split_graph(G) G_split_flat = G_to_flat(G_split[interaction], score) G_cyto = nx.cytoscape_data(G_split_flat) weights = [ d["weight"] for u, v, d in G_split_flat.edges(data=True) ] # prepare data for network graph nodes = G_cyto["elements"]["nodes"] edges = G_cyto["elements"]["edges"] elements = nodes + edges return elements, min(weights), max(weights), np.mean(weights) # Change layout of network graph @app.callback(Output("cyto-graph", "layout"), [Input("network-layout", "value")]) def update_network_layout(layout): return {"name": layout, "automate": True, "fit": True} # Choose gene to color nodes by @app.callback( [Output("node-colors", "children"), Output("min-max", "children")], [Input("gene_dropdown", "value")]) def calculate_colors(gene): if gene is None: return [None, ""] # get all gene expression values for selected gene gene_data = { celltype["data"]["id"]: celltype["data"]["genes"][gene] for celltype in nodes } min_value = min(gene_data.values()) max_value = max(gene_data.values()) # package min max expression information to a list that will be returned expression = html.Ul(children=[ html.Li(f"minimum gene expression: {min_value}"), html.Li(f"maximum gene expression: {max_value}") ]) cmap = matplotlib.cm.get_cmap("coolwarm") color_dict = dict() for k, v in gene_data.items(): color_dict[k] = {"rgb": cmap(v, bytes=True)[0:3], "expression": v} color = pd.Series(color_dict) return color.to_json(), expression # Select visible edges of network graph depending on filter value # node color depending on selected gene # width of edges @app.callback(Output("cyto-graph", "stylesheet"), [ Input("network-filter", "value"), Input("network-filter", "min"), Input("network-filter", "max"), Input("node-size", "value"), Input("node-colors", "children") ]) def style_network_graph(th, min_weight, max_weight, size, colors): # create a filter for edges filter_style = [{ "selector": f"edge[weight < {th}]", "style": { "display": "none" } }, { "selector": "node", "style": { 'height': f'mapData(centrality, {min(cent)}, {max(cent)}, {size[0]}, {size[1]})', 'width': f'mapData(centrality, {min(cent)}, {max(cent)}, {size[0]}, {size[1]})' } }] # create a color style for nodes based on gene expression if isinstance(colors, str): colors = pd.read_json(colors, typ="series", convert_dates=False) color_style = [{ 'selector': f'node[id = "{str(index)}"]', 'style': { 'background-color': f'rgb{tuple(colors[index]["rgb"])}' } } for index in colors.index] filter_style += color_style else: color_style = { "selector": "node", "style": { 'background-color': 'BFD7B5' } } # Map edges width to a set min and max value (scale for visibility) edge_style = [{ "selector": "edge", "style": { "width": f"mapData(weight, {min_weight}, {max_weight}, 1, 10)" } }] return default_stylesheet + filter_style + edge_style # download an image of current network graph view @app.callback(Output("cyto-graph", "generateImage"), Input("download-network-graph", "n_clicks")) def download_networkgraph_image(get_request): if get_request == None: return dict() return {"type": "svg", "action": "download"} # Produce a table of all edge data from tapped edge @app.callback([ Output("edge-info", "children"), Output("edge-selection", "columns"), Output("edge-selection", "data") ], [ Input("cyto-graph", "tapEdgeData"), Input("interaction-selection", "children") ]) def update_data(edge, selection): import pandas as pd import json # check if an edge has really been clicked, return default otherwise if edge is None: return ["", None, None] info = f"Interactions from {edge['source']} to {edge['target']}." # map visible names for columns with columns in edge[interaction] columns = [{ "name": "Interaction", "id": "interaction" }, { "name": "Receptor Family", "id": "receptorfamily" }, { "name": "Score", "id": "score" }, { "name": "Log10(score)", "id": "log_score" }, { "name": "Specificity", "id": "specificity" }, { "name": "Importance", "id": "importance" }, { "name": "Ligand z-score", "id": "ligand_zscore" }, { "name": "Ligand p-value", "id": "ligand_pval" }, { "name": "Receptor z-score", "id": "receptor_zscore" }, { "name": "Receptor p-value", "id": "receptor_pval" }, { "name": "PubMed ID", "id": "pubmedid" }] interactions = pd.DataFrame(edge["interactions"])[[ "interaction", "receptorfamily", "score", "log_score", "specificity", "importance", "ligand_zscore", "ligand_pval", "receptor_zscore", "receptor_pval", "pubmedid" ]] # Sort values based on score interactions.sort_values(by="score", ascending=False, inplace=True) # round values for scores to two decimals interactions[[ "score", "log_score", "specificity", "importance", "ligand_zscore", "receptor_zscore" ]] = interactions[[ "score", "log_score", "specificity", "importance", "ligand_zscore", "receptor_zscore" ]].round(decimals=2) interactions[["ligand_pval", "receptor_pval" ]] = interactions[["ligand_pval", "receptor_pval"]].round(decimals=4) # if selection from interaction graph, filter dataframe if selection != "": selection = json.loads(selection) interactions = interactions.loc[interactions["interaction"].isin( selection)] records = interactions.to_dict("records") return [info, columns, records] @app.callback([Output("interaction-scatter", "figure")], [Input("cyto-graph", "tapEdgeData")]) def interaction_scatter_plot(edge): import plotly.express as px fig = go.Figure() if not isinstance(edge, dict): return [ fig, ] interactions = pd.DataFrame(edge["interactions"])[[ "interaction", "receptorfamily", "score", "log_score", "ligand_zscore", "ligand_pval", "receptor_zscore", "receptor_pval", "specificity", "importance", "pubmedid" ]] # add 10% to the min and max value to not clip the datapoint range_x = (-max(interactions["log_score"]) * 0.1, max(interactions["log_score"]) * 1.1) range_y = (-max(interactions["specificity"]) * 0.1, max(interactions["specificity"]) * 1.1) #interactions["specificity"] = np.log10( interactions["specificity"]) fig = px.scatter(interactions, x="log_score", range_x=range_x, y="specificity", range_y=range_y, color="importance", hover_name="interaction", hover_data=[ "ligand_pval", "receptor_pval", "score", "specificity", "receptorfamily" ], color_continuous_scale=px.colors.sequential.Viridis_r, labels={ "ligand_zscore": "Ligand Z-score", "receptor_zscore": "Receptor Z-score", "log_score": "log(Interaction score)", "score": "Interaction score", "specificity": "Specificity", "importance": "Importance", "receptorfamily": "Receptor family", "pubmedid": "PubMed ID", "ligand_pval": "Ligand p-value", "receptor_pval": "Receptor p-value" }) return [ fig, ] @app.callback(Output("interaction-selection", "children"), [Input("interaction-scatter", "selectedData")]) def interaction_select(selected_data): import json if isinstance(selected_data, dict): interactions = [ point["hovertext"] for point in selected_data["points"] ] else: return "" return json.dumps(interactions) # Produce ligand and receptor graphs based on tapped node @app.callback([ Output("ligand-graph", "figure"), Output("receptor-graph", "figure"), Output("selected-node", "children") ], [Input("cyto-graph", "tapNodeData"), Input("filter_l_r", "value")]) def plot_l_r_expression(node, filter_text): # set output variables to empty figures ligand_fig = go.Figure() receptor_fig = go.Figure() node_id = "Select a node in the network graph" if isinstance(node, dict): import plotly.express as px node_id = node["id"] ligands_score = pd.DataFrame.from_dict(node["ligands_score"], orient="index", columns=["Score"]) ligands_zscore = np.log2( pd.DataFrame.from_dict(node["ligands_zscore"], orient="index", columns=["Z-score"])) ligands_corr_pval = pd.DataFrame.from_dict( node["ligands_corr_pval"], orient="index", columns=["p-value"]) ligands_merge = ligands_score.merge(ligands_zscore, how="left", left_index=True, right_index=True) ligands_merge = ligands_merge.merge(ligands_corr_pval, how="left", left_index=True, right_index=True) ligands_merge["log(score + 1)"] = np.log10(ligands_merge["Score"] + 1) ligands_merge["Significant"] = [ True if p_val < 0.05 else False for p_val in ligands_merge["p-value"] ] ligands_merge["-log(p-value)"] = -np.log10( ligands_merge["p-value"]) if filter_text != "": ligands_merge = ligands_merge.filter(like=filter_text, axis=0) ligand_fig = px.scatter(ligands_merge, x="log(score + 1)", y="-log(p-value)", color="Significant", hover_name=ligands_merge.index, hover_data=["Score", "Z-score", "p-value"]) receptors_score = pd.DataFrame.from_dict(node["receptors_score"], orient="index", columns=["Score"]) receptors_zscore = np.log2( pd.DataFrame.from_dict(node["receptors_zscore"], orient="index", columns=["Z-score"])) receptors_corr_pval = pd.DataFrame.from_dict( node["receptors_corr_pval"], orient="index", columns=["p-value"]) receptors_merge = receptors_score.merge(receptors_zscore, how="left", left_index=True, right_index=True) receptors_merge = receptors_merge.merge(receptors_corr_pval, how="left", left_index=True, right_index=True) receptors_merge["log(score + 1)"] = np.log10( receptors_merge["Score"] + 1) receptors_merge["Significant"] = [ True if p_val < 0.05 else False for p_val in receptors_merge["p-value"] ] receptors_merge["-log(p-value)"] = -np.log10( receptors_merge["p-value"]) if filter_text != "": receptors_merge = receptors_merge.filter(like=filter_text, axis=0) receptor_fig = px.scatter( receptors_merge, x="log(score + 1)", y="-log(p-value)", color="Significant", hover_name=receptors_merge.index, hover_data=["Score", "Z-score", "p-value"]) return [ligand_fig, receptor_fig, node_id] # Builds a sankey graph based on the tapped node (store in global G_s) G_s = nx.MultiDiGraph() #variable holding sankey graph @app.callback([ Output("sankey-filter", "min"), Output("sankey-filter", "max"), Output("sankey-filter", "value") ], [Input("cyto-graph", "tapNodeData"), Input("sankey-toggle", "value")]) def build_sankey_graph(node, score): import numpy as np # If no node has been selected, dont try to build graph if node is None: return (0, 0, 0) node = node["id"] # Find all interactions where node is target or source node nonlocal G_s G_s = nx.MultiDiGraph() # reset content weight = list( ) # list to store all weights (used to set min and max for the filter) for n, nbrs in G.adj.items( ): # graph has been modified by network graph before for nbr, edict in nbrs.items(): if n == node: for e, d in edict.items(): G_s.add_edge(n, " Post " + nbr, **d) weight.append(d[score]) if nbr == node: for e, d in edict.items(): G_s.add_edge("Pre " + n, nbr, **d) weight.append(d[score]) if len(weight) == 0: weight = [0, 1] if score == "specificity": # set default start value to specificity value for ligand and receptor # p-value of (0.05 and 0.05)/2 = 1.3 return (min(weight), max(weight), 1.3) return (min(weight), max(weight), np.mean(weight)) @app.callback(Output("sankey-graph", "figure"), [ Input("sankey-filter", "value"), Input("sankey-toggle", "value"), Input("cyto-graph", "tapNodeData") ]) def filter_sankey_graph(th, score, node): if node: node = node["id"] _G_s = nx.MultiDiGraph() for u, v, n, d in G_s.edges(data=True, keys=True): if d[score] > th: _G_s.add_edge(u, v, n, **d) _G_s.add_nodes_from(G_s.nodes(data=True)) edges = nx.to_pandas_edgelist(_G_s) if len(edges) < 1: fig = dict() return fig # add same color scheme as network graph for node_s in _G_s.nodes(): if " Post" in node_s: original_node = str(node_s).split(sep=" Post")[1] elif "Pre " in node_s: original_node = str(node_s).split(sep="Pre ")[1] else: original_node = str(node_s) new_color = color_map_nodes[original_node.strip()] G_s.nodes[node_s]["color"] = new_color nodes = G_s.nodes() node_map = {cluster: id for id, cluster in enumerate(list(nodes))} sankey = go.Sankey(node=dict(pad=15, thickness=20, line=dict(color="black", width=0.5), label=list(nodes), color=[ f'rgb{tuple(d["color"][0:3])}' for n, d in G_s.nodes(data=True) ]), link=dict( source=list(edges["source"].map(node_map)), target=list(edges["target"].map(node_map)), value=list(edges[score]), label=edges["interaction"])) data = [sankey] layout = go.Layout(autosize=True, title=f"Interactions: {node}", font=dict(size=font_size)) fig = go.Figure(data=data, layout=layout) return fig @app.callback( [Output("ligand-table", "columns"), Output("ligand-table", "data")], [ Input("ligand-graph", "figure"), Input("ligand-graph", "selectedData") ]) def select_ligands(figure, selected): import json ligands = [] score = [] zscore = [] pval = [] for group in figure["data"]: for ligand in group["hovertext"]: ligands.append(ligand) for data in group["customdata"]: score.append(data[0]) zscore.append(data[1]) pval.append(data[2]) df = pd.DataFrame({ "Ligand": ligands, "Score": score, "Z-score": zscore, "P-value": pval }) df.index = df["Ligand"] df.sort_values(by="Score", ascending=False, inplace=True) if isinstance(selected, dict): filt = [] for point in selected["points"]: filt.append(point["hovertext"]) df = df.loc[filt] columns = [{ "name": "Ligand", "id": "Ligand" }, { "name": "Score", "id": "Score" }, { "name": "Z-score", "id": "Z-score" }, { "name": "P-value", "id": "P-value" }] data = df.to_dict("records") return columns, data @app.callback([ Output("receptor-table", "columns"), Output("receptor-table", "data") ], [ Input("receptor-graph", "figure"), Input("receptor-graph", "selectedData") ]) def select_ligands(figure, selected): import json receptors = [] score = [] zscore = [] pval = [] for group in figure["data"]: for receptor in group["hovertext"]: receptors.append(receptor) for data in group["customdata"]: score.append(data[0]) zscore.append(data[1]) pval.append(data[2]) df = pd.DataFrame({ "Receptor": receptors, "Score": score, "Z-score": zscore, "P-value": pval }) df.index = df["Receptor"] df.sort_values(by="Score", ascending=False, inplace=True) if isinstance(selected, dict): filt = [] for point in selected["points"]: filt.append(point["hovertext"]) df = df.loc[filt] columns = [{ "name": "Receptor", "id": "Receptor" }, { "name": "Score", "id": "Score" }, { "name": "Z-score", "id": "Z-score" }, { "name": "P-value", "id": "P-value" }] data = df.to_dict("records") return columns, data # Run server app.run_server(**kwargs)
filtered_df = df[df.fcst_date == fcst_date] fig = go.Figure() fig.add_trace( go.Bar(name='Yield', x=filtered_df['County'], y=filtered_df['avg_yield'], error_y=dict(type='data', array=filtered_df['std_yield'].values))) fig.update_layout return fig # Define callback to update graph @app.callback(Output('plot', 'figure'), [Input("cnty-dropdown", "value")]) def update_figure(cnty): filtered_df = df[df.County == cnty] #return px.bar(filtered_df, x="County", y="avg_yield" return px.line(filtered_df, x="fcst_date", y="avg_yield", title='Average Yield') # Run app and display result inline in the notebook app.run_server(mode='external')
def make_dash_app(self, template='plotly_white', server_mode='external', port=8050, app_type='jupyter', plot_height=680, external_stylesheets=[ 'https://codepen.io/chriddyp/pen/bWLwgP.css' ], infer_proxy=False, slider_width=140, cutout_hdu=None, cutout_size=10): """ Create a Plotly/Dash app for interactive exploration Parameters ---------- template : str `plotly` style `template <https://plotly.com/python/templates/#specifying-themes-in-graph-object-figures>`_. server_mode, port : str, int If not `None`, the app server is started with `app.run_server(mode=server_mode, port=port)`. app_type : str If ``jupyter`` then `app = jupyter_dash.JupyterDash()`, else `app = dash.Dash()` plot_height : int Height in pixels of the scatter and SED+P(z) plot windows. infer_proxy : bool Run `JupyterDash.infer_jupyter_proxy_config()`, before app initilization, e.g., for running on GoogleColab. Returns ------- app : object App object following `app_type`. """ import dash from dash import dcc from dash import html import plotly.express as px from urllib.parse import urlparse, parse_qsl, urlencode import astropy.wcs as pywcs if app_type == 'dash': app = dash.Dash(__name__, external_stylesheets=external_stylesheets) else: from jupyter_dash import JupyterDash if infer_proxy: JupyterDash.infer_jupyter_proxy_config() app = JupyterDash(__name__, external_stylesheets=external_stylesheets) PLOT_TYPES = [ 'zphot-zspec', 'Mag-redshift', 'Mass-redshift', 'UVJ', 'RA/Dec', 'UV-redshift', 'chi2-redshift' ] for _t in self.extra_plots: PLOT_TYPES.append(_t) COLOR_TYPES = ['z_phot', 'z_spec', 'mass', 'sSFR', 'chi2'] #_title = f"{self.photoz.param['MAIN_OUTPUT_FILE']}" #_subhead = f"Nobj={self.photoz.NOBJ} Nfilt={self.photoz.NFILT}" _title = [ html.Strong(self.photoz.param['MAIN_OUTPUT_FILE']), ' / N', html.Sub('obj'), f'={self.photoz.NOBJ}', ' / N', html.Sub('filt'), f'={self.photoz.NFILT}', ] slider_row_style = { 'width': '90%', 'float': 'left', 'margin-left': '10px' } slider_container = { 'width': f'{slider_width}px', 'margin-left': '-25px' } check_kwargs = dict(style={ 'text-align': 'center', 'height': '14pt', 'margin-top': '-20px' }) # bool_options = {'has_zspec': 'z_spec > 0', # 'use': 'Use == 1'} if cutout_hdu is not None: cutout_wcs = pywcs.WCS(cutout_hdu.header, relax=True) cutout_data = cutout_hdu.data print('xxx', cutout_data.shape) cutout_div = html.Div( [dcc.Graph(id='cutout-figure', style={})], style={ 'right': '70px', 'width': '120px', 'height': '120px', 'border': '1px solid rgb(200,200,200)', 'top': '10px', 'position': 'absolute' }) cutout_target = 'figure' else: cutout_div = html.Div(id='cutout-figure', style={ 'left': '1px', 'width': '1px', 'height': '1px', 'bottom': '1px', 'position': 'absolute' }) cutout_data = None cutout_target = 'children' ####### App layout app.layout = html.Div([ # Selectors html.Div( [ dcc.Location(id='url', refresh=False), html.Div([ html.Div(_title, id='title-bar', style={ 'float': 'left', 'margin-top': '4pt' }), html.Div([ html.Div([ dcc.Dropdown(id='plot-type', options=[{ 'label': i, 'value': i } for i in PLOT_TYPES], value='zphot-zspec', clearable=False, style={ 'width': '120px', 'margin-right': '5px', 'margin-left': '5px', 'font-size': '8pt' }), ], style={'float': 'left'}), html.Div([ dcc.Dropdown(id='color-type', options=[{ 'label': i, 'value': i } for i in COLOR_TYPES], value='sSFR', clearable=False, style={ 'width': '80px', 'margin-right': '5px', 'font-size': '8pt' }), ], style={ 'display': 'inline-block', 'margin-left': '10px' }), ], style={'float': 'right'}), ], style=slider_row_style), html.Div( [ html.Div([ dcc.Dropdown( id='mag-filter', options=[{ 'label': i, 'value': i } for i in self.photoz.flux_columns], value=self.DEFAULT_FILTER, style={ 'width': f'{slider_width-45}px', 'margin-right': '20px', 'font-size': '8pt' }, clearable=False), ], style={'float': 'left'}), html.Div([ dcc.RangeSlider(id='mag-slider', min=12, max=32, step=0.2, value=[18, 27], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='mag-checked', options=[{ 'label': 'AB mag', 'value': 'checked' }], value=['checked'], **check_kwargs), ], style=dict(display='inline-block', **slider_container)), # html.Div([ dcc.RangeSlider(id='chi2-slider', min=0, max=20, step=0.1, value=[0, 6], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='chi2-checked', options=[{ 'label': 'chi2', 'value': 'checked' }], value=[], **check_kwargs), ], style=dict(display='inline-block', **slider_container)), html.Div([ dcc.RangeSlider(id='nfilt-slider', min=1, max=self.MAXNFILT, step=1, value=[3, self.MAXNFILT], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='nfilt-checked', options=[{ 'label': 'nfilt', 'value': 'checked' }], value=['checked'], **check_kwargs), ], style=dict(display='inline-block', **slider_container)), ], style=slider_row_style), html.Div( [ html.Div([ dcc.RangeSlider(id='zphot-slider', min=-0.5, max=12, step=0.1, value=[0, self.ZMAX], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='zphot-checked', options=[{ 'label': 'z_phot', 'value': 'checked' }], value=['checked'], **check_kwargs), ], style=dict(float='left', **slider_container)), html.Div([ dcc.RangeSlider(id='zspec-slider', min=-0.5, max=12, step=0.1, value=[-0.5, 6.5], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='zspec-checked', options=[{ 'label': 'z_spec', 'value': 'checked' }], value=['checked'], **check_kwargs), ], style=dict(display='inline-block', **slider_container)), html.Div([ dcc.RangeSlider(id='mass-slider', min=7, max=13, step=0.1, value=[8, 11.8], updatemode='drag', tooltip={"placement": 'left'}), dcc.Checklist(id='mass-checked', options=[{ 'label': 'mass', 'value': 'checked' }], value=['checked'], **check_kwargs), ], style=dict(display='inline-block', **slider_container)), # Boolean dropdown # dcc.Dropdown(id='bool-checks', # options=[{'label': self.bool_options[k], # 'value': k} # for k in self.bool_options], # value=[], # multi=True, # style={'width':'100px', # 'display':'inline-block', # 'margin-left':'0px', # 'font-size':'8pt'}, # clearable=True), ], style=slider_row_style), ], style={ 'float': 'left', 'width': '55%' }), # Object-level controls html.Div([ html.Div([ html.Div('ID / RA,Dec.', style={ 'float': 'left', 'width': '100px', 'margin-top': '5pt' }), dcc.Input(id='id-input', type='text', style={ 'width': '120px', 'padding': '2px', 'display': 'inline', 'font-size': '8pt' }), html.Div(children='', id='match-sep', style={ 'margin': '5pt', 'display': 'inline', 'width': '50px', 'font-size': '8pt' }), dcc.RadioItems(id='sed-unit-selector', options=[{ 'label': i, 'value': i } for i in ['Fλ', 'Fν', 'νFν']], value='Fλ', labelStyle={ 'display': 'inline', 'padding': '3px', }, style={ 'display': 'inline', 'width': '130px' }) ], style={ 'width': '260pix', 'float': 'left', 'margin-right': '20px' }), ]), html.Div( [ # html.Div([ # ], style={'width':'120px', 'float':'left'}), html.Div(id='object-info', children='ID: ', style={ 'margin': 'auto', 'margin-top': '10px', 'font-size': '10pt' }) ], style={ 'float': 'right', 'width': '45%' }), # Plots html.Div( [ # Scatter plot dcc.Graph(id='sample-selection-scatter', hoverData={ 'points': [{ 'customdata': (self.df['id'][0], 1.0, -9.0) }] }, style={'width': '95%'}) ], style={ 'float': 'left', 'height': '70%', 'width': '49%' }), html.Div( [ # SED dcc.Graph(id='object-sed-figure', style={'width': '95%'}) ], style={ 'float': 'right', 'width': '49%', 'height': '70%' }), cutout_div ]) ##### Callback functions @app.callback(dash.dependencies.Output('url', 'search'), [ dash.dependencies.Input('plot-type', 'value'), dash.dependencies.Input('color-type', 'value'), dash.dependencies.Input('mag-filter', 'value'), dash.dependencies.Input('mag-slider', 'value'), dash.dependencies.Input('mass-slider', 'value'), dash.dependencies.Input('chi2-slider', 'value'), dash.dependencies.Input('nfilt-slider', 'value'), dash.dependencies.Input('zphot-slider', 'value'), dash.dependencies.Input('zspec-slider', 'value'), dash.dependencies.Input('id-input', 'value') ]) def update_url_state(plot_type, color_type, mag_filter, mag_range, mass_range, chi2_range, nfilt_range, zphot_range, zspec_range, id_input): search = f'?plot_type={plot_type}&color_type={color_type}' search += f'&mag_filter={mag_filter}' search += f'&mag={mag_range[0]},{mag_range[1]}' search += f'&mass={mass_range[0]},{mass_range[1]}' search += f'&chi2={chi2_range[0]},{chi2_range[1]}' search += f'&nfilt={nfilt_range[0]},{nfilt_range[1]}' search += f'&zphot={zphot_range[0]},{zphot_range[1]}' search += f'&zspec={zspec_range[0]},{zspec_range[1]}' if id_input is not None: search += f"&id={id_input.replace(' ', '%20')}" return search @app.callback([ dash.dependencies.Output('plot-type', 'value'), dash.dependencies.Output('color-type', 'value'), dash.dependencies.Output('mag-filter', 'value'), dash.dependencies.Output('mag-slider', 'value'), dash.dependencies.Output('mass-slider', 'value'), dash.dependencies.Output('chi2-slider', 'value'), dash.dependencies.Output('nfilt-slider', 'value'), dash.dependencies.Output('zphot-slider', 'value'), dash.dependencies.Output('zspec-slider', 'value'), dash.dependencies.Output('id-input', 'value'), ], [dash.dependencies.Input('url', 'href')]) def set_state_from_url(href): plot_type = 'zphot-zspec' color_type = 'sSFR' mag_filter = self.DEFAULT_FILTER mag_range = [18, 27] mass_range = [8, 11.6] chi2_range = [0, 4] nfilt_range = [1, self.MAXNFILT] zphot_range = [0, self.ZMAX] zspec_range = [-0.5, 6.5] id_input = None if '?' not in href: return (plot_type, color_type, mag_filter, mag_range, mass_range, chi2_range, nfilt_range, zphot_range, zspec_range, id_input) search = href.split('?')[1] params = search.split('&') for p in params: if 'plot_type' in p: val = p.split('=')[1] if val in PLOT_TYPES: plot_type = val elif 'color_type' in p: val = p.split('=')[1] if val in COLOR_TYPES: color_type = val elif 'mag_filter' in p: val = p.split('=')[1] if val in self.photoz.flux_columns: mag_filter = val elif 'mag=' in p: try: vals = [float(v) for v in p.split('=')[1].split(',')] if len(vals) == 2: mag_range = vals except ValueError: pass elif 'mass' in p: try: vals = [float(v) for v in p.split('=')[1].split(',')] if len(vals) == 2: mass_range = vals except ValueError: pass elif 'nfilt=' in p: try: vals = [int(v) for v in p.split('=')[1].split(',')] if len(vals) == 2: nfilt_range = vals except ValueError: pass elif 'zspec' in p: try: vals = [float(v) for v in p.split('=')[1].split(',')] if len(vals) == 2: zspec_range = vals except ValueError: pass elif 'zphot' in p: try: vals = [float(v) for v in p.split('=')[1].split(',')] if len(vals) == 2: zphot_range = vals except ValueError: pass elif 'id' in p: try: id_input = p.split('=')[1].replace('%20', ' ') except ValueError: id_input = None if not id_input: id_input = None return (plot_type, color_type, mag_filter, mag_range, mass_range, chi2_range, nfilt_range, zphot_range, zspec_range, id_input) @app.callback( dash.dependencies.Output('sample-selection-scatter', 'figure'), [ dash.dependencies.Input('plot-type', 'value'), dash.dependencies.Input('color-type', 'value'), dash.dependencies.Input('mag-filter', 'value'), dash.dependencies.Input('mag-slider', 'value'), dash.dependencies.Input('mag-checked', 'value'), dash.dependencies.Input('mass-slider', 'value'), dash.dependencies.Input('mass-checked', 'value'), dash.dependencies.Input('chi2-slider', 'value'), dash.dependencies.Input('chi2-checked', 'value'), dash.dependencies.Input('nfilt-slider', 'value'), dash.dependencies.Input('nfilt-checked', 'value'), dash.dependencies.Input('zphot-slider', 'value'), dash.dependencies.Input('zphot-checked', 'value'), dash.dependencies.Input('zspec-slider', 'value'), dash.dependencies.Input('zspec-checked', 'value'), dash.dependencies.Input('id-input', 'value') ]) def update_selection(plot_type, color_type, mag_filter, mag_range, mag_checked, mass_range, mass_checked, chi2_range, chi2_checked, nfilt_range, nfilt_checked, zphot_range, zphot_checked, zspec_range, zspec_checked, id_input): """ Apply slider selections """ sel = np.isfinite(self.df['z_phot']) if 'checked' in zphot_checked: sel &= (self.df['z_phot'] > zphot_range[0]) sel &= (self.df['z_phot'] < zphot_range[1]) if 'checked' in zspec_checked: sel &= (self.df['z_spec'] > zspec_range[0]) sel &= (self.df['z_spec'] < zspec_range[1]) if 'checked' in mass_checked: sel &= (self.df['mass'] > mass_range[0]) sel &= (self.df['mass'] < mass_range[1]) if 'checked' in chi2_checked: sel &= (self.df['chi2'] >= chi2_range[0]) sel &= (self.df['chi2'] <= chi2_range[1]) if 'checked' in nfilt_checked: sel &= (self.df['nusefilt'] >= nfilt_range[0]) sel &= (self.df['nusefilt'] <= nfilt_range[1]) #print('redshift: ', sel.sum()) if mag_filter is None: mag_filter = self.DEFAULT_FILTER #self.self.df['mag'] = self.ABZP #self.self.df['mag'] -= 2.5*np.log10(self.photoz.cat[mag_filter]) mag_col = 'mag_' + mag_filter if 'checked' in mag_checked: sel &= (self.df[mag_col] > mag_range[0]) sel &= (self.df[mag_col] < mag_range[1]) self.df['mag'] = self.df[mag_col] #print('mag: ', sel.sum()) if plot_type == 'zphot-zspec': sel &= self.df['z_spec'] > 0 #print('zspec: ', sel.sum()) if id_input is not None: id_i, dr_i = parse_id_input(id_input) if id_i is not None: self.df['is_selected'] = self.df['id'] == id_i sel |= self.df['is_selected'] else: self.df['is_selected'] = False else: self.df['is_selected'] = False dff = self.df[sel] # Color-coding by color-type pulldown if color_type == 'z_phot': color_kwargs = dict(color=np.clip(dff['z_phot'], *zphot_range), color_continuous_scale='portland') elif color_type == 'z_spec': color_kwargs = dict(color=np.clip(dff['z_spec'], *zspec_range), color_continuous_scale='portland') elif color_type == 'mass': color_kwargs = dict(color=np.clip(dff['mass'], *mass_range), color_continuous_scale='magma_r') elif color_type == 'chi2': color_kwargs = dict(color=np.clip(dff['chi2'], *chi2_range), color_continuous_scale='viridis') else: color_kwargs = dict(color=np.clip(dff['ssfr'], -12., -8.), color_continuous_scale='portland_r') # Scatter plot plot_defs = { 'Mass-redshift': ('z_phot', 'mass', 'z<sub>phot</sub>', 'log Stellar mass', (-0.1, self.ZMAX), (7.5, 12.5)), 'Mag-redshift': ('z_phot', 'mag', 'z<sub>phot</sub>', f'AB mag ({mag_filter})', (-0.1, self.ZMAX), (18, 28)), 'RA/Dec': ('ra', 'dec', 'R.A.', 'Dec.', self.ra_bounds, self.dec_bounds), 'zphot-zspec': ('z_spec', 'z_phot', 'z<sub>spec</sub>', 'z<sub>phot</sub>', (0, 4.5), (0, 4.5)), 'UVJ': ('vj', 'uv', '(V-J)', '(U-V)', (-0.1, 2.5), (-0.1, 2.5)), 'UV-redshift': ('z_phot', 'uv', 'z<sub>phot</sub>', '(U-V)<sub>rest</sub>', (0, 4), (-0.1, 2.50)), 'chi2-redshift': ('z_phot', 'chi2', 'z<sub>phot</sub>', 'chi<sup>2</sup>', (0, 4), (0.1, 30)) } if plot_type in self.extra_plots: args = (*self.extra_plots[plot_type], {}, color_kwargs) elif plot_type in plot_defs: args = (*plot_defs[plot_type], {}, color_kwargs) else: args = (*plot_defs['zphot-zspec'], {}, color_kwargs) fig = update_sample_scatter(dff, *args) # Update ranges for some parameters if ('Mass' in plot_type) & ('checked' in mass_checked): fig.update_yaxes(range=mass_range) if ('Mag' in plot_type) & ('checked' in mag_checked): fig.update_yaxes(range=mag_range) if ('redshift' in plot_type) & ('checked' in zphot_checked): fig.update_xaxes(range=zphot_range) if ('zspec' in plot_type) & ('checked' in zspec_checked): fig.update_yaxes(range=zspec_range) return fig def update_sample_scatter(dff, xcol, ycol, x_label, y_label, x_range, y_range, extra, color_kwargs): """ Make scatter plot """ import plotly.graph_objects as go fig = px.scatter( data_frame=dff, x=xcol, y=ycol, custom_data=['id', 'z_phot', 'mass', 'ssfr', 'mag'], **color_kwargs) htempl = '(%{x:.2f}, %{y:.2f}) <br>' htempl += 'id: %{customdata[0]:0d} z_phot: %{customdata[1]:.2f}' htempl += '<br> mag: %{customdata[4]:.1f} ' htempl += 'mass: %{customdata[2]:.2f} ssfr: %{customdata[3]:.2f}' fig.update_traces(hovertemplate=htempl, opacity=0.7) if dff['is_selected'].sum() > 0: dffs = dff[dff['is_selected']] _sel = go.Scatter(x=dffs[xcol], y=dffs[ycol], mode="markers+text", text=[f'{id}' for id in dffs['id']], textposition="bottom center", marker=dict(color='rgba(250,0,0,0.5)', size=20, symbol='circle-open')) fig.add_trace(_sel) fig.update_xaxes(range=x_range, title_text=x_label) fig.update_yaxes(range=y_range, title_text=y_label) fig.update_layout(template=template, autosize=True, showlegend=False, margin=dict(l=0, r=0, b=0, t=20, pad=0, autoexpand=True)) if plot_height is not None: fig.update_layout(height=plot_height) fig.update_traces(marker_showscale=False, selector=dict(type='scatter')) fig.update_coloraxes(showscale=False) if (xcol, ycol) == ('z_spec', 'z_phot'): _one2one = go.Scatter(x=[0, 8], y=[0, 8], mode="lines", marker=dict(color='rgba(250,0,0,0.5)')) fig.add_trace(_one2one) fig.add_annotation(text=f'N = {len(dff)} / {len(self.df)}', xref="x domain", yref="y domain", x=0.98, y=0.05, showarrow=False) return fig def sed_cutout_figure(id_i): """ SED cutout """ from plotly.subplots import make_subplots if cutout_data is not None: ix = np.where(self.df['id'] == id_i)[0] ri, di = self.df['ra'][ix], self.df['dec'][ix] xi, yi = np.squeeze(cutout_wcs.all_world2pix([ri], [di], 0)) xp = int(np.round(xi)) yp = int(np.round(yi)) slx = slice(xp - cutout_size, xp + cutout_size + 1) sly = slice(yp - cutout_size, yp + cutout_size + 1) try: cutout = cutout_data[sly, slx] except: cutout = np.zeros((2 * cutout_size, 2 * cutout_size)) fig = px.imshow(cutout, color_continuous_scale='gray_r') fig.update_coloraxes(showscale=False) fig.update_layout(width=120, height=120, margin=dict(l=0, r=0, b=0, t=0, pad=0, autoexpand=True)) fig.update_xaxes(range=(0, 2 * cutout_size), visible=False, showticklabels=False) fig.update_yaxes(range=(0, 2 * cutout_size), visible=False, showticklabels=False) return fig def parse_id_input(id_input): """ Parse input as id or (ra dec) """ if id_input in ['None', None, '']: return None, None inp_split = id_input.replace(',', ' ').split() if len(inp_split) == 1: return int(inp_split[0]), None ra, dec = np.cast[float](inp_split) cosd = np.cos(self.df['dec'] / 180 * np.pi) dx = (self.df['ra'] - ra) * cosd dy = (self.df['dec'] - dec) dr = np.sqrt(dx**2 + dy**2) * 3600. imin = np.nanargmin(dr) return self.df['id'][imin], dr[imin] @app.callback([ dash.dependencies.Output('object-sed-figure', 'figure'), dash.dependencies.Output('object-info', 'children'), dash.dependencies.Output('match-sep', 'children'), dash.dependencies.Output('cutout-figure', cutout_target) ], [ dash.dependencies.Input('sample-selection-scatter', 'hoverData'), dash.dependencies.Input('sed-unit-selector', 'value'), dash.dependencies.Input('id-input', 'value') ]) def update_object_sed(hoverData, sed_unit, id_input): """ SED + p(z) plot """ id_i, dr_i = parse_id_input(id_input) if id_i is None: id_i = hoverData['points'][0]['customdata'][0] else: if id_i not in self.zout['id']: id_i = hoverData['points'][0]['customdata'][0] if dr_i is None: match_sep = '' else: match_sep = f'{dr_i:.1f}"' show_fnu = {'Fλ': 0, 'Fν': 1, 'νFν': 2} layout_kwargs = dict(template=template, autosize=True, showlegend=False, margin=dict(l=0, r=0, b=0, t=20, pad=0, autoexpand=True)) fig = self.photoz.show_fit_plotly(id_i, show_fnu=show_fnu[sed_unit], vertical=True, panel_ratio=[0.6, 0.4], show=False, layout_kwargs=layout_kwargs) if plot_height is not None: fig.update_layout(height=plot_height) ix = self.df['id'] == id_i if ix.sum() == 0: object_info = 'ID: N/A' else: ix = np.where(ix)[0][0] ra, dec = self.df['ra'][ix], self.df['dec'][ix] object_info = [ f'ID: {id_i} | α, δ = {ra:.6f} {dec:.6f} ', ' | ', html.A('ESO', href=utils.eso_query(ra, dec, radius=1.0, unit='s')), ' | ', html.A('CDS', href=utils.cds_query(ra, dec, radius=1.0, unit='s')), ' | ', html.A('LegacySurvey', href=utils.show_legacysurvey(ra, dec, layer='ls-dr9')), html.Br(), f"z_phot: {self.df['z_phot'][ix]:.3f} ", f" | z_spec: {self.df['z_spec'][ix]:.3f}", html.Br(), f"mag: {self.df['mag'][ix]:.2f} ", f" | mass: {self.df['mass'][ix]:.2f} ", f" | sSFR: {self.df['ssfr'][ix]:.2f}", html.Br() ] if cutout_data is None: cutout_fig = [''] else: cutout_fig = sed_cutout_figure(id_i) return fig, object_info, match_sep, cutout_fig if server_mode is not None: app.run_server(mode=server_mode, port=port) return app
color_continuous_scale='RdBu', title='Flight count by airline to destination state' ) return [dcc.Graph(figure=tree_fig), dcc.Graph(figure=pie_fig), dcc.Graph(figure=map_fig), dcc.Graph(figure=bar_fig), dcc.Graph(figure=line_fig) ] else: # Compute required information for creating graph from the data avg_car, avg_weather, avg_NAS, avg_sec, avg_late = compute_data_choice_2(df) # Create graph carrier_fig = px.line(avg_car, x='Month', y='CarrierDelay', color='Reporting_Airline', title='Average carrrier delay time (minutes) by airline') weather_fig = px.line(avg_weather, x='Month', y='WeatherDelay', color='Reporting_Airline', title='Average weather delay time (minutes) by airline') nas_fig = px.line(avg_NAS, x='Month', y='NASDelay', color='Reporting_Airline', title='Average NAS delay time (minutes) by airline') sec_fig = px.line(avg_sec, x='Month', y='SecurityDelay', color='Reporting_Airline', title='Average security delay time (minutes) by airline') late_fig = px.line(avg_late, x='Month', y='LateAircraftDelay', color='Reporting_Airline', title='Average late aircraft delay time (minutes) by airline') return[dcc.Graph(figure=carrier_fig), dcc.Graph(figure=weather_fig), dcc.Graph(figure=nas_fig), dcc.Graph(figure=sec_fig), dcc.Graph(figure=late_fig)] # Run the app if __name__ == '__main__': app.run_server(host="localhost", debug=False, dev_tools_ui=False, dev_tools_props_check=False)
mode="lines+markers", showlegend=True ) fig.update_layout( plot_bgcolor=colors['background'], paper_bgcolor=colors['background'], font_color=colors['text'], dragmode="zoom", template="plotly_white", legend_orientation="v", xaxis_rangeslider_visible=True, xaxis_rangeslider_thickness=0.1, xaxis_rangeslider_bgcolor=colors['text'], xaxis=dict( rangeselector=dict( buttons=list([ dict(count=1, label="1d", step="day", stepmode="backward"), dict(count=1, label="1m", step="month", stepmode="backward"), dict(step="all") ]) ) )) return fig if __name__ == '__main__': app.run_server(debug=False) #, port=8051)
style={ "width": "25%", "float": "left" }), html.Div([ dcc.Graph(id="graph", style={ "width": "70%", "display": "inline-block" }) ]) ]) @app.callback(Output(component_id="graph", component_property="figure"), [ Input(component_id='x-axis', component_property="value"), Input(component_id='y-axis', component_property="value"), Input(component_id='color', component_property="value") ]) def make_figure(x, y, color): return px.bar(anes_ft2, x=x, y='index_col', color=color, height=700, opacity=1) if __name__ == '__main__': app.run_server(debug=False)
[ dbc.Row(dbc.Col(title_component), justify="center", align="center", className="text-center", style=row), dbc.Row(widget_card, style=row), dbc.Row(line_card, style=row), ], style=dashboard, fluid=True, ) app.layout = layout @app.callback(Output('line-graph', 'figure'), [ Input('stock-dropdown', 'value'), ]) def update_figure(stocks): if stocks is None: stocks = ['AAPL'] filtered_df = get_filtered_df(df, stocks) line_fig = create_line_graph(filtered_df) line_fig.update_layout() return line_fig app.run_server(port=8056)
survey_card = dbc.Card( [dbc.CardBody(dbc.Row([html.Embed(src=form, height=900, width=750)]))], style={ 'width': 'auto', 'height': 'auto' }) app = JupyterDash(external_stylesheets=[dbc.themes.LITERA]) server = app.server top_cell = dbc.Col([html.H2('Politics of Earth Dashboard')], width=12) right_col = dbc.Col([survey_card], width=6) left_col = dbc.Col([result_card], width=6) app.layout = html.Div([dbc.Row([top_cell]), dbc.Row([left_col, right_col])]) @app.callback( Output("fade-transition", "is_in"), [Input("fade-transition-button", "n_clicks")], [State("fade-transition", "is_in")], ) def toggle_fade(n_clicks, is_in): if n_clicks != 0: return fade else: return None if __name__ == '__main__': app.run_server(debug=True)
dash.dependencies.Input('crossfilter-yaxis-column', 'value'), dash.dependencies.Input('crossfilter-yaxis-type', 'value') ]) def update_x_timeseries(hoverData, yaxis_column_name, axis_type): dff = df[df['Country Name'] == hoverData['points'][0]['customdata']] dff = dff[dff['Indicator Name'] == yaxis_column_name] return create_time_series(dff, axis_type, yaxis_column_name) # %% [markdown] # Serve the app using `run_server`. Unlike the standard `Dash.run_server` method, the `JupyterDash.run_server` method doesn't block execution of the notebook. It serves the app in a background thread, making it possible to run other notebook calculations while the app is running. # # This makes it possible to iterativly update the app without rerunning the potentially expensive data processing steps. # %% app.run_server() # %% [markdown] # By default, `run_server` displays a URL that you can click on to open the app in a browser tab. The `mode` argument to `run_server` can be used to change this behavior. Setting `mode="inline"` will display the app directly in the notebook output cell. # %% app.run_server(mode="inline") # %% [markdown] # When running in JupyterLab, with the `jupyterlab-dash` extension, setting `mode="jupyterlab"` will open the app in a tab in JupyterLab. # # ```python # app.run_server(mode="jupyterlab") # ``` # %%
return fig, range_values @app.callback( [Output('second_plot', 'figure'), Output('output_text', 'children')], [Input('radiobuttons_select', 'value'), Input("text1", "value")]) def second_graph(radiobuttons_select, text1): # Plotly Express fig2 = px.bar( df, x=df.groupby("Content Rating") [radiobuttons_select].sum().values, # Grab labels y=df.groupby( "Content Rating")[radiobuttons_select].sum().index, # Grab values color_discrete_sequence=['indianred'], labels={ "x": "The Total", "y": radiobuttons_select }) # Re-label axis to appropriate names text_values = 'The Content Rating And "{}"'.format(text1) return fig2, text_values if __name__ == '__main__': app.run_server(mode="inline", host="localhost", port=8053)
def run_dash(path, search_criteria, mode=None): PLOTLY_LOGO = "https://images.plot.ly/logo/new-branding/plotly-logomark.png" # instantiating dash application #app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP]) app = JupyterDash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP]) app.title = "Resume Analyzer" files = [f for f in listdir(path) if isfile(join(path, f))] nlp = en_core_web_sm.load() search_bar = dbc.Row( [ dbc.Badge( str(len(files)) + " Resume found", id="doc_info", href="#", color="warning", className="mr-1", ), dbc.Col( dbc.Button("Process ⚙️", color="primary", className="ml-2", id="button", n_clicks=1), width="12", ), ], no_gutters=True, className="ml-auto flex-nowrap mt-3 mt-md-0", align="center", ) navbar = dbc.Navbar( [ html.A( # Use row and col to control vertical alignment of logo / brand dbc.Row( [ dbc.Col(html.Img(src=PLOTLY_LOGO, height="30px")), dbc.Col( dbc.NavbarBrand("Resume Analyzer", className="ml-2")), ], align="center", no_gutters=True, ), href="https://shivanandroy.com", ), dbc.NavbarToggler(id="navbar-toggler"), dbc.Collapse(search_bar, id="navbar-collapse", navbar=True), ], color="dark", dark=True, ) text = "**The table is filterable and sortable" summary = html.Div([ dbc.Row([ dbc.Col(dcc.Loading( html.Div([ html.Div(text, style={'font-size': '10px'}), dash_table.DataTable( id='table', sort_action="native", filter_action="native", style_cell={ 'font_family': 'Trebuchet MS', 'font_size': '15px', 'text_align': 'center' }, style_header={ 'backgroundColor': 'rgb(230, 230, 230)', 'fontWeight': 'bold' }, style_header_conditional=[{ 'if': { 'column_id': 'RANKING', }, 'backgroundColor': '#A8A8A8', 'color': 'black' }, { 'if': { 'column_id': 'TOTAL SCORE', }, 'backgroundColor': '#A8A8A8', 'color': 'black' }, { 'if': { 'column_id': 'RATING', }, 'backgroundColor': '#A8A8A8', 'color': 'black' }]) ])), width={ 'size': 10, 'offset': 1 }) ], align='end') ]) app.layout = html.Div([navbar, html.Br(), summary]) @app.callback( [Output("table", "columns"), Output("table", "data")], [Input("button", "n_clicks")], ) def toggle_navbar_collapse(n): if n is None: raise PreventUpdate else: files = [f for f in listdir(path) if isfile(join(path, f))] df = rank(path=path, search_criteria=search_criteria) return [{ "name": i, "id": i } for i in df.columns], df.to_dict('records') if mode == "browser": app.run_server(debug=True) if mode == "notebook": app.run_server(debug=True, mode="inline", width=950)