def _init_doc(self, doc):
self.doc = doc
self.doc.title = "Explore Dashboard"
with open(os.path.join(os.path.dirname(__file__), 'templates', 'index.html')) as f:
index_template = Template(f.read())
doc.template = index_template
self.doc.theme = Theme(os.path.join(os.path.dirname(__file__), 'theme.yaml'))
self._init_plots()
m_widgetbox = self._init_controls()
# Create tabs
if self.mode == "signal":
exg_tab = Panel(child=self.exg_plot, title="ExG Signal")
orn_tab = Panel(child=column([self.acc_plot, self.gyro_plot, self.mag_plot], sizing_mode='scale_width'),
title="Orientation")
fft_tab = Panel(child=self.fft_plot, title="Spectral analysis")
self.tabs = Tabs(tabs=[exg_tab, orn_tab, fft_tab], width=400, sizing_mode='scale_width')
self.recorder_widget = self._init_recorder()
self.push2lsl_widget = self._init_push2lsl()
self.set_marker_widget = self._init_set_marker()
self.baseline_widget = CheckboxGroup(labels=['Baseline correction'], active=[0])
elif self.mode == "impedance":
imp_tab = Panel(child=self.imp_plot, title="Impedance")
self.tabs = Tabs(tabs=[imp_tab], width=500, sizing_mode='scale_width')
banner = Div(text=""" <a href="https://www.mentalab.com"><img src=
"https://images.squarespace-cdn.com/content/5428308ae4b0701411ea8aaf/1505653866447-R24N86G5X1HFZCD7KBWS/
Mentalab%2C+Name+copy.png?format=1500w&content-type=image%2Fpng" alt="Mentalab" width="225" height="39">""",
width=1500, height=50, css_classes=["banner"], align='center', sizing_mode="stretch_width")
heading = Div(text=""" """, height=2, sizing_mode="stretch_width")
if self.mode == 'signal':
layout = column([heading,
banner,
row(m_widgetbox,
Spacer(width=10, height=300),
self.tabs,
Spacer(width=10, height=300),
column(Spacer(width=170, height=50), self.baseline_widget, self.recorder_widget,
self.set_marker_widget, self.push2lsl_widget),
Spacer(width=50, height=300)),
],
sizing_mode="stretch_both")
elif self.mode == 'impedance':
layout = column(banner,
Spacer(width=600, height=20),
row([m_widgetbox, Spacer(width=25, height=500), self.tabs])
)
self.doc.add_root(layout)
self.doc.add_periodic_callback(self._update_fft, 2000)
self.doc.add_periodic_callback(self._update_heart_rate, 2000)
if self.stream_processor:
self.stream_processor.subscribe(topic=TOPICS.filtered_ExG, callback=self.exg_callback)
self.stream_processor.subscribe(topic=TOPICS.raw_orn, callback=self.orn_callback)
self.stream_processor.subscribe(topic=TOPICS.device_info, callback=self.info_callback)
self.stream_processor.subscribe(topic=TOPICS.marker, callback=self.marker_callback)
self.stream_processor.subscribe(topic=TOPICS.env, callback=self.info_callback)
self.stream_processor.subscribe(topic=TOPICS.imp, callback=self.impedance_callback)
def get_nuts_map_data(request):
p0 = get_nuts_map(0)
p1 = get_nuts_map(1)
p2 = get_nuts_map(2)
tab0 = Panel(child=p0, title="NUTS1")
tab1 = Panel(child=p1, title="NUTS2")
tab2 = Panel(child=p2, title="NUTS3")
tabs = Tabs(tabs=[tab0, tab1, tab2])
tabs.sizing_mode = 'scale_both'
item = json_item(tabs)
item['metadata'] = 'somemetadata'
response = JsonResponse(item)
return response
def generate_report(metrics_df, config_dict, output_dir, show_report):
# Generate HTML
html_file_name = os.path.join(output_dir, 'calibration_report.html')
output_file(html_file_name, mode='inline')
header_html = '<h1>Time-of-Flight Camera Calibration Report</h1>'
header = Div(text=header_html, sizing_mode='stretch_width')
plots_layout = generate_plots(metrics_df)
plots_tab = Panel(child=plots_layout, title='Results')
configs_layout = generate_configs_table(config_dict)
configs_tab = Panel(child=configs_layout, title='Configuration')
body = Tabs(tabs=[plots_tab, configs_tab])
html_layout = layout([
[header],
[body],
])
# Only show report if show_report is True
if show_report:
show(html_layout, title='Calibration Report')
else:
save(html_layout, title='Calibration Report')
def render_dt_num_cat(
itmdt: Intermediate,
yscale: str,
plot_width: int,
plot_height: int,
) -> Tabs:
"""
Render plots from plot(df, x, y) when x is dt and y is num
"""
tabs: List[Panel] = []
data, grp_cnt_stats, timeunit = itmdt["data"]
tabs.append(
dt_multiline_viz(
data,
itmdt["x"],
itmdt["y"],
timeunit,
yscale,
plot_width,
plot_height,
grp_cnt_stats,
z=itmdt["z"],
agg=itmdt["agg"],
))
tabs = Tabs(tabs=tabs)
return tabs
def set_layout(self):
"""Create the plot layout."""
# What to interact with
for control in [self.x_axis, self.y_axis]:
control.on_change('value', lambda attr, old, new: self.update())
# Set up sidebar
cwd = os.path.dirname(__file__)
def path(p):
d = os.path.join(cwd, 'plot_config/{}.html'.format(p))
return open(d).read()
text_top = Div(text=path('text_top'))
text_bottom = Div(text=path('text_bottom'))
sidebar = [text_top, self.x_axis, self.y_axis, text_bottom]
s = widgetbox(sidebar, width=380)
# Set up tabs
panels = []
for tab in self.tabs:
panels.append(Panel(child=tab.fig, title=tab.name))
tab.fig.legend.click_policy = 'hide'
tabs = Tabs(tabs=panels, width=self.width)
# Add sidebar and tabs
L = layout([[s, tabs]])
# Initial load of data
self.update()
# Showtime
curdoc().title = 'frbpoppy'
curdoc().add_root(L)
def build_chart(self, results: List) -> Union[Figure, List[Figure], Tabs]:
"""
Returns the figure to include in the report for a discounted ZCB analysis
Args:
results: The results of the discounted ZCB analysis. It is a list of dicts containing the results
for each ZCB term that has been included in the analysis.
Returns:
The figure to include in the report for the discounted ZCB analysis.
This returns tabs of graphs - one for each ZCB term that is included.
"""
panels = []
for term_result in results:
term = term_result["term"]
charter = MartingaleChart(title=self.title,
x_axis_label="Time (y)",
y_axis_label="Spot rate")
charter.plot_from_results(
results=term_result,
sample_mean_name=f"Discounted ZCB ({term}y)")
charter._figure.yaxis[0].formatter = NumeralTickFormatter(
format="0.00%")
panel = Panel(child=charter.figure, title=f"ZCB ({term}y)")
panels.append(panel)
return Tabs(tabs=panels)
def build_chart(self, results: dict) -> Union[Figure, List[Figure], Tabs]:
"""
Returns the figure to include in the report for a moments analysis
Args:
results: The results of the moment analysis. It should contain keys:
'time', 'mean', 'volatility', 'skewness' and 'kurtosis'
Returns:
The figure to include in the report for a moments analysis.
This returns 4 tabs of graphs - one for each moment.
"""
if not self.title:
raise ValueError(
"No title for the chart for a martingale analysis.")
moments = ['mean', 'volatility', 'skewness', 'kurtosis']
panels = []
for moment in moments:
charter = MomentChart(title=self.title, x_axis_label="Time (y)")
charter.plot_from_results(results=results, moment=moment)
x_values = results["time"]
y_values = results[moment]
self.perform_additional_formatting(moment,
charter,
min_x_value=np.min(x_values),
max_x_value=np.max(x_values),
min_y_value=np.min(y_values),
max_y_value=np.max(y_values))
panel = Panel(child=charter.figure, title=moment.capitalize())
panels.append(panel)
return Tabs(tabs=panels)
def create_layout(self):
tabs = []
main_title = Div(
text='<b>CAVI Medical - Screening Analytics</b>',
width=700,
height=50,
style={
'font-size': '40px',
'font-family':'Helvetica',
'color': '#04537B'
},
)
main_img = Div(text="<img src='CervicalScreeningAnalysis/static/gts.png'>" , width=150, height=50)
for name, factory in self.tabs.items():
tabs.append(Panel(title=name, child=factory()))
if self.debug:
self.preprocess_data()
full_layout = layout(
row(
main_img,
main_title
),
Tabs(tabs=tabs)
)
return full_layout
def create_layout(self) -> Panel:
x_child = column(self.x_range_inputs, self.x_axis_tabs)
x_axis_tab = Panel(title="x", child=x_child)
y_child = column(self.y_range_inputs, self.y_axis_tabs)
y_axis_tab = Panel(title="y", child=y_child)
tabs = Tabs(tabs=[x_axis_tab, y_axis_tab])
return Panel(title="Axes", child=tabs)
def _setup_tabs(sec_to_elements):
"""Create tabs for each section in sec_to_elements with titles.
Args:
sec_to_elements (dict): A nested dictionary. The first level keys will be the
sections ("running", "succeeded", "failed", "scheduled"). The second level keys
are the database names and the second level values a list consisting of the
link to the dashboard and a button to activate tha dashboard.
Returns:
tabs (bokeh.models.Tabs): a tab for every section in sec_to_elements.
"""
tab_list = []
for section, name_to_row in sec_to_elements.items():
text = f"{len(name_to_row.column_names)} optimizations {section}"
table_rows = [
Row(Div(text=text, width=400), name=f"{section}_how_many")
]
for name, row in name_to_row.data.items():
table_rows.append(Row(*row, name=name))
panel = Panel(
child=Column(*table_rows, name=f"{section}_col"),
title=section.capitalize(),
name=f"{section}_panel",
)
tab_list.append(panel)
tabs = Tabs(tabs=tab_list, name="tabs")
return tabs
def render_num(
itmdt: Intermediate,
yscale: str,
plot_width: int,
plot_height: int,
) -> Tabs:
"""
Render plots from plot(df, x) when x is a numerical column
"""
# pylint: disable=too-many-locals
tabs: List[Panel] = []
osd, qsd, dsd = itmdt["statsdata"]
tabs.append(stats_viz_num((osd, qsd, dsd), plot_width, plot_height))
df, miss_pct = itmdt["histdata"]
fig = hist_viz(df, miss_pct, itmdt["col"], yscale, plot_width, plot_height,
True)
tabs.append(Panel(child=fig, title="histogram"))
df, pts_rng, pdf, _, _ = itmdt["kdedata"]
if np.any(pdf):
tabs.append(
hist_kde_viz(df, pts_rng, pdf, itmdt["col"], yscale, plot_width,
plot_height))
actual_qs, theory_qs, _, _ = itmdt["qqdata"]
if np.any(theory_qs[~np.isnan(theory_qs)]):
tabs.append(
qqnorm_viz(actual_qs, theory_qs, itmdt["col"], plot_width,
plot_height))
df, outx, outy, _ = itmdt["boxdata"]
tabs.append(box_viz(df, outx, outy, itmdt["col"], plot_width, plot_height))
tabs = Tabs(tabs=tabs)
return tabs
def render_missing_impact(itmdt: Intermediate, plot_width: int,
plot_height: int) -> Tabs:
"""
Render correlation heatmaps in to tabs
"""
tabs: List[Panel] = []
fig_barchart = render_bar_chart(itmdt["data_bars"], "linear", plot_width,
plot_height)
tabs.append(Panel(child=row(fig_barchart), title="Bar Chart"))
fig_spectrum = render_missing_spectrum(itmdt["data_spectrum"],
itmdt["data_total_missing"],
plot_width, plot_height)
tabs.append(Panel(child=row(fig_spectrum), title="Spectrum"))
fig_heatmap = render_heatmaps(itmdt["data_heatmap"], plot_width,
plot_height)
tabs.append(Panel(child=row(fig_heatmap), title="Heatmap"))
fig_dendrogram = render_dendrogram(itmdt["data_dendrogram"], plot_width,
plot_height)
tabs.append(Panel(child=row(fig_dendrogram), title="Dendrogram"))
tabs = Tabs(tabs=tabs)
return tabs
def prediction_func():
"""Function that wraps the prediction code."""
predict_plots = []
for i, station in enumerate(highrisk_stations):
try:
date, level = predict(station.name, dataset_size=1000, lookback=200, iteration=100,
display=300, use_pretrained=True, batch_size=256, epoch=20)
except Exception:
logger.error('NN prediction failed')
date, level = ([], []), ([], [], [])
predict_plot = plot_prediction(date, level)
try:
poly, d0 = polyfit(date[0], level[0], 4)
predict_plot.line(date[0] + date[1],
[poly(date - d0) for date in date2num(date[0] + date[1])],
line_width=2,
line_color='gray',
legend_label='Polynomial Fit',
line_dash='dashed')
except TypeError:
logger.error('No data for polyfit')
predict_plot.plot_width = 400
predict_plot.plot_height = 400
predict_plot.sizing_mode = 'scale_width'
predict_plots.append(Panel(child=predict_plot, title=station.name))
predicting_text = Div(text='<p><i>Prediction is running... {:.0%}</i></p>'.format(i / 6))
doc.add_next_tick_callback(partial(update_layout,
old=predict_column,
new=column(predict_text, predicting_text, width=500, height=650)))
predict_tabs = Tabs(tabs=predict_plots)
doc.add_next_tick_callback(partial(update_layout,
old=predict_column,
new=column(predict_text, predict_tabs, width=500, height=650)))
def standalone_doc(extra, doc):
doc.title = "HPX performance counter dashboard"
notifier = Notifier()
widget = DataCollectionWidget(doc, notifier.notify)
cmap = task_cmap
if "cmap" in extra:
cmap = extra["cmap"]
task_tab = Panel(
child=tasks_widget(doc, notifier, cmap),
title="Tasks plot",
)
scheduler_tab = Panel(child=scheduler_widget(doc, notifier), title="Scheduler utilization")
custom_counter_tab = Panel(
child=custom_counters_widget(doc, notifier), title="Customizable plots"
)
doc.add_root(
row(
Tabs(tabs=[scheduler_tab, task_tab, custom_counter_tab]),
widget.layout(),
sizing_mode="scale_width",
)
)
doc.template = env.get_template("normal.html")
doc.template_variables.update(extra)
doc.theme = BOKEH_THEME
def main(doc: Document,
repo: Path,
include_files: Iterable[str] = (),
exclude_files: Iterable[str] = (),
limit: int = 9,
use_cache: bool = False) -> None:
from bokeh.models import Panel, Tabs
from .repo_history import main as get_stats
df = get_stats(repo, include_files, exclude_files, use_cache)
commits_df = df[['author', 'date', 'files']].pivot_table(values='files',
index='date',
columns='author',
aggfunc='count')
files_df = df[['author', 'date', 'files']].pivot_table(values='files',
index='date',
columns='author',
aggfunc='sum')
lines_df = df[['author', 'date', 'lines']].pivot_table(values='lines',
index='date',
columns='author',
aggfunc='sum')
doc.clear() # clear the entire document before adding plots
doc.add_root(
Tabs(tabs=[
Panel(title='Commits', child=render(transform(commits_df, limit))),
Panel(title='Files', child=render(transform(files_df, limit))),
Panel(title='Lines', child=render(transform(lines_df, limit))),
]))
def create_page(report: ClusterReport):
structure = []
per_node_df = create_global_resources_df(report.monitoring)
if not per_node_df.empty:
structure += [
(
"Global utilization",
lambda r: render_global_resource_usage(r, per_node_df),
),
("Node utilization", lambda r: render_nodes_resource_usage(r, per_node_df)),
]
per_process_df = create_per_process_resources_df(report.monitoring)
if not per_process_df.empty:
structure += [
(
"Process utilization",
lambda r: render_process_resource_usage(r, per_process_df),
)
]
structure.append(("Output", render_output))
if report.profiling_data:
structure.append(("Profiler", render_profiling_data))
tabs = []
for name, fn in structure:
widget = fn(report)
if widget is not None:
tabs.append(Panel(child=widget, title=name))
return Tabs(tabs=tabs)
def render_two_num_cols(
itmdt: Intermediate,
plot_width: int,
plot_height: int,
tile_size: Optional[float] = None,
) -> Tabs:
"""
Render plots from plot(df, x, y) when x and y are numerical columns
"""
tabs: List[Panel] = []
tabs.append(
scatter_viz(
itmdt["scatdata"],
itmdt["x"],
itmdt["y"],
itmdt["spl_sz"],
plot_width,
plot_height,
))
df, outx, outy, _ = itmdt["boxdata"]
tabs.append(
box_viz(df, outx, outy, itmdt["x"], plot_width, plot_height,
itmdt["y"]))
tabs.append(
hexbin_viz(
itmdt["hexbindata"],
itmdt["x"],
itmdt["y"],
plot_width,
plot_height,
tile_size,
))
tabs = Tabs(tabs=tabs)
return tabs
def render_basic_x_num(
itmdt: Intermediate,
yscale: str,
plot_width: int,
plot_height: int,
) -> Tabs:
"""
Render plots from plot(df, x) when x is a numerical column
"""
tabs: List[Panel] = []
df, miss_pct = itmdt["histdata"]
fig = hist_viz(df, miss_pct, itmdt["col"], yscale, plot_width, plot_height,
True)
tabs.append(Panel(child=fig, title="histogram"))
df, pts_rng, pdf = itmdt["kdedata"]
tabs.append(
hist_kde_viz(df, pts_rng, pdf, itmdt["col"], yscale, plot_width,
plot_height))
actual_qs, theory_qs = itmdt["qqdata"]
tabs.append(
qqnorm_viz(actual_qs, theory_qs, itmdt["col"], plot_width,
plot_height))
df, outx, outy, _ = itmdt["boxdata"]
tabs.append(box_viz(df, outx, outy, itmdt["col"], plot_width, plot_height))
tabs = Tabs(tabs=tabs)
return tabs
def add_thumb_tab(self, spectra, plots, widgets, nspec):
self.ncols_grid = 5 # TODO un-hardcode
self.miniplot_width = (plots.plot_width +
(plots.plot_height // 2)) // self.ncols_grid
self.full_viewer = Tabs()
titles = None # TODO define
self.thumb_grid = grid_thumbs(spectra,
self.miniplot_width,
x_range=(plots.xmin, plots.xmax),
ncols_grid=self.ncols_grid,
titles=titles)
tab1 = Panel(child=self.main_bokehlayout, title='Main viewer')
tab2 = Panel(child=self.thumb_grid, title='Gallery')
self.full_viewer.tabs = [tab1, tab2]
# Dirty trick : callback functions on thumbs need to be defined AFTER the full_viewer is implemented
# Otherwise, at least one issue = no toolbar anymore for main fig. (apparently due to ifiberslider in callback args)
for i_spec in range(nspec):
self.thumb_callback = CustomJS(args=dict(
full_viewer=self.full_viewer,
i_spec=i_spec,
ifiberslider=widgets.ifiberslider),
code="""
full_viewer.active = 0
ifiberslider.value = i_spec
""")
(self.thumb_grid.children[i_spec][0]).js_on_event(
bokeh.events.DoubleTap, self.thumb_callback)
def render_missing_impact_1v1(itmdt: Intermediate, plot_width: int,
plot_height: int) -> Union[Tabs, Figure]:
"""
Render the plot from `plot_missing(df, "x", "y")`
"""
x, y = itmdt["x"], itmdt["y"]
meta = itmdt["meta"]
if is_numerical(meta["dtype"]):
panels = []
fig = render_hist(itmdt["hist"], y, meta, plot_width, plot_height)
panels.append(Panel(child=fig, title="Histogram"))
fig = render_dist(itmdt["dist"], y, "pdf", plot_width, plot_height)
panels.append(Panel(child=fig, title="PDF"))
fig = render_dist(itmdt["dist"], y, "cdf", plot_width, plot_height)
panels.append(Panel(child=fig, title="CDF"))
fig = render_boxwhisker(itmdt["box"], plot_width, plot_height)
panels.append(Panel(child=fig, title="Box"))
tabs = Tabs(tabs=panels)
return tabs
else:
fig = render_hist(itmdt["hist"], y, meta, plot_width, plot_height)
shown, total = meta["partial"]
if shown != total:
fig.title = Title(
text=f"Missing impact of {x} by ({shown} out of {total}) {y}")
else:
fig.title = Title(text=f"Missing impact of {x} by {y}")
return fig
def layout(self):
panels = [None, None]
# Main panel: data
panels[0] = Panel(
child=row(
column(
self.data.layout(),
Spacer(height=10),
self.specials.layout(),
width=160,
),
Spacer(width=10),
column(
self.xaxis.layout([self.yaxis.widget]),
Spacer(height=10),
self.size.layout([self.color.widget]),
),
),
title="data",
)
# Secondary panel: appearance
panels[1] = Panel(child=Div(), title="appearance",)
tabs = Tabs(tabs=panels)
header = Div(
text=f"""<img src="{LOGO_URL}"></img>""",
css_classes=["header-image"],
width=320,
height=100,
)
return row(column(header, tabs), Spacer(width=10), self.plot)
def covid_app(doc, plot_data, description):
"""Create the page with the master dashboard.
Args:
doc (bokeh.Document):
document where the overview over the optimizations will be displayed
by their current stage.
plot_data (dict)
description (pd.DataFrame)
"""
tab_names = ["Overview", "Timeline"]
tab_list = []
for i, sec_title in enumerate(tab_names):
subtopic = description["subtopic"].unique()[i]
title = Div(text=subtopic.capitalize(), style={"font-size": "200%"})
p = create_standard_figure(title="")
source = ColumnDataSource(plot_data)
p.line(source=source, x="x", y="y")
col = Column(*[title, p])
panel = Panel(
child=col,
title=sec_title,
name=f"{sec_title}_panel",
)
tab_list.append(panel)
tabs = Tabs(tabs=tab_list, name="tabs")
doc.add_root(tabs)
def render_missing_impact_1vn(itmdt: Intermediate, plot_width: int,
plot_height: int) -> Tabs:
"""
Render the plot from `plot_missing(df, "x")`
"""
dfs = itmdt["data"]
x = itmdt["x"]
meta = itmdt["meta"]
panels = []
for col, df in dfs.items():
fig = render_hist(df, col, meta[col], plot_width, plot_height)
shown, total = meta[col]["partial"]
if shown != total:
fig.title = Title(
text=f"Missing impact of {x} by ({shown} out of {total}) {col}"
)
else:
fig.title = Title(text=f"Missing impact of {x} by {col}")
panels.append(Panel(child=fig, title=col))
tabs = Tabs(tabs=panels)
return tabs
def examine_daily_distributions(returns, name, n_tr_days):
'''
Function to use in a notebook to organise all the output
:param returns: Daily returns to model
:param name: Name of the strategy
:param n_tr_days: Number of trading days of the strategy
:return:
'''
drv = DailyReturnVisualisations(name,
returns,
n_trading_days=n_tr_days,
n_drawdown_simulations=10000)
display(HTML('<h3>{} Daily Returns</h3>'.format(name)))
display(
HTML('{} days, best fitting distribution is {}'.format(
len(returns), drv.chosen_rv.dist.name)))
tabs = [
Panel(child=drv.generate_daily_returns_plot(), title='Daily returns'),
Panel(child=drv.generate_simulated_drawdown_plot(), title='Drawdown'),
Panel(child=drv.generate_autocorrelation_plot(),
title='Autocorrelation')
]
_ = show(
column(drv.generate_summary_table(), Tabs(tabs=tabs),
drv.generate_simulated_drawdown_table(),
drv.generate_stationarity_table()))
def render_cat_and_num_cols(
itmdt: Intermediate, yscale: str, plot_width: int, plot_height: int,
) -> Tabs:
"""
Render plots from plot(df, x, y) when x is a categorical column
and y is a numerical column
"""
tabs: List[Panel] = []
df, outx, outy, grp_cnt_stats = itmdt["boxdata"]
tabs.append(
box_viz(
df,
outx,
outy,
itmdt["x"],
plot_width,
plot_height,
itmdt["y"],
grp_cnt_stats,
)
)
histdict, grp_cnt_stats = itmdt["histdata"]
tabs.append(
line_viz(
histdict,
itmdt["x"],
itmdt["y"],
yscale,
plot_width,
plot_height,
grp_cnt_stats,
)
)
tabs = Tabs(tabs=tabs)
return tabs
def output_viz(self, width, height):
p2d = self._gen_2d_chart(width, height)
tab2 = Panel(child=p2d, title="2D")
p1d = self._gen_1d_chart(width, height)
tab1 = Panel(child=p1d, title="1D")
tabs = Tabs(tabs=[tab2, tab1])
return tabs
def modify_doc(doc, mytabs):
start, end = 1, 20
samples_count = 5
slider = Slider(start=start, end=end, value=start, step=1, title="Counts")
select = Select(title="Count", value="aux", options=["box", "pack", "image", "user"])
renderer = hv.renderer('bokeh')##.instance(mode='server')
hv.extension('bokeh')
hv.output(size=200)
links = pd.DataFrame(data['links'])
print(links.head(3))
nodes = hv.Dataset(pd.DataFrame(data['nodes']), 'index')
chord = hv.Chord((links, nodes)).select(value=(samples_count, None))
chord.opts(opts.Chord(cmap='Category20', edge_cmap='Category20', edge_color=dim('source').str(), labels='name', node_color=dim('index').str()))
# Create HoloViews plot and attach the document
hvplot = renderer.get_plot(chord, doc)
def slider_update(attrname, old, new):
# Notify the HoloViews stream of the slider update
print ("update received")
samples_count = new
links = pd.DataFrame(data['links'])
print(links.head(3))
nodes = hv.Dataset(pd.DataFrame(data['nodes']), 'index')
chord = hv.Chord((links, nodes)).select(value=(samples_count, None))
chord.opts(opts.Chord(cmap='Category20', edge_cmap='Category20', edge_color=dim('source').str(), labels='name', node_color=dim('index').str()))
# Create HoloViews plot and attach the document
hvplot = renderer.get_plot(chord, doc)
tab3 = Panel(child=row(slider, hvplot.state), title="Chord Plot")
mytabs.append(tab3)
views = Tabs(tabs = mytabs)
layout=row(views)
doc.add_root(layout)
return doc
slider.on_change('value', slider_update)
def select_update(attrname, old, new):
# Notify the HoloViews stream of the slider update
print ("update received. Old: {} New: {}".format(old, new))
select.on_change('value', select_update)
# Combine the holoviews plot and widgets in a layout
tab3 = Panel(child=row(slider, hvplot.state), title="Chord Plot")
mytabs.append(tab3)
views = Tabs(tabs = mytabs)
layout=row(views)
doc.add_root(layout)
return doc
def tabbed_am(df):
output_file("ambulance_tabs.html")
tab1 = Panel(child=ambulance_response(df, 15), title="Quarter Hour")
tab2 = Panel(child=ambulance_response(df), title="Half Hour")
tab3 = Panel(child=ambulance_response(df, 60), title="Hour")
tabs = Tabs(tabs=[tab1, tab2, tab3])
show(tabs)
def tabbed_call(df):
output_file("response_tabs.html")
tab1 = Panel(child=response_to_call(df, 15), title="Quarter Hour")
tab2 = Panel(child=response_to_call(df), title="Half Hour")
tab3 = Panel(child=response_to_call(df, 60), title="Hour")
tabs = Tabs(tabs=[tab1, tab2, tab3])
show(tabs)
def create_figure():
"""
get data from generate_bokeh_data and create the data source. Define widgets and create the two figures.
Position the widgets and figures according to rows and columns
:return: send layout of widgets and plots back to Bokeh
"""
global active_attributes_list, width, depth, level_width, acc, periods, groups, data_source,\
attr_info, attribute_checkbox, apply_changes_button, decision_button, arrow_button, root_select, method_select,\
tree_select, dataset_select, dataset_slider, p, arrow_data_source, circles, rectangles, best_circles,\
best_rectangles, best_root_plot, best_root_plot_data_source, tree_tab, best_arrow_data_source, text_props, Instance
active_attributes_list = [
attr for attr in Instance.attr_list if attr != Instance.attr_list[-1]
]
source, width, depth, level_width, acc = get_bokeh_data(
Instance, "gini", active_attributes_list + [Instance.attr_list[-1]],
selected_root)
# X and y range calculated
periods = [str(i) for i in range(0, width + 1)]
groups = [str(x) for x in range(0, depth + 2)]
elements = pd.DataFrame.from_dict(source)
df = elements.copy()
get_new_data_source(df)
data_source = ColumnDataSource(data=df)
text_props = {
"source": data_source,
"text_align": "center",
"text_baseline": "middle"
}
p, arrow_data_source, circles, rectangles = create_plot("customized")
best_root_plot_data = data_source.data.copy()
best_root_plot_data_source = ColumnDataSource(data=best_root_plot_data)
best_root_plot, best_arrow_data_source, best_circles, best_rectangles = create_plot(
"optimal")
p.select(name="decision_text").visible = False
best_root_plot.select(name="decision_text").visible = False
p.select(name="arrowLabels").visible = False
best_root_plot.select(name="arrowLabels").visible = False
tab1 = Panel(child=p, title="Yeni ağacınız")
tab2 = Panel(child=best_root_plot, title="İdeal ağaç")
tree_tab = Tabs(tabs=[tab1, tab2], width=p.plot_width)
widgets = widgetbox(root_select,
attr_info,
attribute_checkbox,
dataset_slider,
apply_changes_button,
decision_button,
arrow_button,
dataset_select,
tree_select,
file_button,
sizing_mode="stretch_both")
main_frame = layout([[widgets, tree_tab]])
return main_frame
