def createButtons(self, figNames):
buttons = CheckboxButtonGroup(labels=[name for name in figNames],
active=[0, 1, 2])
buttons.on_click(self.buttonClick)
for count, name in enumerate(figNames):
self.buttonToFig[count] = self.figs[name]
return buttons
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
checkbox_group.on_click(lambda value: print('checkbox_group: %s' % value))
checkbox_group.js_on_click(
CustomJS(
code="console.log('checkbox_group: ' + this.active, this.toString())"))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(lambda value: print('radio_group: %s' % value))
radio_group.js_on_click(
CustomJS(
code="console.log('radio_group: ' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(
lambda value: print('checkbox_button_group: %s' % value))
checkbox_button_group.js_on_click(
CustomJS(
code=
"console.log('checkbox_button_group: ' + this.active, this.toString())"
))
radio_button_group = RadioButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(
lambda value: print('radio_button_group: %s' % value))
radio_button_group.js_on_click(
CustomJS(
code=
"console.log('radio_button_group: ' + this.active, this.toString())"))
] * tmp_df.shape[0])
sources_year_vs_usd[state].data = data
def filter_categories(indexes):
if len(indexes):
selected_categories = [categories[ind] for ind in indexes]
else:
selected_categories = categories
update_source(selected_categories)
update_source(categories)
select = CheckboxButtonGroup(labels=categories)
select.on_click(filter_categories)
hover_year_with_usd = HoverTool(tooltips=[
("name", "@name"),
])
p_year_with_usd = figure(plot_height=200,
tools=[hover_year_with_usd, "box_select", "reset"])
for state, color in zip(states, colors):
p_year_with_usd.circle(x='x',
y='y',
line_color='white',
fill_color=color,
alpha=0.7,
size=15,
split = Dropdown(label="Split button",
type="danger",
menu=menu,
default_value="baz")
split.on_click(split_handler)
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
active=[0, 1])
checkbox_group.on_click(checkbox_group_handler)
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(radio_group_handler)
checkbox_button_group = CheckboxButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(checkbox_button_group_handler)
radio_button_group = RadioButtonGroup(
labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(radio_button_group_handler)
vbox = VBox(children=[
button, toggle, dropdown, split, checkbox_group, radio_group,
checkbox_button_group, radio_button_group
])
document = Document()
document.add_root(vbox)
session = push_session(document)
session.show()
menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")]
dropdown = Dropdown(label="Dropdown button", type="warning", menu=menu)
dropdown.on_click(dropdown_handler)
menu = [("Item 1", "foo"), ("Item 2", "bar"), None, ("Item 3", "baz")]
split = Dropdown(label="Split button", type="danger", menu=menu, default_action="baz")
split.on_click(split_handler)
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_group.on_click(checkbox_group_handler)
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(radio_group_handler)
checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(checkbox_button_group_handler)
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(radio_button_group_handler)
vbox = VBox(children=[button, toggle, dropdown, split, checkbox_group, radio_group, checkbox_button_group, radio_button_group])
document.add(vbox)
session.store_document(document)
if __name__ == "__main__":
link = session.object_link(document.context)
print("Please visit %s to see the plots" % link)
view(link)
print("\npress ctrl-C to exit")
session.poll_document(document)
def do_layout(self):
"""
generates the overall layout by creating all the widgets, buttons etc and arranges
them in rows and columns
:return: None
"""
self.source = self.generate_source()
tab_plot = self.generate_plot(self.source)
multi_select = MultiSelect(title="Option (Multiselect Ctrl+Click):",
value=self.active_country_list,
options=countries,
height=500)
multi_select.on_change('value', self.update_data)
tab_plot.on_change('active', self.update_tab)
radio_button_group_per_capita = RadioButtonGroup(
labels=["Total Cases", "Cases per Million"],
active=0 if not self.active_per_capita else 1)
radio_button_group_per_capita.on_click(self.update_capita)
radio_button_group_scale = RadioButtonGroup(
labels=[Scale.log.name.title(),
Scale.linear.name.title()],
active=self.active_y_axis_type.value)
radio_button_group_scale.on_click(self.update_scale_button)
radio_button_group_df = RadioButtonGroup(labels=[
Prefix.confirmed.name.title(),
Prefix.deaths.name.title(),
Prefix.recovered.name.title(),
],
active=int(
self.active_case_type))
radio_button_group_df.on_click(self.update_data_frame)
refresh_button = Button(label="Refresh Data",
button_type="default",
width=150)
refresh_button.on_click(load_data_frames)
export_button = Button(label="Export Url",
button_type="default",
width=150)
export_button.on_click(self.export_url)
slider = Slider(start=1,
end=30,
value=self.active_window_size,
step=1,
title="Window Size for rolling average")
slider.on_change('value', self.update_window_size)
radio_button_average = RadioButtonGroup(
labels=[Average.mean.name.title(),
Average.median.name.title()],
active=self.active_average)
radio_button_average.on_click(self.update_average_button)
plot_variables = [
self.active_plot_raw, self.active_plot_average,
self.active_plot_trend
]
plots_button_group = CheckboxButtonGroup(
labels=["Raw", "Averaged", "Trend"],
active=[i for i, x in enumerate(plot_variables) if x])
plots_button_group.on_click(self.update_shown_plots)
world_map = self.create_world_map()
link_div = Div(
name="URL",
text=
fr'Link <a target="_blank" href="{self.url}">Link to this Plot</a>.',
width=300,
height=10,
align='center')
footer = Div(
text=
"""Covid-19 Dashboard created by Andreas Weichslgartner in April 2020 with python, bokeh, pandas,
numpy, pyproj, and colorcet. Source Code can be found at
<a href="https://github.com/weichslgartner/covid_dashboard/">Github</a>.""",
width=1600,
height=10,
align='center')
self.generate_table_cumulative()
columns = [
TableColumn(field="name", title="Country"),
TableColumn(field="number_rolling",
title="daily avg",
formatter=NumberFormatter(format="0.")),
TableColumn(field="number_daily",
title="daily raw",
formatter=NumberFormatter(format="0."))
]
top_top_14_new_header = Div(text="Highest confirmed (daily)",
align='center')
top_top_14_new = DataTable(source=self.top_new_source,
name="Highest confirmed(daily)",
columns=columns,
width=300,
height=380)
self.generate_table_new()
columns = [
TableColumn(field="name", title="Country"),
TableColumn(field="number",
title="confirmed(cumulative)",
formatter=NumberFormatter(format="0."))
]
top_top_14_cum_header = Div(text="Highest confirmed (cumulative)",
align='center')
top_top_14_cum = DataTable(source=self.top_total_source,
name="Highest confirmed(cumulative)",
columns=columns,
width=300,
height=380)
self.layout = layout([
row(
column(tab_plot, world_map),
column(top_top_14_new_header, top_top_14_new,
top_top_14_cum_header, top_top_14_cum),
column(link_div, row(refresh_button, export_button),
radio_button_group_df, radio_button_group_per_capita,
plots_button_group, radio_button_group_scale, slider,
radio_button_average, multi_select),
),
row(footer)
])
curdoc().add_root(self.layout)
curdoc().title = "Bokeh Covid-19 Dashboard"
p.triangle('x',
'y',
source=chap_1930_geosource,
color="orange",
size=4,
legend="1930s Chaparral")
# p.circle('x','y', source = shrub_1990_geosource,
# color = 'black', size=4,legend="1990s shrubland")
p.square('x',
'y',
source=landfire_geosource,
color='brown',
size=4,
legend="2010s Chaparral")
p.multi_line('xs', 'ys', source=ca_geosource, color="black")
# Add the CheckBox group
Check_Box = CheckboxButtonGroup(labels=checkbox_labels, active=[])
Check_Box.on_click(checkbox_handler)
# Position the color bars
p.add_layout(alt_color_bar, 'right')
p.add_layout(dMAT_color_bar, 'right')
layout = column(Check_Box, p)
curdoc().add_root(layout)
def modify_second_descriptive(doc):
# Captura de los argumentos pasados desde flask
args = doc.session_context.request.arguments
try:
periodo = int(args.get('periodo')[0])
tipo_var = args.get('tipo_var')[0].decode('ascii')
periodo_custom_start = args.get('periodo_custom_start')[0].decode(
'ascii')
periodo_custom_end = args.get('periodo_custom_end')[0].decode('ascii')
current_date = dt.strptime(
args.get('current_date')[0].decode('ascii'), '%d/%m/%Y')
except:
periodo = 0
tipo_var = ''
periodo_custom_start = ''
periodo_custom_end = ''
current_date = ''
if tipo_var == 'abs':
tipo_var = 'ABSOLUTAS'
elif tipo_var == 'rend':
tipo_var = 'RENDIMIENTOS'
print(
f'periodo: {periodo}, tipo_var: {tipo_var}, periodo_custom_start: {periodo_custom_start}, periodo_custom_end: {periodo_custom_end}, current_date: {current_date}'
)
# Creación/Carga en RAM del diccionario con las variables a modelizar
total_model_dict = load_or_create_model_vars(
model_vars_file='resources/total_model_dict.pkl',
mask_file='resources/model_variables_mask.xlsx',
sheets=[
'ID_INFLUENTE', 'ID_BIOS', 'ID_FANGOS', 'ID_HORNO', 'ID_EFLUENTE',
'ID_ELECTRICIDAD', 'YOKO', 'ANALITICA', 'METEO'
],
cols=['OUT', 'IN', 'MANIPULABLES', 'PROCESOS_IN'],
force_create=False)
# Inicialización del diccionario ordenado para almacenar los modelos creados
models = OrderedDict([])
try:
created_models = load_obj(name='resources/created_models.pkl')
except:
created_models = ['Calidad_Agua']
ruta_periodo = f'{SERVER_HOST}/archivos/EDAR4.0_EDAR_Cartuja_ID_PERIOD_{periodo}.csv'
# Crear nuevo archivo custom si periodo=3
if periodo == 3:
create_custom_period(periodo_custom_start, periodo_custom_end)
ruta_periodo = F'{SERVER_HOST}/archivos/EDAR4.0_EDAR_Cartuja_ID_PERIOD_CUSTOM.csv'
current_date = dt.strptime(periodo_custom_end, '%d/%m/%Y')
# Llamada al webservice de RapidMiner
json_perfil_document = call_webservice(
url=
'http://rapidminer.vicomtech.org/api/rest/process/EDAR_Cartuja_Perfil_Out_JSON_v5?',
username='******',
password='******',
parameters={
'Ruta_periodo': ruta_periodo,
'Ruta_tipo_variable':
f'{SERVER_HOST}/archivos/EDAR4.0_EDAR_Cartuja_VARIABLES_{tipo_var}.csv',
'Normalizacion': 1
},
out_json=True)
# Extracción de los datos web
df_perfil = [json_normalize(data) for data in json_perfil_document]
# Asignación de los datos web a su variable correspondiente
prediction_df = df_perfil[3]
outlier_df = df_perfil[4]
# Creación de los gráficos y widgets permanentes en la interfaz
prediction_plot = create_prediction_plot(prediction_df, current_date)
outlier_plot = create_outlier_plot(outlier_df, prediction_df, tipo_var)
simulation_title = create_div_title(
'Creación, Simulación y Optimización de modelos')
model_title, add_model_button, model_select_menu = create_model_menu(
model_variables=list(total_model_dict.keys()))
create_model_spinner = Spinner(size=16)
recreate_button = Button(label='Recrear',
button_type='success',
height=35,
max_width=200,
min_width=200)
model_select_wb = widgetbox([
row([model_title, create_model_spinner.spinner],
sizing_mode='stretch_width',
max_width=400),
row([model_select_menu, recreate_button],
sizing_mode='stretch_width',
max_width=400), add_model_button
],
max_width=400,
sizing_mode='stretch_width')
created_models_title = create_div_title('Modelos creados')
created_models_checkbox = CheckboxButtonGroup(labels=list(models.keys()),
height=35)
created_models_checkbox.active = [0]
delete_model_button = Button(label='Eliminar',
button_type='danger',
height=35,
max_width=200)
created_models_wb = widgetbox(
[created_models_title, created_models_checkbox],
max_width=900,
sizing_mode='stretch_width')
# Callback para crear nuevamente el listado de variables de la mascara
def recreate_callback():
print('Recreando lista de variables para modelizar')
nonlocal total_model_dict
total_model_dict = load_or_create_model_vars(
model_vars_file='resources/total_model_dict.pkl',
mask_file='resources/model_variables_mask.xlsx',
sheets=[
'ID_INFLUENTE', 'ID_BIOS', 'ID_FANGOS', 'ID_HORNO',
'ID_EFLUENTE', 'ID_ELECTRICIDAD', 'YOKO', 'ANALITICA', 'METEO'
],
cols=['OUT', 'IN', 'MANIPULABLES', 'PROCESOS_IN'],
force_create=True)
model_select_menu.options = list(total_model_dict.keys())
model_select_menu.value = 'Calidad_Agua'
recreate_button.on_click(recreate_callback)
# Callbacks para los widgets de la interfaz
def prediction_callback(model='Calidad_Agua'):
create_model_spinner.show_spinner()
if initialize == False:
model_objective = model_select_menu.value
else:
model_objective = model
model_discretise = 5
# Verificar que el modelo no ha sido creado antes
if model_objective not in models:
# print(f'Objetivo: {model_objective}')
# print(f'Discretizacion: {model_discretise}')
# print(f'Ruta_periodo: /home/admin/Cartuja_Datos/EDAR4.0_EDAR_Cartuja_ID_PERIOD_{periodo}.csv')
# print(f'IN_MODELO: {total_model_dict[model_objective]}')
# Llamar al servicio web EDAR_Cartuja_Prediccion con los nuevos parámetros
ruta_periodo = f'https://edar.vicomtech.org/archivos/EDAR4.0_EDAR_Cartuja_ID_PERIOD_{periodo}.csv'
# Crear nuevo archivo custom si periodo=3
if periodo == 3:
create_custom_period(periodo_custom_start, periodo_custom_end)
ruta_periodo = 'https://edar.vicomtech.org/archivos/EDAR4.0_EDAR_Cartuja_ID_PERIOD_CUSTOM.csv'
json_prediction_document = call_webservice(
url=
'http://rapidminer.vicomtech.org/api/rest/process/EDAR_Cartuja_Prediccion_JSON_v5?',
username='******',
password='******',
parameters={
'Objetivo': model_objective,
'Discretizacion': model_discretise,
'Numero_Atributos': 4,
'Ruta_periodo': ruta_periodo,
'IN_MODELO': str(total_model_dict[model_objective])
},
out_json=True)
# Obtener datos
df_prediction = [
json_normalize(data) for data in json_prediction_document
]
decision_tree_df = df_prediction[0]
decision_tree_df = append_count(decision_tree_df)
confusion_df_raw = df_prediction[1].reindex(
columns=list(json_prediction_document[1][0].keys()))
confusion_df = create_df_confusion(confusion_df_raw)
weight_df = df_prediction[2]
pred_df = df_prediction[3]
ranges_df = df_prediction[4]
ranges_df.set_index('Name', inplace=True)
# ranges_df['Values']=ranges_df['Values'].replace(regex=r'\(.*\)',value='')
slider_df = create_df_sliders(weight_df, pred_df)
daily_pred_df = pred_df[[
'Fecha', model_objective, f'prediction({model_objective})'
]]
possible_targets = sorted(list(pred_df[model_objective].unique()))
# print(f'Targets: {possible_targets}')
var_influyentes = list(weight_df['Attribute'])
decision_tree_data = create_decision_tree_data(
decision_tree_df, model_objective)
# Crear nuevos gráficos
simul_or_optim_wb = SimulOptimWidget(
target=model_objective,
simul_df=slider_df,
possible_targets=possible_targets,
var_influyentes=var_influyentes,
periodo=periodo,
ranges=ranges_df,
periodo_custom_start=periodo_custom_start,
periodo_custom_end=periodo_custom_end)
daily_pred_plot = create_daily_pred_plot(daily_pred_df,
model_objective)
decision_tree_plot = create_decision_tree_plot()
decision_tree_graph = create_decision_tree_graph_renderer(
decision_tree_plot, decision_tree_data)
decision_tree_plot = append_labels_to_decision_tree(
decision_tree_plot, decision_tree_graph, decision_tree_data)
confusion_matrix = create_confusion_matrix(confusion_df)
weight_plot = create_attribute_weight_plot(weight_df,
model_objective)
corrects_plot = create_corrects_plot(confusion_df, model_objective)
model_title = create_div_title(f'Modelo - {model_objective}')
confusion_title = create_div_title(
f'Matriz de confusión - {model_objective}')
decision_tree_title = create_div_title(
f'Arbol de decisión - {model_objective}')
ranges_description = create_ranges_description(
possible_targets, model_objective)
new_plots = layout(
[[model_title], [simul_or_optim_wb.rb],
[
row([simul_or_optim_wb.wb, ranges_description],
min_width=1400,
sizing_mode='stretch_width')
], [daily_pred_plot],
[
column([confusion_title, confusion_matrix],
sizing_mode='stretch_width'), weight_plot,
corrects_plot
], [decision_tree_title], [decision_tree_plot]],
name=model_objective,
sizing_mode='stretch_width')
# Almacenar en RAM y algunos gráficos y en ROM algunos modelos creados
model_plots.children.append(new_plots)
if model_objective not in created_models:
created_models.append(model_objective)
save_obj(created_models, 'resources/created_models.pkl')
models.update({model_objective: new_plots})
models.move_to_end(model_objective, last=False)
created_models_checkbox.labels = list(models.keys())
created_models_checkbox.active = list(range(len(models.keys())))
create_model_spinner.hide_spinner()
add_model_button.on_click(prediction_callback)
# Callback para eliminar algunos modelos seleccionados
def remove_model_handler(new):
selected_labels = [
created_models_checkbox.labels[elements]
for elements in created_models_checkbox.active
]
try:
for element in selected_labels:
models.pop(element)
model_plots.children.remove(doc.get_model_by_name(element))
created_models.remove(element)
save_obj(created_models, 'resources/created_models.pkl')
except:
for element in selected_labels:
print(f"El modelo {element} no existe")
created_models_checkbox.labels = list(models.keys())
created_models_checkbox.active = list(range(len(models.keys())))
delete_model_button.on_click(remove_model_handler)
# Callback para mostrar u ocultar los gráficos de los modelos creados
def show_hide_plots(new):
selected_labels = [
created_models_checkbox.labels[elements] for elements in new
]
children = []
for element in selected_labels:
children.append(models[element])
model_plots.children = children
created_models_checkbox.on_click(show_hide_plots)
# Creación del layout inicial de la interfaz
model_plots = column([])
initialize = True
for model in created_models:
prediction_callback(model=model)
initialize = False
# Creación del layout estático de la interfaz
l = layout([[prediction_plot], [outlier_plot], [simulation_title],
[
model_select_wb,
column(created_models_wb,
delete_model_button,
sizing_mode='stretch_width')
], [model_plots]],
sizing_mode='stretch_both')
doc.add_root(l)
class BenchmarkApp(HBox):
"""An example of a browser-based, interactive plot with slider controls."""
extra_generated_classes = [["BenchmarkApp", "BenchmarkApp", "HBox"]]
inputs = Instance(VBoxForm)
# widgets
benchmarks = Instance(Select)
x_axis_options = Instance(Select)
y_axis_options = Instance(Select)
# TODO: Convert this to a MultiSelect once it is fixed
# https://github.com/bokeh/bokeh/issues/2495
device_names = Instance(CheckboxGroup)
platform_names = Instance(CheckboxButtonGroup)
# data displays, not enabled by default
data_display0 = Instance(DataTable)
data_display1 = Instance(DataTable)
# plot and interaction
plot = Instance(Plot)
hover = Instance(HoverTool)
# data
source0 = Instance(ColumnDataSource)
source1 = Instance(ColumnDataSource)
source2 = Instance(ColumnDataSource)
source3 = Instance(ColumnDataSource)
source4 = Instance(ColumnDataSource)
source5 = Instance(ColumnDataSource)
source6 = Instance(ColumnDataSource)
source7 = Instance(ColumnDataSource)
source8 = Instance(ColumnDataSource)
source9 = Instance(ColumnDataSource)
def make_source(self):
# set up the data source
self.source0 = ColumnDataSource(data=dict())
self.source1 = ColumnDataSource(data=dict())
self.source2 = ColumnDataSource(data=dict())
self.source3 = ColumnDataSource(data=dict())
self.source4 = ColumnDataSource(data=dict())
self.source5 = ColumnDataSource(data=dict())
self.source6 = ColumnDataSource(data=dict())
self.source7 = ColumnDataSource(data=dict())
self.source8 = ColumnDataSource(data=dict())
self.source9 = ColumnDataSource(data=dict())
def make_inputs(self):
columns = [
TableColumn(field='x', title='x'),
TableColumn(field='y', title='y'),
TableColumn(field='device', title='device'),
TableColumn(field='platform', title='platform')
]
# obj.data_display0 = DataTable(source=obj.source2, columns=columns)
# obj.data_display1 = DataTable(source=obj.source3, columns=columns)
# setup user input
self.x_axis_options = Select(title="X:", value='size', options=axis_options)
self.y_axis_options = Select(title="Y:", value='throughput [1/sec]', options=axis_options)
self.benchmarks = Select(title="Benchmark:", value=benchmark_names[0],
options=benchmark_names)
self.device_names = CheckboxGroup(labels=device_names, active=[0])
self.platform_names = CheckboxButtonGroup(labels=platform_names, active=[0])
@classmethod
def create(cls):
"""One-time creation of app's objects.
This function is called once, and is responsible for
creating all objects (plots, datasources, etc)
"""
obj = cls()
obj.make_source()
obj.make_inputs()
obj.make_plot()
obj.update_data()
obj.set_children()
return obj
def plot_data(self, source, linecolor, symbolfill):
self.plot.line( 'x', 'y', source=source, line_color=linecolor,
line_width=3, line_alpha=0.6)
self.plot.scatter('x', 'y', source=source, fill_color=symbolfill, size=8)
def make_plot(self):
# configure the toolset
toolset = ['wheel_zoom,save,box_zoom,resize,reset']
self.hover = BenchmarkApp.make_hovertool()
toolset.append(self.hover)
title = self.benchmarks.value + " " + \
"(" + self.y_axis_options.value + " vs." + self.x_axis_options.value + ")"
self.plot = figure(title_text_font_size="12pt",
plot_height=400,
plot_width=400,
tools=toolset,
title=title,
)
# remove the logo
self.plot.logo = None
# Generate a figure container
# Plot the line by the x,y values in the source property
self.plot_data(self.source0, "#F0A3FF", "white")
self.plot_data(self.source1, "#0075DC", "white")
self.plot_data(self.source2, "#993F00", "white")
self.plot_data(self.source3, "#4C005C", "white")
self.plot_data(self.source4, "#191919", "white")
self.plot_data(self.source5, "#005C31", "white")
self.plot_data(self.source6, "#2BCE48", "white")
self.plot_data(self.source7, "#FFCC99", "white")
self.plot_data(self.source8, "#808080", "white")
self.plot_data(self.source9, "#94FFB5", "white")
# set the x/y axis labels
# plot.xaxis.axis_label = self.x_axis_options.value
# plot.yaxis.axis_label = self.y_axis_options.value
def set_children(self):
self.inputs = VBoxForm(
children=[self.benchmarks, self.device_names, self.platform_names,
self.x_axis_options, self.y_axis_options,
# self.data_display0, self.data_display1
]
)
self.children.append(self.inputs)
self.children.append(self.plot)
@classmethod
def make_hovertool(self):
hover = HoverTool(
tooltips = [
("Device", "@device"),
("Backend", "@platform"),
("(x,y)", "(@x,@y)")
]
)
return hover
def setup_events(self):
"""Attaches the on_change event to the value property of the widget.
The callback is set to the input_change method of this app.
"""
super(BenchmarkApp, self).setup_events()
if not self.benchmarks:
return
# Event registration for everything except checkboxes
self.benchmarks.on_change('value', self, 'benchmark_changed')
self.x_axis_options.on_change('value', self, 'input_change')
self.y_axis_options.on_change('value', self, 'input_change')
# Event registration for checkboxes
self.device_names.on_click(self.checkbox_handler)
self.platform_names.on_click(self.checkbox_handler)
def checkbox_handler(self, active):
self.update_data()
def benchmark_changed(self, obj, attrname, old, new):
self.update_data()
self.make_plot()
curdoc().add(self)
def input_change(self, obj, attrname, old, new):
"""Executes whenever the input form changes.
It is responsible for updating the plot, or anything else you want.
Args:
obj : the object that changed
attrname : the attr that changed
old : old value of attr
new : new value of attr
"""
self.update_data()
self.make_plot()
curdoc().add(self)
def getXY(self, celero_result, axis_filter):
"""Returns the X or Y value as specified by axis_filter"""
# TODO: Remove the baseline measurement from the timing results
if axis_filter == 'size':
return celero_result['data_sizes']
elif axis_filter == 'log2(size)':
return np.log2(celero_result['data_sizes'])
elif axis_filter == 'log10(size)':
return np.log10(celero_result['data_sizes'])
elif axis_filter == 'time [ms]':
return celero_result['times'] * 1E-3
elif axis_filter == 'throughput [1/sec]':
return 1.0 / (celero_result['times'] * 1E-6)
elif axis_filter == 'throughput [log2(1/sec)]':
return np.log2(1.0 / (celero_result['times'] * 1E-6))
elif axis_filter == 'throughput [log10(1/sec)]':
return np.log10(1.0 / (celero_result['times'] * 1E-6))
@classmethod
def make_field_ids(self, id_number):
"""Creates a unique set of named fields for the y, device, and platform"""
i = str(id_number)
y_id = 'y' + i
device_id = 'device' + i
platform_id = 'platform' + i
return [y_id, device_id, platform_id]
def update_data(self):
"""Called each time that any watched property changes.
This updates the sin wave data with the most recent values of the
sliders. This is stored as two numpy arrays in a dict into the app's
data source property.
"""
# extract the user's input
benchmark = self.benchmarks.value
devices = list(device_names[i] for i in self.device_names.active)
platforms = list(platform_names[i] for i in self.platform_names.active)
x_axis_label = self.x_axis_options.value
y_axis_label = self.y_axis_options.value
# extract only the results which match this group
filtered_results = filter(lambda x: x['benchmark_name'] == benchmark, celero_results)
# remove the baseline measurements from the plots
filtered_results = filter(lambda x: x['benchmark_name'] != "Baseline", filtered_results)
# select the desired devices
filtered_results = filter(lambda x: x['extra_data']['AF_DEVICE'] in devices, filtered_results)
filtered_results = filter(lambda x: x['extra_data']['AF_PLATFORM'] in platforms, filtered_results)
# extract the data
sources = dict()
result_number = 0
for result in filtered_results:
# ensure we don't plot too many results
if result_number > MAX_PLOTS:
break
y_id, device_id, platform_id = self.make_field_ids(result_number)
# Extract the results from the benchmark
platform = result['extra_data']['AF_PLATFORM']
device = result['extra_data']['AF_DEVICE']
x = self.getXY(result, x_axis_label)
y = self.getXY(result, y_axis_label)
# store the benchmark results in the self.source object
# NOTE: we replicate the device and platform data here so that
# it works correctly with the mouseover/hover
sources['x'] = x
sources[y_id] = y
sources[device_id] = [device] * len(x)
sources[platform_id] = [platform] * len(x)
# increment the counter
result_number += 1
# assign the data
self.assign_source(sources, self.source0, 0)
self.assign_source(sources, self.source1, 1)
self.assign_source(sources, self.source2, 2)
self.assign_source(sources, self.source3, 3)
self.assign_source(sources, self.source4, 4)
self.assign_source(sources, self.source5, 5)
self.assign_source(sources, self.source6, 6)
self.assign_source(sources, self.source7, 7)
self.assign_source(sources, self.source8, 8)
self.assign_source(sources, self.source9, 9)
def assign_source(self, src, dest, index):
"""Assigns the data from src to the dictionary in dest if the
corresponding data exists in src."""
y_id, device_id, platform_id = self.make_field_ids(index)
dest.data = dict()
if y_id in src:
dest.data['x'] = src['x']
dest.data['y'] = src[y_id]
dest.data['device'] = src[device_id]
dest.data['platform'] = src[platform_id]
dest._dirty = True
sort_widgets = [modelsort, datasetsort, filtersort]
def handler(new):
layout.children[0] = create_figure()
def showall_handler():
for w in visibility_widgets:
w.active = list(range(len(w.labels)))
layout.children[0] = create_figure()
def hideall_handler():
for w in visibility_widgets:
w.active = []
layout.children[0] = create_figure()
modelboxes.on_click(handler)
datasetboxes.on_click(handler)
filterboxes.on_click(handler)
showall.on_click(showall_handler)
hideall.on_click(hideall_handler)
modelsort.on_click(handler)
datasetsort.on_click(handler)
filtersort.on_click(handler)
legendtext = ('\n'*8 + 'Solid: SVM Score\nOutline: RF Score\n\n' +
'Green: UK\nPink: US\nOrange: Mixed\n' +
'Purple: Reverse Split\nBlue: Split\n\n' +
'Circle: Complete\nDiamond: Filtered')
controls = widgetbox([PreText(text='Choose Visible Items')] +
visibility_widgets + [showall, hideall] +
[PreText(text='Choose What to Sort Kmers by')] +
dropdown_disabled.js_on_click(CustomJS(code="console.log('dropdown_disabled: ' + this.value, this.toString())"))
#dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default")
#dropdown_split.on_click(lambda value: print('dropdown_split: %s' % value))
#dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())"))
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_group.on_click(lambda value: print('checkbox_group: %s' % value))
checkbox_group.js_on_click(CustomJS(code="console.log('checkbox_group: ' + this.active, this.toString())"))
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_group.on_click(lambda value: print('radio_group: %s' % value))
radio_group.js_on_click(CustomJS(code="console.log('radio_group: ' + this.active, this.toString())"))
checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
checkbox_button_group.on_click(lambda value: print('checkbox_button_group: %s' % value))
checkbox_button_group.js_on_click(CustomJS(code="console.log('checkbox_button_group: ' + this.active, this.toString())"))
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)
radio_button_group.on_click(lambda value: print('radio_button_group: %s' % value))
radio_button_group.js_on_click(CustomJS(code="console.log('radio_button_group: ' + this.active, this.toString())"))
widgetBox = WidgetBox(children=[
button, button_disabled,
toggle_inactive, toggle_active,
dropdown, dropdown_disabled, #dropdown_split,
checkbox_group, radio_group,
checkbox_button_group, radio_button_group,
])
document = curdoc()
def select_data():
data_val = data_select.value
with h5py.File('demo_data.hdf5', 'r') as f:
return get_data(f, data_val)
def show_hide(active):
if 0 in active:
alpha = 1
elif 0 not in active:
alpha = 0
renderer.glyph.line_alpha = alpha
def update_data(attrname, old, new):
# hardcoded length of 100
x = list(range(1, 101))
y = select_data()
source.data = dict(x=x, y=y)
data_select.on_change('value', update_data)
checkbox_button_group.on_click(show_hide)
inputs = VBoxForm(data_select, checkbox_button_group, width=300)
update_data(None, None, None)
curdoc().add_root(HBox(inputs, p, width=1100))
def modify_second_descriptive(doc):
models = OrderedDict([])
# Llamada al webservice de RapidMiner
json_perfil_document = call_webservice(
'http://rapidminer.vicomtech.org/api/rest/process/EDAR_Cartuja_Perfil_Out_JSON?',
'rapidminer',
'rapidminer',
out_json=True)
# Extracción de los datos web
df_perfil = [json_normalize(data) for data in json_perfil_document]
# Asignación de los datos web a su variable correspondiente
prediction_df = df_perfil[3]
outlier_df = df_perfil[4]
# Creación de los gráficos y widgets permanentes en la interfaz
prediction_plot = create_prediction_plot(prediction_df)
outlier_plot = create_outlier_plot(outlier_df)
simulation_title = create_div_title('Simulación')
model_title, add_model_button, model_select_menu = create_model_menu()
model_select_wb = widgetbox(
[model_title, model_select_menu, add_model_button],
max_width=200,
sizing_mode='stretch_width')
created_models_title = create_div_title('Modelos creados')
created_models_checkbox = CheckboxButtonGroup(labels=list(models.keys()),
height=35)
created_models_checkbox.active = [0]
delete_model_button = Button(label='Eliminar',
button_type='danger',
height=45,
max_width=200)
created_models_wb = widgetbox(
[created_models_title, created_models_checkbox],
max_width=900,
sizing_mode='stretch_width')
# Callbacks para los widgets de la interfaz
def prediction_callback():
# Llamar al servicio web EDAR_Cartuja_Prediccion con los nuevos parámetros
model_objective = model_select_menu.value
model_discretise = 5
# Verificar que el modelo no ha sido creado antes
if model_objective not in models:
json_prediction_document = call_webservice(
'http://rapidminer.vicomtech.org/api/rest/process/EDAR_Cartuja_Prediccion_JSON?',
'rapidminer',
'rapidminer', {
'Objetivo': model_objective,
'Discretizacion': model_discretise,
'Numero_Atributos': 4
},
out_json=True)
# Obtener datos
df_prediction = [
json_normalize(data) for data in json_prediction_document
]
decision_tree_df = df_prediction[0]
confusion_df_raw = df_prediction[1].reindex(
columns=list(json_prediction_document[1][0].keys()))
confusion_df = create_df_confusion(confusion_df_raw)
weight_df = df_prediction[2]
daily_pred_df = df_prediction[3][[
'timestamp', model_objective, f'prediction({model_objective})'
]]
decision_tree_data = create_decision_tree_data(
decision_tree_df, model_objective)
# Crear nuevos gráficos
daily_pred_plot = create_daily_pred_plot(daily_pred_df,
model_objective)
decision_tree_plot = create_decision_tree_plot()
decision_tree_graph = create_decision_tree_graph_renderer(
decision_tree_plot, decision_tree_data)
decision_tree_plot = append_labels_to_decision_tree(
decision_tree_plot, decision_tree_graph, decision_tree_data)
confusion_matrix = create_confusion_matrix(confusion_df)
weight_plot = create_attribute_weight_plot(weight_df,
model_objective)
corrects_plot = create_corrects_plot(confusion_df, model_objective)
confusion_title = create_div_title(
f'Matriz de confusión - {model_objective}')
decision_tree_title = create_div_title(
f'Arbol de decisión - {model_objective}')
new_plots = layout(
[[daily_pred_plot],
[
column([confusion_title, confusion_matrix],
sizing_mode='stretch_width'), weight_plot,
corrects_plot
], [decision_tree_title], [decision_tree_plot]],
name=model_objective,
sizing_mode='stretch_width')
model_plots.children.append(new_plots)
models.update({model_objective: new_plots})
models.move_to_end(model_objective, last=False)
created_models_checkbox.labels = list(models.keys())
created_models_checkbox.active = list(range(len(models.keys())))
add_model_button.on_click(prediction_callback)
def remove_options_handler(new):
selected_labels = [
created_models_checkbox.labels[elements]
for elements in created_models_checkbox.active
]
try:
for element in selected_labels:
models.pop(element)
model_plots.children.remove(doc.get_model_by_name(element))
except:
for element in selected_labels:
print(f"El modelo {element} no existe")
created_models_checkbox.labels = list(models.keys())
created_models_checkbox.active = list(range(len(models.keys())))
delete_model_button.on_click(remove_options_handler)
def show_hide_plots(new):
selected_labels = [
created_models_checkbox.labels[elements] for elements in new
]
# model_plots.children = []
children = []
for element in selected_labels:
children.append(models[element])
model_plots.children = children
created_models_checkbox.on_click(show_hide_plots)
# Creación del layout dinámico de la interfaz
model_plots = column([])
prediction_callback()
# Creación del layout estático de la interfaz
l = layout([[prediction_plot], [outlier_plot], [simulation_title],
[
model_select_wb,
column(created_models_wb,
delete_model_button,
sizing_mode='stretch_width')
], [model_plots]],
sizing_mode='stretch_both')
doc.add_root(l)
def monitors(doc):
## Streaming Update Function
def update():
global cfg
global s1
global s2
global s3
df = get_vars(cfg['mon_fname'])
s1.stream(df.to_dict(orient='list'), rollover=len(df))
df = get_res(cfg['tra_fname'], cfg['resid_len'])
if cfg['resid_len'] is None:
s2.stream(df.to_dict(orient='list'), rollover=len(df))
else:
s2.stream(df.to_dict(orient='list'), rollover=cfg['resid_len'])
s3.stream(get_prog(cfg['tra_fname']), rollover=1)
def update_images():
global cfg
global s4
s4.stream(get_img_data(cfg), rollover=1)
## Backgroud Color Update Function
def night_mode():
if (pd.datetime.now().hour >= 19) or (pd.datetime.now().hour < 6):
curdoc().theme = 'dark_minimal'
#curdoc().template = 'dark.html'
else:
curdoc().theme = 'light_minimal'
#curdoc().template = 'index.html'
# THIS NEEDS TO BE A JINJA TYPE?
## Not sure why this doesn't work...
#curdoc().template_variables.update(background='#BA55D3')
global cfg
## Plotting Setup
do_not_plot = [
'iteration', 'time', 'iter_left', 'converged', 'relative_total_time',
'relative_time_step'
]
sizes = cfg['sizes'].tolist()
colors = itertools.cycle(palette)
colors_res = itertools.cycle(palette)
hover = HoverTool()
res_hover = HoverTool()
if 'flow_time' in s1.data.keys():
# Unsteady Flow (transient)
x_opts = [('Flow Time', '@flow_time s'), ('Time Step', '@time_step')]
x_var = 'flow_time'
else:
# Steady Flow
x_opts = [('Iteration', '@iteration')]
x_var = 'iteration'
hover.tooltips = [('Variable', '$name'), ('Value', '$y'), *x_opts]
res_hover.tooltips = [('Variable', '$name'), ('Value', '$y'),
('Iteration', '@iteration')]
## Plot Residuals
w, h = sizes.pop(0)
res_plots = figure(tools="pan,wheel_zoom,box_zoom,undo,reset,save",
plot_width=w,
plot_height=h,
y_axis_type='log')
res_plots.add_tools(res_hover)
for var, color in zip(s2.data.keys(), colors_res):
if var not in do_not_plot:
res_plots.line('iteration',
var,
line_width=2,
source=s2,
color=color,
legend=var.replace('_', ' ').title(),
name=var.replace('_', ' ').title())
res_plots.legend.location = "top_left"
res_plots.legend.click_policy = "hide"
## Progress Bar
prog_bar = figure(plot_width=300,
plot_height=25,
toolbar_location=None,
x_range=[0, 1])
prog_bar.grid.visible = False
prog_bar.axis.visible = False
prog_bar.hbar_stack(['steps_complete', 'steps_left'],
y=1,
height=0.8,
color=("limegreen", "lightgrey"),
source=s3)
prog_bar.text(0.5,
1,
text='text',
text_baseline="middle",
text_align="center",
text_color="white",
text_font_style="bold",
source=s3)
## Plot Monitor Variables
variables = var_name_cleaner(cfg['variables'])
if cfg['var_ylims']:
ylims = cfg['var_ylims']
else:
ylims = len(variables) * [None]
plots = [res_plots]
for var, ylim, color in zip(variables, ylims, colors):
w, h = sizes.pop(0)
p = figure(tools="pan,wheel_zoom,box_zoom,undo,reset,save",
plot_width=w,
plot_height=h)
# Link x ranges
try:
p.x_range = plots[1].x_range
except:
pass
if ylim is not None:
print(ylim)
p.y_range = Range1d(*ylim)
if isinstance(var, str):
p.line(x_var,
var,
line_width=2,
source=s1,
color=color,
legend=var.replace('_', ' ').title(),
name=var.replace('_', ' ').title())
elif isinstance(var, list) or isinstance(var, tuple):
for y, color in zip(var, itertools.cycle(palette_2)):
p.line(x_var,
y,
line_width=2,
source=s1,
color=color,
legend=y.replace('_', ' ').title(),
name=y.replace('_', ' ').title())
p.add_tools(hover)
p.legend.click_policy = "hide"
p.legend.location = "top_left"
plots.append(p)
## Legend Locations
select = Select(value="top_left",
options=list(LegendLocation),
width=100,
height=25)
[select.js_link('value', f.legend[0], 'location') for f in plots[1::]]
## Legend Visibility
def legend_visibility(active):
for n, plot in enumerate(plots):
if n in active:
plot.legend[0].visible = True
else:
plot.legend[0].visible = False
legend_button_group = CheckboxButtonGroup(
labels=['Legend ' + str(n) for n in range(0, len(plots))],
active=[n for n in range(0, len(plots))],
width=cfg['width'] - 400,
height=25)
legend_button_group.on_click(legend_visibility)
## Turn off all active tools (helps for mobile)
#https://stackoverflow.com/questions/49282688/how-do-i-set-default-active-tools-for-a-bokeh-gridplot
# THIS DOESNT @!#$#@ WORK
for p in plots:
p.toolbar.active_drag = None
p.toolbar.active_scroll = None
p.toolbar.active_tap = None
## Initialize Image Plots
if cfg['img_folder']:
try:
img_basenames = cfg['images']
tabs = [Panel(child=plots[0], title='Residuals')]
for img in img_basenames:
p = figure(plot_width=plots[0].width,
plot_height=plots[0].height,
x_range=(0, 1),
y_range=(0, 1))
p.image_url(url=img, x='x', y='y', w='w', h='h', source=s4)
tabs.append(Panel(child=p, title=img))
plots[0] = Tabs(tabs=tabs)
except:
print('Cannot add images')
## Create Layout
# This will split the flat arry where sizes sum to the width of the doc
sizes = cfg['sizes']
splits = 1 + np.where(np.cumsum(sizes[:, 0]) % cfg['width'] == 0)[0]
layout = [
x.tolist() for x in np.split(np.array(plots), splits) if len(x) > 0
]
## Build the Document
#doc.template = 'dark.html'
night_mode()
doc.add_periodic_callback(update, cfg['polling_int'])
if cfg['img_folder']:
doc.add_periodic_callback(update_images, 1000 * 30)
doc.add_periodic_callback(night_mode, 1000 * 60 * 10)
doc.title = 'Fluent Monitors'
#Panel(child=p, title=fname)
#gps = gridplot([[prog_bar,select,legend_button_group],[layout]], toolbar_location=None)
#doc.add_root(gps)
doc.add_root(
gridplot([[prog_bar, select, legend_button_group]],
toolbar_location=None))
[doc.add_root(gridplot([row], toolbar_location='right')) for row in layout]
'Associate Professor', 'Full Professor'],
axis=1).rename({"Other (please specify)":"Other"},axis=1)
pt = dfTotal.cumsum(axis=1)
p = figure(title="Count of Positions of Data Science Professionals",
x_axis_label='Primary Role', y_axis_label='Total',
x_range = FactorRange(factors=list(pt.index)),
plot_height=600, plot_width=900,tools=[])
for column,color in zip(pt.columns,all_palettes['PiYG'][len(pt.columns)]):
p.vbar(x=pt.index,bottom=pt[column]-dfTotal[column],top=pt[column],width=.2,color=color, legend = column)
p.ygrid.minor_grid_line_color = 'black'
p.ygrid.minor_grid_line_alpha = 0.1
p.legend.location = "top_left"
p.toolbar.logo = None
return p
pronoun = CheckboxButtonGroup(
labels=["She/Her/Hers", "He/His/Him", "Other","NA"], active=[0,1,2])
pronoun.on_click(update)
controls = column([pronoun], width=200)
layout = row(controls, create_figure())
curdoc().add_root(layout)
def create_message_timeseries_panel(message_df, title, participants,
colour_palette):
""" Creates a plot of messages to a chat over time
Parameters:
===========
message_df - pandas Dataframe
A dataframe containing data of every message from a chat
title - string
A string containing the name of the group chat
participants - list
a list of strings of each pariticipant in the messenger chat
colour_palette - list
a list of strings which have a participant
Returns:
===========
message_panel - bokeh Panel
A layout of graphs for analysis of message data
"""
def plot_summary_data(messages):
# See if your chat is dying:
def curve(x, a, b, c):
return a * np.exp(-b * x) + c
total_messages = messages.groupby('Date').mean()
total_messages = total_messages.resample('W', convention='end').sum(
).reset_index() # Convert to a weekly aggregation of messages
x_data = total_messages.Date.array.asi8 / 1e18
y_data = total_messages['Message'].values
popt, _ = curve_fit(curve, x_data, y_data, maxfev=100000)
x_data_step = x_data[1] - x_data[0]
x_data = list(x_data)
for _ in range(51):
x_data.append(x_data[-1] + x_data_step)
x_data = np.array(x_data)
y_prediction = curve(x_data, *popt)
total_messages['Prediction'] = y_prediction[:len(total_messages)]
total_messages_cds = ColumnDataSource(data=total_messages)
main_figure.line(x='Date',
y='Message',
source=total_messages_cds,
alpha=0.45,
muted_alpha=0.2,
legend_label='Weekly Total',
color='black')
main_figure.circle(x='Date',
y='Message',
source=total_messages_cds,
alpha=0.45,
muted_alpha=0.2,
legend_label='Weekly Average',
color='black')
main_figure.line(x='Date',
y='Prediction',
source=total_messages_cds,
alpha=0.45,
muted_alpha=0.2,
legend_label='Trend',
line_dash='dashed',
color='red')
# Find x-axis limits:
start_date = min(message_df.loc[:, 'Date'])
end_date = max(message_df.loc[:, 'Date'])
# Create widget objects:
name_buttons = CheckboxButtonGroup(
labels=participants, active=[i for i in range(len(participants))])
date_slider = DateRangeSlider(end=end_date,
start=start_date,
value=(start_date, end_date),
step=1)
# Create figures to be included:
main_figure = figure(plot_width=800,
plot_height=250,
x_axis_type="datetime",
toolbar_location=None)
main_figure.toolbar.logo = None
main_figure.x_range.start = start_date
main_figure.x_range.end = end_date
main_figure.toolbar.active_drag = None
main_figure.toolbar.active_scroll = None
messages_tooltip = HoverTool(tooltips=[('Name', '@Name'),
('Message Count', '@Message'),
('Date', '@Date{%A, %e %B %Y}')],
formatters={'@Date': "datetime"})
main_figure.add_tools(messages_tooltip)
overview_figure = figure(plot_height=80,
plot_width=800,
x_axis_type='datetime',
toolbar_location=None,
x_range=(start_date, end_date))
overview_figure.yaxis.major_label_text_color = None
overview_figure.yaxis.major_tick_line_color = None
overview_figure.yaxis.minor_tick_line_color = None
overview_figure.grid.grid_line_color = None
overview_figure.toolbar.active_drag = None
overview_figure.toolbar.active_scroll = None
box = BoxAnnotation(fill_alpha=0.5,
line_alpha=0.5,
level='underlay',
left=start_date,
right=end_date)
messages = message_df.groupby(['Name', 'Date']).count().reset_index()
messages = messages.loc[:, messages.columns != 'Reacts']
source = ColumnDataSource(data=messages)
# Plot a line for each person onto both figures:
for index, name in enumerate(participants):
view = CDSView(source=source,
filters=[GroupFilter(column_name='Name', group=name)])
main_figure.line(x='Date',
y='Message',
source=source,
view=view,
alpha=0.45,
muted_color=colour_palette[index],
muted_alpha=0.2,
legend_label=name,
color=colour_palette[index])
main_figure.circle(x='Date',
y='Message',
alpha=0.55,
source=source,
view=view,
muted_color=colour_palette[index],
muted_alpha=0.2,
legend_label=name,
color=colour_palette[index])
overview_figure.line(x='Date',
y='Message',
source=source,
view=view,
color=colour_palette[index])
if len(participants) > 2:
plot_summary_data(messages)
main_figure.xaxis.axis_label = 'Time'
main_figure.yaxis.axis_label = 'Total Messages'
main_figure.title.text = title
main_figure.legend.location = "top_right"
main_figure.legend.click_policy = "mute"
main_figure.legend.orientation = 'horizontal'
main_figure.legend.spacing = 7
overview_figure.add_layout(box)
# --------------------------------------------------------------------------+
# Creating Real Python callbacks for interaction between plots and widgets |
# --------------------------------------------------------------------------+
def update_graph(active_labels):
df = message_df
selected_names = [name_buttons.labels[i] for i in name_buttons.active]
df = df[df['Name'].isin(selected_names)]
df = df.groupby(by=['Name', 'Date']).count().reset_index()
source.data = dict(
Date=df['Date'],
Message=df['Message'],
Name=df["Name"],
)
def update_range(attr, old, new):
start = datetime.fromtimestamp(new[0] / 1e3)
end = datetime.fromtimestamp(new[1] / 1e3)
main_figure.x_range.start = start
main_figure.x_range.end = end
box.left = start
box.right = end
# Assign callbacks to appropriate widget interactions
name_buttons.on_click(update_graph)
date_slider.on_change('value', update_range)
date_slider_layout = row(Spacer(width=46, height=50, sizing_mode="fixed"),
date_slider,
sizing_mode="scale_width")
plots = column(main_figure,
date_slider_layout,
overview_figure,
sizing_mode="scale_width")
# Create the layout of the Bokeh application
message_timeseries = layout([[name_buttons], [plots]],
sizing_mode="scale_width")
message_timeseries.margin = (10, 35, 60, 20)
message_panel = Panel(child=message_timeseries, title='Message Data')
return message_panel
