def create_callbacks():
global display_value
try:
display_value
except Exception:
if det_dict:
@app.callback(
Output('hidden-div-det', 'children'),
[*[Input(f'{det_id}_hvolt', 'value') for det_id in det_dict],
*[Input(f'{det_id}_threshvolt', 'value') for det_id in det_dict]])
def display_value(*values):
ctx = dash.callback_context
trigger_id = ctx.triggered[0]['prop_id']
trigger_id = trigger_id.rstrip(
'on').rstrip('value').rstrip('.')
trigger_value = dash.callback_context.triggered[0]['value']
if trigger_id != '' and '_hvolt' in trigger_id:
det_dict[trigger_id.strip('_hvolt')].hvolt = trigger_value
if trigger_id != '' and '_threshvolt' in trigger_id:
det_dict[trigger_id.strip(
'_threshvolt')].threshvolt = trigger_value
if trigger_id != '':
det_dict[trigger_id.split('_')[0]].save_settings()
return f'{trigger_id}, {trigger_value}'
for det_id in det_dict:
if not det_id + "button_pressed" in globals():
func_name = det_id + "button_pressed"
globals()[det_id + "button_pressed"] = func_name
def func_name(n):
ctx = dash.callback_context
trigger_id = ctx.triggered[0]['prop_id']
trigger_id = trigger_id.rstrip(
'on').rstrip('value').rstrip('.')
trigger_value = dash.callback_context.triggered[0]['value']
if n is None:
return ''
else:
detector = det_dict[trigger_id.strip(
'_counts_button.n_clicks')]
detector.time = 1000
counts = detector.counts()
return str(counts) + ' counts per second'
app.callback(Output(f'{det_id}_counts_label', 'children'), [Input(f'{det_id}_counts_button', 'n_clicks')])(func_name)
def add_heading_from_search_callback(id_preset):
"""
Returns a callback to add the 2nd part of a page heading on page load.
:param id_preset: preset of id, e.g. <preset>-heading-part2, & search arg
"""
def generate_callback(id_preset):
def insert_heading(_, search):
parsed_search = parse.parse_qs(search[1:])
return parsed_search[id_preset]
return insert_heading
trigger_id = id_preset + '-heading-part1'
heading_id = id_preset + '-heading-part2'
# Add the callback
app.callback(Output(heading_id,
'children'), [Input(trigger_id, 'children')],
[State('url', 'search')])(generate_callback(id_preset))
def add_test_details_callbacks(id_preset):
"""
This function will add callbacks for all possible tests.
Unfortunately, callbacks can not be dynamically generated for each new test
added. Therefore, we have to add a finite number of them and hope we never
need more.
:param id_preset: preset for id, e.g. <preset>-test-output-<number>
"""
def generate_callbacks():
"""
Generate the callback function for toggling test output visibility.
: returns: A callback function.
"""
def toggle_test_output_visibility(n):
if n % 2 == 0:
return [{
'display': 'none'
},
html.Div(className='triangle-down'),
"Show test output"]
return [{}, html.Div(className='triangle-up'), "Hide test output"]
return toggle_test_output_visibility
# Iterate through i in '0', '1', '2', ...
for i in list(map(str, range(0, 100))):
toggle_id = id_preset + '-test-toggle-output-' + i
output_id = id_preset + '-test-output-' + i
# And add the callback to each possible test-more-button
app.callback([
Output(output_id, 'style'),
Output(toggle_id, 'children'),
Output(toggle_id, 'title')
], [Input(toggle_id, 'n_clicks')])(generate_callbacks())
fig.update_layout(
# Colors
plot_bgcolor=colors['plot_background'],
paper_bgcolor=colors['background'],
font_color=colors['text'],
hoverlabel_bgcolor=colors['infobox'],
# Graph
title=
"<b>Energy Balance between Production and Consumption (excl. Exchanges)</b>",
xaxis_title="<b>Time</b>",
yaxis_title="<b>MWh/h</b>",
hovermode='x unified')
return fig
## Popover
def toggle_popover(n, is_open):
if n:
return not is_open
return is_open
for src in sources:
app.callback(
Output(f'popover-{src}', 'is_open'),
[Input(f'{src}-btn', 'n_clicks')],
[State(f'popover-{src}', 'is_open')],
)(toggle_popover)
if times.size:
time=np.max(times)
if time==t_r:
return router_dash_layout(router_id),True,False,False,False
elif time==t_nw:
return router_details(router_id,'network'),False,True,False,False
elif time==t_sw:
return router_details(router_id,'software'),False,False,True,False
else:
return router_details(router_id,'hardware'),False,False,False,True
return router_dash_layout(router_id),True,False,False,False
return generate_nw_details_tabs_sub
for router_id in get_list_of_routers():
app.callback(
[Output('dash_contents'+router_id,'children'),
Output('dash'+router_id,'active'),
Output('nw'+router_id,'active'),
Output('sw'+router_id,'active'),
Output('hw'+router_id,'active')],
[Input('dash'+router_id,'n_clicks_timestamp'),
Input('nw'+router_id,'n_clicks_timestamp'),
Input('sw'+router_id,'n_clicks_timestamp'),
Input('hw'+router_id,'n_clicks_timestamp'),
Input("update","n_intervals")]
)(generate_nw_details_tabs(router_id))
else:
existingvaluedef["value"] = "Multiple options selected"
return existingvaluedef
return set_dropdown_value_fund
# Add callbacks for all the filters
for filter_id, filter_def in FILTERS.items():
# callback to update the text showing filtered options next to the filter
if filter_def.get("type") in ["rangeslider"]:
app.callback(
Output("df-change-{}-wrapper".format(filter_id), "value"),
[Input("df-change-{}".format(filter_id), "value")],
[
State("df-change-{}".format(filter_id), "marks"),
State("df-change-{}-wrapper".format(filter_id), "value"),
],
)(set_dropdown_value(filter_id, filter_def))
else:
app.callback(
Output("df-change-{}-wrapper".format(filter_id), "value"),
[Input("df-change-{}".format(filter_id), "value")],
[
State("df-change-{}".format(filter_id), "options"),
State("df-change-{}-wrapper".format(filter_id), "value"),
],
)(set_dropdown_value(filter_id, filter_def))
if filter_def.get("type") in ["dropdown", "multidropdown"]:
##Domain 1-6
def toggle_collapse_domain_selection_measures(n, is_open):
if n and n % 2 == 1:
return not is_open, "Confirm"
elif n and n % 2 == 0:
return not is_open, "Edit"
return is_open, "Edit"
for i in range(domain_ct):
app.callback(
[
Output(f"collapse-{i+1}", "is_open"),
Output(f"collapse-button-{i+1}", "children")
],
[Input(f"collapse-button-{i+1}", "n_clicks")],
[State(f"collapse-{i+1}", "is_open")],
)(toggle_collapse_domain_selection_measures)
def open_measure_lv2(n, is_open):
if n:
return [not is_open]
return [is_open]
for d in range(len(list(Domain_options.keys()))):
for i in range(
len(list(Domain_options[list(Domain_options.keys())[d]].keys()))):
app.callback(
color="dark",
dark=True,
className="mb-4",
style={'width': '100%'})
def toggle_navbar_collapse(n, is_open):
if n:
return not is_open
return is_open
for i in [2]:
app.callback(
Output(f"navbar-collapse{i}", "is_open"),
[Input(f"navbar-toggler{i}", "n_clicks")],
[State(f"navbar-collapse{i}", "is_open")],
)(toggle_navbar_collapse)
# embedding the navigation bar
app.layout = html.Div([
dcc.Location(id='url', refresh=False), navbar,
html.Div(id='page-content')
])
@app.callback(Output('page-content', 'children'), [Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/artworks':
return artworks.layout
else:
len(MaterialDF.PROPERTIES) + 1)
]
#if here, then callback was triggered by closing modal
# therefore, return False for all modals
dropdown_previous_state = n1
return [False for i in range(len(MaterialDF.PROPERTIES))]
#all properties with '°F' as units
def phys_update_range_output(value):
return 'You have selected between {} °F and {} °F'.format(
value[0], value[1])
for key, value in MaterialDF.PROPERTIES.items():
#FAW (PROPERTIES = 3) does not have °F as units
if key == 3:
continue
app.callback(
Output('output-container-range-slider-' + value, 'children'),
[Input('my-range-slider-' + value, 'value')])(phys_update_range_output)
#FAW
@app.callback(Output('output-container-range-slider-FAW', 'children'),
[Input('my-range-slider-FAW', 'value')])
def update_range_output_FAW(value):
return 'You have selected between {} g/m\N{SUPERSCRIPT TWO} and {} g/m\N{SUPERSCRIPT TWO}'.format(
value[0], value[1])
import dash_core_components as dcc
import dash_html_components as html
from app import app
server = app.server
from apps import world, country
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.layout = html.Div([
dcc.Location(id='url', refresh=False),
html.Div(id='page-content')
])
app.layout = html.Div([
dcc.ConfirmDialog(
id='confirm',
)
@app.callback(Output('page-content', 'children'),
[Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/country':
return country.layout
else:
return world.layout
if __name__ == '__main__':
app.run_server()
Callbacks to change which button is active in the menu
'''
def toggle_path_button(check_path):
def toggle_button(pathname):
if check_path == pathname:
return 'link active'
else:
return 'link'
return toggle_button
for check_path in ['onevariable', 'twovariables', 'wrtoutput']:
app.callback(
Output(check_path, 'className'),
[Input('url', 'pathname')])(toggle_path_button('/'+check_path))
'''
Serving css stylesheets
'''
css_directory = 'css'
stylesheets = ['main.css']
static_css_route = '/static/'
@app.server.route('{}<stylesheet>'.format(static_css_route))
def serve_stylesheet(stylesheet):
if stylesheet not in stylesheets:
what_to_display = html.Table(
generate_table_from_data(row, column, inv(matrix1)))
except:
what_to_display = "Matrix is not invertable."
else:
what_to_display = "Matrix has to be square in order to be inverted!"
else:
what_to_display = html.Table(
generate_table_from_data(row, column, (matrix1 + matrix2)))
return html.Div([html.Hr(), "Answer: ", what_to_display])
return output_callback
for value1, value2 in itertools.product(
# For each dropdown (One defining # of rows, the other defining # of columns
[o['value'] for o in layout['row_dropdown'].options],
[o['value'] for o in layout['column_dropdown'].options]):
app.callback(
# Get the output from dictionary depending on what the current row and column number is
Output(answer_options.get(str(value1)).get(str(value2)), 'children'),
# Input will always be the same - a button
[Input('answer_matrix_submit_button', 'n_clicks')],
# Have to generate states representing the dcc.Inputs based on what the current row/col count is. +1 because it's a list
[
State('t{}_r{}_c{}'.format(t, r, c), 'value') for t in range(1, 3)
for r in range(1, value1 + 1) for c in range(1, value2 + 1)
] + [State('answer_matrix_radio', 'value')])(generate_output_callback(
value1, value2))
State('service_detail_description', 'value'),
State('service_detail_price', 'value'),
State('service_detail_discount', 'value'),
State('service_detail_img_major', 'src'),
State('service_detail_checklist_online', 'values'),
State('service_detail_checklist_headline', 'values'),
]
state_list.extend(
[State(generate_img_id(i), 'src') for i in range(MAX_IMG_TXT)])
state_list.extend(
[State(generate_txt_id(i), 'value') for i in range(MAX_IMG_TXT)])
for i in range(MAX_IMG_TXT):
section_id, upload_id, img_id, txt_id = generate_id(i)
app.callback(Output(img_id, 'src'),
[Input(upload_id, 'contents')])(preview_img)
app.callback(Output('service_detail_img_major', 'src'),
[Input('service_detail_upload_major', 'contents')])(preview_img)
app.callback(Output(gen_id(SNACK_BAR), 'message'),
[Input('service_detail_button_submit', 'n_clicks')],
state_list)(update_service)
@app.callback(Output(gen_id(REDIRECT),
'href'), [Input(gen_id(SNACK_BAR), 'message')],
[State(gen_id(SNACK_BAR), 'open')])
def redirect_to_list(msg, open_snack_bar):
if msg == SUCCESS_UPDATE and open_snack_bar is False:
return "/service/list"
raise PreventUpdate()
def generate_callbacks(tags,generic=False):
if generic:
for tag in tags:
if tag['controlable']:
app.callback(Output(f'gen-params-Price-min-{tag["var"]}-sel','children'), [Input(f'gen-params-Price-min-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Price_min',tag["var"]))
app.callback(Output(f'gen-params-Price-max-{tag["var"]}-sel','children'), [Input(f'gen-params-Price-max-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Price_max',tag["var"]))
if tag['type']=='consumption':
app.callback(Output(f'gen-params-Power-min-{tag["var"]}-sel','children'), [Input(f'gen-params-Power-min-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Power_min',tag["var"]))
app.callback(Output(f'gen-params-Power-max-{tag["var"]}-sel','children'), [Input(f'gen-params-Power-max-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Power_max',tag["var"]))
if tag['solar']:
app.callback(Output(f'gen-params-solar-{tag["var"]}-sel','children'), [Input(f'gen-params-solar-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Solar_Installed',tag["var"]))
app.callback(Output(f'gen-general-{tag["var"]}-solar-sel','children'), [Input(f'gen-general-{tag["var"]}-solar', 'value')
])(TestGen.GenericFctSolar(tag["var"]))
app.callback(Output(f'gen-general-{tag["var"]}-click-sel','children'), [Input(f'gen-general-{tag["var"]}-click', 'n_clicks')
])(TestGen.GenericMenuSolar(tag["var"]))
app.callback(Output(f'gen-general-{tag["var"]}-sel','children'), [Input(f'gen-general-{tag["var"]}', 'value')
])(TestGen.GenericFct(tag["var"]))
else:
for tag in tags:
app.callback(Output(f'gen-general-{tag}-sel','children'), [Input(f'gen-general-{tag}', 'value')])(getattr(TestGen,tag))
#import plotly.graph_objs as go
#from collections import deque
#from loremipsum import get_sentences
layout = html.Div(TestGen.ShowApp(),
id='TestGen-container',
style={
'width': '98%',
'fontFamily': 'Sans-Serif',
'margin-left': 'auto',
'margin-right': 'auto'
}
)
#%% Callbacks
#%% General Tab layout
app.callback(Output('gen-tab-output', 'children'), [Input('gen-tabs', 'value')])(TestGen.ShowTab)
#%% General Menu
def generate_callbacks(tags,generic=False):
if generic:
for tag in tags:
if tag['controlable']:
app.callback(Output(f'gen-params-Price-min-{tag["var"]}-sel','children'), [Input(f'gen-params-Price-min-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Price_min',tag["var"]))
app.callback(Output(f'gen-params-Price-max-{tag["var"]}-sel','children'), [Input(f'gen-params-Price-max-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Price_max',tag["var"]))
if tag['type']=='consumption':
app.callback(Output(f'gen-params-Power-min-{tag["var"]}-sel','children'), [Input(f'gen-params-Power-min-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Power_min',tag["var"]))
app.callback(Output(f'gen-params-Power-max-{tag["var"]}-sel','children'), [Input(f'gen-params-Power-max-{tag["var"]}', 'value')
])(TestGen.GenericFctParams('Power_max',tag["var"]))
id="modal-body-scroll-4",
scrollable=True
)
])
# modal callback
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
app.callback(
Output("modal-body-scroll", "is_open"),
[
Input("open-body-scroll", "n_clicks"),
Input("close-body-scroll", "n_clicks"),
],
[State("modal-body-scroll", "is_open")
],
)(toggle_modal)
app.callback(
Output("modal-body-scroll-2", "is_open"),
[
Input("open-body-scroll-2", "n_clicks"),
Input("close-body-scroll-2", "n_clicks"),
],
[State("modal-body-scroll-2", "is_open")
],
)(toggle_modal)
# callback for card tabs in our journey page
def tab_content(active_tab):
if active_tab == 'our-journey-tab1':
return early_stages_tab_content
if active_tab == 'our-journey-tab2':
return data_collection_tab_content
if active_tab == 'our-journey-tab3':
return eda_tab_content
if active_tab == 'our-journey-tab4':
return results_tab_content
else:
return 'Error with loading content!'
app.callback(Output('our-journey-card-content', 'children'),
[Input('our-journey-card-tabs', 'active_tab')])(tab_content)
# modal callbacks for geospatial maps and visualizations in the visualizations view (one callback for each modal)
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
# for geo map modals showing the extra info we want it to show
app.callback(
Output('modal-overview-geomap', 'is_open'),
[
Input('open-modal-overview-geomap', 'n_clicks'),
Input('close-modal-overview-geomap', 'n_clicks')
if n:
return not is_open
return is_open
# this function applies the "open" class to rotate the chevron
def set_navitem_class(is_open):
if is_open:
return "open"
return ""
for i in [1, 2]:
app.callback(
Output(f"submenu-{i}-collapse", "is_open"),
[Input(f"submenu-{i}", "n_clicks")],
[State(f"submenu-{i}-collapse", "is_open")],
)(toggle_collapse)
app.callback(
Output(f"submenu-{i}", "className"),
[Input(f"submenu-{i}-collapse", "is_open")],
)(set_navitem_class)
@app.callback(Output("page-content", "children"), [Input("url", "pathname")])
def render_page_content(pathname):
if pathname in ["/", "/page-1/1"]:
return html.P("This is the content of page 1.1!")
elif pathname == "/page-1/2":
return html.P("This is the content of page 1.2. Yay!")
val,
pathname,
)
return val
raise PreventUpdate
return update_dropdown_from_url
for selector_id, page_state_key, default, is_multi in [
("numerators-dropdown", "numerators", None, True),
("denominator-tests-dropdown", "denominators", "", True),
("groupby-dropdown", "groupby", "lab_id", False),
]:
app.callback(Output(selector_id, "value"),
[Input("url-from-user", "pathname")])(
_create_dropdown_update_func(selector_id, page_state_key,
default, is_multi))
@app.callback(Output("chart-selector-tabs", "active_tab"),
[Input("url-from-user", "pathname")])
def update_chart_selector_tabs_from_url(pathname):
if pathname:
# Sometimes None for reasons explained here:
# https://github.com/plotly/dash/issues/133#issuecomment-330714608
try:
_, url_state = urls.match(pathname)
return url_state.get("page_id", "measure")
except NotFound:
return "measure"
raise PreventUpdate
return MarketTab.ShowTab()
elif tab_id=='Simulation':
SimTab.MGraph = MarketTab.MGraph
SimTab.Optimizer = MarketTab.Optimizer
return SimTab.ShowTab()
else:
return []
@app.callback(Output('market-graph-graph', 'children'),events=[Event('market-graph-interval', 'interval')])
def voidfct_IntervalGraphUpdate():
return MarketTab.MGraph.BuildGraphOfMarketGraph()
#%% Market tab
# Action's options
app.callback(Output('market-topmenu-second', 'children'),[Input('market-topmenu-insert','value')
])(MarketTab.TopMenu_Insert)
# Action's options - number
app.callback(Output('market-topmenu-third', 'children'),[Input('market-topmenu-second-drop','value')],[
State('market-topmenu-insert', 'value')
])(MarketTab.TopMenu_Number)
# Detect click on button 'Add'/'Select'
app.callback(Output('market-menu', 'children'),[Input('add-button', 'n_clicks')],
[State('market-topmenu-insert', 'value'),
State('market-topmenu-second-drop', 'value'),
State('market-topmenu-third-number', 'value')
])(MarketTab.Menu)
# Detect click on buttons Refresh
app.callback(Output('market-menu-agent-refresh', 'children'),[Input('agent-refresh-button', 'n_clicks')
# html.Button(id="submit-btn",n_clicks=0,children="apply"),
])
######################## Callbacks ###############################################
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
app.callback(
Output("modal-body-scroll", "is_open"),
[
Input("main_table", "selected_cells"),
Input("close-body-scroll", "n_clicks")
],
[State("modal-body-scroll", "is_open")],
)(toggle_modal)
@app.callback(Output("testingz", "children"), [
Input("main_table", "selected_cells"),
Input("main_table", "derived_virtual_data")
])
def toggle_details(t1, t2):
if t1:
print(t1)
print(t2[0])
print("row number:")
row_num = t1[0]["row"]
style_header={
'backgroundColor': '#151819',
'color': 'white'
},
style_cell={
'backgroundColor': '#1C1F23',
'color': '#DCDCDC'
},
),
])
]),
html.Br(),
html.Br(),
html.Section([]),
modal,
])
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
app.callback(
Output("modal-xl", "is_open"),
[Input("open-xl", "n_clicks"),
Input("close-xl", "n_clicks")],
[State("modal-xl", "is_open")],
)(toggle_modal)
y=centers[:, 1],
mode="markers",
marker={
"color": "#000",
"size": 12,
"symbol": "diamond"
},
name="Cluster centers",
))
layout = {"xaxis": {"title": x}, "yaxis": {"title": y}}
# return a graph object (a "Figure") with data (list of 4 scatter plots) and a layout
return go.Figure(data=data, layout=layout)
# make sure that x and y values can't be the same variable
def filter_options(v):
"""Disable option v"""
return [{
"label": col,
"value": col,
"disabled": col == v
} for col in iris.columns]
# functionality is the same for both dropdowns, so we reuse filter_options
app.callback(Output("x-variable", "options"),
[Input("y-variable", "value")])(filter_options)
app.callback(Output("y-variable", "options"),
[Input("x-variable", "value")])(filter_options)
]
return figure
return callback
#app.css.append_css({
# "external_url": "https://codepen.io/chriddyp/pen/bWLwgP.css"})
# app.callback is a decorator which means that it takes a function
# as its argument.
# highlight is a function "generator": it's a function that returns function
app.callback(Output('g1', 'figure'), [
Input('g1', 'selectedData'),
Input('g2', 'selectedData'),
Input('g3', 'selectedData')
])(highlight('Column 0', 'Column 1'))
app.callback(Output('g2', 'figure'), [
Input('g2', 'selectedData'),
Input('g1', 'selectedData'),
Input('g3', 'selectedData')
])(highlight('Column 2', 'Column 3'))
app.callback(Output('g3', 'figure'), [
Input('g3', 'selectedData'),
Input('g1', 'selectedData'),
Input('g2', 'selectedData')
])(highlight('Column 4', 'Column 5'))
return is_open
# prior questionnaire answer modal
def open_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
else:
return is_open
for n in range(2, 4):
app.callback(Output(u"kccq-modal-answer-prior-{}".format(n), 'is_open'), [
Input("kccq-modal-answer-prior-button-open-{}".format(n), "n_clicks"),
Input("kccq-modal-answer-prior-button-submit-{}".format(n), "n_clicks")
], [State("kccq-modal-answer-prior-{}".format(n), 'is_open')])(open_modal)
# prior video review modal
def open_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
else:
return is_open
for n in range(2, 4):
app.callback(
Output(u"modal-selfrecording-review-prior-{}".format(n), 'is_open'), [
elif len(value_labels) == 1:
existingvaluedef['value'] = value_labels[0]
elif len(value_labels) <= 3:
existingvaluedef['value'] = ", ".join(value_labels)
else:
existingvaluedef['value'] = "Multiple options selected"
return existingvaluedef
return set_dropdown_value_fund
# Add callbacks for all the filters
for filter_id, filter_def in FILTERS.items():
# callback to update the text showing filtered options next to the filter
app.callback(Output('df-change-{}-wrapper'.format(filter_id), 'value'),
[Input('df-change-{}'.format(filter_id), 'value')],
[State('df-change-{}'.format(filter_id), 'options'),
State('df-change-{}-wrapper'.format(filter_id), 'value')])(
set_dropdown_value(filter_id, filter_def)
)
if filter_def.get("type") in ['dropdown', 'multidropdown']:
# callback adding the filter itself
app.callback(
Output('df-change-{}'.format(filter_id), 'options'),
[Input('award-dates', 'data')])(
dropdown_filter(filter_id, filter_def)
)
# callback setting the default value of the filter (nothing selected)
app.callback(
Output('df-change-{}'.format(filter_id), 'value'),
