def __init__(self, host="localhost", *args, **kwargs):
if "value" in kwargs:
kwargs["index"] = kwargs["value"]
del kwargs["value"]
if kwargs["index"] is None:
kwargs["index"] = tuple()
if isinstance(kwargs["index"], int):
kwargs["index"] = (kwargs["index"], )
try:
c = requests.get("http://{}:12345".format(host))
assert c.status_code == 200
SelectMultiple.__init__(
self,
*args,
options=list("GPU {index} ({utilization}%)".format(
index=x["index"], utilization=x["utilization.gpu"])
for x in c.json()["gpus"]),
**kwargs,
)
except Exception:
SelectMultiple.__init__(
self,
*args,
options=list(range(8)), # default, just in case
**kwargs,
)
def __init__(self, *args) -> None:
super().__init__(*args)
training_path = Path(self.training_repo.value) # type: ignore
if not training_path.exists():
raise RuntimeError("Path {} does not exist".format(training_path))
if training_path.is_dir():
self.train_labels = SelectMultiple(
options=[],
value=[],
description="Training labels",
disabled=False,
)
self.test_labels = SelectMultiple(
options=[],
value=[],
description="Testing labels",
disabled=False,
)
if not ',' in self.testing_repo.value:
self.testing_repo.value = '[\'' + self.testing_repo.value + '\']'
self.testing_repo.observe( # type: ignore
self.update_label_list, names="value")
self.training_repo.observe( # type: ignore
self.update_label_list, names="value")
self.train_labels.observe(self.update_train_dir_list,
names="value")
self.test_labels.observe(self.update_test_dir_list, names="value")
self.file_list.observe(self.display_img, names="value")
else:
self.train_labels = Button(
description=Path(self.training_repo.value).name # type: ignore
)
if not ',' in self.testing_repo.value:
self.testing_repo.value = '[\'' + self.testing_repo.value + '\']'
self.test_labels = Button(description=Path(
eval(self.testing_repo.value)[0]).name # type: ignore
)
self.train_labels.on_click(self.update_train_file_list)
self.test_labels.on_click(self.update_test_file_list)
self.file_list.observe(self.display_img, names="value")
self._img_explorer.children = [
HBox([HBox([self.train_labels, self.test_labels])]),
self.file_list,
self.output,
]
self.update_label_list(())
def setup_products_out_selector(self):
self.selector_products_out = SelectMultiple(
options=sorted(self.get_unique_products(self.rules)),
value=[],
rows=10,
# description="Drop",
disabled=False,
)
self.selector_products_out.observe(self.handler_products_out_filter, "value")
def __init__(self, *args, **kwargs):
# Compute selected and unselected values
options = kwargs.get('options', {})
if isinstance(options, list):
options = named_objs([(opt, opt) for opt in options])
self._reverse_lookup = {v: k for k, v in options.items()}
selected = [self._reverse_lookup[v] for v in kwargs.get('value', [])]
unselected = [k for k in options if k not in selected]
# Define whitelist and blacklist
self._lists = {
False: SelectMultiple(options=unselected),
True: SelectMultiple(options=selected)
}
self._lists[False].observe(self._update_selection, 'value')
self._lists[True].observe(self._update_selection, 'value')
# Define buttons
button_layout = Layout(width='50px')
self._buttons = {
False: Button(description='<<', layout=button_layout),
True: Button(description='>>', layout=button_layout)
}
self._buttons[False].on_click(self._apply_selection)
self._buttons[True].on_click(self._apply_selection)
# Define search
self._search = {
False: Text(placeholder='Filter available options'),
True: Text(placeholder='Filter selected options')
}
self._search[False].observe(self._filter_options, 'value')
self._search[True].observe(self._filter_options, 'value')
# Define Layout
no_margin = Layout(margin='0')
row_layout = Layout(margin='0',
display='flex',
justify_content='space-between')
search_row = HBox([self._search[False], self._search[True]])
search_row.layout = row_layout
button_box = VBox([self._buttons[True], self._buttons[False]],
layout=Layout(margin='auto 0'))
tab_row = HBox([self._lists[False], button_box, self._lists[True]])
tab_row.layout = row_layout
self._composite = VBox([search_row, tab_row], layout=no_margin)
self.observe(self._update_options, 'options')
self.observe(self._update_value, 'value')
self._selected = {False: [], True: []}
self._query = {False: '', True: ''}
super(CrossSelect, self).__init__(*args, **dict(kwargs,
options=options))
def setup_products_in_selector(self):
self.selector_products_in = SelectMultiple(
options=sorted(self.get_unique_products(self.rules)),
value=sorted(self.get_unique_products(self.rules)),
rows=10,
# description="Include",
disabled=False,
)
self.products_to_in = sorted(self.get_unique_products(self.rules))
self.selector_products_in.observe(self.handler_products_in_filter, "value")
def widget_plots(self):
return interact(
self.show_plots,
plots=SelectMultiple(options=self.ERROR_FUNCTION_NAMES, value=["mean", "max"], description="Plots"),
datasets=SelectMultiple(options=["raw", "image"], value=["image"], description="Datasets"),
error_type=Dropdown(options={"Absolute": "absolute", "Relative": "relative"}, value="absolute", description='Error'),
xmin=Text(value="", placeholder="Type a number or leave blank to disable", description='Min x'),
xmax=Text(value="", placeholder="Type a number or leave blank to disable", description='Max x'),
ymin=Text(value="", placeholder="Type a number or leave blank to disable", description='Min y'),
ymax=Text(value="", placeholder="Type a number or leave blank to disable", description='Max y'),
width=IntSlider(value=15, min=5, max=50, step=1, continuous_update=False, description="Subplot width"),
height=IntSlider(value=15, min=5, max=50, step=1, continuous_update=False, description="Subplot height")
)
def __init__(self, signal_components: dict, _type=""):
"""
Summary:
"""
self.type = _type
# Create the list of signals available
# Include an empty option
self.signals = ["", *list(signal_components)]
self.wsm_signals = SelectMultiple(options=self.signals,
value=[""],
description="Signals:",
placeholder="Signals",
disabled=False)
# Components
self.components = signal_components
components = [""]
for key in signal_components:
components = [*components, *signal_components[key]]
self.wsm_components = SelectMultipleOrdered(options=components,
value=[""],
description="Components:",
placeholder="Components",
disabled=False)
def on_signal_change(change):
components = [""]
if "" in self.wsm_signals.value:
for key in self.components:
components = [*components, *self.components[key]]
else:
for key in self.wsm_signals.value:
components = [*components, *self.components[key]]
self.wsm_components.options = components
self.wsm_signals.observe(on_signal_change, 'value')
super().__init__([
HTML(value=f"<B>Processor type: {self.type}</B>"),
HBox([self.wsm_signals, self.wsm_components]),
HTML(value="<B>Options :</B>")
],
layout=Layout(border='1px solid black'))
self.options = []
def generate_pdp_grid(models: list) -> GridBox:
children = []
# Row 1
children.append(
Label(layout=Layout(width='auto', height='auto'),
value='Choose a PDP method'))
children.append(
Label(layout=Layout(width='auto', height='auto'),
value='Choose one or more model(s)'))
# Row 2
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
Select(description='Type',
options=[elem.name for elem in PDPType],
disabled=False))
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
SelectMultiple(description='Model(s)',
options=[model.name for model in models],
disabled=False))
return GridBox(children=children,
layout=Layout(width='auto',
grid_template_columns="50% 50%",
grid_template_rows='auto',
align_items='center',
grid_gap='3px 3px'))
def replay(workplane, index=0, debug=False, cad_width=600, height=600):
reset_replay()
r = Replay(debug, cad_width, height)
r.stack = r.to_array(workplane,
result_name=getattr(workplane, "name", None))
r.indexes = [index]
if r._debug:
print("Dump of stack:")
r.dump()
r.select_box = SelectMultiple(options=[
"[%02d] %s" % (i, code) for i, (code, obj) in enumerate(r.stack)
],
index=r.indexes,
rows=len(r.stack),
description='',
disabled=False,
layout=Layout(width="600px"))
r.select_box.add_class("monospace")
r.select_box.observe(r.select_handler)
display(HBox([r.select_box, r.debug_output]))
r.select(r.indexes)
return r
def interact_plot_model(self):
Q=interact(
self.plot_model,
m_background=FloatSlider(
min=-2, max=2, step=0.05, value=0., continuous_update=False, description="m$_{background}$",
),
m1=FloatSlider(
min=-2, max=2, step=0.05, value=1., continuous_update=False, description="m1",
),
m2=FloatSlider(
min=-2, max=2, step=0.05, value=2., continuous_update=False, description="m2",
),
m1_center=FloatSlider(
min=-2, max=2, step=0.05, value=0.2, continuous_update=False, description="m1$_{center}$",
),
dm1 =FloatSlider(
min=0, max=0.5, step=0.05, value=0.2, continuous_update=False, description="m1$_{width}$",
),
m2_center=FloatSlider(
min=-2, max=2, step=0.05, value=0.75, continuous_update=False, description="m2$_{center}$",
),
sigma_2=FloatSlider(
min=0.01, max=0.1, step=0.01, value=0.07, continuous_update=False, description="m2$_{sigma}$",
),
option=SelectMultiple(
options=["kernel", "model", "data"],
value=["model"],
description='option'
),
percentage=FloatText(value=5),
floor=FloatText(value=0.02),
)
return Q
def _make_affix_box(self, a_e):
aff = getattr(self._rgx_mchr, a_e[0])
err = getattr(self._rgx_mchr, a_e[1])
dct = getattr(self._rgx_mchr, a_e[2])
opt = getattr(self._rgx_mchr, a_e[3])
form_item_layout = Layout(display='flex',
flex_flow='column',
align_items='stretch',
display_content='center')
ctrl = VBox([
Checkbox(
value=opt,
description=a_e[0] + 'fix',
),
Text(value=aff, ),
IntSlider(
value=err,
min=0,
max=6,
readout=True,
),
SelectMultiple(options=dct),
],
layout=form_item_layout)
#ctrl.children[1].disabled = not ctrl.children[0].value
link((self._rgx_mchr, a_e[0]), (ctrl.children[1], 'value'))
link((self._rgx_mchr, a_e[1]), (ctrl.children[2], 'value'))
link((self._rgx_mchr, a_e[3]), (ctrl.children[0], 'value'))
return ctrl
def build_widget(self):
# init interactive plot
self.plot_output = Output(layout={'width': '600px'})
self.text_output = Output()
self.select = SelectMultiple(options=self.file_list,
layout={'width': '400px'},
rows=20)
self.select.observe(self.update_plot)
VB = VBox([self.select], layout={'align_self': 'center'})
HB = HBox([VB, self.plot_output])
widget = VBox([HB, self.text_output])
return widget
def replay(cad_obj, index=0, debug=False, cad_width=600, height=600):
r = Replay(debug, cad_width, height)
if isinstance(cad_obj, cq.Workplane):
workplane = cad_obj
elif is_cqparts_part(cad_obj):
workplane = convert_cqparts(cad_obj, replay=True)
else:
print("Cannot replay", cad_obj)
return None
r.stack = r.format_steps(
r.to_array(workplane, result_name=getattr(workplane, "name", None)))
r.indexes = [index]
r.select_box = SelectMultiple(options=[
"[%02d] %s" % (i, code) for i, (code, obj) in enumerate(r.stack)
],
index=r.indexes,
rows=len(r.stack),
description='',
disabled=False,
layout=Layout(width="600px"))
r.select_box.add_class("monospace")
r.select_box.observe(r.select_handler)
display(HBox([r.select_box, r.debug_output]))
r.select(r.indexes)
return r
def _create_widget(self) -> SelectMultiple:
_tokens = list(self.tokens.index)
_layout = Layout(width="200px")
self._tokens_widget = SelectMultiple(options=_tokens,
value=[],
rows=30)
self._tokens_widget.layout = _layout
self._tokens_widget.observe(self._on_selection_changed, "value")
self._text_widget = Text(description="")
self._text_widget.layout = _layout
self._text_widget.observe(self._on_filter_changed, "value")
_widget = VBox(
[HTML("<b>Filter</b>"), self._text_widget, self._tokens_widget])
return _widget
def generate_local_interpretation_grid(models: list) -> GridBox:
children = []
# Row 1
children.append(
Label(layout=Layout(width='auto', height='auto'),
value='Choose an interpretation method'))
children.append(
Label(layout=Layout(width='auto', height='auto'),
value='Choose one or more model(s)'))
# Row 2
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
Select(description='Type',
options=[elem.name for elem in LocalInterpreterType],
disabled=False))
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
SelectMultiple(description='Model(s)',
options=[model.name for model in models],
disabled=False))
# Row 3
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
RadioButtons(options=[elem.name for elem in ExampleType],
layout={'width': 'max-content'},
description='Example(s) type:',
disabled=False))
# if you change the description of this widget,
# you have to also adjust it in the notebook function call.
children.append(
IntSlider(
value=1,
min=1,
max=10,
step=1,
description='Number of examples:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='d',
))
return GridBox(children=children,
layout=Layout(width='auto',
grid_template_columns="50% 50%",
grid_template_rows='auto',
align_items='center',
grid_gap='3px 3px'))
def replay(
cad_obj,
index=-1,
quality=None,
deviation=0.1,
angular_tolerance=0.2,
edge_accuracy=None,
debug=False,
cad_width=600,
height=600,
):
if not REPLAY:
print(
"Replay is not enabled. To do so call 'enable_replay()'. Falling back to 'show()'"
)
return show(cad_obj, cad_width=cad_width, height=height)
else:
print(
"Use the multi select box below to select one or more steps you want to examine"
)
r = Replay(quality, deviation, angular_tolerance, edge_accuracy, debug,
cad_width, height)
if isinstance(cad_obj, cq.Workplane):
workplane = cad_obj
elif is_cqparts_part(cad_obj):
workplane = convert_cqparts(cad_obj, replay=True)
else:
print("Cannot replay", cad_obj)
return None
r.stack = r.format_steps(
r.to_array(workplane, result_name=getattr(workplane, "name", None)))
if index == -1:
r.indexes = [len(r.stack) - 1]
else:
r.indexes = [index]
r.select_box = SelectMultiple(
options=[
"[%02d] %s" % (i, code) for i, (code, obj) in enumerate(r.stack)
],
index=r.indexes,
rows=len(r.stack),
description="",
disabled=False,
layout=Layout(width="600px"),
)
r.select_box.add_class("monospace")
r.select_box.observe(r.select_handler)
display(HBox([r.select_box, r.debug_output]))
r.select(r.indexes)
return r
def _init_gui(self):
close = Button(description=' Close', icon='trash', layout=_wlo)
def _close(b):
self.close()
close.on_click(_close)
frame = IntSlider(min=self._df.frame.astype(int).min(),
max=self._df.frame.astype(int).max(),
value=-1,
description='Frame',
layout=_wlo)
cbut = Button(description=' Columns', icon='barcode')
cols = self._df.columns.tolist()
cols = SelectMultiple(options=cols, value=cols)
def _cols(c):
self.columns = c.new
self._update_output()
cols.observe(_cols, names='value')
cfol = Folder(cbut, _ListDict([('cols', cols)]))
rbut = Button(description=' Rows', icon='bars')
rows = IntRangeSlider(min=self.indexes[0],
max=self.indexes[1],
value=[0, 50])
def _rows(c):
self.indexes = c.new
print(self.indexes)
self._update_output()
rows.observe(_rows, names='value')
rfol = Folder(rbut, _ListDict([('rows', rows)]))
return _ListDict([('close', close), ('frame', frame), ('cols', cfol),
('rows', rfol)])
def _init_gui(self):
close = Button(description=' Close', icon='trash', layout=_wlo)
def _close(b): self.close()
close.on_click(_close)
frame = IntSlider(min=self._df.frame.astype(int).min(),
max=self._df.frame.astype(int).max(),
value=-1, description='Frame', layout=_wlo)
cbut = Button(description=' Columns', icon='barcode')
cols = self._df.columns.tolist()
cols = SelectMultiple(options=cols, value=cols)
def _cols(c):
self.columns = c.new
self._update_output()
cols.observe(_cols, names='value')
cfol = Folder(cbut, _ListDict([('cols', cols)]))
rbut = Button(description=' Rows', icon='bars')
rows = IntRangeSlider(min=self.indexes[0],
max=self.indexes[1],
value=[0, 50])
def _rows(c):
self.indexes = c.new
print(self.indexes)
self._update_output()
rows.observe(_rows, names='value')
rfol = Folder(rbut, _ListDict([('rows', rows)]))
return _ListDict([('close', close),
('frame', frame),
('cols', cfol),
('rows', rfol)])
def layer_select(m, design):
layers_to_plot = m
features_to_plot = {'features':[],'layer':[]}
if len(layers_to_plot)>0:
features_to_plot['features'] = [x for x in design.features if design.features[x].layer in layers_to_plot]
features_to_plot['layers'] = [layers_to_plot.index(design.features[x].layer) for x in design.features if design.features[x].layer in layers_to_plot]
if len(features_to_plot['features'])>0:
#chk = [Checkbox(description=a) for a in features_to_plot]
#interact(updatePlot, **{c.description: c.value for c in chk})
sel_mult2 = SelectMultiple(options = features_to_plot['features'])
interactive_plot2 = interactive(updatePlot, n=sel_mult2,
design = fixed(design), all_features = fixed(features_to_plot))
display(interactive_plot2)
def interact_ft_vs_markers(self):
"""Interactor for plotting nuclei feature vs marker values."""
def _interact_ft_vs_markers(feature, markers, sample=1.0):
"""Plot scatter plot of a marker vs a feature, allows plotting more than one marker at a time using different
colors.
The sample parameter is a float from 0.0 to 1.0 that defines how many nuclei to sample from the total number
of nuclei available to plot - plotting a smaller number of points makes comparisons easier to see."""
button, text = _create_button_text_display('feature_vs_markers.png')
# check that both dataframes matche in CellID column
if not np.all(self.markers_df.CellID == self.df_full.CellID):
raise Exception('The cell id columns of both dataframe do not match, not running function')
# subset the markers dataframe by only the markers of interest and concatenate horizontally
markers = list(markers)
df = concat([self.df_full, self.markers_df[markers]], axis=1)
# sample the nuclei
if sample < 1.0:
df = df.sample(frac=sample, random_state=64)
# create the figure canvas
fig, ax = plt.subplots(figsize=(10, 10))
# plot the scatter of the feature vs each marker
for i, marker in enumerate(markers):
df.plot.scatter(x=feature, y=marker, c=COLOR_NAMES[i], ax=ax, alpha=0.2)
ax.set_ylabel('Marker value', fontsize=18)
ax.set_xlabel(f'Feature: {feature}', fontsize=18)
ax.legend(markers, fontsize=14)
ax.set_title('Comparison of nuclei feature and marker value', fontsize=20)
plt.show()
button.on_click(partial(self.on_button_clicked, text_widget=text, fig_to_save=fig))
display(widgets.HBox([text, button]))
a = Dropdown(options=self.features, value=self.features[0], description='Feature:')
b = SelectMultiple(options=self.markers, value=[self.markers[0]], style=DESC_STYLES,
layout=Layout(width='500px'),description='Select markers (hold control to select multiple):')
c = FloatSlider(value=0.1, min=0.05, max=1.0, step=0.05, description='Frac. nuclei sampled:', style=DESC_STYLES,
continuous_update=False)
row = widgets.HBox([a, b, c])
out = widgets.interactive_output(_interact_ft_vs_markers, {'feature': a, 'markers': b, 'sample': c})
display(row, out)
def build_knobs(self):
# Dropdowns
for name, (options, default) in self.dropdowns.items():
if None not in options:
options = options + [None]
self.knobs[name] = Dropdown(options=options,
description=name,
value=default)
# Selectors
for name, options in self.selectors.items():
self.knobs[name] = SelectMultiple(options=options,
value=options,
rows=len(options))
self.knobs["xlog"] = Checkbox(description="xlog", value=False)
self.knobs["ylog"] = Checkbox(description="ylog", value=False)
def __init__(self, signal_components: dict, md_type="", parent=None):
self.type = md_type
self.parent = parent
if self.parent is not None:
try:
self.parent.set_title_from_widget(self)
except:
print("Unable to set the Tab title.")
# Retain only the signals (at this stage a single component should be present)
self.signals = list(signal_components.keys())
self.wsm_signals = SelectMultiple(options=["", *self.signals],
value=[""],
description="Signals:",
placeholder="Signals",
disabled=False)
# Components
self.components = signal_components
# start date
wdp_start_date = DatePicker(description='Start date:', disabled=False)
# stop date
wdp_stop_date = DatePicker(description='Stop date:', disabled=False)
self.whb_dates = HBox([wdp_start_date, wdp_stop_date])
# Max number of markers to detect
self.wit_max_num = BoundedIntText(value=0,
min=0,
step=1,
description="Max Number of Markers:")
# Initialize the
super().__init__([
HTML(value=f"<B>Processor type: {self.type}</B>"),
self.wsm_signals, self.whb_dates,
HTML(value="<B>Options :</B>")
],
layout=Layout(border='1px solid black'))
self.options = []
def interact_with_plot_all_outputs(sa_dict, demo=False, manual=True):
"""
This function adds the ability to interactively adjust all of the
plotting.make_plot() arguments.
Parameters
----------
sa_dict : dict
a dictionary with all the sensitivity analysis results.
demo : bool, optional
plot only few outcomes for demo purpose.
Returns
-------
Interactive widgets to control plot
"""
min_val_box = BoundedFloatText(value=0.01,
min=0,
max=1,
description='Min value:')
top_box = IntText(value=20, description='Show top:')
stacks = Checkbox(
description='Show stacked plots:',
value=True,
)
error_bars = Checkbox(description='Show error bars:', value=True)
log_axis = Checkbox(description='Use log axis:', value=True)
# get a list of all the parameter options
key = sa_dict.keys()[0]
param_options = list(sa_dict[key][0].Parameter.values)
highlighted = SelectMultiple(description="Choose parameters to highlight",
options=param_options,
value=[])
return interact(plot_all_outputs,
sa_dict=fixed(sa_dict),
demo=fixed(demo),
min_val=min_val_box,
top=top_box,
stacked=stacks,
error_bars=error_bars,
log_axis=log_axis,
highlighted_parameters=highlighted,
__manual=manual)
def __fill_smoothing_method(self):
"""
Fill smooth methods
"""
smoothing_methods = ['smoothn',
'ExponentialSmoothing',
'SimpleExpSmoothing',
'Holt']
self.smoothing_methods = SelectMultiple(
options=tuple(smoothing_methods),
value=tuple([smoothing_methods[0]]),
rows=len(smoothing_methods),
description='Smoothing methods',
disabled=False,
style = {'description_width': 'initial'},
layout={'width': '330px'},
)
def __fill_interpolation_method(self):
"""
Fill interpolation methods
"""
interpolation_methods = [
'linear', 'nearest', 'slinear', 'quadratic', 'cubic', 'krog',
'pchip', 'spline', 'akima'
]
self.interpolation_methods = SelectMultiple(
options=tuple(interpolation_methods),
value=tuple([interpolation_methods[0]]),
rows=len(interpolation_methods),
description='Interpolation methods',
disabled=False,
style={'description_width': 'initial'},
layout={'width': '220px'},
)
def __init__(self):
log.info("__init__")
self.cl = int_field(settings.CACHE_LINES_VAL,
settings.CACHE_LINES_DESC)
self.cb = int_field(settings.CACHE_BLOCK_VAL,
settings.CACHE_BLOCK_DESC)
self.ml = int_field(settings.OUTPUT_LINES_VAL,
settings.OUTPUT_LINES_DESC)
self.cwd = Combobox(placeholder=settings.CWD_PATH_DEF,
options=load_cwd_file(),
description=settings.CWD_PATH_DESC,
style=settings.WIDGET_DESC_PROP,
layout=settings.WIDGET_LAYOUT)
self.ex = text_field(settings.EXEC_PATH_DEF, settings.EXEC_PATH_DESC)
self.to = text_field(settings.TRACE_NAME_DEF, settings.TRACE_NAME_DESC)
self.st = text_field(settings.START_FUN_DEF, settings.START_FUN_DESC)
self.vh = v.Html(
tag='style',
children=[".v-input__slot .v-label{color: black!important}"])
self.gt_in = VBox([
self.cl, self.cb, self.ml, self.cwd, self.ex, self.to, self.st,
self.vh
],
layout=Layout(width='100%'))
self.gb = button(settings.GENERATE_DESC, color=settings.GENERATE_COLOR)
self.lb = button(settings.LOAD_DESC, color=settings.LOAD_COLOR)
self.db = button(settings.DELETE_DESC, color=settings.DELETE_COLOR)
self.bs = HBox([self.gb, self.lb, self.db])
self.sw = SelectMultiple(options=[],
value=[],
description=settings.SELECT_MULTIPLE_DESC,
layout=settings.WIDGET_LAYOUT,
rows=10)
self.tw = HBox([self.gt_in, self.sw],
layout=Layout(justify_content="space-around"))
self.widgets = VBox([self.tw, self.bs],
layout=Layout(justify_content="space-around"))
def __init__(self, *, default_folder: str, **defaults):
"""GUI base for PoS token count statistics."""
super().__init__()
self.default_folder: str = default_folder
self.document_index: pd.DataFrame = None
self.data: pd.DataFrame = None
self.defaults: dict = defaults
self.PoS_tag_groups: pd.DataFrame = pu.PD_PoS_tag_groups
self._source_folder: FileChooserExt2 = None
self._normalize: ToggleButton = ToggleButton(
description="Normalize",
icon='check',
value=defaults.get('normalize', False),
layout=Layout(width='140px'))
self._smooth: ToggleButton = ToggleButton(description="Smooth",
icon='check',
value=defaults.get(
'smooth', False),
layout=Layout(width='140px'))
self._temporal_key: Dropdown = Dropdown(
options=TEMPORAL_GROUP_BY,
value=defaults.get('temporal_key', 'decade'),
description='',
disabled=False,
layout=Layout(width='90px'),
)
self._status: HTML = HTML(
layout=Layout(width='50%', border="0px transparent white"))
self._pos_groups: SelectMultiple = SelectMultiple(
options=['Total'] + [
x
for x in self.PoS_tag_groups.index.tolist() if x != "Delimiter"
],
value=['Total'],
rows=10,
layout=Layout(width='120px'),
)
self._tab: OutputsTabExt = OutputsTabExt(["Table", "Line", "Bar"],
layout={'width': '98%'})
self._widgets_placeholder: HBox = HBox(children=[])
self._sidebar_placeholder: HBox = HBox(children=[])
def new_dataset(self):
"""
A handy widget for creating new `DataSets`.
"""
samples = list(self.tier)
option_map = {sample.name: sample for sample in samples}
selection = SelectMultiple(options=option_map.keys(),
description='Auto Add')
def create(name, auto_add):
with form.status:
self.tier.setup_technique(name)
if auto_add:
for sample in (option_map[name] for name in auto_add):
o = sample[name]
o.setup_files()
display(widgetify_html(o._repr_html_()))
form = InputSequence(
create, Text(description=f'Name:', placeholder='e.g. XRD'),
selection)
return form.as_widget()
def view():
info = Label("Select a parcel to display.")
temppath = config.get_value(['paths', 'temp'])
datapath = config.get_value(['paths', 'data'])
method = ToggleButtons(options=[('From local storage', 0),
('Remote to memory', 1)],
value=0,
description='',
disabled=True,
button_style='info',
tooltips=[
'View data that are stored on the local drive.',
'View data from memory.'
])
paths = RadioButtons(options=[
(f"Temporary folder: '{temppath}'.", temppath),
(f"Personal data folder: '{datapath}'.", datapath)
],
layout={'width': 'max-content'},
value=temppath)
paths_box = Box([Label(value="Select folder:"), paths])
tables_first = [
f for f in os.listdir(paths.value)
if os.path.isdir(os.path.join(paths.value, f))
]
select_table = Dropdown(
options=[f for f in tables_first if not f.startswith('.')],
value=None,
description='Select tabe:',
disabled=False,
)
select_option = RadioButtons(options=[(f"Single parcel selection.", 1),
(f"Multiple parcels selection.", 2)],
disabled=True,
layout={'width': 'max-content'})
button_refresh = Button(layout=Layout(width='35px'), icon='fa-refresh')
select_option_box = HBox([
select_table, button_refresh,
Label(value="Selection method:"), select_option
])
selection_single = Dropdown(
options=[],
value=None,
description='Select parcel:',
disabled=False,
)
selection_multi = SelectMultiple(
options=[],
value=[],
description='Select parcels:',
disabled=False,
)
view_method = ToggleButtons(
options=[],
value=None,
description='',
disabled=False,
button_style='info',
tooltips=[],
)
rm_parcel = Button(value=False,
disabled=False,
button_style='danger',
tooltip='Delete parcel data.',
icon='trash',
layout=Layout(width='35px'))
code_info = Label()
single_box = HBox([selection_single, rm_parcel])
select_box = Box([single_box])
method_0 = VBox([info, paths_box, select_option_box, select_box])
method_1 = VBox([])
view_box = Output(layout=Layout(border='1px solid black'))
method_out = Output()
with method_out:
display(method_0)
def method_options(obj):
with method_out:
method_out.clear_output()
if obj['new'] == 0:
display(method_0)
elif obj['new'] == 1:
display(method_1)
method.observe(method_options, 'value')
@button_refresh.on_click
def button_refresh_on_click(b):
view_box.clear_output()
tables_first = [
f for f in os.listdir(paths.value)
if os.path.isdir(os.path.join(paths.value, f))
]
select_table.options = [
f for f in tables_first if not f.startswith('.')
]
if select_table.value is not None:
parcels = f"{paths.value}{select_table.value}"
parcels_list = [
f for f in os.listdir(parcels) if not f.startswith('.')
]
selection_single.options = parcels_list
selection_multi.options = parcels_list
else:
selection_single.options = []
selection_single.value = None
selection_multi.options = []
selection_multi.value = []
@rm_parcel.on_click
def rm_parcel_on_click(b):
try:
parcel_to_rm = f"{paths.value}{select_table.value}/{selection_single.value}"
try:
shutil.rmtree(f'{parcel_to_rm}')
except Exception:
pass
try:
os.remove(f'{parcel_to_rm}')
except Exception:
pass
# print(f"The parce: '{selection_single.value}' is deleted.")
parcels = f"{paths.value}{select_table.value}"
parcels_list = [
f for f in os.listdir(parcels) if not f.startswith('.')
]
selection_single.options = parcels_list
view_box.clear_output()
except Exception:
pass
def on_select_option_change(change):
if select_option.value == 1:
select_box.children = [single_box]
else:
select_box.children = [selection_multi]
select_option.observe(on_select_option_change, 'value')
def on_datapath_change(change):
tables = [
f for f in os.listdir(paths.value)
if os.path.isdir(os.path.join(paths.value, f))
]
tables = [f for f in tables if not f.startswith('.')]
select_table.options = tables
paths.observe(on_datapath_change, 'value')
def on_table_change(change):
if select_table.value is not None:
parcels = f"{paths.value}{select_table.value}"
parcels_list = [
f for f in os.listdir(parcels) if not f.startswith('.')
]
selection_single.options = parcels_list
selection_multi.options = parcels_list
else:
selection_single.options = []
selection_single.value = None
selection_multi.options = []
selection_multi.value = []
view_method.options = []
select_table.observe(on_table_change, 'value')
def on_selection_change(obj):
code_info.value = "Select how to view the dataset."
options_list = [('Get example code', 1)]
if obj['new'] is not None:
parceldata = f"{paths.value}{select_table.value}/{selection_single.value}"
data_list = [
f for f in os.listdir(parceldata) if not f.startswith('.')
]
if any("time_series" in s for s in data_list):
options_list.append(('Plot time series', 2))
if any("chip_images" in s for s in data_list):
options_list.append(('View images', 3))
options_list.append(("Show on map", 4))
if select_option.value == 2:
options_list.append(('Comparison', 5))
view_method.options = options_list
view_method.value = None
selection_single.observe(on_selection_change, 'value')
selection_multi.observe(on_selection_change, 'value')
def method_options(obj):
view_box.clear_output()
with view_box:
if selection_single.value is None:
with view_box:
print("Please select a parcel")
elif select_option.value == 1:
data_path = f'{paths.value}{select_table.value}/{selection_single.value}/'
if obj['new'] == 1:
from src.ipycbm.ui_view import view_code
display(view_code.code(data_path))
elif obj['new'] == 2:
from src.ipycbm.ui_view import view_time_series
display(view_time_series.time_series(data_path))
elif obj['new'] == 3:
from src.ipycbm.ui_view import view_calendar
display(view_calendar.calendar(data_path))
elif obj['new'] == 4:
from src.ipycbm.ui_view import view_map
display(view_map.widget_box(data_path))
elif select_option.value == 2 and len(selection_multi.value) > 0:
data_path = f'{paths.value}{select_table.value}/'
data_paths = [
f'{data_path}{s}/' for s in selection_multi.value
]
if obj['new'] == 1:
from src.ipycbm.ui_view import view_code
display(view_code.code(data_paths[0]))
pass
elif obj['new'] == 2:
from src.ipycbm.ui_view import view_time_series
# display(view_time_series.time_series(data_list[0]))
pass
elif obj['new'] == 3:
from src.ipycbm.ui_view import view_calendar
# display(view_chip_images.calendar(data_path))
pass
elif obj['new'] == 4:
from src.ipycbm.ui_view import view_maps
display(view_maps.with_polygons(data_paths))
selection_single.observe(method_options, 'value')
selection_multi.observe(method_options, 'value')
view_method.observe(method_options, 'value')
notes_info = Label("Add a note for the parcel")
notes_bt = Button(value=False,
description='Add note',
disabled=False,
button_style='info',
tooltip='Add a note.',
icon='sticky-note')
notes_box = VBox([])
@notes_bt.on_click
def notes_bt_on_click(b):
if notes_box.children == ():
notes_box.children = [
view_notes.notes(f"{paths.value}{select_table.value}/",
select_table.value,
selection_single.value.replace('parcel_', ''))
]
else:
notes_box.children = []
wbox = VBox([
method_out, code_info, view_method, view_box,
HBox([notes_info, notes_bt]), notes_box
])
return wbox
def plot_design(design):
output_notebook()
sel_mult = SelectMultiple(options = [x for x in design.layers])
interactive_plot = interactive(layer_select, m=sel_mult, design=fixed(design))
display(interactive_plot)
def __init__(self, signal_components: dict):
"""
Summary:
Object constructor.
This is a quite specific processor and has a dedicated constructor.
"""
self.type = "band_filter"
# Create the list of signals available
# Include an empty option
self.signals = list(signal_components.keys())
# In this case, only one signal can be selected
self.wdd_signals = Dropdown(options=self.signals,
description="Signals:",
placeholder="Signals",
disabled=False)
self.components = signal_components
components = signal_components[self.wdd_signals.value]
self.wdd_nir = Dropdown(options=components,
description="NIR:",
disabled=False)
self.wdd_swir = Dropdown(options=components,
description="SWIR:",
disabled=False)
self.wdd_red = Dropdown(options=components,
description="RED:",
disabled=False)
self.nsr_bar = HBox([self.wdd_nir, self.wdd_swir, self.wdd_red])
self.wsm_components = SelectMultiple(options=["", *components],
value=[""],
description="Components:",
placeholder="Components",
disabled=False)
def on_signal_change(change):
components = self.components[self.wdd_signals.value]
self.wdd_nir.options = components
self.wdd_swir.options = components
self.wdd_red.options = components
self.wsm_components.options = ["", *components]
self.wdd_signals.observe(on_signal_change, 'value')
super(type(self).__bases__[0],
self).__init__([
HTML(value=f"<B>Processor type: {self.type}</B>"),
HBox([self.wdd_signals, self.wsm_components]), self.nsr_bar,
HTML(value="<B>Options :</B>")
],
layout=Layout(border='1px solid black'))
self.options = []
# Add specific options
wsm_cat = SelectMultiple(
description="excluded_categories:",
options=red_nir_swir_processor_widget.class_labels,
disabled=False)
# "min_val": [1200, 800, 150],
# "max_val": [5700, 4100, 2800]
# wt_minval = Text(
# description="min_val:",
# value = "1200, 800, 150",
# disabled = False)
# wt_maxval = Text(
# description="max_val:",
# value = "5700, 4100, 2800",
# disabled = False)
# wfc_trainingfile = FileChooser(
# description = "training_file:",
# disabled = False
# )
# self.add_options([wsm_cat, wt_minval, wt_maxval, wfc_trainingfile])
self.add_options([wsm_cat])
