def __init__(
self,
existing: Optional[Dict[str, Any]] = None,
save_file_name: Optional[str] = "tmp.json",
) -> None:
self.box_layout = Layout(
overflow="scroll hidden",
border="1px solid black",
width="600px",
height="",
flex_flow="row",
display="flex",
)
self.textbox_layout = Layout(
overflow="scroll hidden",
border="1px solid black",
width="10px",
height="",
flex_flow="row",
display="flex",
)
self.tab_layout = Layout(
# border="1px solid black",
width="600px")
self.label_layout = Layout(width="600px")
self.textarea_layout = Layout(width="592px")
self.smalltextarea_layout = Layout(width="570px")
self.item_layout = Layout(height="200px", min_width="40px")
self.cg_backend = ConfigGenerator(existing)
self.save_file_name = save_file_name
self.config = Textarea()
self.tab = Tab()
self.dict_res = {}
self._make_grid()
def create_layout(self):
self._layout_viewer_options = self._options_cls(self.state)
# Check for a custom layout factory
layout_factory = get_layout_factory()
if layout_factory is not None:
self._layout = layout_factory(self)
return
# Take all the different widgets and construct a standard layout
# for the viewers, based on ipywidgets HBox and VBox. This can be
# overriden in sub-classes to create alternate layouts.
self._layout_toolbar = HBox([
self.toolbar_selection_tools, self.toolbar_active_subset,
self.toolbar_selection_mode
])
self._layout_tab = Tab(
[self._layout_viewer_options, self._layout_layer_options])
self._layout_tab.set_title(0, "General")
self._layout_tab.set_title(1, "Layers")
self._layout = VBox([
self._layout_toolbar,
HBox([self.figure_widget, self._layout_tab]), self._output_widget
])
def __init__(self, querier, citation_var, citation_file=None, debug=False, start=None, load=True):
from .selenium_scholar import URLQuery
reload()
self.querier = querier
work = work_by_varname(citation_var)
citation_file = citation_file or getattr(work, "citation_file", citation_var)
self.navigator = ArticleNavigator(citation_var, citation_file, backward=False, force_citation_file=False)
self.query = URLQuery(self.navigator.work.scholar, start)
self.next_page_widget = Button(description='Next Page', icon='fa-arrow-right')
self.reload_widget = Button(description='Reload', icon='fa-refresh')
self.previous_page_widget = Button(description='Previous Page', icon='fa-arrow-left')
self.debug_widget = ToggleButton(value=debug, description="Debug")
self.page_number_widget = Label(value="")
self.next_page_widget.on_click(self.next_page)
self.reload_widget.on_click(self.reload)
self.previous_page_widget.on_click(self.previous_page)
self.view = Tab([
VBox([
HBox([
self.previous_page_widget,
self.reload_widget,
self.next_page_widget,
self.debug_widget,
self.page_number_widget
]),
self.navigator.output_widget,
]),
self.navigator.view
])
self.view.set_title(0, "Page")
self.view.set_title(1, "Article")
if load:
self.reload(None)
def _display(self):
clear_output(wait=True)
# Get current tab index
tab_index = 0
if self.tab is not None:
tab_index = self.tab.selected_index
# Get Wikipedia tab
self.tab = Tab()
self.tab.children = [
self.wikipedia_tab.tab_child,
self.free_text_tab.tab_child,
]
self.tab.set_title(0, self.wikipedia_tab.title)
self.tab.set_title(1, self.free_text_tab.title)
# Select the wanted tab
self.tab.selected_index = tab_index
# Go button with tab
box = VBox((HBox((self._do_embeddings_button,
self._document_vector_type)), self.tab))
if self.fig is not None:
# noinspection PyTypeChecker
display(box, self.fig)
else:
# noinspection PyTypeChecker
display(box)
class WWTJupyterViewer(WWTDataViewerBase, IPyWidgetView):
_layer_style_widget_cls = {
WWTImageLayerArtist: JupyterImageLayerOptions,
WWTTableLayerArtist: JupyterTableLayerOptions,
}
def __init__(self, session, state=None):
IPyWidgetView.__init__(self, session, state=state)
WWTDataViewerBase.__init__(self)
# In Glue+Jupyter Notebook, we need to explicitly specify this to get
# the widget to fill up the horizontal space.
self._wwt.layout.width = '100%'
self._layout_viewer_options = JupterViewerOptions(
self.state, self.state.imagery_layers)
self._layout_tab = Tab(
[self._layout_viewer_options, self._layout_layer_options])
self._layout_tab.set_title(0, "General")
self._layout_tab.set_title(1, "Layers")
self._layout = HBox([self.figure_widget, self._layout_tab])
def _initialize_wwt(self):
self._wwt = WWTJupyterWidget()
def redraw(self):
self._update_wwt()
@property
def figure_widget(self):
return self._wwt
def __init__(self, viewer):
self.viewer = viewer
self._layout_tab = Tab(
[self.viewer.viewer_options, self.viewer.layer_options])
self._layout_tab.set_title(0, "General")
self._layout_tab.set_title(1, "Layers")
self._advanced_button = Button(description='Show advanced')
self._advanced_button.on_click(self._toggle_basic_advanced)
self._layout_toolbar = HBox([], layout={'justify_content': 'center'})
self._layout_top = HBox([], layout={'justify_content': 'center'})
self._layout_middle = HBox([], layout={'justify_content': 'center'})
self._layout_bottom = HBox([self._advanced_button],
layout={'justify_content': 'center'})
# Default to basic mode
self.advanced = False
super().__init__([
self._layout_toolbar, self._layout_top, self._layout_middle,
self._layout_bottom, self.viewer.output_widget
])
self._update_layout()
class NanoTab(object):
def __init__(self, xml_root):
# uep = xml_root.find('.//nanoparticle') # find unique entry point into XML for (1st) nanoparticle
self.type1 = NanoType1(xml_root)
# for np in xml_root.iter('nanoparticle'): # hacky: iterate thru all (2) NPs to land on last/2nd
# uep = np
self.type2 = NanoType2(xml_root)
self.xform = NanoTransform()
tab_height = '500px'
tab_layout = Layout(
width='800px', # border='2px solid black',
height=tab_height,
overflow_y='scroll')
# self.tab = Tab(children=[self.type1.tab, self.type2.tab, self.xform.tab])
# self.tab.set_title(0, 'Type 1')
# self.tab.set_title(1, 'Type 2')
# self.tab.set_title(2, 'Transformations')
self.tab = Tab(children=[self.type1.tab])
self.tab.set_title(0, 'Type 1')
def fill_gui(self, xml_root):
# uep = xml_root.find('.//cell_definition') # find unique entry point into XML
self.type1.fill_gui()
# self.type2.fill_gui()
# self.xform.fill_gui(xml_root)
def fill_xml(self, xml_root):
self.type1.fill_xml(xml_root)
def __init__(self):
self.run_bt = Button(description='Demo0', button_style='info')
self.mod_add_bt = Button(description='Add model', button_style='info')
self.mod_remove_bt = Button(description='Remove model',
button_style='warning')
self.dts_selector = self.get_default_dts_selector()
self.dts_selector.description = 'Dataset:'
self.size_selector = self.get_default_size_selector()
self.features_selector = self.get_default_features_selector()
self.features_selector.layout = Layout(width='900px')
self.model_name_column = VBox([Label(value='Model')])
self.sampler_name_column = VBox([Label(value='Sampler')])
self.box_type_column = VBox([Label(value='Box Type')])
self.n_estim_column = VBox([Label(value='Number Estimators')])
self.pca_column = VBox([Label(value='PCA?')])
self.pca_order_column = VBox([Label(value='PCA Order')])
self.models_bar = HBox([
self.model_name_column,
self.sampler_name_column,
self.box_type_column,
self.n_estim_column,
self.pca_column,
self.pca_order_column,
],
layout=Layout(border='3px solid black'))
self.gui = Tab()
self.tab0 = VBox([
self.dts_selector,
self.size_selector,
self.mod_add_bt,
self.mod_remove_bt,
self.features_selector,
self.models_bar,
self.run_bt,
])
self.tab1 = self.get_dt_hp_tab()
self.tab2 = self.get_logit_hp_tab()
self.tab3 = self.get_linearsvc_hp_tab()
self.tab4 = self.get_samplers_params_tab()
self.gui.children = [
self.tab0, self.tab1, self.tab2, self.tab3, self.tab4
]
tab_names = [
'General', 'DT H-Params.', 'Logit H-Params.', 'SVC H-Params.',
'Samplers Params'
]
for i, e in enumerate(tab_names):
self.gui.set_title(i, e)
self.mod_add_bt.on_click(self.insert_model_bar)
self.mod_remove_bt.on_click(self.remove_model_bar)
self.insert_model_bar()
# self.box_type_changed()
self.sampler_changed()
super().__init__()
def get_final_plots(self, quad_funcs=[np.abs, np.angle]):
from ipywidgets import Tab
tab = Tab()
plots = []
for i, p in enumerate(self.plotters):
tab.set_title(i, p.filter_name)
plots.append(p.get_final_plot(quad_funcs=quad_funcs))
tab.children = plots
return tab
class JDAVizStandardLayout(VBox):
def __init__(self, viewer):
self.viewer = viewer
self._layout_tab = Tab(
[self.viewer.viewer_options, self.viewer.layer_options])
self._layout_tab.set_title(0, "General")
self._layout_tab.set_title(1, "Layers")
self._advanced_button = Button(description='Show advanced')
self._advanced_button.on_click(self._toggle_basic_advanced)
self._layout_toolbar = HBox([], layout={'justify_content': 'center'})
self._layout_top = HBox([], layout={'justify_content': 'center'})
self._layout_middle = HBox([], layout={'justify_content': 'center'})
self._layout_bottom = HBox([self._advanced_button],
layout={'justify_content': 'center'})
# Default to basic mode
self.advanced = False
super().__init__([
self._layout_toolbar, self._layout_top, self._layout_middle,
self._layout_bottom, self.viewer.output_widget
])
self._update_layout()
def _toggle_basic_advanced(self, *args):
# Switch between basic and advanced mode
self.advanced = not self.advanced
self._update_layout()
def _update_layout(self, *args):
# Show/hide widgets dependending on whether we are in basic or advanced mode
if self.advanced:
self._layout_middle.children = (self.viewer.figure_widget,
self._layout_tab)
self._layout_toolbar.children = (
self.viewer.toolbar_selection_tools,
self.viewer.toolbar_active_subset,
self.viewer.toolbar_selection_mode)
self._advanced_button.description = 'Hide advanced'
else:
self._layout_middle.children = (self.viewer.figure_widget, )
self._layout_toolbar.children = (
self.viewer.toolbar_selection_tools,
self.viewer.toolbar_active_subset)
self._advanced_button.description = 'Show advanced'
def total():
def bar_datazoom_slider_a() -> Bar:
c = (Bar().add_xaxis(
["Male", "Unknown", "Female", "Male/Female ",
"M"]).add_yaxis("人数", [272, 21, 5, 4, 1]).set_global_opts(
title_opts=opts.TitleOpts(title="枪手的性别分布"), ))
return c
def bar_datazoom_slider_b() -> Bar:
c = (Bar().add_xaxis([
'White American or European American',
'Black American or African American ', 'Unknown ',
'Some other race', 'white', 'Asian American ', 'Asian ',
'Native American or Alaska Native', 'black', 'White', 'Latino',
'Two or more races', 'Asian American/Some other race ',
'White American or European American/Some other Race',
'Black American or African American/Unknown'
]).add_yaxis("人数",
[122, 76, 42, 20, 12, 11, 5, 3, 3, 2, 2, 2, 1, 1, 1
]).set_global_opts(
title_opts=opts.TitleOpts(title="枪手种族"), ))
return c
def bar_datazoom_slider_c() -> Bar:
c = (Bar().add_xaxis(['Unknown', 'Yes', 'No', 'Unclear']).add_yaxis(
"人数", [111, 99, 90, 3]).set_global_opts(
title_opts=opts.TitleOpts(title="枪手的精神状态"), ))
return c
tab = Tab()
tab.add(bar_datazoom_slider_a(), "枪手的性别分布")
tab.add(bar_datazoom_slider_b(), "枪手的种族")
tab.add(bar_datazoom_slider_c(), "枪手的精神状态")
return Markup(tab.render_embed())
def __init__(self):
# self.gammas = [0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100]
self.gammas = [10**i for i in range(-5, 3)]
self.all_datasets_names = SUPPORTED_DATASETS
self.run_bt = Button(description='Demo3', button_style='info')
self.dataset_selector = self.get_default_dts_selector()
self.size_selector = self.get_default_size_selector()
self.dataset_selector.description = 'Dataset:'
self.model_selector = self.get_default_model_selector()
self.model_selector.description = 'Model'
self.sampler_selector = Dropdown(
options=['rbf', 'nystroem'], value='rbf', description='Sampler')
self.features_selector = self.get_default_features_selector()
self.features_selector.description = 'Features'
self.features_selector.layout = Layout(width='800px')
self.box_type_selector = self.get_default_box_type_selector()
self.box_type_selector.description = 'Bagging'
self.n_estimators_selector = self.get_default_n_estimators_selector()
self.n_estimators_selector.description = 'N. estim.'
self.pca_checkbox = self.get_default_pca_checkbox()
self.pca_checkbox.description = 'Perform PCA?'
self.pca_order_selector = self.get_default_pca_order_selector()
self.g = VBox([
self.dataset_selector,
self.size_selector,
self.model_selector,
self.sampler_selector,
self.features_selector,
self.box_type_selector,
self.n_estimators_selector,
self.pca_checkbox,
self.pca_order_selector,
])
# self.gui = VBox([self.g, self.run_bt])
self.tab0 = VBox([self.g, self.run_bt])
self.tab1 = self.get_dt_hp_tab()
self.tab2 = self.get_logit_hp_tab()
self.tab3 = self.get_linearsvc_hp_tab()
self.gui = Tab()
self.gui.children = [self.tab0, self.tab1, self.tab2, self.tab3]
tab_names = ['General', 'DT H-Params.', 'Logit H-Params.',
'SVC H-Params.']
for i, e in enumerate(tab_names):
self.gui.set_title(i, e)
self.box_type_selector.observe(self.box_type_changed, 'value')
self.pca_checkbox.observe(self.pca_checkbox_changed, 'value')
# self.sampler_selector.observe(self.sampler_changed, 'value')
# Solo para inhabilitar los que tocan
self.box_type_changed()
self.pca_checkbox_changed()
# self.sampler_changed()
super().__init__()
def create_tab(do_display: bool = True) -> Tab:
"""Creates a `ipywidgets.Tab` which can display outputs in its tabs."""
tab = Tab(children=(Output(), ))
tab.set_title(0, "Info")
if do_display:
display(tab)
with tab.children[-1]:
print("Plots and snapshots will show up here!")
return tab
def create_tab(do_display: bool = True) -> Tab:
"""Creates a `ipywidgets.Tab` which can display outputs in its tabs."""
output = Output()
tab = Tab(children=(output, ))
tab.set_title(0, "Info")
if do_display:
display(tab)
with output:
# Prints it in the Output inside the tab.
print("Plots and snapshots will show up here!")
return tab
def display_html(vals):
'''
Convert objects into three AXON forms for output in IPython notebook.
:param vals:
List of objects or ordered dict.
:returns:
IPython TabbedView widget.
'''
try:
from ipywidgets import Tab, HTML
except:
from IPython.html.widgets import Tab, HTML
# Compact form
p1 = dumps(vals, crossref=1)
# Formatted form without braces
p2 = dumps(vals, pretty=1, crossref=1)
# Formatted form with braces
p3 = dumps(vals, pretty=1, braces=1, crossref=1)
wg = Tab(
( HTML("<pre>%s</pre>" % p1),
HTML("<pre>%s</pre>" % p2),
HTML("<pre>%s</pre>" % p3))
)
wg.set_title(0, "Compact")
wg.set_title(1, "Formatted")
wg.set_title(2, "Formatted with {}")
wg.selected_index = 1
return wg
def __init__(self, session, state=None):
IPyWidgetView.__init__(self, session, state=state)
WWTDataViewerBase.__init__(self)
# In Glue+Jupyter Notebook, we need to explicitly specify this to get
# the widget to fill up the horizontal space.
self._wwt.layout.width = '100%'
self._layout_viewer_options = JupterViewerOptions(
self.state, self.state.imagery_layers)
self._layout_tab = Tab(
[self._layout_viewer_options, self._layout_layer_options])
self._layout_tab.set_title(0, "General")
self._layout_tab.set_title(1, "Layers")
self._layout = HBox([self.figure_widget, self._layout_tab])
def __init__(
self,
neurolang_engine,
default_query="union(region_union(r)) :- destrieux(..., r)",
reraise=False,
callbacks: Dict[str, Callable] = None,
):
if neurolang_engine is None:
raise TypeError("neurolang_engine should not be NoneType!")
super().__init__()
self.layout.max_width = "1000px"
self.neurolang_engine = neurolang_engine
self.reraise = reraise
self.callbacks = callbacks
self.query = NlCodeEditor(
default_query,
disabled=False,
layout=Layout(
display="flex",
flex_flow="row",
align_items="stretch",
width="75%",
min_height="100px",
border="solid 1px silver",
),
)
self.button = Button(description="Run query")
self.button.on_click(self._on_query_button_clicked)
self.error_display = HTML(layout=Layout(visibility="hidden"))
self.info_display = HTML(layout=Layout(visibility="hidden"))
self.query_section = Tab(children=[
VBox([
HBox([self.query, self.button]),
self.error_display,
self.info_display,
]),
SymbolsWidget(self.neurolang_engine),
])
for i, tab_title in enumerate(["query", "symbols"]):
self.query_section.set_title(i, tab_title)
self.result_viewer = QResultWidget(layout=Layout(visibility="hidden"))
self.children = [self.query_section, self.result_viewer]
def __init__(self, obj=None):
"""
TESTS::
sage: from sage_explorer.sage_explorer import SageExplorer
sage: S = StandardTableaux(15)
sage: t = S.random_element()
sage: widget = SageExplorer(t)
"""
super(SageExplorer, self).__init__()
self.title = Title()
self.propsbox = VBox(
) # Will be a VBox full of HBoxes, one for each property
self.titlebox = VBox()
self.titlebox.add_class('titlebox')
self.titlebox.children = [self.title, self.propsbox]
self.visualbox = Box()
self.visualtext = Textarea('', rows=8)
self.visualwidget = None
self.visualbox.add_class('visualbox')
self.visualbox.children = [self.visualtext]
self.top = HBox([self.titlebox, self.visualbox],
layout=justified_h_layout)
self.menus = Accordion(selected_index=None)
self.menusbox = VBox([Title("Menus", 2), self.menus])
self.inputs = HBox()
self.gobutton = Button(
description='Run!',
tooltip='Run the function or method, with specified arguments')
self.output = HTML()
self.worktab = VBox((self.inputs, self.gobutton, self.output))
self.doc = HTML()
self.doctab = HTML() # For the method docstring
self.tabs = Tab(
(self.worktab,
self.doctab)) # Will be used when a method is selected
self.tabs.add_class('tabs')
self.tabs.set_title(0, 'Call')
self.tabs.set_title(1, 'Help')
self.main = Box((self.doc, self.tabs))
self.tabs.add_class('invisible') # Hide tabs at first display
self.bottom = HBox((self.menusbox, self.main), layout=main_h_layout)
self.menusbox.add_class('lightborder')
self.main.add_class('lightborder')
self.titlebox.add_class('lightborder')
self.children = (self.top, self.bottom)
self.history = []
self.set_value(obj)
def get_color_changer_widget(self,
skeletons: List[DrawableSkeleton]) -> Tab:
skeleton_color_changer_tabs: List[VBox] = []
pred_color_pickers: List[Tuple[ColorPicker, ColorPicker, ColorPicker,
ColorPicker]] = []
gt_color_pickers: List[Tuple[ColorPicker, ColorPicker, ColorPicker,
ColorPicker]] = []
for skeleton in skeletons:
skeleton_color_changer_tab, color_pickers = self.__create_color_changer_tab(
skeleton)
skeleton_color_changer_tabs.append(skeleton_color_changer_tab)
if skeleton.is_ground_truth:
gt_color_pickers.append(color_pickers)
else:
pred_color_pickers.append(color_pickers)
if len(pred_color_pickers) != 0 and len(gt_color_pickers) != 0:
pred_skeleton_color_changer_tab = self.__create_color_synchronizer_tab(
pred_color_pickers)
gt_skeleton_color_changer_tab = self.__create_color_synchronizer_tab(
gt_color_pickers)
skeleton_color_changer_tabs.append(pred_skeleton_color_changer_tab)
skeleton_color_changer_tabs.append(gt_skeleton_color_changer_tab)
color_changer_widget: Tab = Tab(children=skeleton_color_changer_tabs)
for i in range(len(skeletons)):
color_changer_widget.set_title(
i, 'Skeleton {:d} colors'.format(i + 1))
if len(skeleton_color_changer_tabs) > len(skeletons):
color_changer_widget.set_title(len(skeletons),
'Pred skeleton colors')
color_changer_widget.set_title(
len(skeletons) + 1, 'GT skeleton colors')
return color_changer_widget
def _make_delay_tab(box_factory, selected_index=0):
"""
Parameters
----------
box_factory : list of (func, tab_name)
Example of box_factory: [(_make_gen_box, 'General'),
(_make_repr_box, 'Representation')]
"""
tab = Tab([Box() for box, _ in box_factory])
[tab.set_title(i, title) for i, (_, title) in enumerate(box_factory)]
# trick
if not tab.children[selected_index].children:
tab.selected_index = 1
def on_update_selected_index(change):
index = change['new']
if not tab.children[index].children:
# make widget on demand
tab.children[index].children = [
box_factory[index][0](),
]
tab.observe(on_update_selected_index, names='selected_index')
# trigger
tab.selected_index = selected_index
return tab
class MatplotlibJupyterViewer(MatplotlibViewerMixin, IPyWidgetView):
_state_cls = MatplotlibDataViewerState
large_data_size = None
def __init__(self, session, parent=None, wcs=None, state=None):
self.figure = Figure()
self.canvas = FigureCanvasNbAgg(self.figure)
self.canvas.manager = FigureManagerNbAgg(self.canvas, 0)
self.figure, self.axes = init_mpl(self.figure, wcs=wcs)
# FIXME: The following is required for now for the tools to work
self.central_widget = self.figure
self._axes = self.axes
super(MatplotlibJupyterViewer, self).__init__(session, state=state)
MatplotlibViewerMixin.setup_callbacks(self)
self.create_tab()
self.output_widget = Output()
self.css_widget = HTML(REMOVE_TITLE_CSS)
self.main_widget = VBox([
self.css_widget, self.widget_toolbar,
HBox([self.canvas, self.tab]), self.output_widget
])
def show(self):
display(self.main_widget)
def get_layer_artist(self, cls, layer=None, layer_state=None):
# TODO: this method should be defined on the base viewer class
layer = super().get_layer_artist(cls,
layer=layer,
layer_state=layer_state)
self._add_layer_tab(layer)
return layer
def create_tab(self):
self.tab = Tab([self._options_cls(self.state)])
self.tab.set_title(0, "General")
def __init__(self,
experiments_directory,
bias_correction=False,
figsize=(12, 16)):
self.experiments_dict = {
exp_name: Experiment(exp_name, experiments_directory,
bias_correction)
for exp_name in os.listdir(experiments_directory)
if os.path.isdir(experiments_directory + '/' +
exp_name) and exp_name +
'.h5' in os.listdir(experiments_directory + '/' + exp_name)
}
self.site = 'north'
self.ref = 'none'
colors = np.arange(0,
1,
1 / len(self.experiments_dict.keys()),
dtype=np.float32)
np.random.seed(1)
np.random.shuffle(colors)
cmap = plt.cm.tab20
for (key, color) in zip(self.experiments_dict.keys(), colors):
self.experiments_dict[key].color = cmap(color)
visible_experiments = set()
experiment_info_box = Tab()
tabs = {}
self._fig_resolution, self._axes_resolution = create_resolution_fig(
figsize=figsize)
ax_eff_area = self._axes_resolution[1][1]
ax_eff_area.set_ylim(ax_eff_area.get_ylim())
self._fig_resolution.subplots_adjust(bottom=0.2)
carousel = make_experiments_carousel(self.experiments_dict,
experiment_info_box, tabs,
self._fig_resolution,
visible_experiments)
site_selector = Dropdown(options=['North', 'South'],
value='North',
description='Site')
site_selector.observe(create_update_site(self), names='value')
reference_selector = Dropdown(
options=['None', 'performances', 'requirements'],
value='None',
description='Reference')
reference_selector.observe(create_update_reference(self),
names='value')
self.exp_box = VBox([
HBox([site_selector, reference_selector]),
HBox([carousel, experiment_info_box])
])
def foi_widget_box():
tab_box = Tab(children=[foi_panel.foi(), foi_panel.foi_v2(), foi_help.widget_box_foi(),
foi_settings.widget_box()])
tab_box.set_title(0, 'FOI Assessment V1')
tab_box.set_title(1, 'FOI Assessment V2')
tab_box.set_title(2, 'Help')
tab_box.set_title(3, 'Settings')
return tab_box
def __init__(self, querier, debug=False):
from snowballing.selenium_scholar import URLQuery
reload()
self.querier = querier
self.query = None
self.search_text_widget = Text(value="", layout=Layout(width="99%"))
self.do_search_widget = Button(description="Search", icon="fa-search")
self.navigator = ArticleNavigator(force_citation_file=False)
self.next_page_widget = Button(description="Next Page", icon="fa-arrow-right")
self.reload_widget = Button(description="Reload", icon="fa-refresh")
self.previous_page_widget = Button(description="Previous Page", icon="fa-arrow-left")
self.debug_widget = ToggleButton(value=debug, description="Debug")
self.page_number_widget = Label(value="")
self.next_page_widget.on_click(self.next_page)
self.reload_widget.on_click(self.reload)
self.previous_page_widget.on_click(self.previous_page)
self.do_search_widget.on_click(self.search)
self.search_text_widget.on_submit(self.search)
self.tab_widget = Tab([
VBox([
HBox([
self.previous_page_widget,
self.reload_widget,
self.next_page_widget,
self.debug_widget,
self.page_number_widget
]),
self.navigator.output_widget,
]),
self.navigator.view
])
self.view = VBox([
self.search_text_widget,
self.do_search_widget,
self.tab_widget
])
self.tab_widget.set_title(0, "Page")
self.tab_widget.set_title(1, "Article")
def qa_widget_box():
tab_box = Tab(
children=[qa_panel.qa(),
help_docs.widget_box(),
settings.main()])
tab_box.set_title(0, 'Quality assessment')
tab_box.set_title(1, 'Help')
tab_box.set_title(2, 'Settings')
return tab_box
def data_column_dropdown_multiple_tabs(data, t=['x', 'y', 'y2', 'z']):
"""
Helper function for putting together multiple data column dropdowns in tab format
"""
from ipywidgets import Tab
if t is None:
t = ['x', 'y', 'y2', 'z']
tab_contents = t
children = [data_column_dropdown(data) for name in tab_contents]
tab = Tab()
tab.children = children
tab_dict = {}
for i, var in enumerate(tab_contents):
tab.set_title(i, var)
tab_dict[var] = tab.children[i]
return tab_dict, tab
def __init__(self):
chg.dim = 2 # инициализация
self.tabs = Tab()
self.title = HTML('<h1>Выравнивание электрического поля в конденсаторе</h1>')
self.label1 = Label('Допустимая неравномерность')
children = [VBox(), VBox(), VBox(), VBox(), VBox(), VBox()]
# Нулевая вкладка - параметры
self.tab0 = Tab0()
self.tab1 = Tab1()
self.tab2 = Tab2()
self.tab3 = Tab3()
self.tab4 = Tab4()
self.tab5 = Tab5()
children[0] = self.tab0.layout
children[1] = self.tab1.layout
children[2] = self.tab2.layout
children[3] = self.tab3.layout
children[4] = self.tab4.layout
children[5] = self.tab5.layout
layout = self.tab0.layout.layout
#layout.justify_content='space-between' # разношу столбцы
# заношу вкладки
self.tabs.children = children
for i in range(len(Tabs.tab_names)):
self.tabs.set_title(i, Tabs.tab_names[i])
self.layout = VBox([self.title, self.tabs])
# инициализация
chg.c = None
chg.err = None
chg.EmaxEmin = None
chg.t = None
chg.n3 = 20
chg.dim = 2
# обработчики
self.tab0.btn0.on_click(self.btn0_click)
self.tab0.btn01.on_click(self.btn01_click)
self.tab0.btn02.on_click(self.btn02_click)
def compose_panel(self, widgets_dict):
# compose navigation_bar
navigation_bar = self.navigation_bar.panel
track_config = compose_track_config_panel(widgets_dict['track_config'])
panel = Tab()
panel.children = [navigation_bar, track_config]
panel.set_title(0, "Navigation")
panel.set_title(1, "Tracks")
return panel
def proc_widget_box():
tab_box = Tab(children=[
proc_panel.proc(),
help_docs.widget_box(),
proc_settings.widget_box()
])
tab_box.set_title(0, 'Process Data')
tab_box.set_title(1, 'Help')
tab_box.set_title(2, 'Settings')
return tab_box
def cbm_widget_box():
tab_box = Tab(children=[
cbm_panel.cbm(),
help_docs.widget_box(),
cbm_settings.widget_box()
])
tab_box.set_title(0, 'Checks by Monitoring')
tab_box.set_title(1, 'Help')
tab_box.set_title(2, 'Settings')
return tab_box
def ext_widget_box():
tab_box = Tab(children=[
ext_panel.extract(),
help_docs.widget_box(),
settings.main()
])
tab_box.set_title(0, 'Extract Data')
tab_box.set_title(1, 'Help')
tab_box.set_title(2, 'Settings')
return tab_box
def _make_delay_tab(box_factory, selected_index=0):
"""
Parameters
----------
box_factory : list of (func, tab_name)
Example of box_factory: [(_make_gen_box, 'General'),
(_make_repr_box, 'Representation')]
"""
tab = Tab([Box() for box, _ in box_factory])
[tab.set_title(i, title) for i, (_, title) in enumerate(box_factory)]
# trick
if not tab.children[selected_index].children:
tab.selected_index = -1
def on_update_selected_index(change):
index = change['new']
if not tab.children[index].children:
# make widget on demand
tab.children[index].children = [box_factory[index][0](),]
tab.observe(on_update_selected_index, names='selected_index')
# trigger
tab.selected_index = selected_index
return tab
def gen_figure(msids, group_name):
def select_next_msid(junk):
current_msid = msid_select.value
options = msid_select.options
i = options.index(current_msid)
if i < len(options) - 1:
msid_select.value=options[i + 1]
dummyfig = plt.figure(facecolor=[1,1,1],figsize=(14,8))
msid_select = Select(description='MSID:',options=msids, visible=True, padding=4)
button_next_msid = Button(description='Next', padding=4)
button_next_msid.on_click(select_next_msid)
msid_select_group = HBox(children=[msid_select, button_next_msid])
latest = DateTime().date
t1 = Text(description='Start Date:', value='2000:001:00:00:00.000', visible=True, padding=4)
t2 = Text(description='Stop Date:', value=latest, visible=True, padding=4)
time_select = Box(children=[t1, t2])
page1 = HBox(children=[msid_select_group, time_select])
wL = Checkbox(description='Plot Warning Low', value=False, visible=True, padding=4)
cL = Checkbox(description='Plot Caution Low', value=False, visible=True, padding=4)
cH = Checkbox(description='Plot Caution High', value=True, visible=True, padding=4)
wH = Checkbox(description='Plot Warning High', value=True, visible=True, padding=4)
low_select = Box(children=[wL, cL])
high_select = Box(children=[wH, cH])
page2 = HBox(children=[high_select, low_select])
stat_select = Select(description='Stat:',options=('daily', '5min', 'None'), visible=True, padding=4)
filter_bads = Checkbox(description='Filter Bad Times:', value=True, visible=True, padding=4)
group_select = Select(description='Group Name:',options=['sc', 'tel', 'isim'], visible=True, value=group_name, padding=4)
left_select = Box(children=[stat_select, filter_bads])
page3 = HBox(children=[left_select, group_select], description='Misc.')
q = interactive(plot_msid_interactive, msid=msid_select, group=group_select, tstart=t1, tstop=t2, stat=stat_select,
plot_warning_low=wL, plot_caution_low=cL, plot_caution_high=cH,
plot_warning_high=wH, remove_bads=filter_bads)
tabs = Tab(children=[page1, page2, page3])
tabs.set_title(0, 'MSID, Dates')
tabs.set_title(1, 'Limits')
tabs.set_title(2, 'Misc.')
display(tabs)
def _make_widget_repr(self):
self.widget_repr_name = Text(value='', description='representation')
self.widget_repr_name._ngl_name = 'repr_name_text'
repr_selection = Text(value=' ', description='selection')
repr_selection._ngl_name = 'repr_selection'
repr_selection.width = self.widget_repr_name.width = default.DEFAULT_TEXT_WIDTH
max_n_components = max(self._view.n_components-1, 0)
self.widget_component_slider = IntSlider(value=0, max=max_n_components, min=0, description='component')
self.widget_component_slider._ngl_name = 'component_slider'
cvalue = ' '
self.widget_component_dropdown = Dropdown(value=cvalue, options=[cvalue,],
description='component')
self.widget_component_dropdown._ngl_name = 'component_dropdown'
self.widget_repr_slider = IntSlider(value=0, description='representation', width=default.DEFAULT_SLIDER_WIDTH)
self.widget_repr_slider._ngl_name = 'repr_slider'
self.widget_repr_slider.visible = True
self.widget_component_slider.layout.width = default.DEFAULT_SLIDER_WIDTH
self.widget_repr_slider.layout.width = default.DEFAULT_SLIDER_WIDTH
self.widget_component_dropdown.layout.width = self.widget_component_dropdown.max_width = default.DEFAULT_TEXT_WIDTH
# turn off for now
self.widget_component_dropdown.layout.display = 'none'
self.widget_component_dropdown.description = ''
# self.widget_accordion_repr_parameters = Accordion()
self.widget_accordion_repr_parameters = Tab()
self.widget_repr_parameters = self._make_widget_repr_parameters(self.widget_component_slider,
self.widget_repr_slider,
self.widget_repr_name)
self.widget_accordion_repr_parameters.children = [self.widget_repr_parameters, Box()]
self.widget_accordion_repr_parameters.set_title(0, 'Parameters')
self.widget_accordion_repr_parameters.set_title(1, 'Hide')
self.widget_accordion_repr_parameters.selected_index = 1
checkbox_reprlist = Checkbox(value=False, description='reprlist')
checkbox_reprlist._ngl_name = 'checkbox_reprlist'
self.widget_repr_choices = self._make_repr_name_choices(self.widget_component_slider,
self.widget_repr_slider)
self.widget_repr_choices._ngl_name = 'reprlist_choices'
self.widget_repr_add = self._make_add_widget_repr(self.widget_component_slider)
def on_update_checkbox_reprlist(change):
self.widget_repr_choices.visible= change['new']
checkbox_reprlist.observe(on_update_checkbox_reprlist, names='value')
def on_repr_name_text_value_changed(change):
name = change['new'].strip()
old = change['old'].strip()
should_update = (self._real_time_update
and old and name
and name in REPRESENTATION_NAMES
and name != change['old'].strip())
if should_update:
component=self.widget_component_slider.value
repr_index=self.widget_repr_slider.value
self._view._remote_call('setRepresentation',
target='Widget',
args=[change['new'], {}, component, repr_index])
self._view._request_repr_parameters(component, repr_index)
def on_component_or_repr_slider_value_changed(change):
self._view._request_repr_parameters(component=self.widget_component_slider.value,
repr_index=self.widget_repr_slider.value)
self.widget_component_dropdown.options = tuple(self._view._ngl_component_names)
if self.widget_accordion_repr_parameters.selected_index >= 0:
self.widget_repr_parameters.name = self.widget_repr_name.value
self.widget_repr_parameters.repr_index = self.widget_repr_slider.value
self.widget_repr_parameters.component_index = self.widget_component_slider.value
def on_repr_selection_value_changed(change):
if self._real_time_update:
component = self.widget_component_slider.value
repr_index = self.widget_repr_slider.value
self._view._set_selection(change['new'],
component=component,
repr_index=repr_index)
def on_change_component_dropdown(change):
choice = change['new']
if choice:
self.widget_component_slider.value = self._view._ngl_component_names.index(choice)
self.widget_component_dropdown.observe(on_change_component_dropdown, names='value')
self.widget_repr_slider.observe(on_component_or_repr_slider_value_changed, names='value')
self.widget_component_slider.observe(on_component_or_repr_slider_value_changed, names='value')
self.widget_repr_name.observe(on_repr_name_text_value_changed, names='value')
repr_selection.observe(on_repr_selection_value_changed, names='value')
self.widget_repr_control_buttons = self._make_button_repr_control(self.widget_component_slider,
self.widget_repr_slider, repr_selection)
blank_box = Box([Label("")])
all_kids = [self.widget_repr_control_buttons,
blank_box,
self.widget_repr_add,
self.widget_component_dropdown,
self.widget_repr_name,
repr_selection,
self.widget_component_slider,
self.widget_repr_slider,
self.widget_repr_choices,
self.widget_accordion_repr_parameters
]
vbox = VBox(all_kids)
self._view._request_repr_parameters(component=self.widget_component_slider.value,
repr_index=self.widget_repr_slider.value)
self.widget_repr = _relayout_master(vbox, width='100%')
self._refresh(self.widget_component_slider, self.widget_repr_slider)
setattr(self.widget_repr, "_saved_widgets", [])
for _box in self.widget_repr.children:
if hasattr(_box, 'children'):
for kid in _box.children:
self.widget_repr._saved_widgets.append(kid)
return self.widget_repr
class TrajectoryPlayer(DOMWidget):
# should set default values here different from desired defaults
# so `observe` can be triggered
step = Int(0).tag(sync=True)
sync_frame = Bool(True).tag(sync=True)
interpolate = Bool(False).tag(sync=False)
delay = Float(0.0).tag(sync=True)
parameters = Dict().tag(sync=True)
iparams = Dict().tag(sync=False)
_interpolation_t = Float().tag(sync=False)
_iterpolation_type = CaselessStrEnum(['linear', 'spline']).tag(sync=False)
spin = Bool(False).tag(sync=False)
_spin_x = Int(1).tag(sync=False)
_spin_y = Int(0).tag(sync=False)
_spin_z = Int(0).tag(sync=False)
_spin_speed = Float(0.005).tag(sync=False)
camera = CaselessStrEnum(['perspective', 'orthographic'],
default_value='perspective').tag(sync=False)
_render_params = Dict().tag(sync=False)
_real_time_update = Bool(False).tag(sync=False)
widget_tab = Any(None).tag(sync=False)
widget_repr = Any(None).tag(sync=False)
widget_repr_parameters = Any(None).tag(sync=False)
widget_quick_repr = Any(None).tag(sync=False)
widget_general = Any(None).tag(sync=False)
widget_picked = Any(None).tag(sync=False)
widget_preference = Any(None).tag(sync=False)
widget_extra = Any(None).tag(sync=False)
widget_theme = Any(None).tag(sync=False)
widget_help = Any(None).tag(sync=False)
widget_export_image = Any(None).tag(sync=False)
widget_component_slider = Any(None).tag(sync=False)
widget_repr_slider = Any(None).tag(sync=False)
widget_repr_choices = Any(None).tag(sync=False)
widget_repr_control_buttons = Any(None).tag(sync=False)
widget_repr_add = Any(None).tag(sync=False)
widget_accordion_repr_parameters = Any(None).tag(sync=False)
widget_repr_parameters_dialog = Any(None).tag(sync=False)
widget_repr_name = Any(None).tag(sync=False)
widget_component_dropdown = Any(None).tag(sync=False)
widget_drag = Any(None).tag(sync=False)
def __init__(self, view, step=1, delay=100,
sync_frame=False, min_delay=40):
self._view = view
self.step = step
self.sync_frame = sync_frame
self.delay = delay
self.min_delay = min_delay
self._interpolation_t = 0.5
self._iterpolation_type = 'linear'
self.iparams = dict(
t=self._interpolation_t,
step=1,
type=self._iterpolation_type)
self._render_params = dict(factor=4,
antialias=True,
trim=False,
transparent=False)
self._widget_names = [w for w in dir(self) if w.startswith('wiget_')]
self.observe(self._on_widget_built, names=['widget_repr_parameters',
'widget_repr',
'widget_preference'])
self._movie_maker = None
def _on_widget_built(self, change):
widget = change['new']
if widget is not None:
widget.layout.padding = '5%'
def _update_padding(self, padding=default.DEFAULT_PADDING):
widget_collection = [
self.widget_general,
self.widget_repr,
self.widget_preference,
self.widget_repr_parameters,
self.widget_help,
self.widget_extra,
self.widget_picked
]
for widget in widget_collection:
if widget is not None:
widget.layout.padding = padding
def _create_all_widgets(self):
if self.widget_tab is None:
self.widget_tab = self._display()
old_index = self.widget_tab.selected_index
for index, _ in enumerate(self.widget_tab.children):
self.widget_tab.selected_index = index
self.widget_tab.selected_index = old_index
def smooth(self):
self.interpolate = True
@observe('camera')
def on_camera_changed(self, change):
camera_type = change['new']
self._view._remote_call("setParameters",
target='Stage',
kwargs=dict(cameraType=camera_type))
@property
def frame(self):
return self._view.frame
@frame.setter
def frame(self, value):
self._view.frame = value
@property
def count(self):
return self._view.count
@observe('sync_frame')
def update_sync_frame(self, change):
value = change['new']
if value:
self._view._set_sync_frame()
else:
self._view._set_unsync_frame()
@observe("delay")
def update_delay(self, change):
delay = change['new']
self._view._set_delay(delay)
@observe('parameters')
def update_parameters(self, change):
params = change['new']
self.sync_frame = params.get("sync_frame", self.sync_frame)
self.delay = params.get("delay", self.delay)
self.step = params.get("step", self.step)
@observe('_interpolation_t')
def _interpolation_t_changed(self, change):
self.iparams['t'] = change['new']
@observe('spin')
def on_spin_changed(self, change):
self.spin = change['new']
if self.spin:
self._view._set_spin([self._spin_x, self._spin_y, self._spin_z],
self._spin_speed)
else:
# stop
self._view._set_spin(None, None)
@observe('_spin_x')
def on_spin_x_changed(self, change):
self._spin_x = change['new']
if self.spin:
self._view._set_spin([self._spin_x, self._spin_y, self._spin_z],
self._spin_speed)
@observe('_spin_y')
def on_spin_y_changed(self, change):
self._spin_y = change['new']
if self.spin:
self._view._set_spin([self._spin_x, self._spin_y, self._spin_z],
self._spin_speed)
@observe('_spin_z')
def on_spin_z_changed(self, change):
self._spin_z = change['new']
if self.spin:
self._view._set_spin([self._spin_x, self._spin_y, self._spin_z],
self._spin_speed)
@observe('_spin_speed')
def on_spin_speed_changed(self, change):
self._spin_speed = change['new']
if self.spin:
self._view._set_spin([self._spin_x, self._spin_y, self._spin_z],
self._spin_speed)
def _display(self):
box_factory = [(self._make_general_box, 'General'),
(self._make_widget_repr, 'Representation'),
(self._make_widget_preference, 'Preference'),
(self._make_theme_box, 'Theme'),
(self._make_extra_box, 'Extra'),
(self._show_website, 'Help')]
tab = _make_delay_tab(box_factory, selected_index=-1)
# tab = _make_autofit(tab)
tab.layout.align_self = 'center'
tab.layout.align_items = 'stretch'
self.widget_tab = tab
return self.widget_tab
def _make_widget_tab(self):
return self._display()
def _make_button_center(self):
button = Button(description=' Center', icon='fa-bullseye')
@button.on_click
def on_click(button):
self._view.center()
return button
def _make_button_theme(self):
button = Button(description='Oceans16')
@button.on_click
def on_click(button):
from nglview import theme
display(theme.oceans16())
self._view._remote_call('cleanOutput',
target='Widget')
return button
def _make_button_reset_theme(self, hide_toolbar=False):
from nglview import theme
if hide_toolbar:
button = Button(description='Simplified Default')
@button.on_click
def on_click(button):
theme.reset(hide_toolbar=True)
else:
button = Button(description='Default')
@button.on_click
def on_click(button):
theme.reset()
return button
def _make_button_clean_error_output(self):
button = Button(description='Clear Error')
@button.on_click
def on_click(_):
js_utils.clean_error_output()
return button
def _make_widget_preference(self, width='100%'):
def make_func():
parameters = self._view._full_stage_parameters
def func(pan_speed=parameters.get('panSpeed', 0.8),
rotate_speed=parameters.get('rotateSpeed', 2),
zoom_speed=parameters.get('zoomSpeed', 1.2),
clip_dist=parameters.get('clipDist', 10),
camera_fov=parameters.get('cameraFov', 40),
clip_far=parameters.get('clipFar', 100),
clip_near=parameters.get('clipNear', 0),
fog_far=parameters.get('fogFar', 100),
fog_near=parameters.get('fogNear', 50),
impostor=parameters.get('impostor', True),
light_intensity=parameters.get('lightIntensity', 1),
quality=parameters.get('quality', 'medium'),
sample_level=parameters.get('sampleLevel', 1)):
self._view.parameters = dict(
panSpeed=pan_speed,
rotateSpeed=rotate_speed,
zoomSpeed=zoom_speed,
clipDist=clip_dist,
clipFar=clip_far,
clipNear=clip_near,
cameraFov=camera_fov,
fogFar=fog_far,
fogNear=fog_near,
impostor=impostor,
lightIntensity=light_intensity,
quality=quality,
sampleLevel=sample_level)
return func
def make_widget_box():
widget_sliders = interactive(make_func(),
pan_speed=(0, 10, 0.1),
rotate_speed=(0, 10, 1),
zoom_speed=(0, 10, 1),
clip_dist=(0, 200, 5),
clip_far=(0, 100, 1),
clip_near=(0, 100, 1),
camera_fov=(15, 120, 1),
fog_far=(0, 100, 1),
fog_near=(0, 100, 1),
light_intensity=(0, 10, 0.02),
quality=['low', 'medium', 'high'],
sample_level=(-1, 5, 1))
for child in widget_sliders.children:
if isinstance(child, (IntSlider, FloatSlider)):
child.layout.width = default.DEFAULT_SLIDER_WIDTH
return widget_sliders
if self.widget_preference is None:
widget_sliders = make_widget_box()
reset_button = Button(description='Reset')
widget_sliders.children = [reset_button,] + list(widget_sliders.children)
@reset_button.on_click
def on_click(reset_button):
self._view.parameters = self._view._original_stage_parameters
self._view._full_stage_parameters = self._view._original_stage_parameters
widget_sliders.children = [reset_button,] + list(make_widget_box().children)
self.widget_preference = _relayout_master(widget_sliders, width=width)
return self.widget_preference
def _show_download_image(self):
# "interactive" does not work for True/False in ipywidgets 4 yet.
button = Button(description=' Screenshot', icon='fa-camera')
@button.on_click
def on_click(button):
self._view.download_image()
return button
def _make_button_url(self, url, description):
button = Button(description=description)
@button.on_click
def on_click(button):
display(Javascript(js_utils.open_url_template.format(url=url)))
return button
def _show_website(self, ngl_base_url=default.NGL_BASE_URL):
buttons = [self._make_button_url(url.format(ngl_base_url), description) for url, description in
[("'http://arose.github.io/nglview/latest/'", "nglview"),
("'{}/index.html'", "NGL"),
("'{}/tutorial-selection-language.html'", "Selection"),
("'{}/tutorial-molecular-representations.html'", "Representation")]
]
self.widget_help = _make_autofit(HBox(buttons))
return self.widget_help
def _make_button_qtconsole(self):
from nglview import js_utils
button = Button(description='qtconsole',
tooltip='pop up qtconsole')
@button.on_click
def on_click(button):
js_utils.launch_qtconsole()
return button
def _make_text_picked(self):
ta = Textarea(value=json.dumps(self._view.picked), description='Picked atom')
ta.layout.width = '300px'
return ta
def _refresh(self, component_slider, repr_slider):
"""update representation and component information
"""
self._view._request_repr_parameters(component=component_slider.value,
repr_index=repr_slider.value)
self._view._remote_call('requestReprInfo', target='Widget')
self._view._handle_repr_dict_changed(change=dict(new=self._view._repr_dict))
def _make_button_repr_control(self, component_slider, repr_slider, repr_selection):
button_refresh = Button(description=' Refresh', tooltip='Get representation info', icon='fa-refresh')
button_center_selection = Button(description=' Center', tooltip='center selected atoms',
icon='fa-bullseye')
button_center_selection._ngl_name = 'button_center_selection'
button_hide = Button(description=' Hide',
icon='fa-eye-slash',
tooltip='Hide/Show current representation')
button_remove = Button(description=' Remove',
icon='fa-trash',
tooltip='Remove current representation')
button_repr_parameter_dialog = Button(description=' Dialog',
tooltip='Pop up representation parameters control dialog')
@button_refresh.on_click
def on_click_refresh(button):
self._refresh(component_slider, repr_slider)
@button_center_selection.on_click
def on_click_center(center_selection):
self._view.center_view(selection=repr_selection.value,
component=component_slider.value)
@button_hide.on_click
def on_click_hide(button_hide):
component=component_slider.value
repr_index=repr_slider.value
if button_hide.description == 'Hide':
hide = True
button_hide.description = 'Show'
else:
hide = False
button_hide.description = 'Hide'
self._view._remote_call('setVisibilityForRepr',
target='Widget',
args=[component, repr_index, not hide])
@button_remove.on_click
def on_click_remove(button_remove):
self._view._remove_representation(component=component_slider.value,
repr_index=repr_slider.value)
self._view._request_repr_parameters(component=component_slider.value,
repr_index=repr_slider.value)
@button_repr_parameter_dialog.on_click
def on_click_repr_dialog(_):
from nglview.widget_box import DraggableBox
if self.widget_repr_parameters is not None and self.widget_repr_choices:
self.widget_repr_parameters_dialog = DraggableBox([self.widget_repr_choices,
self.widget_repr_parameters])
self.widget_repr_parameters_dialog._ipython_display_()
self.widget_repr_parameters_dialog._dialog = 'on'
bbox = _make_autofit(HBox([button_refresh, button_center_selection,
button_hide, button_remove,
button_repr_parameter_dialog]))
return bbox
def _make_widget_repr(self):
self.widget_repr_name = Text(value='', description='representation')
self.widget_repr_name._ngl_name = 'repr_name_text'
repr_selection = Text(value=' ', description='selection')
repr_selection._ngl_name = 'repr_selection'
repr_selection.width = self.widget_repr_name.width = default.DEFAULT_TEXT_WIDTH
max_n_components = max(self._view.n_components-1, 0)
self.widget_component_slider = IntSlider(value=0, max=max_n_components, min=0, description='component')
self.widget_component_slider._ngl_name = 'component_slider'
cvalue = ' '
self.widget_component_dropdown = Dropdown(value=cvalue, options=[cvalue,],
description='component')
self.widget_component_dropdown._ngl_name = 'component_dropdown'
self.widget_repr_slider = IntSlider(value=0, description='representation', width=default.DEFAULT_SLIDER_WIDTH)
self.widget_repr_slider._ngl_name = 'repr_slider'
self.widget_repr_slider.visible = True
self.widget_component_slider.layout.width = default.DEFAULT_SLIDER_WIDTH
self.widget_repr_slider.layout.width = default.DEFAULT_SLIDER_WIDTH
self.widget_component_dropdown.layout.width = self.widget_component_dropdown.max_width = default.DEFAULT_TEXT_WIDTH
# turn off for now
self.widget_component_dropdown.layout.display = 'none'
self.widget_component_dropdown.description = ''
# self.widget_accordion_repr_parameters = Accordion()
self.widget_accordion_repr_parameters = Tab()
self.widget_repr_parameters = self._make_widget_repr_parameters(self.widget_component_slider,
self.widget_repr_slider,
self.widget_repr_name)
self.widget_accordion_repr_parameters.children = [self.widget_repr_parameters, Box()]
self.widget_accordion_repr_parameters.set_title(0, 'Parameters')
self.widget_accordion_repr_parameters.set_title(1, 'Hide')
self.widget_accordion_repr_parameters.selected_index = 1
checkbox_reprlist = Checkbox(value=False, description='reprlist')
checkbox_reprlist._ngl_name = 'checkbox_reprlist'
self.widget_repr_choices = self._make_repr_name_choices(self.widget_component_slider,
self.widget_repr_slider)
self.widget_repr_choices._ngl_name = 'reprlist_choices'
self.widget_repr_add = self._make_add_widget_repr(self.widget_component_slider)
def on_update_checkbox_reprlist(change):
self.widget_repr_choices.visible= change['new']
checkbox_reprlist.observe(on_update_checkbox_reprlist, names='value')
def on_repr_name_text_value_changed(change):
name = change['new'].strip()
old = change['old'].strip()
should_update = (self._real_time_update
and old and name
and name in REPRESENTATION_NAMES
and name != change['old'].strip())
if should_update:
component=self.widget_component_slider.value
repr_index=self.widget_repr_slider.value
self._view._remote_call('setRepresentation',
target='Widget',
args=[change['new'], {}, component, repr_index])
self._view._request_repr_parameters(component, repr_index)
def on_component_or_repr_slider_value_changed(change):
self._view._request_repr_parameters(component=self.widget_component_slider.value,
repr_index=self.widget_repr_slider.value)
self.widget_component_dropdown.options = tuple(self._view._ngl_component_names)
if self.widget_accordion_repr_parameters.selected_index >= 0:
self.widget_repr_parameters.name = self.widget_repr_name.value
self.widget_repr_parameters.repr_index = self.widget_repr_slider.value
self.widget_repr_parameters.component_index = self.widget_component_slider.value
def on_repr_selection_value_changed(change):
if self._real_time_update:
component = self.widget_component_slider.value
repr_index = self.widget_repr_slider.value
self._view._set_selection(change['new'],
component=component,
repr_index=repr_index)
def on_change_component_dropdown(change):
choice = change['new']
if choice:
self.widget_component_slider.value = self._view._ngl_component_names.index(choice)
self.widget_component_dropdown.observe(on_change_component_dropdown, names='value')
self.widget_repr_slider.observe(on_component_or_repr_slider_value_changed, names='value')
self.widget_component_slider.observe(on_component_or_repr_slider_value_changed, names='value')
self.widget_repr_name.observe(on_repr_name_text_value_changed, names='value')
repr_selection.observe(on_repr_selection_value_changed, names='value')
self.widget_repr_control_buttons = self._make_button_repr_control(self.widget_component_slider,
self.widget_repr_slider, repr_selection)
blank_box = Box([Label("")])
all_kids = [self.widget_repr_control_buttons,
blank_box,
self.widget_repr_add,
self.widget_component_dropdown,
self.widget_repr_name,
repr_selection,
self.widget_component_slider,
self.widget_repr_slider,
self.widget_repr_choices,
self.widget_accordion_repr_parameters
]
vbox = VBox(all_kids)
self._view._request_repr_parameters(component=self.widget_component_slider.value,
repr_index=self.widget_repr_slider.value)
self.widget_repr = _relayout_master(vbox, width='100%')
self._refresh(self.widget_component_slider, self.widget_repr_slider)
setattr(self.widget_repr, "_saved_widgets", [])
for _box in self.widget_repr.children:
if hasattr(_box, 'children'):
for kid in _box.children:
self.widget_repr._saved_widgets.append(kid)
return self.widget_repr
def _make_widget_repr_parameters(self, component_slider, repr_slider, repr_name_text=None):
name = repr_name_text.value if repr_name_text is not None else ' '
widget = self._view._display_repr(component=component_slider.value,
repr_index=repr_slider.value,
name=name)
widget._ngl_name = 'repr_parameters_box'
return widget
def _make_button_export_image(self):
slider_factor = IntSlider(value=4, min=1, max=10, description='scale')
checkbox_antialias = Checkbox(value=True, description='antialias')
checkbox_trim = Checkbox(value=False, description='trim')
checkbox_transparent = Checkbox(value=False, description='transparent')
filename_text = Text(value='Screenshot', description='Filename')
delay_text = FloatText(value=1, description='delay (s)', tooltip='hello')
start_text, stop_text, step_text = (IntText(value=0, description='start'),
IntText(value=self._view.count, description='stop'),
IntText(value=1, description='step'))
start_text.layout.max_width = stop_text.layout.max_width = step_text.layout.max_width \
= filename_text.layout.max_width = delay_text.layout.max_width = default.DEFAULT_TEXT_WIDTH
button_movie_images = Button(description='Export Images')
def download_image(filename):
self._view.download_image(factor=slider_factor.value,
antialias=checkbox_antialias.value,
trim=checkbox_trim.value,
transparent=checkbox_transparent.value,
filename=filename)
@button_movie_images.on_click
def on_click_images(button_movie_images):
for i in range(start_text.value, stop_text.value, step_text.value):
self._view.frame = i
time.sleep(delay_text.value)
download_image(filename=filename_text.value + str(i))
time.sleep(delay_text.value)
vbox = VBox([
button_movie_images,
start_text,
stop_text,
step_text,
delay_text,
filename_text,
slider_factor,
checkbox_antialias,
checkbox_trim,
checkbox_transparent,
])
form_items = _relayout(vbox, make_form_item_layout())
form = Box(form_items, layout=_make_box_layout())
# form = _relayout_master(vbox)
return form
def _make_resize_notebook_slider(self):
resize_notebook_slider = IntSlider(min=300, max=2000, description='resize notebook')
def on_resize_notebook(change):
width = change['new']
self._view._remote_call('resizeNotebook',
target='Widget',
args=[width,])
resize_notebook_slider.observe(on_resize_notebook, names='value')
return resize_notebook_slider
def _make_add_widget_repr(self, component_slider):
dropdown_repr_name = Dropdown(options=REPRESENTATION_NAMES, value='cartoon')
repr_selection = Text(value='*', description='')
repr_button = Button(description='Add', tooltip="""Add representation.
You can also hit Enter in selection box""")
repr_button.layout = Layout(width='auto', flex='1 1 auto')
dropdown_repr_name.layout.width = repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH
def on_click_or_submit(button_or_text_area):
self._view.add_representation(selection=repr_selection.value.strip(),
repr_type=dropdown_repr_name.value,
component=component_slider.value)
repr_button.on_click(on_click_or_submit)
repr_selection.on_submit(on_click_or_submit)
add_repr_box = HBox([repr_button, dropdown_repr_name, repr_selection])
add_repr_box._ngl_name = 'add_repr_box'
return add_repr_box
def _make_repr_playground(self):
vbox = VBox()
children = []
rep_names = REPRESENTATION_NAMES[:]
excluded_names = ['ball+stick', 'distance']
for name in excluded_names:
rep_names.remove(name)
repr_selection = Text(value='*')
repr_selection.layout.width = default.DEFAULT_TEXT_WIDTH
repr_selection_box = HBox([Label('selection'), repr_selection])
setattr(repr_selection_box, 'value', repr_selection.value)
for index, name in enumerate(rep_names):
button = ToggleButton(description=name)
def make_func():
def on_toggle_button_value_change(change, button=button):
selection = repr_selection.value
new = change['new'] # True/False
if new:
self._view.add_representation(button.description, selection=selection)
else:
self._view._remove_representations_by_name(button.description)
return on_toggle_button_value_change
button.observe(make_func(), names='value')
children.append(button)
button_clear = Button(description='clear', button_style='info',
icon='fa-eraser')
@button_clear.on_click
def on_clear(button_clear):
self._view.clear()
for kid in children:
# unselect
kid.value = False
vbox.children = children + [repr_selection, button_clear]
_make_autofit(vbox)
self.widget_quick_repr = vbox
return self.widget_quick_repr
def _make_repr_name_choices(self, component_slider, repr_slider):
repr_choices = Dropdown(options=[" ",])
def on_chose(change):
repr_name = change['new']
repr_index = repr_choices.options.index(repr_name)
repr_slider.value = repr_index
repr_choices.observe(on_chose, names='value')
repr_choices.layout.width = default.DEFAULT_TEXT_WIDTH
self.widget_repr_choices = repr_choices
return self.widget_repr_choices
def _make_drag_widget(self):
button_drag = Button(description='widget drag: off', tooltip='dangerous')
drag_nb = Button(description='notebook drag: off', tooltip='dangerous')
button_reset_notebook = Button(description='notebook: reset', tooltip='reset?')
button_dialog = Button(description='dialog', tooltip='make a dialog')
button_split_half = Button(description='split screen', tooltip='try best to make a good layout')
@button_drag.on_click
def on_drag(button_drag):
if button_drag.description == 'widget drag: off':
self._view._set_draggable(True)
button_drag.description = 'widget drag: on'
else:
self._view._set_draggable(False)
button_drag.description = 'widget drag: off'
@drag_nb.on_click
def on_drag_nb(button_drag):
if drag_nb.description == 'notebook drag: off':
js_utils._set_notebook_draggable(True)
drag_nb.description = 'notebook drag: on'
else:
js_utils._set_notebook_draggable(False)
drag_nb.description = 'notebook drag: off'
@button_reset_notebook.on_click
def on_reset(button_reset_notebook):
js_utils._reset_notebook()
@button_dialog.on_click
def on_dialog(button_dialog):
self._view._remote_call('setDialog', target='Widget')
@button_split_half.on_click
def on_split_half(button_dialog):
from nglview import js_utils
import time
js_utils._move_notebook_to_the_left()
js_utils._set_notebook_width('5%')
time.sleep(0.1)
self._view._remote_call('setDialog', target='Widget')
drag_box = HBox([button_drag, drag_nb, button_reset_notebook,
button_dialog, button_split_half])
drag_box = _make_autofit(drag_box)
self.widget_drag = drag_box
return drag_box
def _make_spin_box(self):
checkbox_spin = Checkbox(self.spin, description='spin')
spin_x_slide = IntSlider(
self._spin_x,
min=-1,
max=1,
description='spin_x')
spin_y_slide = IntSlider(
self._spin_y,
min=-1,
max=1,
description='spin_y')
spin_z_slide = IntSlider(
self._spin_z,
min=-1,
max=1,
description='spin_z')
spin_speed_slide = FloatSlider(
self._spin_speed,
min=0,
max=0.2,
step=0.001,
description='spin speed')
# spin
link((checkbox_spin, 'value'), (self, 'spin'))
link((spin_x_slide, 'value'), (self, '_spin_x'))
link((spin_y_slide, 'value'), (self, '_spin_y'))
link((spin_z_slide, 'value'), (self, '_spin_z'))
link((spin_speed_slide, 'value'), (self, '_spin_speed'))
spin_box= VBox([checkbox_spin,
spin_x_slide,
spin_y_slide,
spin_z_slide,
spin_speed_slide])
spin_box = _relayout_master(spin_box, width='75%')
return spin_box
def _make_widget_picked(self):
self.widget_picked = self._make_text_picked()
picked_box = HBox([self.widget_picked,])
return _relayout_master(picked_box, width='75%')
def _make_export_image_widget(self):
if self.widget_export_image is None:
self.widget_export_image = HBox([self._make_button_export_image()])
return self.widget_export_image
def _make_extra_box(self):
if self.widget_extra is None:
extra_list = [(self._make_drag_widget, 'Drag'),
(self._make_spin_box, 'Spin'),
(self._make_widget_picked, 'Picked'),
(self._make_repr_playground, 'Quick'),
(self._make_export_image_widget, 'Image'),
(self._make_command_box, 'Command')]
extra_box = _make_delay_tab(extra_list, selected_index=0)
self.widget_extra = extra_box
return self.widget_extra
def _make_theme_box(self):
if self.widget_theme is None:
self.widget_theme = Box([self._make_button_theme(),
self._make_button_reset_theme(hide_toolbar=False),
self._make_button_reset_theme(hide_toolbar=True),
self._make_button_clean_error_output()])
return self.widget_theme
def _make_general_box(self):
if self.widget_general is None:
step_slide = IntSlider(
value=self.step,
min=-100,
max=100,
description='step')
delay_text = IntSlider(
value=self.delay,
min=10,
max=1000,
description='delay')
toggle_button_interpolate = ToggleButton(self.interpolate, description='Smoothing',
tooltip='smoothing trajectory')
link((toggle_button_interpolate, 'value'), (self, 'interpolate'))
background_color_picker = ColorPicker(value='white', description='background')
camera_type = Dropdown(value=self.camera,
options=['perspective', 'orthographic'], description='camera')
link((step_slide, 'value'), (self, 'step'))
link((delay_text, 'value'), (self, 'delay'))
link((toggle_button_interpolate, 'value'), (self, 'interpolate'))
link((camera_type, 'value'), (self, 'camera'))
link((background_color_picker, 'value'), (self._view, 'background'))
center_button = self._make_button_center()
render_button = self._show_download_image()
qtconsole_button = self._make_button_qtconsole()
center_render_hbox = _make_autofit(HBox([toggle_button_interpolate, center_button,
render_button, qtconsole_button]))
v0_left = VBox([step_slide,
delay_text,
background_color_picker,
camera_type,
center_render_hbox,
])
v0_left = _relayout_master(v0_left, width='100%')
self.widget_general = v0_left
return self.widget_general
def _make_command_box(self):
widget_text_command = Text()
@widget_text_command.on_submit
def _on_submit_command(_):
command = widget_text_command.value
js_utils.execute(command)
widget_text_command.value = ''
return widget_text_command
def _create_all_tabs(self):
tab = self._display()
for index, _ in enumerate(tab.children):
# trigger ceating widgets
tab.selected_index = index
self.widget_extra = self._make_extra_box()
for index, _ in enumerate(self.widget_extra.children):
self.widget_extra.selected_index = index
def _simplify_repr_control(self):
for widget in self.widget_repr._saved_widgets:
if not isinstance(widget, Tab):
widget.layout.display = 'none'
self.widget_repr_choices.layout.display = 'flex'
self.widget_accordion_repr_parameters.selected_index = 0
def settings_panel(self):
# getMolMap calulation settings. NOTE: should only be called once.
margin = 2
num_angles_slider_text = "Number of Inverse Cone Angles to calculate:"
num_angles_slider_widget = IntSlider(value=1, min=1, max=5)
num_angles_slider = VBox(
children=[HTML(value=num_angles_slider_text), num_angles_slider_widget], margin=margin, width="100%"
)
link((self.model, "num_angles"), (num_angles_slider_widget, "value"))
sub_slider_text = "Subdivision value of the icosphere for numerical calculation:"
sub_slider_widget = IntSlider(value=5, min=1, max=9)
link((self.model, "sub"), (sub_slider_widget, "value"))
sub_slider = VBox(children=[HTML(value=sub_slider_text), sub_slider_widget], margin=margin, width="100%")
# link((sub_slider, 'value'), (i, 'value'))
# print(self.width)
# sub_slider.align = 'center'
# sub_slider.width = '100%'
# sub_slider.border_color = 'black'
# sub_slider.border_width = 2
radius_slider_text = "Cut radius measured from the central atom:"
radius_slider_widget = FloatSlider(value=0, min=0, max=10)
link((self.model, "radius"), (radius_slider_widget, "value"))
radius_slider = VBox(children=[HTML(value=radius_slider_text), radius_slider_widget], margin=margin)
atomradscale_slider_text = "Atomic radius scaling factor:"
atomradscale_slider_widget = FloatSlider(value=1, min=0, max=4)
link((self.model, "rad_scale"), (atomradscale_slider_widget, "value"))
atomradscale_slider = VBox(
children=[HTML(value=atomradscale_slider_text), atomradscale_slider_widget], margin=margin
)
excludeH_button = Checkbox(description="Exclude H from every geometry:")
link((self.model, "excludeH"), (excludeH_button, "value"))
excludeH_button.on_trait_change(self.excludeH_changed, "value")
dont = "Don't exclude any elements"
self.dont = dont
# TODO: Syncronize exclude_list_widget with excludeH button and define an event on the
# model to filter out the `dont` text.
# Alternatevily, separate this option into a checkbox and hide the exclude options
# while the button is selected.
exclude_list_text = "Exclude elements from every geometry:"
exclude_list_widget = SelectMultiple(
options=[dont] + [e.symbol for e in ELEMENTS],
selected_labels=[dont],
color="Black",
font_size=14,
height=120,
)
link((exclude_list_widget, "value"), (self.model, "excludes"))
# The dirty old SelectMultiple widget does not have an .on_trait_change method.
# So we create a new traitlet (excludes_notifier), which has an .on_trait_change method
# because it inherits HasTraits. We link the 'value' trait to excludes_notifier.excludes;
# and we bind the event handler to excludes_notifier.on_trait_change
self.excludes_notifier = ExcludesNotifier()
link((exclude_list_widget, "value"), (self.excludes_notifier, "excludes"))
self.excludes_notifier.on_trait_change(self.excludes_changed)
exclude_list = VBox(children=[HTML(value=exclude_list_text), exclude_list_widget], margin=margin)
atomrad_button = ToggleButtons(
description="Atomic radius type:",
options=["vdwrad", "covrad", "atmrad"],
background_color="AliceBlue",
margin=margin,
)
link((self.model, "rad_type"), (atomrad_button, "value"))
runbutton = Button(
description="Run calculation!",
tooltip="Click here to calculate Buried Volumes and Inverse Cone Angles!",
margin=margin * 3,
border_color="#9acfea",
# border_radius=5,
border_width=3,
font_size=20,
)
runbutton.on_click(self.run_button_clicked)
basic_tab = VBox(children=[atomrad_button, excludeH_button])
sliders = VBox(children=[num_angles_slider, atomradscale_slider, radius_slider, sub_slider])
sliders.width = "100%"
sliders.pack = "center"
advanced_tab = VBox(children=[atomrad_button, sliders, exclude_list])
main_window = Tab(children=[basic_tab, advanced_tab])
main_window.set_title(0, "Basic")
main_window.set_title(1, "Advanced")
return ControlPanel(
title="getMolMap Settings:",
children=[main_window, runbutton],
border_width=2,
border_radius=4,
margin=10,
padding=0,
)
