def controls(self):
get_supercell = ToggleButton(
value=False,
description='Get supercell',
disabled=False,
button_style='',
tooltip='Click to show supercell'
)
get_supercell.observe(self.supercell_callback, 'value')
run_command = Button(
description='Run Command',
disabled=False
)
run_command.on_click(self.run_cmd_callback)
self.command_text = Text(
value='spin on',
placeholder='spin on',
description='Command:',
disabled=False
)
data_filter_vbox = VBox(
[HBox([get_supercell]), HBox([self.command_text, run_command])])
return data_filter_vbox
def __init__(self, viewer_state):
self.state = viewer_state
self.widget_show_axes = Checkbox(value=True, description="Show axes")
link((self.widget_show_axes, 'value'), (self.state, 'show_axes'))
self.button_normalize = ToggleButton(value=False,
description='normalize',
tooltip='Normalize histogram')
link((self.button_normalize, 'value'), (self.state, 'normalize'))
self.button_cumulative = ToggleButton(value=False,
description='cumulative',
tooltip='Cumulative histogram')
link((self.button_cumulative, 'value'), (self.state, 'cumulative'))
self.widget_x_axis = LinkedDropdown(self.state,
'x_att',
label='x axis')
super().__init__([
self.widget_x_axis, self.button_normalize, self.button_cumulative,
self.widget_show_axes
])
def _make_selection_repr_buttons(self):
vbox = VBox()
children = []
rep_names = REPR_NAMES[:]
excluded_names = ['ball+stick', 'distance']
for name in excluded_names:
rep_names.remove(name)
for index, name in enumerate(rep_names):
button = ToggleButton(description=name)
def make_func():
def on_toggle_button_value_change(change, button=button):
new = change['new'] # True/False
if new:
self._view.add_representation(button.description)
else:
self._view._remove_representations_by_name(
button.description)
return on_toggle_button_value_change
button.observe(make_func(), names='value')
children.append(button)
boxes = []
for index, arr in enumerate(np.array_split(children, 4)):
box = HBox([child for child in arr])
boxes.append(box)
vbox.children = boxes
return vbox
def __init__(self,
token_selector: TokensSelector,
update_handler: Callable = None):
self.token_selector: TokensSelector = token_selector
self.update_handler: Callable = update_handler
self._page_size = IntSlider(
description="Count",
min=0,
max=100,
step=1,
value=3,
continuous_update=False,
layout=Layout(width="300px"),
)
self._forward = Button(
description=">>",
button_style="Success",
layout=Layout(width="40px", color="green"),
)
self._back = Button(
description="<<",
button_style="Success",
layout=Layout(width="40px", color="green"),
)
self._split = ToggleButton(description="Split",
layout=Layout(width="80px", color="green"))
self._output = Output(layout=Layout(width="80%"))
def start_demo():
images_widget = ImageSelector(IMAGES, max_width=450)
images_box = VBox(
children=[HTML('<h1>Select Image</h1>'), images_widget.widget])
styles_widget = ImageSelector(STYLES, max_width=450)
styles_box = VBox(
children=[HTML('<h1>Select Style</h1>'), styles_widget.widget])
selectors = HBox(children=[images_box, styles_box],
layout=Layout(justify_content="space-between"))
confirm_button = ToggleButton(value=False,
description='Stylise',
disabled=False,
button_style='success',
tooltip='Description',
icon='check')
confirm_box = HBox(children=[confirm_button],
layout=Layout(justify_content='space-around'))
def on_click(change):
stylised_img = stylise(image=images_widget.image,
style=styles_widget.image)
stylised_widget = Image(value=to_binary(stylised_img),
width=stylised_img.size[0],
height=stylised_img.size[1],
format='png')
stylised_box = HBox(children=[stylised_widget],
layout=Layout(justify_content='space-around'))
full_display.children = [selectors, confirm_box, stylised_box]
confirm_button.observe(on_click, 'value')
full_display = VBox(children=[selectors, confirm_box])
return full_display
def __init__(self, querier, worklist, force=False, debug=False, index=0, rules=None):
reload()
self.rules = rules or config.BIBTEX_TO_INFO
self.worklist = worklist
self.force = force
self.querier = querier
self.next_page_widget = Button(description="Next Work", icon="fa-arrow-right")
self.reload_widget = Button(description="Reload", icon="fa-refresh")
self.previous_page_widget = Button(description="Previous Work", icon="fa-arrow-left")
self.debug_widget = ToggleButton(value=debug, description="Debug")
self.textarea_widget = ToggleButton(value=False, description="TextArea")
self.page_number_widget = Label(value="")
self.output_widget = Output()
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.textarea_widget.observe(self.show)
self.runner_widget = RunWidget() if config.RUN_WIDGET else ReplaceCellWidget()
self.view = VBox([
HBox([
self.previous_page_widget,
self.reload_widget,
self.next_page_widget,
self.debug_widget,
self.textarea_widget,
self.page_number_widget
]),
self.output_widget,
self.runner_widget.view,
])
self.index = index
self.varname = ""
self.work = None
self.articles = []
self.reload(show=False)
def create_highlight_toggle(self,
tag,
stats=None): #TODO move constants out
if stats is None:
stats = self.get_stats(tag)
tooltip = self.tag_tooltip(tag, stats)
toggle_btn = ToggleButton(
value=False,
description='',
disabled=False,
button_style='', # 'success', 'info', 'warning', 'danger' or ''
tooltip='Press to toggle highlighting of the tag region.',
icon='binoculars', # (FontAwesome names without the `fa-` prefix)
layout=Layout(height='35px',
width='35px',
borders='none',
align_items='center'))
def highlight(toggle_value):
self.model.plot.backend.highlight_selection(
float(tag.access[0]),
float(tag.access[1]) + 1, float(tag.address[0]),
float(tag.address[1]) + 1, toggle_value, tag)
toggle_btn.observe(highlight, 'value')
return toggle_btn, tooltip
def __init__(self, querier, worklist, force=False, debug=False, index=0):
reload()
self.worklist = worklist
self.force = force
self.querier = querier
self.next_page_widget = Button(description='Next Work', icon='fa-arrow-right')
self.reload_widget = Button(description='Reload', icon='fa-refresh')
self.previous_page_widget = Button(description='Previous Work', icon='fa-arrow-left')
self.debug_widget = ToggleButton(value=debug, description="Debug")
self.textarea_widget = ToggleButton(value=False, description="TextArea")
self.page_number_widget = Label(value="")
self.output_widget = Output()
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.textarea_widget.observe(self.show)
self.view = VBox([
HBox([
self.previous_page_widget,
self.reload_widget,
self.next_page_widget,
self.debug_widget,
self.textarea_widget,
self.page_number_widget
]),
self.output_widget
])
self.index = index
self.varname = ""
self.work = None
self.articles = []
self.reload(show=False)
def create_interactive_widgets(self, start_handler, stop_handler):
"""
This method will create the necessary ipywidget objects and return the final Box to display.
:return:
"""
self.start_streaming_button = ToggleButton(
description='Start Streaming',
value=False,
disabled=False,
button_style='',
tooltip='Start Streaming',
icon='play' # (FontAwesome names without the `fa-` prefix)
)
self.stop_streaming_button = ToggleButton(
description='Stop Streaming',
value=True,
disabled=False,
button_style='',
tooltip='Stop Streaming',
icon='stop' # (FontAwesome names without the `fa-` prefix)
)
self.output_area = Output()
self.start_handler = start_handler
self.stop_handler = stop_handler
self.start_streaming_button.observe(
self.start_streaming_button_handler)
self.stop_streaming_button.observe(self.stop_streaming_button_handler)
self.display_holder = VBox([
HBox([self.start_streaming_button, self.stop_streaming_button]),
self.output_area
])
return self.display_holder
def _default_toolbar(figure):
pz = panzoom(figure.marks)
normal_btn = ToggleButton(icon='fa-circle-o', tooltip='Normal', value=True)
pz_btn = ToggleButton(icon='fa-arrows',
tooltip='Pan and Zoom',
value=False)
snapshot_btn = Button(icon='fa-thumb-tack', tooltip='Snapshot View')
reset_btn = Button(icon='fa-refresh', tooltip='Reset View')
save_btn = Button(icon='fa-save', tooltip='Save as .png Image')
def tog(btn, *args):
# Traitlets closure
def cb():
for other in args:
other.value = not btn.value
return cb
def overl(btn, value):
# Traitlets closure
def cb():
if btn.value:
figure.interaction = value
return cb
def snapshot(_):
pz.snapshot()
def reset(_):
pz.reset()
def save(_):
figure.save()
pz_btn.on_trait_change(tog(pz_btn, normal_btn))
pz_btn.on_trait_change(overl(pz_btn, pz))
normal_btn.on_trait_change(tog(normal_btn, pz_btn))
normal_btn.on_trait_change(overl(normal_btn, None))
snapshot_btn.on_click(snapshot)
reset_btn.on_click(reset)
save_btn.on_click(save)
figure.interaction = None
button_group = HBox(
[normal_btn, pz_btn, snapshot_btn, reset_btn, save_btn])
button_group._dom_classes = list(button_group._dom_classes) + ['btn-group']
return button_group
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 __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 __init__(self, viewer_state):
self.state = viewer_state
self.widget_show_axes = Checkbox(value=True, description="Show axes")
link((self.widget_show_axes, 'value'), (self.state, 'show_axes'))
self.widget_reference_data = LinkedDropdown(self.state,
'reference_data',
label='reference')
self.widget_axis_x = LinkedDropdown(self.state,
'x_att',
label='x axis')
self.widget_function = LinkedDropdown(self.state,
'function',
label='function')
self.button_normalize = ToggleButton(value=False,
description='normalize',
tooltip='Normalize profiles')
link((self.button_normalize, 'value'), (self.state, 'normalize'))
super().__init__([
self.widget_reference_data, self.widget_axis_x,
self.widget_function, self.button_normalize, self.widget_show_axes
])
def __init__(self, viewer_state):
self.state = viewer_state
self.widget_show_axes = Checkbox(value=False, description="Show axes")
link((self.state, 'visible_axes'), (self.widget_show_axes, 'value'))
self.widgets_axis = []
for i, axis_name in enumerate('xyz'):
widget_axis = LinkedDropdown(self.state,
axis_name + '_att',
label=axis_name + ' axis')
self.widgets_axis.append(widget_axis)
super().__init__([self.widget_show_axes] + self.widgets_axis)
if hasattr(self.state, 'figure'):
self.widget_show_movie_maker = ToggleButton(
value=False, description="Show movie maker")
self.movie_maker = ipv.moviemaker.MovieMaker(
self.state.figure, self.state.figure.camera)
dlink((self.widget_show_movie_maker, 'value'),
(self.movie_maker.widget_main.layout, 'display'),
lambda value: None if value else 'none')
self.children += (self.widget_show_movie_maker,
self.movie_maker.widget_main)
def _active_folder(self):
"""Folder that houses the controls for active scenes."""
active = Button(icon='bars', description=' Active Scenes')
opts = _ListDict([(str(i), ToggleButton(description=str(i),
value=True))
for i, scn in enumerate(self.scenes)])
for obj in opts.values():
obj.observe(self._update_active, names='value')
return Folder(active, opts)
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 __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 gen_widget(anim):
viewer = AnimationViewer(anim)
clear_output(True)
anim_widget = AnimationWidget()
anim_widget.loop = True
button = ToggleButton(description="run", default=False)
link((button, 'value'), (anim_widget, 'run'))
display(anim_widget)
display(viewer.image)
display(button)
anim_widget.observe(lambda value: viewer.update(value["new"]),
names="value")
def on_selector_change(self, change):
if self.image_selector.value in self.image_dict:
self.change_image(self.image_dict[self.image_selector.value])
self.widget.children = [self.selector_box, self.display_box]
else:
self.upload_widget = FileUpload(accept='image/*', multiple=False)
self.name_widget = Text(description='<b>Image Name</b>', style={'description_width': 'initial'})
self.ok_widget = ToggleButton(
value=False,
description='Add',
disabled=False,
button_style='success',
tooltip='Description',
icon='check')
self.add_widget = HBox(children=[self.upload_widget, self.name_widget, self.ok_widget],
layout=Layout(justify_content='space-around'))
self.widget.children = [self.selector_box, self.add_widget]
self.upload_widget.observe(self.on_upload, 'value')
self.ok_widget.observe(self.on_add, 'value')
def __init__(self, data, dimensions, **kwargs):
self.data = data
self.options = {}
self.margins = {}
self.dimensions = dimensions
self.debug = kwargs.get('debug', None)
self.modal = kwargs.get('modal', True)
self.only_subsets = kwargs.get('only_subsets', False)
self.output_cont = Output()
self.output_cont.layout.width = '100%'
self.options_cont = Output()
self.margins_cont = Output()
self.option_tab = Tab()
self.option_tab.children = [self.options_cont, self.margins_cont]
self.option_tab.set_title(0, "Plot")
self.option_tab.set_title(1, "Layout")
self.option_tab.layout.display = 'none'
self.options_check = ToggleButton(value=False,
description="Options",
icon='cog')
self.options_check.observe(lambda v: self.showWidget(v["new"]),
names='value')
self.tab = HBox()
self.tab.children = [self.option_tab, self.output_cont]
init_notebook_mode(connected=True)
if (self.window == None):
if (self.modal == True):
title = kwargs.get('title', "")
mode = kwargs.get('mode', "")
self.window = Floatview(title=title, mode=mode)
else:
self.window = Output()
display(self.window)
self.DefaultMargins()
self.displayWindow()
def generatePara(templateFile):
items = []
with open(templateFile, 'r') as fd:
for line in fd.readlines():
g = re.search(r'[\w:]*\s*.*=*\s*\${(.*)}',line)
if g:
label_value = ''
isTB = False
for match in re.findall(r'(\w+)=("[^"]*"|\'[^\']*|[^,\n]*)', g.group(1)):
if match[0] == 'label':
lbs = match[1].split('/')
label_value = lbs[0]
if len(lbs) == 2:
isTB = True
if match[0] == 'option':
ops = match[1].split('/')
# if the first element of options is 'CO', remove it's label name.
if ops[0] == 'CO':
label = Label(layout = Layout(width = "150px"))
if not isTB:
togBtns = ToggleButtons(options = ops[1:])
else:
togBtns = ToggleButton(description = ops[1], value = True)
else:
label = Label(value = label_value, layout = Layout(width = "150px"))
if not isTB:
togBtns = ToggleButtons(options = ops)
else:
togBtns = ToggleButton(description = ops[0], value = True)
box = Box([label, togBtns], layout = Layout(width = '100%', justify_content = 'flex-start'))
items.append(box)
if match[0] == 'value':
label = Label(value = label_value, layout = Layout(width = "150px"))
text = Text(value = match[1])
box = Box([label, text], layout = Layout(width = '100%', justify_content = 'flex-start'))
items.append(box)
fd.close()
return items
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()
center_render_hbox = _make_autofit(
HBox([
toggle_button_interpolate,
center_button,
render_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 _default_toolbar(figure):
pz = panzoom(figure.marks)
normal_btn = ToggleButton(icon='fa-circle-o', tooltip='Normal', value=True)
pz_btn = ToggleButton(icon='fa-arrows', tooltip='Pan and Zoom', value=False)
snapshot_btn = Button(icon='fa-thumb-tack', tooltip='Snapshot View')
reset_btn = Button(icon='fa-refresh', tooltip='Reset View')
save_btn = Button(icon='fa-save', tooltip='Save as .png Image')
def tog(btn, *args):
# Traitlets closure
def cb():
for other in args:
other.value = not btn.value
return cb
def overl(btn, value):
# Traitlets closure
def cb():
if btn.value:
figure.interaction = value
return cb
def snapshot(_):
pz.snapshot()
def reset(_):
pz.reset()
def save(_):
figure.save()
pz_btn.on_trait_change(tog(pz_btn, normal_btn))
pz_btn.on_trait_change(overl(pz_btn, pz))
normal_btn.on_trait_change(tog(normal_btn, pz_btn))
normal_btn.on_trait_change(overl(normal_btn, None))
snapshot_btn.on_click(snapshot)
reset_btn.on_click(reset)
save_btn.on_click(save)
figure.interaction = None
button_group = HBox([normal_btn, pz_btn, snapshot_btn, reset_btn, save_btn])
button_group._dom_classes = list(button_group._dom_classes) + ['btn-group']
return button_group
def _(*_):
self.buttons = [
ToggleButton(description=label,
layout=Layout(margin='1', width='auto'))
for label in self._selection_obj._options_labels
]
self.label = Label(
self.description,
layout=Layout(
width=self.style.get('description_width', '100px')))
self.children = [self.label] + self.buttons
@observer(self.buttons, 'value')
def _(*_):
self.value = tuple(value for btn, value in zip(
self.buttons, self._selection_obj._options_values)
if btn.value)
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 __init__(self, name: str = "Network", **opts):
super().__init__(name=name, **opts)
self.network: ipycytoscape.CytoscapeWidget = None
self._view: Output = Output()
self._node_spacing: IntSlider = IntSlider(description='', min=3, max=500, value=50, layout={'width': '200px'})
self._edge_length_val: IntSlider = IntSlider(
description='', min=3, max=500, value=50, layout={'width': '200px'}
)
self._padding: IntSlider = IntSlider(description='', min=3, max=500, value=50, layout={'width': '200px'})
self._label: HTML = HTML(value=' ', layout={'width': '200px'})
self._network_layout = Dropdown(
description='',
options=['cola', 'klay', 'circle', 'concentric'],
value='cola',
layout={'width': '115px'},
)
self._relayout = Button(
description="Continue", button_style='Info', layout=Layout(width='115px', background_color='blue')
)
self._animate: Checkbox = ToggleButton(
description="Animate",
icon='check',
value=True,
layout={'width': '115px'},
)
self._curve_style = Dropdown(
description='',
options=[
('Straight line', 'haystack'),
('Curve, Bezier', 'bezier'),
('Curve, Bezier*', 'unbundled-bezier'),
],
value='haystack',
layout={'width': '115px'},
)
self._custom_styles: dict = None
self._buzy: bool = False
def interact_gravity_sphere():
Q = interactive(
drawfunction,
delta_rho=FloatSlider(
description=r"$\Delta\rho$",
min=-5.0,
max=5.0,
step=0.1,
value=1.0,
continuous_update=False,
),
a=FloatSlider(min=0.1,
max=4.0,
step=0.1,
value=1.0,
continuous_update=False),
z=FloatSlider(min=0.1,
max=5.0,
step=0.1,
value=1.0,
continuous_update=False),
stationSpacing=FloatSlider(
description="Step",
min=0.005,
max=0.1,
step=0.005,
value=0.01,
continuous_update=False,
readout_format=".3f",
),
B=ToggleButton(
value=True,
description="keep previous plots",
disabled=False,
button_style="",
tooltip="Click me",
layout=Layout(width="20%"),
),
)
return Q
def create_category(self, name, attr, value, color, font_color):
"""Create category widget"""
VIS = ["none", ""]
widget = self.toggle_widgets[attr] = ToggleButton(value=value,
description=name)
wcolor = self.color_widgets[attr] = ColorPicker(value=color,
description=name,
width="180px")
wfont_color = self.font_color_widgets[attr] = ColorPicker(
value=font_color, width="110px")
def visibility(*args):
"""" Toggles visibility of category """
self._display_stack += 1
wcolor.layout.display = VIS[int(widget.value)]
wfont_color.layout.display = VIS[int(widget.value)]
self.display()
widget.observe(visibility, "value")
wcolor.observe(self.update_widget, "value")
wfont_color.observe(self.update_widget, "value")
visibility()
def create_tab(self):
def change(visible):
with self.figure:
if visible:
ipv.style.axes_on()
ipv.style.box_on()
else:
ipv.style.axes_off()
ipv.style.box_off()
self.state.add_callback('visible_axes', change)
self.widget_show_movie_maker = ToggleButton(value=False, description="Show movie maker")
self.movie_maker = ipv.moviemaker.MovieMaker(self.figure, self.figure.camera)
dlink((self.widget_show_movie_maker, 'value'), (self.movie_maker.widget_main.layout, 'display'), lambda value: None if value else 'none')
self.tab_general = VBox([])
self.tab_general.children += self._options_cls(self.state).children
self.tab_general.children += (self.widget_show_movie_maker, self.movie_maker.widget_main)
children = [self.tab_general]
self.tab = Tab(children)
self.tab.set_title(0, "General")
self.tab.set_title(1, "Axes")
def _(*_):
self.buttons = []
for label in self._selection_obj._options_labels:
short_label = short_label_map.get(label, label)
self.buttons.append(
ToggleButton(
description=short_label
if len(short_label) < 15 else short_label[:12] + "…",
tooltip=label,
layout=Layout(
margin='1',
width='auto',
),
))
if self.description:
self.label = Label(
self.description,
layout=Layout(
width=self.style.get('description_width', '100px')))
else:
self.label = Label(
self.description,
layout=Layout(
width=self.style.get('description_width', '0px')))
self.children = [self.label] + self.buttons
@observer(self.buttons, 'value')
def _(*_):
proposed_value = tuple(value for btn, value in zip(
self.buttons, self._selection_obj._options_values)
if btn.value)
# When nothing is selected, treat as if everything is selected.
if len(proposed_value) == 0:
proposed_value = tuple(value for btn, value in zip(
self.buttons, self._selection_obj._options_values))
self.value = proposed_value
def __init__(self,
*,
bundle: Bundle,
default_token_filter: str = None,
**kwargs):
global CURRENT_BUNDLE
CURRENT_BUNDLE = bundle
"""Alternative implementation that uses VectorizedCorpus"""
self.bundle: Bundle = bundle
self.co_occurrences: pd.DataFrame = None
self.pivot_column_name: str = 'time_period'
if not isinstance(bundle.token2id, Token2Id):
raise ValueError(
f"Expected Token2Id, found {type(bundle.token2id)}")
if not isinstance(bundle.compute_options, dict):
raise ValueError(
"Expected Compute Options in bundle but found no such thing.")
"""Current processed corpus"""
self.corpus: VectorizedCorpus = bundle.corpus
"""Properties that changes current corpus"""
self._pivot: Dropdown = Dropdown(
options=["year", "lustrum", "decade"],
value="decade",
placeholder='Group by',
layout=Layout(width='auto'),
)
""""Keyness source"""
self._keyness_source: Dropdown = Dropdown(
options={
"Full corpus": KeynessMetricSource.Full,
"Concept corpus": KeynessMetricSource.Concept,
"Weighed corpus": KeynessMetricSource.Weighed,
} if bundle.concept_corpus is not None else {
"Full corpus": KeynessMetricSource.Full,
},
value=KeynessMetricSource.Weighed
if bundle.concept_corpus is not None else KeynessMetricSource.Full,
layout=Layout(width='auto'),
)
"""Properties that changes current corpus"""
self._keyness: Dropdown = Dropdown(
options={
"TF": KeynessMetric.TF,
"TF (norm)": KeynessMetric.TF_normalized,
"TF-IDF": KeynessMetric.TF_IDF,
"HAL CWR": KeynessMetric.HAL_cwr,
"PPMI": KeynessMetric.PPMI,
"LLR": KeynessMetric.LLR,
"LLR(Z)": KeynessMetric.LLR_Z,
"LLR(N)": KeynessMetric.LLR_N,
"DICE": KeynessMetric.DICE,
},
value=KeynessMetric.TF,
layout=Layout(width='auto'),
)
"""Properties that don't change current corpus"""
self._token_filter: Text = Text(value=default_token_filter,
placeholder='token match',
layout=Layout(width='auto'))
self._global_threshold_filter: Dropdown = Dropdown(
options={
f'>= {i}': i
for i in (1, 2, 3, 4, 5, 10, 25, 50, 100, 250, 500)
},
value=5,
layout=Layout(width='auto'),
)
self.concepts: Set[str] = set(self.bundle.context_opts.concept or [])
self._largest: Dropdown = Dropdown(
options=[10**i for i in range(0, 7)],
value=10000,
layout=Layout(width='auto'),
)
self._show_concept = ToggleButton(
description='Show concept',
value=False,
icon='',
layout=Layout(width='auto'),
)
self._message: HTML = HTML()
self._compute: Button = Button(description="Compute",
button_style='success',
layout=Layout(width='auto'))
self._save = Button(description='Save', layout=Layout(width='auto'))
self._download = Button(description='Download',
layout=Layout(width='auto'))
self._download_output: Output = Output()
self._table_view = TableViewerClass(data=empty_data())
self._button_bar = HBox(
children=[
VBox([HTML("<b>Token match</b>"), self._token_filter]),
VBox([HTML("<b>Source</b>"), self._keyness_source]),
VBox([HTML("<b>Keyness</b>"), self._keyness]),
VBox([HTML("🙂"), self._show_concept]),
VBox([HTML("<b>Group by</b>"), self._pivot]),
VBox([HTML("<b>Threshold</b>"),
self._global_threshold_filter]),
VBox([HTML("<b>Group limit</b>"), self._largest]),
VBox([self._save, self._download]),
VBox([self._compute, self._message]),
self._download_output,
],
layout=Layout(width='auto'),
)
super().__init__(
children=[self._button_bar, self._table_view.container],
layout=Layout(width='auto'),
**kwargs)
self._save.on_click(self.save)
self._download.on_click(self.download)
self.start_observe()
class TabularCoOccurrenceGUI(GridBox): # pylint: disable=too-many-ancestors
def __init__(self,
*,
bundle: Bundle,
default_token_filter: str = None,
**kwargs):
global CURRENT_BUNDLE
CURRENT_BUNDLE = bundle
"""Alternative implementation that uses VectorizedCorpus"""
self.bundle: Bundle = bundle
self.co_occurrences: pd.DataFrame = None
self.pivot_column_name: str = 'time_period'
if not isinstance(bundle.token2id, Token2Id):
raise ValueError(
f"Expected Token2Id, found {type(bundle.token2id)}")
if not isinstance(bundle.compute_options, dict):
raise ValueError(
"Expected Compute Options in bundle but found no such thing.")
"""Current processed corpus"""
self.corpus: VectorizedCorpus = bundle.corpus
"""Properties that changes current corpus"""
self._pivot: Dropdown = Dropdown(
options=["year", "lustrum", "decade"],
value="decade",
placeholder='Group by',
layout=Layout(width='auto'),
)
""""Keyness source"""
self._keyness_source: Dropdown = Dropdown(
options={
"Full corpus": KeynessMetricSource.Full,
"Concept corpus": KeynessMetricSource.Concept,
"Weighed corpus": KeynessMetricSource.Weighed,
} if bundle.concept_corpus is not None else {
"Full corpus": KeynessMetricSource.Full,
},
value=KeynessMetricSource.Weighed
if bundle.concept_corpus is not None else KeynessMetricSource.Full,
layout=Layout(width='auto'),
)
"""Properties that changes current corpus"""
self._keyness: Dropdown = Dropdown(
options={
"TF": KeynessMetric.TF,
"TF (norm)": KeynessMetric.TF_normalized,
"TF-IDF": KeynessMetric.TF_IDF,
"HAL CWR": KeynessMetric.HAL_cwr,
"PPMI": KeynessMetric.PPMI,
"LLR": KeynessMetric.LLR,
"LLR(Z)": KeynessMetric.LLR_Z,
"LLR(N)": KeynessMetric.LLR_N,
"DICE": KeynessMetric.DICE,
},
value=KeynessMetric.TF,
layout=Layout(width='auto'),
)
"""Properties that don't change current corpus"""
self._token_filter: Text = Text(value=default_token_filter,
placeholder='token match',
layout=Layout(width='auto'))
self._global_threshold_filter: Dropdown = Dropdown(
options={
f'>= {i}': i
for i in (1, 2, 3, 4, 5, 10, 25, 50, 100, 250, 500)
},
value=5,
layout=Layout(width='auto'),
)
self.concepts: Set[str] = set(self.bundle.context_opts.concept or [])
self._largest: Dropdown = Dropdown(
options=[10**i for i in range(0, 7)],
value=10000,
layout=Layout(width='auto'),
)
self._show_concept = ToggleButton(
description='Show concept',
value=False,
icon='',
layout=Layout(width='auto'),
)
self._message: HTML = HTML()
self._compute: Button = Button(description="Compute",
button_style='success',
layout=Layout(width='auto'))
self._save = Button(description='Save', layout=Layout(width='auto'))
self._download = Button(description='Download',
layout=Layout(width='auto'))
self._download_output: Output = Output()
self._table_view = TableViewerClass(data=empty_data())
self._button_bar = HBox(
children=[
VBox([HTML("<b>Token match</b>"), self._token_filter]),
VBox([HTML("<b>Source</b>"), self._keyness_source]),
VBox([HTML("<b>Keyness</b>"), self._keyness]),
VBox([HTML("🙂"), self._show_concept]),
VBox([HTML("<b>Group by</b>"), self._pivot]),
VBox([HTML("<b>Threshold</b>"),
self._global_threshold_filter]),
VBox([HTML("<b>Group limit</b>"), self._largest]),
VBox([self._save, self._download]),
VBox([self._compute, self._message]),
self._download_output,
],
layout=Layout(width='auto'),
)
super().__init__(
children=[self._button_bar, self._table_view.container],
layout=Layout(width='auto'),
**kwargs)
self._save.on_click(self.save)
self._download.on_click(self.download)
self.start_observe()
def _compute_handler(self, *_):
try:
self.set_buzy(True, "Computing...")
self.update_corpus()
self.update_co_occurrences()
self.set_buzy(False, "✔")
except ValueError as ex:
self.alert(str(ex))
except Exception as ex:
logger.exception(ex)
self.alert(str(ex))
raise
self.set_buzy(False)
def set_buzy(self, is_buzy: bool = True, message: str = None):
if message:
self.alert(message)
self._keyness.disabled = is_buzy
self._keyness_source.disabled = is_buzy
self._show_concept.disabled = is_buzy or self.bundle.concept_corpus is None
self._pivot.disabled = is_buzy
self._global_threshold_filter.disabled = is_buzy
self._token_filter.disabled = is_buzy
self._save.disabled = is_buzy
self._download.disabled = is_buzy
self._largest.disabled = is_buzy
def start_observe(self):
self.stop_observe()
self._compute.on_click(self._compute_handler)
self._show_concept.observe(self.update_co_occurrences, 'value')
self._largest.observe(self.update_co_occurrences, 'value')
self._show_concept.observe(self._update_toggle_icon, 'value')
self._token_filter.observe(self._filter_co_occurrences, 'value')
return self
def stop_observe(self):
with contextlib.suppress(Exception):
self._show_concept.unobserve(self.update_co_occurrences, 'value')
self._largest.unobserve(self.update_co_occurrences, 'value')
self._token_filter.unobserve(self._filter_co_occurrences, 'value')
self._show_concept.unobserve(self._update_toggle_icon, 'value')
def alert(self, message: str) -> None:
self._message.value = f"<span style='color: red; font-weight: bold;'>{message}</span>"
def info(self, message: str) -> None:
self._message.value = f"<span style='color: green; font-weight: bold;'>{message}</span>"
def update_corpus(self, *_):
self.set_buzy(True, "⌛ Computing...")
self.corpus = self.to_corpus()
self.set_buzy(False, "✔")
def update_co_occurrences(self, *_) -> pd.DataFrame:
self.set_buzy(True, "⌛ Preparing data...")
self.co_occurrences = self.to_co_occurrences()
self.set_buzy(False, "✔")
self.set_buzy(True, "⌛ Loading table...")
self._table_view.update(self.co_occurrences[DISPLAY_COLUMNS])
self.set_buzy(False, "✔")
self.info(f"Data size: {len(self.co_occurrences)}")
def _filter_co_occurrences(self, *_) -> pd.DataFrame:
co_occurrences: pd.DataFrame = self.to_filtered_co_occurrences()
self._table_view.update(co_occurrences[DISPLAY_COLUMNS])
self.info(f"Data size: {len(co_occurrences)}")
def _update_toggle_icon(self, event: dict) -> None:
with contextlib.suppress(Exception):
event['owner'].icon = 'check' if event['new'] else ''
@property
def ignores(self) -> List[str]:
if self.show_concept or not self.concepts:
return set()
if isinstance(self.concepts, Iterable):
return set(self.concepts)
return {self.concepts}
@property
def show_concept(self) -> bool:
return self._show_concept.value
@show_concept.setter
def show_concept(self, value: bool):
self._show_concept.value = value
@property
def keyness(self) -> KeynessMetric:
return self._keyness.value
@keyness.setter
def keyness(self, value: KeynessMetric):
self._keyness.value = value
@property
def keyness_source(self) -> KeynessMetricSource:
return self._keyness_source.value
@keyness_source.setter
def keyness_source(self, value: KeynessMetricSource):
self._keyness_source.value = value
@property
def global_threshold(self) -> int:
return self._global_threshold_filter.value
@global_threshold.setter
def global_threshold(self, value: int):
self._global_threshold_filter.value = value
@property
def largest(self) -> int:
return self._largest.value
@largest.setter
def largest(self, value: int):
self._largest.value = value
@property
def token_filter(self) -> List[str]:
return self._token_filter.value.strip().split()
@token_filter.setter
def token_filter(self, value: List[str]):
self._token_filter.value = ' '.join(value) if isinstance(
value, list) else value
@property
def pivot(self) -> str:
return self._pivot.value
@pivot.setter
def pivot(self, value: str):
self._pivot.value = value
def save(self, *_b):
store_co_occurrences(
filename=path_add_timestamp('co_occurrence_data.csv'),
co_occurrences=self.co_occurrences,
store_feather=False,
)
def download(self, *_):
self._button_bar.disabled = True
with contextlib.suppress(Exception):
js_download = create_js_download(self.co_occurrences, index=True)
if js_download is not None:
with self._download_output:
IPython_display.display(js_download)
self._button_bar.disabled = False
def to_co_occurrences(self) -> pd.DataFrame:
self.set_buzy(True, "⌛ Preparing co-occurrences...")
try:
if self.pivot_column_name not in self.corpus.document_index.columns:
raise ValueError(
f"expected '{self.pivot_column_name}' but not found in {', '.join(self.corpus.document_index.columns)}"
)
co_occurrences: pd.DataFrame = (CoOccurrenceHelper(
corpus=self.corpus,
source_token2id=self.bundle.token2id,
pivot_keys=self.pivot_column_name,
).exclude(self.ignores).largest(self.largest)).value
self.set_buzy(False, None)
self.alert("✔")
except Exception as ex:
self.set_buzy(False)
self.alert(f"😢 {str(ex)}")
raise
return co_occurrences
def to_filtered_co_occurrences(self) -> pd.DataFrame:
if not self.token_filter:
return self.co_occurrences
co_occurrences: pd.DataFrame = self.co_occurrences
re_filters: List[str] = [
fnmatch.translate(s) for s in self.token_filter
]
for re_filter in re_filters:
co_occurrences = co_occurrences[co_occurrences.token.astype(
str).str.contains(pat=re_filter, case=False, na="")]
return co_occurrences
def to_corpus(self) -> VectorizedCorpus:
"""Returns a grouped, optionally TF-IDF, corpus filtered by token & threshold."""
self.set_buzy(True, "⌛ updating corpus...")
try:
corpus: VectorizedCorpus = self.bundle.keyness_transform(
opts=self.compute_opts())
self.set_buzy(False, None)
self.alert("✔")
except Exception as ex:
self.set_buzy(False)
self.alert(f"😢 {str(ex)}")
raise
return corpus
def setup(self) -> "TabularCoOccurrenceGUI":
self.update_corpus()
return self
def compute_opts(self) -> ComputeKeynessOpts:
return ComputeKeynessOpts(
period_pivot=self.pivot,
keyness_source=self.keyness_source,
keyness=self.keyness,
tf_threshold=self.global_threshold,
pivot_column_name=self.pivot_column_name,
normalize=False,
)
