def _build_tabs(self, resources: dict, options_box: Box, instance_creation: Optional[Box] = None) -> Tab: """ Build tabs of widgets to display in Jupyter notebook :param resources: Dictionary description: html link from which the values are put into HTML and presented as description and link :param options_box: Box with method parameters/options (displayed under 'Method parameters' tab) :param instance_creation: Box with instance creation widget (displayed under 'Explained instance' tab) if provided. If None, no 'Explained instance' tab will be created. :return: Tabs to be displayed """ tabs = Tab() if instance_creation is not None: tabs.children = [ instance_creation, options_box, self._build_resources_widgets(resources) ] tabs.set_title(0, 'Explained instance') tabs.set_title(1, 'Method parameters') tabs.set_title(2, 'Resources') else: tabs.children = [ options_box, self._build_resources_widgets(resources) ] tabs.set_title(0, 'Method parameters') tabs.set_title(1, 'Resources') return tabs
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
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 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
buildBtn.on_click(buildBtn_clicked) #modelDd.observe(model_change) buildTab = VBox(build_items) ################################# image tab end ################################### ################################ Finally ########################################################## tab_nest = Tab() tab_nest.children = [swanInputBox, runBox, outputBox, buildTab] tab_nest.set_title(0, 'Input') tab_nest.set_title(1, 'Run') tab_nest.set_title(2, 'Output') tab_nest.set_title(3, 'Build') setvar("""PATH=$HOME/agave-model/bin:$PATH""") cmd("auth-tokens-refresh") clear_output() def on_change(change): global cur_model if change['type'] == 'change' and change['name'] == 'value': with logOp: setvar("MODEL_TITLE="+modelTitle.value)
def _widget(self): """Create IPython widget for display within a notebook""" try: return self._cached_widget except AttributeError: pass try: from ipywidgets import ( HTML, Accordion, Button, HBox, IntText, Layout, Tab, VBox, ) except ImportError: self._cached_widget = None return None layout = Layout(width="150px") status = HTML(self._repr_html_()) if self._supports_scaling: request = IntText(0, description="Workers", layout=layout) scale = Button(description="Scale", layout=layout) minimum = IntText(0, description="Minimum", layout=layout) maximum = IntText(0, description="Maximum", layout=layout) adapt = Button(description="Adapt", layout=layout) accordion = Accordion( [HBox([request, scale]), HBox([minimum, maximum, adapt])], layout=Layout(min_width="500px"), ) accordion.selected_index = None accordion.set_title(0, "Manual Scaling") accordion.set_title(1, "Adaptive Scaling") def adapt_cb(b): self.adapt(minimum=minimum.value, maximum=maximum.value) update() adapt.on_click(adapt_cb) def scale_cb(b): with log_errors(): n = request.value with suppress(AttributeError): self._adaptive.stop() self.scale(n) update() scale.on_click(scale_cb) else: accordion = HTML("") scale_status = HTML(self._scaling_status()) tab = Tab() tab.children = [status, VBox([scale_status, accordion])] tab.set_title(0, "Status") tab.set_title(1, "Scaling") self._cached_widget = tab def update(): status.value = self._repr_html_() scale_status.value = self._scaling_status() cluster_repr_interval = parse_timedelta( dask.config.get("distributed.deploy.cluster-repr-interval", default="ms")) pc = PeriodicCallback(update, cluster_repr_interval * 1000) self.periodic_callbacks["cluster-repr"] = pc pc.start() return tab
print("Successfully convert images to " + videoNameText.value + '.mp4') except Exception as ex_results: print('Error: ', ex_results) cvtBtn.on_click(convert_btn_clicked) tab1_items = [ Box([ Label(value="Images Folder:", layout=Layout(width='200px')), imgsDicText ]), Box([ Label(value="Video Name:", layout=Layout(width='200px')), videoNameText ]), Box([ Label(value="Frames Per Second:", layout=Layout(width='200px')), fpsSlider ]), Box([cvtBtn]) ] tab1Box = VBox(tab1_items) tab_nest = Tab() tab_nest.children = [tab0Box, tab1Box] tab_nest.set_title(0, 'Download') tab_nest.set_title(1, 'ImgsToVideo') display(tab_nest)
def interface(f): try: with open(f.selected, "r") as file: data = json.loads(file.read(), cls=MontyDecoder) except FileNotFoundError: return "Please select an existing file." print("NKPTS = " + str(data["n_kpoints"]) + "\tNBANDS = " + str(data["nbands"])) timing_list = data["timing_list"] try: assert isinstance(timing_list, list) except AssertionError: return "timing_list is not a List. Please check your input file." nodes_list = list(set([t["nodes"] for t in timing_list])) nodes_list.sort() kpar_list = list(set([t["kpar"] for t in timing_list])) kpar_list.sort() ncore_list = list(set([t["ncore"] for t in timing_list])) ncore_list.sort() select_layout = Layout(width='70px') versus = Select(options=["NODES", "KPAR"], index=0, layout=select_layout) nodes = Select(options=nodes_list, index=0, layout=select_layout) x_axis_select = Select(options=["NCORE", "NPAR"], index=0, layout=select_layout) nodes_select = SelectMultiple(options=nodes_list, value=nodes_list[:3], rows=len(nodes_list), layout=select_layout) kpar_select = SelectMultiple(options=kpar_list, value=kpar_list[:3], rows=len(kpar_list), layout=select_layout) ncore_select = SelectMultiple(options=ncore_list, value=ncore_list[:3], rows=len(ncore_list), layout=select_layout) is_hybrid = Checkbox(value=False, description="Hybrid?") widget_mappings = { "Timestep": { "descriptions": ["X-axis", ], "input": (versus, ), "output": interactive_output( time_plot, {"timing_list": fixed(timing_list), "versus": versus} ) }, "Chessboard": { "descriptions": ["Nodes", "X-axis", "Hybrid"], "input": (nodes, x_axis_select, is_hybrid), "output": interactive_output( chessboard_plot, {"data": fixed(data), "nodes": nodes, "x_axis": x_axis_select, "is_hybrid": is_hybrid} ) }, "Tetris": { "descriptions": ["Nodes", "KPAR", "NCORE", "Hybrid"], "input": [nodes_select, kpar_select, ncore_select, is_hybrid], "output": interactive_output( tetris_plot, {"data": fixed(data), "nodes_choices": nodes_select, "kpar_choices": kpar_select, "ncore_choices": ncore_select, "is_hybrid": is_hybrid} ) }, "Optimal": { "descriptions": [], "input": (), "output": interactive_output( optimal_settings, {"timing_list": fixed(timing_list)} ) }, # "NPAR line plot": { # "descriptions": ["Nodes", ], # "input": (nodes, ), # "output": interactive_output( # npar_line_plot, {"timing_list": fixed(timing_list), # "nodes": nodes} # ) # }, # "NCORE line plot": { # "descriptions": ["Nodes", ], # "input": (nodes, ), # "output": interactive_output( # ncore_line_plot, {"timing_list": fixed(timing_list), # "nodes": nodes} # ) # } } tab = Tab() tab.children = [VBox((HBox([VBox((Button(description=desc, layout=select_layout), inp)) if desc != "Hybrid" else inp for (desc, inp) in zip(w["descriptions"], w["input"])]), w["output"])) for w in widget_mappings.values()] for i, title in enumerate(widget_mappings.keys()): tab.set_title(i, title) return tab
def display(self, states, shapes, mapping, tree, height=600, tree_width=250, cad_width=800, quality=0.5, axes=True, axes0=True, grid=True, ortho=True, transparent=False, position=None, rotation=None, zoom=None, mac_scrollbar=True): if platform.system() != "Darwin": mac_scrollbar = False # Output widget output_height = height * 0.4 - 20 + 2 self.info = Info(tree_width, output_height - 6) self.info.html.add_class("scroll-area") if mac_scrollbar: self.info.html.add_class("mac-scrollbar") self.output = Box([self.info.html]) self.output.layout = Layout(height="%dpx" % output_height, width="%dpx" % tree_width, overflow_y="scroll", overflow_x="scroll") self.output.add_class("view_output") ## Threejs rendering of Cadquery objects self.cq_view = CadqueryView(width=cad_width, height=height, quality=quality, default_mesh_color=self.default_mesh_color, default_edge_color=self.default_edge_color, info=self.info) for shape in shapes: self.cq_view.add_shape(shape["name"], shape["shape"], shape["color"]) renderer = self.cq_view.render(position, rotation, zoom) renderer.add_class("view_renderer") bb = self.cq_view.bb clipping = Clipping(self.image_path, self.output, self.cq_view, tree_width) for normal in ((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)): clipping.add_slider(bb.max * 1.2, -bb.max * 1.3, bb.max * 1.2, 0.01, normal) # Tree widget to change visibility # tree_height = height - output_height - 35 tree_view = TreeView(image_paths=self.image_paths, tree=tree, state=states, layout=Layout(height="%dpx" % (height * 0.6 - 25), width="%dpx" % (tree_width - 20))) tree_view.add_class("view_tree") tree_view.add_class("scroll-area") if mac_scrollbar: tree_view.add_class("mac-scrollbar") tree_view.observe(self.cq_view.change_visibility(mapping), "state") tab_contents = ['Tree', 'Clipping'] tree_clipping = Tab(layout=Layout(height="%dpx" % (height * 0.6 + 20), width="%dpx" % tree_width)) tree_clipping.children = [tree_view, clipping.create()] for i in range(len(tab_contents)): tree_clipping.set_title(i, tab_contents[i]) tree_clipping.add_class("tab-content-no-padding") # Check controls to swith orto, grid and axis self.check_controls = [ self.create_checkbox("axes", "Axes", axes, self.cq_view.toggle_axes), self.create_checkbox("grid", "Grid", grid, self.cq_view.toggle_grid), self.create_checkbox("zero", "@ 0", axes0, self.cq_view.toggle_center), self.create_checkbox("ortho", "Ortho", ortho, self.cq_view.toggle_ortho), self.create_checkbox("transparent", "Transparency", transparent, self.cq_view.toggle_transparent), self.create_checkbox("black_edges", "Black Edges", False, self.cq_view.toggle_black_edges), ] self.check_controls[-2].add_class("indent") # Set initial state self.cq_view.toggle_ortho(ortho) self.cq_view.toggle_axes(axes) self.cq_view.toggle_center(axes0) self.cq_view.toggle_grid(grid) self.cq_view.toggle_transparent(transparent) for obj, vals in states.items(): for i, val in enumerate(vals): self.cq_view.set_visibility(mapping[obj], i, val) # Buttons to switch camera position self.view_controls = [] for typ in CadqueryDisplay.types: if typ == "refit": tooltip = "Fit view" elif typ == "reset": tooltip = "Reset view" else: tooltip = "Change view to %s" % typ button = self.create_button( typ, self.cq_view.change_view(typ, CadqueryDisplay.directions), tooltip) self.view_controls.append(button) return HBox([ VBox([HBox(self.check_controls[:-2]), tree_clipping, self.output]), VBox([ HBox(self.view_controls + self.check_controls[-2:]), renderer ]) ])
def init_dashboard(self): from bqplot import DateScale, LinearScale, DateScale, Axis, Lines, Figure, Tooltip from bqplot.colorschemes import CATEGORY10, CATEGORY20 from bqplot.toolbar import Toolbar from ipywidgets import VBox, Tab from IPython.display import display from tornado import gen cpu_sx = LinearScale() cpu_sy = LinearScale() cpu_x = Axis(label='Time (s)', scale=cpu_sx) cpu_y = Axis(label='CPU Usage (%)', scale=cpu_sy, orientation='vertical') mem_sx = LinearScale() mem_sy = LinearScale() mem_x = Axis(label='Time (s)', scale=mem_sx) mem_y = Axis(label='Memory Usage (MB)', scale=mem_sy, orientation='vertical') thru_sx = LinearScale() thru_sy = LinearScale() thru_x = Axis(label='Time (s)', scale=thru_sx) thru_y = Axis(label='Data Processed (MB)', scale=thru_sy, orientation='vertical') colors = CATEGORY20 tt = Tooltip(fields=['name'], labels=['Filter Name']) self.cpu_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': cpu_sx, 'y': cpu_sy }) for i, n in enumerate(self.other_nodes) } self.mem_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': mem_sx, 'y': mem_sy }) for i, n in enumerate(self.other_nodes) } self.thru_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': thru_sx, 'y': thru_sy }) for i, n in enumerate(self.other_nodes) } self.cpu_fig = Figure(marks=list(self.cpu_lines.values()), axes=[cpu_x, cpu_y], title='CPU Usage', animation_duration=50) self.mem_fig = Figure(marks=list(self.mem_lines.values()), axes=[mem_x, mem_y], title='Memory Usage', animation_duration=50) self.thru_fig = Figure(marks=list(self.thru_lines.values()), axes=[thru_x, thru_y], title='Data Processed', animation_duration=50) tab = Tab() tab.children = [self.cpu_fig, self.mem_fig, self.thru_fig] tab.set_title(0, 'CPU') tab.set_title(1, 'Memory') tab.set_title(2, 'Throughput') display(tab) perf_queue = Queue() self.exit_perf = Event() def wait_for_perf_updates(q, exit, cpu_lines, mem_lines, thru_lines): while not exit.is_set(): messages = [] while not exit.is_set(): try: messages.append(q.get(False)) except queue.Empty as e: time.sleep(0.05) break for message in messages: filter_name, time_val, cpu, mem_info, processed = message mem = mem_info[0] / 2.**20 vmem = mem_info[1] / 2.**20 proc = processed / 2.**20 cpu_lines[filter_name].x = np.append( cpu_lines[filter_name].x, [time_val.total_seconds()]) cpu_lines[filter_name].y = np.append( cpu_lines[filter_name].y, [cpu]) mem_lines[filter_name].x = np.append( mem_lines[filter_name].x, [time_val.total_seconds()]) mem_lines[filter_name].y = np.append( mem_lines[filter_name].y, [mem]) thru_lines[filter_name].x = np.append( thru_lines[filter_name].x, [time_val.total_seconds()]) thru_lines[filter_name].y = np.append( thru_lines[filter_name].y, [proc]) for n in self.other_nodes: n.perf_queue = perf_queue self.perf_thread = Thread(target=wait_for_perf_updates, args=(perf_queue, self.exit_perf, self.cpu_lines, self.mem_lines, self.thru_lines)) self.perf_thread.start()
def resetSpGCheckBoxes(b): for k in spgSelector: if type(k) == int: spgSelector[k].value = False spgSelector[1].value = True spgSelector['reset'].on_click(resetSpGCheckBoxes) spgSelectorLayout = HBox([ VBox([spgSelector[i] for i in range(1, 6)]), VBox([spgSelector[i] for i in range(6, 11)]), VBox([spgSelector[i] for i in [11, 21, 31, 'which', 'reset']]) ]) bottLine = HBox([AOGenus, ATspecies, spgSelectorLayout]) startEnd = IntRangeSlider(value=[1, 10], min=1, max=10, step=1, description='Ranks') aggWidg = VBox([topRowGroup, midLine, bottLine, startEnd]) kind = Tab() kind.children = [aggWidg, unaggWidg] for i, name in enumerate(['Aggregated', 'Unaggregated']): kind.set_title(i, name)
'left': 80, 'right': 20 }) run_viewmodel({'new': 0.}) UI_model = VBox([ HBox(UI_viewcontrol, layout=Layout(width='1000px')), HBox([fig_bar]), HBox([fig_line]) ]) # specifies the length of the lhs of the interface #UI_model = HBox([loading_html]) # END OF ************************************************************************************************************** Build bar charts (use of bqp) *********************** tab = Tab() #tab.children = [UI_model, UI_sec_input] tab.children = [UI_model] tab.set_title(0, 'Portfolio Optimizer') #tab.set_title(1, 'Settings') #tab.set_title(2, 'Reference Data') def updatedseclist(obj=None): if obj['old'] == 1: save_settings() solve_intial_opt_weight() run_viewmodel({'new': 0.}) # START OF ************************************************************************************************************** (use of bqcde) *********************** #import bqcde #Requires Bloomberg's Database and is henceforth unaccessible to us. AND BELOW...interal portfolio thing
def __init__(self, *args, **kwargs): self.progress_callback = self.set_progress super().__init__(progress_callback=self.progress_callback, *args, **kwargs) fc = FileChooser() fc.show_only_dirs = True fc.default_path = tempfile.gettempdir() self.ms_storage_path = fc self.ms_upload = FileUpload() self.peaklist_files_button = FileUpload(description='Peaklists', accept='csv,xlsx', multiple=False) self.peaklist_files_button.observe(self.load_peaklist, names='value') self.load_ms_button = Button(description='Load MS-files') self.load_ms_button.on_click(self.search_files) self.detect_peaks_button = Button(description="Detect Peaks") self.detect_peaks_button.on_click(self.detect_peaks) self.message_box = Textarea( value='', placeholder='Please select some files and click on Run.', description='', disabled=True, layout={ 'width': '90%', 'height': '500px', 'font_family': 'monospace' }) self.run_button = Button(description="Run") self.run_button.on_click(self.run) self.run_button.style.button_color = 'lightgray' self.optimize_rt_button = Button(description="Find closest peaks") self.optimize_rt_button.on_click(self.action_optimize_rt) self.download_button = Button(description="Export") self.download_button.on_click(self.export_action) self.download_button.style.button_color = 'lightgray' self.progress_bar = Progress(min=0, max=100, layout=Layout(width='90%'), description='Progress:', bar_style='info') self.output = widgets.Output() tabs = Tab() tabs.children = [ HBox([self.ms_storage_path, self.ms_upload, self.load_ms_button]), HBox([ self.peaklist_files_button, self.detect_peaks_button, self.optimize_rt_button ]), ] tabs.set_title(0, 'MS-Files') tabs.set_title(1, 'Peaklists') self.layout = VBox([ tabs, self.message_box, HBox([self.run_button, self.download_button]), self.progress_bar ])