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)
