def __init__(self, tree: "DataTree"):
self.tree = tree
JupyterDash.infer_jupyter_proxy_config()
self.app = JupyterDash(__name__, external_stylesheets=STYLESHEET)
self.server = self.app.server
self.model = CellModel(tree)
self.scatter = Scatter(self.app, data={"model": self.model})
self.dim_dropdowns = DropDownColumn(
self.app,
data=dict(title_list=self.model.DIMENSIONS,
options=self.model.col_options))
self.sliders = SliderColumn(
data={"slider_params": self.model.MARKER_ARGS_PARAMS})
self.col_adder = ColumnAdder()
self.annotator = ScatterAnnotator(data={
"model": self.model,
"options": self.model.col_options
})
self.colname_store = DropDownOptionsStore()
self.gene_data = GeneData(self.app, data={"model": self.model})
self.colname_store.callbacks(master=self.annotator,
subscribers=[
*self.dim_dropdowns.contents,
self.annotator.dropdown
])
self.annotator.callbacks(self.scatter, self.col_adder)
self.scatter.callbacks(self.dim_dropdowns, self.sliders)
self.gene_data.callbacks(self.scatter)
def __init__(self, as_website=False):
# global app_data
# global fig
self.as_website = as_website
self.app_port = get_unused_port(initial_port=port)
self.as_website = as_website
# just for testing local website
# self.app_data = {'traces':{}, 'selection':{}} #application_data.ApplicationData()
# self.app_data = app_data
self.server = flask.Flask(__name__) # define flask app.server
#self.app = JupyterDash(__name__, external_stylesheets=external_stylesheets, external_scripts=external_scripts,server=self.server)
self.app = JupyterDash(__name__,
external_stylesheets=external_stylesheets,
external_scripts=external_scripts,
server=self.server)
if not as_website:
self.socketio = SocketIO(self.server)
#self.app = JupyterSocketDash(__name__, external_stylesheets=external_stylesheets,external_scripts=external_scripts, server=self.server)
self.app.server.secret_key = 'SOME_KEY_STRING'
self.app.title = "Spectrum Viewer"
self.app_data = process_manager.dict()
self.app_data_timestamp = process_manager.dict()
for key, value in self.build_app_data().items():
self.app_data[key] = value
# setting the default values, which also show in the UI dropdown.
#self.app_data['traces'] = {}
#self.app_data['fitted_models'] = {}
#self.app_data['selection'] = {}
self.app_data_timestamp['timestamp'] = 0
self.debug_data = process_manager.dict()
self.smoother = Smoother()
self.model_fitter = ModelFitter()
# self.spectral_lines_info = spectral_lines_info
# self.view = V.SpecView(width, height, dpi)
# self.view.select_all_button.on_clicked(self.select_all_button_callback)
# self.view.delete_unchecked_button.on_clicked(self.delete_unchecked_button_callback)
# self.model = M.SpecModel(streams=OrderedDict(), spectral_lines=OrderedDict())
# self.spec_figure = make_subplots(rows=1, cols=1)
# self.fill_spec_figure_with_app_data()
#self.spec_figure = self.get_spec_figure_from_data(self.app_data)
#app.layout = self.load_app_layout
storage_mode = "session" if as_website else "memory"
self.app.layout = app_layout.load_app_layout(self, self.app_port,
storage_mode)
callbacks.load_callbacks(self)
@self.server.route('/api/health')
def health():
return {'is_healthy': 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'
}
]
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 __init__(self, mode='default', **kwargs):
external_stylesheets = [BOOTSTRAP]
if mode == 'jupyter':
self.app = JupyterDash(external_stylesheets=external_stylesheets)
else:
self.app = Dash(external_stylesheets=external_stylesheets)
app = self.app # For referencing with the decorator (see line below)
app.title = 'CEHS Uganda'
@app.server.route('/static/<asset_type>/<path>')
def static_file(asset_type, path):
return send_from_directory(here / 'static' / asset_type, path)
def __init__(self, mode="default", **kwargs):
external_stylesheets = [BOOTSTRAP]
if mode == "jupyter":
self.app = JupyterDash(external_stylesheets=external_stylesheets)
else:
self.app = Dash(
external_stylesheets=external_stylesheets,
prevent_initial_callbacks=True,
)
app = self.app # For referencing with the decorator (see line below)
app.title = "CEHS Uganda"
@app.server.route("/static/<asset_type>/<path>")
def static_file(asset_type, path):
return send_from_directory(here / "static" / asset_type, path)
def __init__(self, graph_one, graph_two, app_display='default'):
"""
Initialises the dual graph interface and generates the interface layout.
:param graph_one: (Graph) The first graph for the comparison interface.
:param graph_two: (Graph) The second graph for the comparison interface.
:param app_display: (str) 'default' by default and 'jupyter notebook' for running Dash inside Jupyter Notebook.
"""
# Dash app styling with Bootstrap
if app_display == 'jupyter notebook':
self.app = JupyterDash(__name__,
external_stylesheets=[dbc.themes.BOOTSTRAP])
else:
self.app = Dash(__name__,
external_stylesheets=[dbc.themes.BOOTSTRAP])
# Setting input graphs as objest variables
cyto.load_extra_layouts()
self.graph_one = graph_one
self.graph_two = graph_two
# Getting a list of tuples with differnet edge connections
difference = graph_one.get_difference(graph_two)
# Updating the elements needed for the Dash Cytoscape Graph object
self.one_components = None
self.two_components = None
self._update_elements_dual(self.graph_one, difference, 1)
self._update_elements_dual(self.graph_two, difference, 2)
self.cyto_one = None
self.cyto_two = None
# Callback functions to allow simultaneous node selection when clicked
self.app.callback(Output('cytoscape_two',
'elements'), [Input('cytoscape', 'tapNode')],
[State('cytoscape_two', 'elements')])(
DualDashGraph._select_other_graph_node)
self.app.callback(Output('cytoscape', 'elements'),
[Input('cytoscape_two', 'tapNode')],
[State('cytoscape', 'elements')])(
DualDashGraph._select_other_graph_node)
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 create_app(available_indicators, df):
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = JupyterDash(__name__, external_stylesheets=external_stylesheets)
# Create server variable with Flask server object for use with gunicorn
server = app.server
app.layout = html.Div([
html.Div(
[
html.Div([
dcc.Dropdown(
id='crossfilter-xaxis-column',
options=[{
'label': i,
'value': i
} for i in available_indicators],
value='Fertility rate, total (births per woman)'),
dcc.RadioItems(id='crossfilter-xaxis-type',
options=[{
'label': i,
'value': i
} for i in ['Linear', 'Log']],
value='Linear',
labelStyle={'display': 'inline-block'})
],
style={
'width': '49%',
'display': 'inline-block'
}),
html.Div([
dcc.Dropdown(
id='crossfilter-yaxis-column',
options=[{
'label':
i,
'value':
i
} for i in available_indicators],
value='Life expectancy at birth, total (years)'),
dcc.RadioItems(id='crossfilter-yaxis-type',
options=[{
'label': i,
'value': i
} for i in ['Linear', 'Log']],
value='Linear',
labelStyle={'display': 'inline-block'})
],
style={
'width': '49%',
'float': 'right',
'display': 'inline-block'
})
],
style={
'borderBottom': 'thin lightgrey solid',
'backgroundColor': 'rgb(250, 250, 250)',
'padding': '10px 5px'
}),
html.Div([
dcc.Graph(id='crossfilter-indicator-scatter',
hoverData={'points': [{
'customdata': 'Japan'
}]})
],
style={
'width': '49%',
'display': 'inline-block',
'padding': '0 20'
}),
html.Div([
dcc.Graph(id='x-time-series'),
dcc.Graph(id='y-time-series'),
],
style={
'display': 'inline-block',
'width': '49%'
}),
html.Div(dcc.Slider(
id='crossfilter-year--slider',
min=df['Year'].min(),
max=df['Year'].max(),
value=df['Year'].max(),
marks={str(year): str(year)
for year in df['Year'].unique()},
step=None),
style={
'width': '49%',
'padding': '0px 20px 20px 20px'
})
])
@app.callback(
dash.dependencies.Output('crossfilter-indicator-scatter', 'figure'), [
dash.dependencies.Input('crossfilter-xaxis-column', 'value'),
dash.dependencies.Input('crossfilter-yaxis-column', 'value'),
dash.dependencies.Input('crossfilter-xaxis-type', 'value'),
dash.dependencies.Input('crossfilter-yaxis-type', 'value'),
dash.dependencies.Input('crossfilter-year--slider', 'value')
])
def update_graph(xaxis_column_name, yaxis_column_name, xaxis_type,
yaxis_type, year_value):
dff = df[df['Year'] == year_value]
return {
'data': [
dict(
x=dff[dff['Indicator Name'] == xaxis_column_name]['Value'],
y=dff[dff['Indicator Name'] == yaxis_column_name]['Value'],
text=dff[dff['Indicator Name'] ==
yaxis_column_name]['Country Name'],
customdata=dff[dff['Indicator Name'] ==
yaxis_column_name]['Country Name'],
mode='markers',
marker={
'size': 25,
'opacity': 0.7,
'color': 'orange',
'line': {
'width': 2,
'color': 'purple'
}
})
],
'layout':
dict(xaxis={
'title': xaxis_column_name,
'type': 'linear' if xaxis_type == 'Linear' else 'log'
},
yaxis={
'title': yaxis_column_name,
'type': 'linear' if yaxis_type == 'Linear' else 'log'
},
margin={
'l': 40,
'b': 30,
't': 10,
'r': 0
},
height=450,
hovermode='closest')
}
def create_time_series(dff, axis_type, title):
return {
'data':
[dict(x=dff['Year'], y=dff['Value'], mode='lines+markers')],
'layout': {
'height':
225,
'margin': {
'l': 20,
'b': 30,
'r': 10,
't': 10
},
'annotations': [{
'x': 0,
'y': 0.85,
'xanchor': 'left',
'yanchor': 'bottom',
'xref': 'paper',
'yref': 'paper',
'showarrow': False,
'align': 'left',
'bgcolor': 'rgba(255, 255, 255, 0.5)',
'text': title
}],
'yaxis': {
'type': 'linear' if axis_type == 'Linear' else 'log'
},
'xaxis': {
'showgrid': False
}
}
}
@app.callback(dash.dependencies.Output('x-time-series', 'figure'), [
dash.dependencies.Input('crossfilter-indicator-scatter', 'hoverData'),
dash.dependencies.Input('crossfilter-xaxis-column', 'value'),
dash.dependencies.Input('crossfilter-xaxis-type', 'value')
])
def update_y_timeseries(hoverData, xaxis_column_name, axis_type):
country_name = hoverData['points'][0]['customdata']
dff = df[df['Country Name'] == country_name]
dff = dff[dff['Indicator Name'] == xaxis_column_name]
title = '<b>{}</b><br>{}'.format(country_name, xaxis_column_name)
return create_time_series(dff, axis_type, title)
@app.callback(dash.dependencies.Output('y-time-series', 'figure'), [
dash.dependencies.Input('crossfilter-indicator-scatter', 'hoverData'),
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)
return app
import plotly.graph_objects as go
import pandas as pd
import json
# Load Data
#df = px.data.tips()
df = pd.read_csv('FcstCompare.csv', parse_dates=True)
with open('../shps/AEZs.geojson') as f:
counties = json.load(f)
for feature in counties["features"]:
feature['id'] = str(feature['properties']['COUNTY'])
# Build App
app = JupyterDash(__name__)
app.layout = html.Div([
html.H1("RHEAS-DSSAT Demo"),
dcc.Dropdown(id='fcst-dropdown',
clearable=False,
value='fcst_dates',
options=[{
'label': f,
'value': f
} for f in df['fcst_date'].unique()]),
dcc.Graph(id='map'),
dcc.Graph(id='graph'),
dcc.Dropdown(id='cnty-dropdown',
clearable=False,
value='fcst_dates',
options=[{
def init_app(self):
app = JupyterDash(__name__)
# app = dash.Dash()
app.css.config.serve_locally = True
app.scripts.config.serve_locally = True
# self.add_rec(['main', 'MLPClassifier'], 'alpha=0.1', self.icicle_data)
# self.add_rec(['main', 'MLPClassifier'], 'alpha=0.01', self.icicle_data)
def df_to_dict(ut):
data = {}
for col_name in self.hierarchy_path:
for i, g in ut.groupby(col_name):
data_key = g[col_name].iloc[0]
data[data_key] = {}
data = copy.deepcopy(self.icicle_data)
icicle_plot_fig = icicle_plot.Icicle(id='icicle_plot_fig',
value='main/',
label='my-label',
low=self.low_color,
high=self.high_color,
data=data)
def make_ints(row):
for col in self.hierarchy_path:
if row[col] != None:
try:
row[col] = float(row[col].split("=")[1])
except:
row[col]
return row
pc_data_numeric = self.pc_data.apply(make_ints, axis=1)
pc = go.Figure(data=[go.Scatter(x=[], y=[])])
if self.pc_data is not 0 and not self.pc_data.empty:
pc = px.parallel_coordinates(pc_data_numeric.apply(make_ints,
axis=1),
color="accuracy",
dimensions=self.hierarchy_path +
['accuracy'],
color_continuous_scale='RdBu',
height=350)
pc_o = pc
marks = {}
for i in range(0, 100, 10):
marks[i / 100] = str(i / 100)
button_style = {
"background-color": "#008CBA",
"border": "none",
"color": "white",
"padding": "15px 32px",
"text-align": "center",
"display": "inline-block",
"font-size": 16,
"margin": "4px 2px",
"cursor": "pointer",
"width": "150px",
"border-radius": "5%"
}
app.layout = html.Div(
[
html.Div(
[
html.Div(icicle_plot_fig, id='icicle-wrap'),
dcc.Graph(id='pc', figure=pc, style={'height': 350}),
dcc.Interval(
id='interval-component',
interval=1000, # in milliseconds
n_intervals=0),
dcc.Interval(
id='interval-component2',
interval=1000, # in milliseconds
n_intervals=0),
dcc.Interval(id='interval-loading',
interval=100,
n_intervals=0),
html.H3('Sand Box', id='sandboxtext'),
dcc.Textarea(id='sandbox',
value='',
style={
'height': 120,
'width': '90%'
}),
html.Div([
html.Button('Execute',
id='execute-button',
style=button_style),
dcc.Loading(id="loading",
children=html.Div(
[html.Div(id='output')]),
type="circle",
style={'margin-bottom': '6%'})
])
],
style={
'width': '87%',
'height': '100%',
'float': 'left'
}),
html.Div([
dcc.RangeSlider(id='metric-slider',
min=0,
max=1,
step=0.01,
value=[0, 1],
marks=marks,
vertical=True,
verticalHeight=500)
],
style={
'margin-left': '90%',
'margin-top': '2%'
})
# html.Div([
# html.H3('Sand Box', id='sandboxtext', style={"text-align": 'center'}),
# dcc.Textarea(
# id='sandbox',
# value='',
# style={'height': 400}
# ),
# html.Div([
# html.Button('Execute', id='execute-button', style=button_style),
# dcc.Loading(
# id="loading",
# children=html.Div([
# html.Div(id='output')
# ]),
# type="circle"
# )
# ], style= {'right': 37, 'position': 'absolute'})
# ], style={'margin-left': '5%'})
],
style={
'height': '100%',
'overflow': 'hidden'
})
@app.callback(Output('icicle-wrap', 'children'), [
Input('metric-slider', 'value'),
Input('interval-component', 'n_intervals')
])
def update_icicle(rangeData, n):
trigger_context = dash.callback_context.triggered[0]['prop_id']
if len(dash.callback_context.triggered
) <= 1 and self.update_available == False and (
trigger_context == 'interval-component.n_intervals'
or trigger_context == '.'):
raise PreventUpdate
# revert to original state
data = copy.deepcopy(self.icicle_data)
# print(data)
if not self.pc_data.empty:
# delete entries
self.remove_nodes_out_of_range(rangeData[0], rangeData[1],
data)
filtered_accs = self.pc_data.query(
"accuracy >= " + str(rangeData[0]) + " and accuracy <= " +
str(rangeData[1]))['accuracy']
self.low_color = filtered_accs.min()
self.high_color = filtered_accs.max()
if rangeData != self.rangeDataOld:
self.id_updater += 1
self.rangeDataOld = rangeData
if self.update_available:
# print("update vailable")
self.id_updater += 1
self.update_available = False
# id is dictionary for Dash pattern matching callbacks
return icicle_plot.Icicle(id={
'role': 'icicle_plot_fig',
'index': self.id_updater
},
value='main/',
label='my-label',
low=self.low_color,
high=self.high_color,
data=data)
@app.callback(Output('pc', 'figure'), [
Input({
'role': 'icicle_plot_fig',
'index': ALL
}, 'value'),
Input('metric-slider', 'value'),
Input('interval-component2', 'n_intervals')
])
def update_pc(clickData, rangeData, n):
if self.pc_data.empty:
return go.Figure(data=[go.Scatter(x=[], y=[])])
trigger_context = dash.callback_context.triggered[0]['prop_id']
if len(dash.callback_context.triggered
) <= 1 and self.update_available == False and (
trigger_context == 'interval-component2.n_intervals'):
raise PreventUpdate
pc_data_copy = self.pc_data
if len(clickData) == 0:
if self.update_available:
pc = px.parallel_coordinates(
pc_data_copy.apply(make_ints, axis=1),
color="accuracy",
dimensions=self.hierarchy_path + ['accuracy'],
color_continuous_scale='RdBu',
height=350)
return pc
raise PreventUpdate
# return self.pc
# revert to original state
# delete entries
pc_data_copy = pc_data_copy.query("accuracy >= " +
str(rangeData[0]) +
" and accuracy <= " +
str(rangeData[1]))
if isinstance(clickData, list):
clickData = clickData[0]
if 'recommendationval' in clickData:
raise PreventUpdate
if clickData.split("/")[:-2] == []:
pc = px.parallel_coordinates(pc_data_copy.apply(make_ints,
axis=1),
color="accuracy",
dimensions=self.hierarchy_path +
['accuracy'],
color_continuous_scale='RdBu',
height=350)
return pc
if clickData:
click_path = clickData.split("/")[:-1][1:]
subset_counter = len(click_path)
if click_path == []:
return pc_o
selected_df = pc_data_copy
j = -1
for i in click_path:
j += 1
if "=" in i:
comps_name = i.split("=")
hyp_name = comps_name[0]
hyp_val = comps_name[1]
selected_df = selected_df[selected_df.apply(
lambda x: x['model_params'][hyp_name] == hyp_val
if hyp_name in x['model_params'] else False,
axis=1)]
else:
selected_df = selected_df[selected_df['model'] == i]
sample_vals = selected_df.iloc[0]
labels_pc = {}
for i in self.hierarchy_path[subset_counter:]:
if sample_vals[i]:
labels_pc[i] = sample_vals[i].split("=")[0]
selected_df = selected_df.apply(make_ints, axis=1)
self.pc = px.parallel_coordinates(
selected_df,
color="accuracy",
dimensions=self.hierarchy_path[subset_counter:] +
['accuracy'],
labels=labels_pc,
color_continuous_scale='RdBu',
height=350)
# print(pc_data_copy.apply(make_ints, axis=1))
return self.pc
self.pc = px.parallel_coordinates(pc_data_copy.apply(make_ints,
axis=1),
color="accuracy",
dimensions=self.hierarchy_path +
['accuracy'],
color_continuous_scale='RdBu',
height=350)
return self.pc
@app.callback(
Output('sandbox', 'value'),
[Input({
'role': 'icicle_plot_fig',
'index': ALL
}, 'value')])
def update_sandbox(clickData):
if len(clickData) == 0:
raise PreventUpdate
if isinstance(clickData, list):
clickData = clickData[0]
if 'recommendationval' in clickData:
# update the sand box
clickData = clickData.replace(" recommendationval", "")
model_name = ""
params_rec = {}
for i in clickData.split("/"):
if 'main' in i or not i or not i.strip():
continue
# model name
if '=' not in i:
model_name = i
continue
try:
params_rec[i.split("=")[0]] = float(i.split(
"=")[1]) # for int, long, float and complex
if params_rec[i.split("=")[0]].is_integer():
params_rec[i.split("=")[0]] = int(
params_rec[i.split("=")[0]])
except ValueError:
params_rec[i.split("=")[0]] = i.split("=")[1]
code = "app.experiment(\nlibrary = 'sklearn',\nmodel = " + model_name + ",\nparams = \n" + str(
params_rec).replace('{', '{\n ').replace(
',', ',\n ').replace('}',
'\n}') + ",\nhighlighted = True)"
return code
else:
raise PreventUpdate
@app.callback(Output('execute-button', 'style'),
[Input('interval-loading', 'n_intervals')])
def check_execution(n_intervals):
button_style = {
"background-color": "#008CBA",
"border": "none",
"color": "white",
"padding": "15px 32px",
"text-align": "center",
"display": "inline-block",
"font-size": 16,
"margin": "4px 2px",
"cursor": "pointer",
"width": "150px",
"border-radius": "5%"
}
if not self.running_experiment and not self.running_recommendation:
return button_style
if self.running_recommendation:
button_style['visibility'] = "hidden"
button_style["cursor"] = 'not-allowed'
button_style['pointer-events'] = "none"
return button_style
button_style["cursor"] = 'not-allowed'
button_style['pointer-events'] = "none"
button_style["opacity"] = 0.5
return button_style
# execute button handler
app.callback(Output('output',
'value'), [Input('execute-button', 'n_clicks')],
[State('sandbox', 'value')])(self.execute_code)
self.app = app
filter_action='none',
sort_action="native",
style_cell={
'textAlign': 'center',
'font-family': 'sans-serif'
},
editable=False))
])
content = html.Div([
html.H2('Transcript Review Tool', style=TEXT_STYLE),
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
id="fade-transition-button",
className="mb-3",
n_clicks=0), fade
])
]))
result_card = dbc.Card([dbc.CardBody([dbc.Row([result_blurb])])])
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:
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
from jupyter_dash import JupyterDash
import plotly.graph_objects as go
import plotly.express as px
from flask import Flask
import numpy as np # library to handle data in a vectorized manner
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
import requests # library to handle requests
from urllib.request import urlopen
from urllib.request import Request
app = JupyterDash(__name__)
app.config.suppress_callback_exceptions = True
#state_AT = pd.read_csv('C:/Users/Raihan/Downloads/JUPYTER LAB/state_AT.csv')
url = 'https://github.com/Roijin/Covid-Dash-App/blob/808bc92d8a4107a97f98ca836b5050e700aa798e/state_AT.csv?raw=true'
state_AT = pd.read_csv(url)
states = state_AT['code']
cells = state_AT['Cell_Num']
cases = state_AT['Total Cases']
q1, q2, q3 = state_AT['Cell_Num'].quantile([.25, .5, .75])
q4 = state_AT['Cell_Num'].max()
# Just replace the standard `dash.Dash` class with the `jupyter_dash.JupyterDash` subclass.
# %%
from jupyter_dash import JupyterDash
# %%
import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
# %% [markdown]
# When running in JupyterHub or Binder, call the `infer_jupyter_config` function to detect the proxy configuration.
# %%
JupyterDash.infer_jupyter_proxy_config()
# %% [markdown]
# Load and preprocess data
# %%
df = pd.read_csv('https://plotly.github.io/datasets/country_indicators.csv')
available_indicators = df['Indicator Name'].unique()
# %% [markdown]
# Construct the app and callbacks
# %%
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = JupyterDash(__name__, external_stylesheets=external_stylesheets)
# In[41]:
import plotly
import plotly.graph_objects as go
# import dash
from jupyter_dash import JupyterDash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output
external_stylesheets=[{'crossorigin':'anonymous','rel':'stylesheet','href':"https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"}]
app = JupyterDash(__name__,external_stylesheets=external_stylesheets)
# app = dash.Dash(__name__)
server = app.server
site_indicators = result['Site'].unique().tolist()
all_options={}
config={"editable":True, "edits":{"shapePosition": False}, #"scrollZoom": False,
'modeBarButtonsToAdd':['drawline',
# 'drawopenpath',
# 'drawclosedpath',
'drawcircle',
'drawrect',
'eraseshape'
],
'modeBarButtonsToRemove':['lasso2d',
# 'drawopenpath',
# 'drawclosedpath',
# replace invalid values in 'Installs', 'Size' and 'Price' columns with nans
df['Price'] = df['Price'].replace('Everyone', np.nan)
df['Installs'] = df['Installs'].replace('Free', np.nan)
df['Size'] = df['Size'].replace('Varies with device', np.nan)
# convert the column type
df['Installs'] = pd.to_numeric(df['Installs'])
df['Size'] = pd.to_numeric(df['Size'])
df['Price'] = pd.to_numeric(df['Price'])
# drop the invalid value from 'Type' column
df.drop(df.index[df['Type'] == '0'], inplace=True)
#------------------------------------------------------------ build app -------------------------------------------------------------------
app = JupyterDash(__name__)
app.layout = html.Div(children=[
# All elements from the top of the page
html.Div([
html.H1("App Store Dashboard", style={'text-align': 'center'}),
html.P('Select The Type Of The App:'),
dcc.Dropdown(id="type_select",
options=[{
"label": "Free",
"value": "Free"
}, {
"label": "Paid",
"value": "Paid"
}],
multi=False,
value="Free",
df: Input airline data.
Returns:
Computed average dataframes for carrier delay, weather delay, NAS delay, security delay, and late aircraft delay.
"""
def compute_data_choice_2(df):
# Compute delay averages
avg_car = df.groupby(['Month','Reporting_Airline'])['CarrierDelay'].mean().reset_index()
avg_weather = df.groupby(['Month','Reporting_Airline'])['WeatherDelay'].mean().reset_index()
avg_NAS = df.groupby(['Month','Reporting_Airline'])['NASDelay'].mean().reset_index()
avg_sec = df.groupby(['Month','Reporting_Airline'])['SecurityDelay'].mean().reset_index()
avg_late = df.groupby(['Month','Reporting_Airline'])['LateAircraftDelay'].mean().reset_index()
return avg_car, avg_weather, avg_NAS, avg_sec, avg_late
# Create a dash application
app = JupyterDash(__name__)
JupyterDash.infer_jupyter_proxy_config()
app.config.suppress_callback_exceptions = True
# Application layout
app.layout = html.Div(children=[
html.H1('US Domestic Airline Flights Performance', style={'textAlign': 'center', 'color': '#503D36', 'font-size': 24}),
# Create an outer division
html.Div([
# Add an division
html.Div([
# Create a division for adding dropdown helper text for report type
html.Div(
[
def __init__(self, model, N_handles=4):
self.model = model
# Generate an initial state
init_state = dict(
signal_mode='sin', # sin, am, fm, qpsk_bb, or qpsk_if
fc=20000,
fm=2000,
agc_ref=0.7,
agc_alpha=0.6,
agc_window=6,
agc_graph_mode='time', # time, const, freq
t=self.model.t,
N_handles=N_handles,
handle_pos=[
((i + 1) * self.model.N / self.model.fs / (N_handles + 1), 1)
for i in range(N_handles)
],
)
(init_state['i'],
init_state['q']) = model.ref_signal(init_state['signal_mode'],
init_state['fc'],
init_state['fm'])
model.agc_cfg(1, init_state['agc_window'], init_state['agc_ref'],
init_state['agc_alpha'])
(init_state['agc_i'], init_state['agc_q'],
init_state['agc_g']) = model.agc_loopback(init_state['i'],
init_state['q'])
# Set preset configurations
init_state['presets'] = {
'Default': {
'signal_mode':
'sin',
'fm':
2000,
'fc':
20000,
'agc_ref':
0.7,
'agc_alpha':
0.7,
'agc_window':
64,
'agc_bypass':
False,
'agc_graph_mode':
'time',
'handle_pos':
[(x * self.model.N / self.model.fs, y)
for (x, y) in [(0.2, 1.0), (0.4, 1.0), (0.6, 1.0), (0.8, 1.0)]
],
},
'Slow fading': {
'signal_mode':
'sin',
'fm':
2000,
'fc':
40000,
'agc_ref':
0.7,
'agc_alpha':
1.0,
'agc_window':
64,
'agc_bypass':
False,
'agc_graph_mode':
'time',
'handle_pos':
[(x * self.model.N / self.model.fs, y)
for (x, y) in [(0.1, 1.0), (0.4, 0.2), (0.5, 0.2), (0.9, 1.0)]
],
},
'AM envelope preservation': {
'signal_mode':
'am',
'fm':
8000,
'fc':
80000,
'agc_ref':
0.4,
'agc_alpha':
0.9,
'agc_window':
256,
'agc_bypass':
False,
'agc_graph_mode':
'time',
'handle_pos':
[(x * self.model.N / self.model.fs, y)
for (x, y) in [(0.1, 1.0), (0.105, 0.1), (0.6,
0.1), (0.62, 1.0)]],
},
'Packet preambles with QPSK': {
'signal_mode':
'qpsk_bb',
'fm':
8000,
'fc':
80000,
'agc_ref':
0.7,
'agc_alpha':
0.5,
'agc_window':
64,
'agc_bypass':
False,
'agc_graph_mode':
'time',
'handle_pos':
[(x * self.model.N / self.model.fs, y)
for (x, y) in [(0.18, 0), (0.181, 1.0), (0.68, 1.0), (0.681,
0)]],
},
}
self.init_state = init_state
view = view_template(init_state)
# Make Dash app
app = JupyterDash(
__name__,
external_stylesheets=[
dbc.themes.BOOTSTRAP,
'https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css'
])
app.layout = view
self.app = app
@app.callback(Output('agc-ref-label', 'children'),
[Input('agc-ref', 'value')])
def update_data_rate_label(f):
return f'{int(f*100)} %'
@app.callback(Output('agc-window-label', 'children'),
[Input('agc-window', 'value')])
def update_data_rate_label(f):
return f'{int(2**f)} Samples'
@app.callback(Output('agc-alpha-label', 'children'),
[Input('agc-alpha', 'value')])
def update_data_rate_label(f):
return str(f)
@app.callback(Output('in-f-data-label', 'children'),
[Input('in-f-data', 'value')])
def update_data_rate_label(f):
return f'{int(f)} Hz'
@app.callback(Output('in-f-carrier-label', 'children'),
[Input('in-f-carrier', 'value')])
def update_carrier_label(f):
return f'{int(f)} kHz'
@app.callback([
Output('in-sig-type', 'value'),
Output('in-f-carrier', 'value'),
Output('in-f-data', 'value'),
Output('agc-ref', 'value'),
Output('agc-alpha', 'value'),
Output('agc-window', 'value'),
Output('agc-bypass', 'value'),
Output('agc-graph-mode', 'value'),
Output('new-env-preset', 'value'),
], [Input('preset-option', 'value')])
def set_to_preset(preset_name):
preset = self.init_state['presets'][preset_name]
# Return new GUI values
return (preset['signal_mode'], preset['fc'] / 1000, preset['fm'],
preset['agc_ref'], preset['agc_alpha'],
int(np.log2(preset['agc_window'])), preset['agc_bypass'],
preset['agc_graph_mode'], str(preset['handle_pos']))
@app.callback([
Output('graph-inputs', 'figure'),
Output('new-input-signal', 'children')
], [
Input('graph-inputs', 'relayoutData'),
Input('btn-add-handle', 'n_clicks'),
Input('btn-rm-handle', 'n_clicks'),
Input('in-sig-type', 'value'),
Input('in-f-carrier', 'value'),
Input('in-f-data', 'value'),
Input('new-env-preset', 'value'),
], [State('graph-inputs', 'figure')])
def input_stage_callback(_, _btnadd, _btnrm, in_sig_type, in_f_carrier,
in_data_rate, env_preset, fig_in):
changed_ids = [
p['prop_id'] for p in dash.callback_context.triggered
]
if 'btn-add-handle' in changed_ids[0]:
add_envelope_handle(fig_in['layout']['shapes'],
max(self.model.t))
if 'btn-rm-handle' in changed_ids[0]:
rm_envelope_handle(fig_in['layout']['shapes'])
if any(map(lambda x: 'new-env-preset' in x, changed_ids)):
h_template = get_envelope_handle(fig_in['layout']['shapes'], 0)
points = ast.literal_eval(env_preset)
if points:
new_shapes = []
for (i, (x, y)) in enumerate(points):
p = dict(h_template)
p.update({
'name': 'envelope_' + str(i),
'xanchor': x,
'yanchor': y,
})
new_shapes.append(p)
fig_in['layout']['shapes'] = new_shapes
in_f_carrier = in_f_carrier * 1000
(ref_i, ref_q) = self.model.ref_signal(in_sig_type, in_f_carrier,
in_data_rate)
handles = get_envelope_handles(fig_in['layout']['shapes'])
env = self.model.envelope(handles)
(trace_i, trace_q) = self.model.test_input((ref_i, ref_q), env)
trace_t = self.model.t
fig_in['data'][0]['x'] = trace_t
fig_in['data'][0]['y'] = trace_i
fig_in['data'][1]['x'] = trace_t
fig_in['data'][1]['y'] = trace_q
return fig_in, [
f'{in_sig_type} {in_f_carrier} {in_data_rate}, {handles}'
]
@app.callback(Output('graph-agc', 'figure'), [
Input('new-input-signal', 'children'),
Input('agc-ref', 'value'),
Input('agc-alpha', 'value'),
Input('agc-window', 'value'),
Input('agc-bypass', 'value'),
Input('agc-graph-mode', 'value')
], [State('graph-inputs', 'figure'),
State('graph-agc', 'figure')])
def agc_stage_callback(_, agc_ref, agc_alpha, agc_window, agc_bypass,
graph_mode, fig_in, fig_agc):
# TODO Check if State uses client... if so, remove the graph-inputs state arg to avoid round trip for no reason
agc_en = 0 if agc_bypass else 1
self.model.agc_cfg(agc_en, agc_window, agc_ref, agc_alpha)
(trace_i, trace_q) = (fig_in['data'][0]['y'],
fig_in['data'][1]['y'])
(agc_i, agc_q, agc_g) = self.model.agc_loopback(trace_i, trace_q)
trace_t = self.model.t
if graph_mode == 'time':
fig_agc['data'][0]['x'] = trace_t
fig_agc['data'][0]['y'] = agc_i
fig_agc['data'][1]['x'] = trace_t
fig_agc['data'][1]['y'] = agc_q
fig_agc['data'][2]['x'] = trace_t
fig_agc['data'][2]['y'] = agc_g
fig_agc['layout']['xaxis']['title'] = "Time (s)"
fig_agc['layout']['yaxis']['title'] = "Normalised Amplitude"
fig_agc['layout']['shapes'] = [
dict(
visible=True,
type='rect',
editable=False,
layer='below',
opacity=0.6,
fillcolor='#DCD8EA',
xref='x',
x0=self.model.t[-1] - (2**agc_window / self.model.fs),
x1=self.model.t[-1],
yref='y',
y0=-1,
y1=1,
line={'width': -1},
)
]
if graph_mode == 'const':
fig_agc['data'][0]['x'] = agc_i
fig_agc['data'][0]['y'] = agc_q
fig_agc['data'][1]['x'] = []
fig_agc['data'][1]['y'] = []
fig_agc['data'][2]['x'] = []
fig_agc['data'][2]['y'] = []
fig_agc['layout']['xaxis']['title'] = "I Amplitude"
fig_agc['layout']['yaxis']['title'] = "Q Amplitude"
fig_agc['layout']['shapes'] = []
if graph_mode == 'freq':
(freq_x, freq_y) = self.model.calc_fft(agc_i, agc_q)
fig_agc['data'][0]['x'] = freq_x
fig_agc['data'][0]['y'] = freq_y
fig_agc['data'][1]['x'] = []
fig_agc['data'][1]['y'] = []
fig_agc['data'][2]['x'] = []
fig_agc['data'][2]['y'] = []
fig_agc['layout']['xaxis']['title'] = "Frequency (Hz)"
fig_agc['layout']['yaxis']['title'] = "Power dB"
fig_agc['layout']['shapes'] = []
return fig_agc
from jupyter_dash import JupyterDash
from nkicap.gradient import cap_to_gradient
from nkicap.utils import get_project_path
gradient_space = cap_to_gradient(
Path(get_project_path()) / "data/cap_gradient_space.tsv"
)
gradient_space["type"] = None
mask_group = gradient_space["participant_id"] == "group"
gradient_space.loc[mask_group, "type"] = "group"
gradient_space.loc[~mask_group, "type"] = "sub"
app = JupyterDash(__name__)
app.layout = html.Div(
[
dcc.Graph(id="gradient-space"),
html.P("CAP label"),
dcc.Checklist(
id="cap-label",
options=[{"label": f"{i}", "value": f"{i}"} for i in range(1, 9)],
value=["1", "2"],
labelStyle={"display": "inline-block"},
),
]
)
@app.callback(Output("gradient-space", "figure"), [Input("cap-label", "value")])
from crystal_toolkit.helpers.layouts import Columns, Column
from crystal_toolkit.settings import SETTINGS
from jupyter_dash import JupyterDash
from pydefect.analyzer.calc_results import CalcResults
from pydefect.analyzer.dash_components.cpd_energy_dash import CpdEnergyComponent
from pydefect.chem_pot_diag.chem_pot_diag import ChemPotDiag, CpdPlotInfo, CompositionEnergy
from pydefect.corrections.manual_correction import ManualCorrection
from pydefect.input_maker.defect_entry import DefectEntry
from pymatgen import Composition, Structure, Lattice, Element
import dash_html_components as html
import crystal_toolkit.components as ctc
from dash.dependencies import Input, Output, State
import json
app = JupyterDash(suppress_callback_exceptions=True,
assets_folder=SETTINGS.ASSETS_PATH)
from vise.analyzer.band_edge_properties import BandEdge
comp_energies = [
CompositionEnergy(Composition("Mg"), 0.0, "a"),
CompositionEnergy(Composition("Ca"), 0.0, "a"),
CompositionEnergy(Composition("Sr"), 0.0, "a"),
CompositionEnergy(Composition("O"), 0.0, "a"),
CompositionEnergy(Composition("H"), 0.0, "a"),
# CompositionEnergy(Composition("MgCaO3"), -100.0, "a"),
CompositionEnergy(Composition("MgCaSrO3"), -100.0, "a"),
]
#cpd = ChemPotDiag(comp_energies, target=Composition("MgCaO3"))
cpd = ChemPotDiag(comp_energies, target=Composition("MgCaSrO3"))
cpd_plot_info = CpdPlotInfo(cpd)
color_discrete_map={
'male': 'blue',
'female': 'red'
})
gss_p6.update(layout=dict(title=dict(x=0.5)))
gss_p6.update_layout(showlegend=False)
mycol_ch2 = [
'satjob', 'relationship', 'male_breadwinner', 'men_bettersuited',
'child_suffer', 'men_overwork'
]
cat_columns3 = ['sex', 'region', 'education']
anes_ft2 = gss_clean[mycol_ch2 + cat_columns3].dropna()
anes_ft2['index_col'] = anes_ft2.index
app = JupyterDash(__name__, external_stylesheets=external_stylesheets)
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
colors = {'background': '#111111', 'text': '#7FDBFF'}
table.update_layout(plot_bgcolor=colors['background'],
paper_bgcolor=colors['background'],
font_color=colors['text'])
gss_p3.update_layout(plot_bgcolor=colors['background'],
paper_bgcolor=colors['background'],
font_color=colors['text'])
app.layout = html.Div([
html.H1("Wage gap study"),
dcc.Markdown(style={
"background-color": "yellow",
import pandas as pd
! pip install dash==0.36.0rc1
! pip install dash_html_components
! pip install dash_core_components
import dash
! pip install jupyter-dash
from jupyter_dash import JupyterDash
import dash_html_components as html
import dash_core_components as dcc
from dash.dependencies import Input, Output, State
import plotly.graph_objects as go
import plotly.express as px
# Create a dash application
app = JupyterDash(__name__)
JupyterDash.infer_jupyter_proxy_config()
# REVIEW1: Clear the layout and do not display exception till callback gets executed
app.config.suppress_callback_exceptions = True
# Read the airline data into pandas dataframe
airline_data = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DV0101EN-SkillsNetwork/Data%20Files/airline_data.csv',
encoding = "ISO-8859-1",
dtype={'Div1Airport': str, 'Div1TailNum': str,
'Div2Airport': str, 'Div2TailNum': str})
# List of years
year_list = [i for i in range(2005, 2021, 1)]
if selected_value == 1:
return random.choice([
"/content/network-snapshot-000480.pkl",
"/content/network-snapshot-000492.pkl",
])
else:
return random.choice([
"/content/network-snapshot-000612.pkl",
"/content/network-snapshot-000624.pkl",
"/content/network-snapshot-000636.pkl",
])
img_no = 50
app = JupyterDash(external_stylesheets=[dbc.themes.DARKLY])
server = app.server
navbar = dbc.NavbarSimple(
children=[
dbc.NavItem(
dbc.NavLink(
"Github Repo",
href="https://github.com/mphirke/fire-emblem-fake-portaits-GBA",
target="_blank",
style={"font-weight": "bold"},
)),
],
style={
"margin-bottom": "20px",
"padding": "5px"
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
# Import required libraries
import pandas as pd
import dash
import dash_html_components as html
import dash_core_components as dcc
from dash.dependencies import Input, Output, State
from jupyter_dash import JupyterDash
import plotly.graph_objects as go
import plotly.express as px
from dash import no_update
# Create a dash application
app = JupyterDash(__name__)
JupyterDash.infer_jupyter_proxy_config()
# REVIEW1: Clear the layout and do not display exception till callback gets executed
app.config.suppress_callback_exceptions = True
# Read the airline data into pandas dataframe
airline_data = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DV0101EN-SkillsNetwork/Data%20Files/airline_data.csv',
encoding = "ISO-8859-1",
dtype={'Div1Airport': str, 'Div1TailNum': str,
'Div2Airport': str, 'Div2TailNum': str})
# List of years
year_list = [i for i in range(2005, 2021, 1)]
"""Compute graph data for creating yearly airline performance report
from callbacks import register_callbacks
###############################################################################
# Start coding
# For the structure of the app, I took Phillippe's advice from this thread:
# https://community.plotly.com/t/dash-callback-in-a-separate-file/14122/15
##### Use Dash if running the script in Anaconda prompt #####
##### Use JupyterDash if running in Spyder (or Jupyter Notebook) #####
shell = ''
try:
shell = get_ipython().__class__.__name__
if shell == 'ZMQInteractiveShell':
app = JupyterDash(__name__,
external_stylesheets=[dbc.themes.BOOTSTRAP])
elif shell == 'TerminalInteractiveShell':
app = dash.Dash(__name__)
# , 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__':
# Copyright (C) 2021, RTE (http://www.rte-france.com/)
# See AUTHORS.txt
# SPDX-License-Identifier: MPL-2.0
"""
This file handles the html entry point of the application through dash components.
It will generate the layout of a given page and handle the routing
"""
import dash_bootstrap_components as dbc
# from dash import Dash
from jupyter_dash import JupyterDash
# We need to create app before importing the rest of the project as it uses @app decorators
JupyterDash.infer_jupyter_proxy_config(
) # for binder or jupyterHub for instance
app = JupyterDash(__name__, external_stylesheets=[
dbc.themes.BOOTSTRAP
]) # ,server_url="http://127.0.0.1:8050/")
"""
Get Imports to create layout and callbacks
"""
from grid2viz.main_callbacks import register_callbacks_main
from grid2viz.layout import make_layout as layout
from grid2viz.src.episodes.episodes_clbk import register_callbacks_episodes
from grid2viz.src.overview.overview_clbk import (
register_callbacks_overview, ) # as overview_clbk
from grid2viz.src.macro.macro_clbk import register_callbacks_macro # as macro_clbk
from grid2viz.src.micro.micro_clbk import register_callbacks_micro # as micro_clbk
"""
# code and plot setup
# settings
pd.options.plotting.backend = "plotly"
countdown = 20
#global df
# sample dataframe of a wide format
cols = ['temperature']
X = np.ones(50) * 18
df = pd.DataFrame(X, columns=cols)
# plotly figure
fig = df.plot(template='plotly_dark')
app = JupyterDash(__name__)
app.layout = html.Div([
html.H1("Winecellar temperatures"),
dcc.Interval(
id='interval-component',
interval=20 * 1000, # in milliseconds
n_intervals=0),
dcc.Graph(id='graph'),
])
# Define callback to update graph
@app.callback(Output('graph', 'figure'),
[Input('interval-component', "n_intervals")])
def streamFig(value):
