def report(self, show=False, **kwargs):
'''
Generates a PANEL object of interesting Model Stats and Data Info
can be saved as HTML, PDF
'''
def get_df_info(df):
import io
buffer = io.StringIO()
df.info(buf=buffer)
s = buffer.getvalue()
return s
X = self.X
app = pn.template.BootstrapTemplate(title="Model Report")
pn.config.sizing_mode = "stretch_width"
# Header
app.header.header_background = 'blue'
# app.header.append(pn.pane.Markdown("# Report"))
# Side Bar
#inputs = {f"{col}" : pnw.FloatSlider(name=col,start=X[col].min(), end=max(1,X[col].max()), value=X[col].median()) for col in X.columns}
# for input in inputs:
# app.sidebar.append(inputs[input])
# Main
summary_df = self.summary().T
preds = pd.DataFrame({
"Actual": self.y.values.ravel(),
"Predicted": self.predict(X=self.X).ravel()
})
act_vs_pred = preds.hvplot(x='Predicted',
y='Actual',
kind='scatter',
title='Actual vs Predicted') * hv.Slope(
1, 0).opts(color='red')
summary = pn.Row(
pn.Card(summary_df, title='Summary Statistics', height=500),
pn.Card(act_vs_pred, title="Actual Vs Predicted", height=500))
raw_data_page = pn.Row(
pn.Card(pn.pane.Markdown(get_df_info(self.df)),
title='Data Info',
height=500),
pn.Card(self.df.describe(), title='Data Stats', height=500))
pages = pn.Tabs(('Summary', summary),
('Raw Data Stats', raw_data_page),
('Feature Importance', pn.panel("in work")))
app.main.append(pages)
if show:
server = app.show("KJ's Model Anlaysis report", threaded=True)
return (app, server)
else:
return app
def test_vanilla_with_sidebar():
"""Returns an app that uses the vanilla template in various ways.
Inspect the app and verify that the issues of [Issue 1641]\
(https://github.com/holoviz/panel/issues/1641) have been solved
- Navbar is "sticky"/ fixed to the top
- Navbar supports adding header items to left, center and right
- There is a nice padding/ margin everywhere
- Independent scroll for sidebar and main
- Only vertical scrollbars
"""
vanilla = pn.template.VanillaTemplate(
title="Vanilla Template",
logo=LOGO,
)
pn.config.sizing_mode = "stretch_width"
xs = np.linspace(0, np.pi)
freq = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
phase = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
@pn.depends(freq=freq, phase=phase)
def sine(freq, phase):
return hv.Curve((xs, np.sin(xs * freq + phase))).opts(responsive=True,
min_height=400)
@pn.depends(freq=freq, phase=phase)
def cosine(freq, phase):
return hv.Curve((xs, np.cos(xs * freq + phase))).opts(responsive=True,
min_height=400)
vanilla.sidebar.append(freq)
vanilla.sidebar.append(phase)
vanilla.sidebar.append(pn.pane.Markdown(test_vanilla_with_sidebar.__doc__))
vanilla.sidebar.append(pn.pane.Markdown("## Sidebar Item\n" * 50))
vanilla.main.append(
pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
))
vanilla.main.append(
pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
))
vanilla.header[:] = [
pn.Row(
pn.widgets.Button(name="Left", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Center", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Right", sizing_mode="fixed", width=50),
)
]
vanilla.main_max_width = "600px"
return vanilla
def panel(self):
result = bootstrap
price_slider = pn.widgets.RangeSlider.from_param(
self.param.price_slider, step=10000, format='0.0a')
result.sidebar.append(price_slider)
result.sidebar.append(self.param.rooms_slider)
result.sidebar.append(self.param.bathrooms_slider)
result.sidebar.append(self.param.type)
result.sidebar.append(self.param.transit_time)
image_format = r'<div> <img src="<%= value %>" height="70" alt="<%= value %>" width="70" style="float: left; margin: 0px 15px 15px 0px;" border="2" ></img> </div>'
tabulator_formatters = {
'price': NumberFormatter(format='$0,0'),
'size': NumberFormatter(format='0,0 sqft'),
'photo': HTMLTemplateFormatter(template=image_format)
}
df_widget = pn.widgets.Tabulator(self.filter_df(),
pagination='remote',
page_size=10,
formatters=tabulator_formatters,
sizing_mode='scale_both')
df_widget.add_filter(self.param.price_slider, 'price')
df_widget.add_filter(self.param.rooms_slider, 'bedrooms')
# df_pins = pn.widgets.Tabulator(self.distance_df(), pagination='remote', page_size=10, sizing_mode='scale_both')
layout = pn.Row(
pn.Card(pn.bind(self.location,
x=self.stream.param.x,
y=self.stream.param.y),
title="Map",
sizing_mode='stretch_height'),
pn.Column(
pn.Card(df_widget,
title="Properties",
sizing_mode='scale_both')))
result.sidebar.append(
pn.Card(pn.bind(self.distance_df,
x=self.stream.param.x,
y=self.stream.param.y),
title="Pins",
sizing_mode='scale_both'))
bootstrap.main.append(layout)
bootstrap.main.append(pn.Card(self.details_area, title='Details'))
return result
def environment_variables_view(self):
self.environment_variables.pop('', None) # Clear blank key if there is one
self.env_names = list()
self.env_values = list()
self.env_browsers = list()
self.env_delete_buttons = list()
for i, (k, v) in enumerate(self.environment_variables.items()):
name_widget = self.env_var_widget(val=k, tag=f'env_key_{i}')
val_widget = self.env_var_widget(val=str(v), tag=f'env_val_{i}')
browser_widget = self.env_file_browser_widget(tag=f'env_browser_{i}')
delete_btn = self.env_delete_btn(tag=f'env_del_{i}')
self.env_names.append(name_widget)
self.env_values.append(val_widget)
self.env_browsers.append(browser_widget)
self.env_delete_buttons.append(delete_btn)
self.env_names.append(self.env_var_widget(val=None, tag='env_key_-1', placeholder='NEW_ENV_VAR'))
self.env_values.append(self.env_var_widget(val=None, tag='env_val_-1', disabled=True))
self.env_names[0].name = 'Name'
self.env_values[0].name = 'Value'
return pn.Card(
*[pn.Row(k, v, b, d, sizing_mode='stretch_width') for k, v, b, d in
zip_longest(self.env_names, self.env_values, self.env_browsers, self.env_delete_buttons)],
self.file_browser_col,
title='Environment Variables',
sizing_mode='stretch_width',
)
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel is housed in a row which can then be rendered by the
parent Dashboard.
"""
self.row[0] = pn.Card(
pn.Row(self.plot, sizing_mode="stretch_both"),
header=pn.Row(
pn.Spacer(width=25, sizing_mode="fixed"),
self.close_button,
pn.Row(self.param.X_variable, max_width=100),
pn.Row(self.param.Y_variable, max_width=100),
max_width=400,
sizing_mode="fixed",
),
collapsible=False,
sizing_mode="stretch_both",
)
return self.row
def _construct_card(self, title, views):
kwargs = dict(self.kwargs)
layout = self.layout
if isinstance(layout, list):
item = pn.Column(sizing_mode='stretch_both')
for row_spec in layout:
row = pn.Row(sizing_mode='stretch_width')
for index in row_spec:
if isinstance(index, int):
view = views[index].panel
else:
matches = [
view for view in views if view.name == index
]
if matches:
view = matches[0].panel
else:
raise KeyError("Target could not find named "
f"view '{index}'.")
row.append(view)
item.append(row)
else:
if isinstance(layout, dict):
layout_kwargs = dict(layout)
layout = layout_kwargs.pop('type')
kwargs.update(layout_kwargs)
if layout == 'grid' and 'ncols' not in kwargs:
kwargs['ncols'] = 2
layout_type = _LAYOUTS[layout]
item = layout_type(*(view.panel for view in views), **kwargs)
params = {k: v for k, v in self.kwargs.items() if k in pn.Card.param}
return pn.Card(item, title=title, name=title, **params)
def panel(self):
layout = pn.Card(sizing_mode='stretch_width',
title="Parametres",
collapsed=True)
layout.append(
pn.Param(
self.param,
widgets={
# 'logo': pn.widgets.FileInput(accept='.jpg,.png,.ico,.gif',name="Logo"),
'specfile':
pn.widgets.FileInput(accept='.yaml,.yml',
name="Specification File")
},
show_name=False,
expand_button=False,
expand=False,
sizing_mode="stretch_width"), )
if self.config:
layout.append(
pn.Param(
self.config.param,
show_name=False,
expand_button=False,
expand=False,
sizing_mode="stretch_width",
))
return layout
def addFigure():
if buttonValue:
try:
bootstrap.main[0][2].pop(1)
except:
pass
finally:
bootstrap.main[0][2].append(
pn.Card(plotGraph)
)
else:
try:
bootstrap.main[0][2].pop(1)
except:
pass
finally:
bootstrap.main[0][2].append(
pn.Card(createTable)
)
def division_slider(
building_block_type,
label,
params,
param_1,
param_2,
param_3=None,
ignore_param=None,
popup_label=None,
):
"""Create a slider used to divide the range 0-100 into 2 or 3 parts"""
colors = config.app.style.colors
color = colors.get(building_block_type.lower().replace(" ", "_"),
colors.default)
if param_3 is None:
spinners, slider = _division_slider_with_2_params(
params, param_1, param_2)
else:
spinners, slider = _division_slider_with_3_params(
params, param_1, param_2, param_3)
widget = pn.Card(
pn.Row(pn.layout.HSpacer(), *spinners, pn.layout.HSpacer()),
pn.Row(slider),
title=f"{building_block_type}: {label}",
header_background=color,
active_header_background=color,
background="white",
sizing_mode="stretch_width",
)
if ignore_param is not None:
var_ignore = getattr(params, ignore_param)
widget.append(
pn.Row(
pn.layout.HSpacer(),
pn.widgets.Checkbox.from_param(var_ignore, width_policy="min"),
pn.layout.HSpacer(),
))
@param.depends(widget.param.collapsed, watch=True)
def update_ignore_param(collapsed):
"""Set ignore parameter when card is collapsed"""
params.set_param(**{ignore_param: collapsed})
@param.depends(var_ignore, watch=True)
def collapse_card(var_ignore):
"""Collapse card when parameter is ignored"""
widget.collapsed = var_ignore
if popup_label is not None:
widget[-1].append(popup(label=popup_label))
return widget
def report(self, show=False, **kwargs):
#X = self.X
app = pn.template.BootstrapTemplate(title="Model Report")
pn.config.sizing_mode = "stretch_width"
# Header
app.header.header_background = 'blue'
# Side Bar
# inputs = dict()
# for col in self.db.Features[1]:
# if self.df[col].dtype == 'object':
# inputs[col] = pn.widgets.Select(
# name=col, value=self.df[col][0], options=self.df[col].unique().tolist())
# else:
# inputs[col] = pn.widgets.FloatSlider(
# name=col, value=self.df[col].median())
# widgets = pn.WidgetBox("# Model Inputs", *[inputs[w] for w in inputs])
# app.sidebar.append(widgets)
# Main
db = self.db.drop('Model', axis=1)
summary_df = self.summary()
#summary_df.columns = summary_df.loc[0]
#summary_df = summary_df.loc[1:]
#preds =pd.DataFrame({"Actual" : self.df[self.Target[0]], "Predicted" : self.predict()})
#act_vs_pred = preds.hvplot(x='Predicted', y='Actual',kind='scatter', title='Actual vs Predicted') * hv.Slope(1,0).opts(color='red')
summary = pn.Row(
pn.Card(db, title='Available Models', height=500),
pn.Card(summary_df, title='Summary Statistics', height=500)
#pn.Card(act_vs_pred, title= "Actual Vs Predicted" , height=500)
)
pages = pn.Tabs(('Summary', summary),
('Feature Importance', pn.panel("in work")))
app.main.append(pages)
if show:
server = app.show("KJ's Model Anlaysis report", threaded=True)
return (app, server)
else:
return app
def main():
global series_viewer
series_viewer = SeriesViewer(
) # model_path=sm.output()[0], sim_run=sm.output()[1], locality=sm.output()[2])
button = pnw.Button(name='Refresh', button_type='primary')
button.on_click(refresh)
# Assembling the panel
material.sidebar.append(pn.Param(series_viewer, name='Control Panel'))
# material.sidebar.append(button)
material.sidebar.append(pn.layout.Divider())
material.sidebar.append(series_viewer.view_meta)
# material.sidebar.append(pn.Row(save_fname, save_button))
# material.sidebar.append(pn.widgets.StaticText(sm.simulation_run.path))
material.main.append(
pn.Column(
pn.Row(pn.Card(series_viewer.view_map, title='Final State')),
pn.Row(pn.Card(series_viewer.view_network, title='Network')),
pn.Row(pn.Card(series_viewer.view_series, title='Time Map')),
pn.Row(pn.Card(series_viewer.altair_series, title='Time Series')),
))
return material, series_viewer
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel is housed in a row which can then be rendered by the
parent Dashboard.
"""
self.row[0] = pn.Card(self.al_tabs, collapsible=False)
return self.row
def advanced_options_view(self):
return pn.Column(
self.environment_variables_view,
pn.Card(
'<h3>Modules to Load</h3>',
pn.widgets.CrossSelector.from_param(self.param.modules_to_load, width=700),
'<h3>Modules to Unload</h3>',
pn.widgets.CrossSelector.from_param(self.param.modules_to_unload, width=700),
title='Modules',
sizing_mode='stretch_width',
collapsed=True,
),
name='Environment',
)
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel is housed in a row which can then be rendered by the
parent Dashboard.
"""
if not self.pipeline_initialised:
self.row[0] = self.create_mode_selection_menu()
return self.row
else:
if self.pipeline["Active Learning Settings"].is_complete():
self._close_settings_button.disabled = False
self.row[0] = pn.Card(
pn.Column(
pn.Row(self.pipeline.stage),
pn.Row(
pn.layout.HSpacer(),
pn.layout.HSpacer(),
self.pipeline.buttons[1],
max_height=50,
# max_width=500,
),
),
header=pn.Row(
pn.widgets.StaticText(
name="Settings Panel",
value=
"Please choose the appropriate settings for your data",
),
pn.pane.Markdown(
"### " +
list(self.pipeline._stages)[self._pipeline_stage], ),
self._close_settings_button,
),
collapsible=False,
)
return self.row
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel contents is housed in a row which can then be
rendered by the Panel layout.
"""
if hasattr(self.panel_contents, "panel"):
self.row[0] = self.panel_contents.panel()
else:
self.row[0] = pn.Card(
self.panel_contents,
header=pn.Row(self._close_button),
collapsible=False,
)
return self.row
async def plot_checked(self, event):
async with self.lock:
names = self.enabled_plots.value
for name in names:
metadata = self.plot_metadata[name]
if name in self.plots:
continue
if metadata['type'] not in globals():
print("UNSUPPORTED PLOT TYPE:", metadata['type'])
continue
row, col = (0, 0)
for key, column in self.layout_widgets.items():
if len(column) != 0:
continue
row, col = key
widget = globals()[metadata['type']]
widget = widget(topics=metadata['topics'],
terms=metadata['terms'],
addr=self.graphmgr_addr,
name=name,
idx=(row, col),
ctx=self.ctx)
self.plots[name] = widget
column.append(
pn.Card(widget.plot,
title=name,
min_height=300,
min_width=300))
self.latency_lbls.append(widget.latency)
self.tasks[name] = asyncio.create_task(widget.update())
break
removed_plots = set(self.plots.keys()).difference(names)
for name in removed_plots:
self.remove_plot(name)
def create_mode_selection_menu(self):
layout = pn.Card(
pn.Row(
pn.Column(
pn.pane.PNG(
"images/classification.png",
width=250,
height=250,
margin=(0, 0, 0, 50),
),
pn.Row(self.select_labelling_mode_button, max_height=30),
),
pn.Column(
pn.pane.PNG(
"images/cluster.png",
width=250,
height=250,
margin=(0, 0, 0, 50),
),
pn.Row(self.select_AL_mode_button, max_height=30),
),
))
return layout
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.overwrite_request = None
self.cb = None
self.progress_bar = pn.widgets.misc.Progress(width=250,
active=False,
css_classes=["hidden"])
self.alert = pn.pane.Alert(css_classes=['hidden'])
self.no_version_profiles_alert = pn.pane.Alert(
'No profiles have been created for the selected version',
alert_type='warning',
css_classes=['hidden'],
margin=(0, 5, 20, 5))
self.profile_management_card = pn.Card(
self.profile_management_panel,
title='Manage Profiles',
collapsed=False,
sizing_mode='stretch_width',
)
self.revert_btn = pn.widgets.Button(name='Revert',
button_type='primary',
width=100)
self.revert_btn.on_click(self.revert)
self.profile_panel = pn.Column()
def test_template_with_no_sidebar(template_class=pn.template.VanillaTemplate, theme=pn.template.DefaultTheme):
"""Returns an app that uses the vanilla template in various ways.
Inspect the app and verify that the issues of [Issue 1641]\
(https://github.com/holoviz/panel/issues/1641) have been solved
- Navbar is "sticky"/ fixed to the top
- Navbar supports adding header items to left, center and right
- There is a nice padding/ margin everywhere
- Independent scroll for sidebar and main
- Only vertical scrollbars
"""
vanilla = template_class(
title="Vanilla Template",
logo=LOGO,
favicon="https://raw.githubusercontent.com/MarcSkovMadsen/awesome-panel/2781d86d4ed141889d633748879a120d7d8e777a/assets/images/favicon.ico",
theme=theme
)
vanilla.main_max_width="1100px"
xs = np.linspace(0, np.pi)
freq = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
phase = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
@pn.depends(freq=freq, phase=phase)
def sine(freq, phase):
return hv.Curve((xs, np.sin(xs * freq + phase))).opts(responsive=True, min_height=400)
@pn.depends(freq=freq, phase=phase)
def cosine(freq, phase):
return hv.Curve((xs, np.cos(xs * freq + phase))).opts(responsive=True, min_height=400)
markdown = pn.pane.Markdown(test_template_with_no_sidebar.__doc__)
row1 = pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
)
row2 = pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
)
if issubclass(template_class, pn.template.ReactTemplate):
vanilla.main[0, :] = freq
vanilla.main[1, :] = phase
vanilla.main[2, :] = markdown
vanilla.main[3:5, :] = row1
vanilla.main[5:7, :] = row2
else:
vanilla.main.append(freq)
vanilla.main.append(phase)
vanilla.main.append(markdown)
vanilla.main.append(row1)
vanilla.main.append(row2)
vanilla.header[:] = [
pn.Row(
pn.widgets.Button(name="Left", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Center", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Right", sizing_mode="fixed", width=50),
)
]
return vanilla
def test_template_with_sidebar(template_class=pn.template.VanillaTemplate, theme=pn.template.DefaultTheme):
"""Returns an app that uses the vanilla template in various ways.
Inspect the app and verify that the issues of [Issue 1641]\
(https://github.com/holoviz/panel/issues/1641) have been solved
- Navbar is "sticky"/ fixed to the top
- Navbar supports adding header items to left, center and right
- There is a nice padding/ margin everywhere
- Independent scroll for sidebar and main
- Only vertical scrollbars
"""
vanilla = template_class(
title=template_class.__name__,
logo=LOGO,
theme=theme
)
vanilla.site="My Site"
xs = np.linspace(0, np.pi)
freq = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2,
sizing_mode='stretch_width')
phase = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi,
sizing_mode='stretch_width')
@pn.depends(freq=freq, phase=phase)
def sine(freq, phase):
return hv.Curve((xs, np.sin(xs * freq + phase))).opts(
responsive=True, min_height=150, max_height=450)
@pn.depends(freq=freq, phase=phase)
def cosine(freq, phase):
return hv.Curve((xs, np.cos(xs * freq + phase))).opts(
responsive=True, min_height=150, max_height=450)
vanilla.sidebar.append(freq)
vanilla.sidebar.append(phase)
vanilla.sidebar.append(pn.pane.Markdown(test_template_with_sidebar.__doc__, height=280,
sizing_mode='stretch_width'))
vanilla.sidebar.append(pn.pane.Markdown("## Sidebar Item\n" * 50))
row1 = pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
)
row2 = pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
)
row3 = pn.Row(
pn.Card(hv.DynamicMap(sine), title="Sine"),
pn.Card(hv.DynamicMap(cosine), title="Cosine"),
)
if issubclass(template_class, pn.template.ReactTemplate):
vanilla.main[0:2, :] = row1
vanilla.main[2:4, :] = row2
vanilla.main[4:6, :] = row3
else:
vanilla.main.append(row1)
vanilla.main.append(row2)
vanilla.header[:] = [
pn.Row(
pn.widgets.Button(name="Left", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Center", sizing_mode="fixed", width=50),
pn.layout.HSpacer(),
pn.widgets.Button(name="Right", sizing_mode="fixed", width=50),
)
]
return vanilla
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel is housed in a row which can then be rendered by the
parent Dashboard.
"""
df_pane = hv.Table(
self.region_criteria_df).opts(hooks=[self._apply_format])
buttons_row = pn.Row(
self.assign_label_group,
pn.Row(
self.assign_label_button,
max_height=30,
),
max_height=30,
max_width=600,
)
plot = pn.Row(self.plot, height=400, width=500, sizing_mode="fixed")
total = len(self.labels.keys())
index = self.get_current_index_in_labelled_data()
self._reset_index_buttons()
if (index == 0) or (total == 0):
self.first_labelled_button.disabled = True
self.prev_labelled_button.disabled = True
if index >= (total - 1):
self.next_labelled_button.disabled = True
if len(self.sample_region) == 0:
self.new_labelled_button.disabled = True
if self.src.data[config.settings["id_col"]][0] in list(
self.labels.keys()):
raw_label = self.labels[self.src.data[config.settings["id_col"]]
[0]]
label = config.settings["labels_to_strings"][f"{raw_label}"]
previous_label = pn.widgets.StaticText(
name="Current Label",
value=f"{label}",
)
else:
previous_label = pn.widgets.StaticText(
name="Current Label",
value=f"Unlabelled",
)
dataset_raw_label = self.src.data[config.settings["label_col"]][0]
dataset_label = config.settings["labels_to_strings"][
f"{dataset_raw_label}"]
if (index + 1) > total:
index_tally = f"NEW ({total} Labelled)"
else:
index_tally = f"{index+1}/{total}"
labelling_info_col = pn.Column(
pn.Column(
pn.Row(self.region_message, max_height=50),
pn.Row(df_pane,
max_height=130,
sizing_mode="stretch_width",
scroll=True),
max_height=100,
margin=(0, 0, 50, 0),
max_width=400,
),
pn.Row(
self.column_dropdown,
self.operation_dropdown,
self.input_value,
),
self.add_sample_criteria_button,
self.remove_sample_selection_dropdown,
self.remove_sample_criteria_button,
pn.widgets.StaticText(name="Labelled Point", value=index_tally),
pn.widgets.StaticText(
name="Source ID",
value=f"{self.src.data[config.settings['id_col']][0]}"),
pn.widgets.StaticText(
name="Original Dataset Label",
value=f"{dataset_label}",
),
pn.Row(previous_label, max_height=25),
pn.Row(
self.first_labelled_button,
self.prev_labelled_button,
self.next_labelled_button,
self.new_labelled_button,
),
)
self.assign_label_button.disabled = False
self.row[0] = pn.Card(
pn.Row(
plot,
labelling_info_col,
margin=(0, 20),
),
buttons_row,
header=pn.Row(
pn.Spacer(width=25, sizing_mode="fixed"),
pn.Row(self.param.X_variable, max_width=100),
pn.Row(self.param.Y_variable, max_width=100),
max_width=100,
sizing_mode="fixed",
),
collapsible=False,
sizing_mode="stretch_both",
)
return self.row
def panel(self):
"""Render the current view.
Returns
-------
row : Panel Row
The panel is housed in a row which can then be rendered by the
parent Dashboard.
"""
# CHANGED :: Remove need to rerender with increases + decreases
selected = self._check_valid_selected()
if selected:
self._add_selected_to_history()
button_row = pn.Row()
if self.check_required_column("ra_dec"):
button_row.append(self.zoom_increase)
button_row.append(self.zoom_decrease)
self.deselect_buttton = pn.widgets.Button(name="Deselect")
self.deselect_buttton.on_click(self._deselect_source_cb)
extra_data_list = [
["Source ID", self.src.data[config.settings["id_col"]][0]]
]
for i, col in enumerate(config.settings["extra_info_cols"]):
extra_data_list.append([col, self.src.data[f"{col}"][0]])
extra_data_df = pd.DataFrame(extra_data_list, columns=["Column", "Value"])
extra_data_pn = pn.widgets.DataFrame(
extra_data_df, show_index=False, autosize_mode="fit_viewport"
)
self.row[0] = pn.Card(
pn.Column(
pn.Row(
pn.Column(
button_row,
pn.Row(
pn.Row(self.optical_image),
self.radio_image,
),
),
pn.Row(extra_data_pn, max_height=250, max_width=300),
),
self._create_image_tab(),
),
collapsible=False,
header=pn.Row(self.close_button, self.deselect_buttton, max_width=300),
)
if not self._image_updated:
self._image_updated = True
Process(target=self._update_default_images).start()
else:
self.row[0] = pn.Card(
pn.Column(
self.search_id,
self._search_status,
pn.Row(
pn.widgets.DataFrame(
pd.DataFrame(
self.selected_history, columns=["Selected IDs"]
),
show_index=False,
),
max_width=300,
),
),
header=pn.Row(self.close_button, max_width=300),
)
return self.row
react = pn.template.ReactTemplate(title='React Template')
pn.config.sizing_mode = 'stretch_both'
xs = np.linspace(0, np.pi)
freq = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
phase = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
@pn.depends(freq=freq, phase=phase)
def sine(freq, phase):
return hv.Curve((xs, np.sin(xs * freq + phase))).opts(responsive=True,
min_height=400)
@pn.depends(freq=freq, phase=phase)
def cosine(freq, phase):
return hv.Curve((xs, np.cos(xs * freq + phase))).opts(responsive=True,
min_height=400)
react.sidebar.append(freq)
react.sidebar.append(phase)
# Unlike other templates the `ReactTemplate.main` area acts like a GridSpec
react.main[:4, :6] = pn.Card(hv.DynamicMap(sine), title='Sine')
react.main[:4, 6:] = pn.Card(hv.DynamicMap(cosine), title='Cosine')
react.servable()
