def __init__(self, images, vqa, use_camera=False): self.vqa = vqa self.images = images self.image_output = None self.label_question = widgets.Label(value="Is the plane red?") self.label_answer = widgets.Label(value="") self.label_query = widgets.Output(layout={'border': 'none'}) self.label_expression = widgets.Output(layout={'border': 'none'}) self.current_image = None self.text = widgets.Text() self.text.on_submit(self._handle_submit) self.use_pattern_matcher = True self.width = 400 self.height = 400 if use_camera: self.camera = CameraStream( constraints={ 'facing_mode': 'user', 'audio': False, 'video': { 'width': 640, 'height': 480 } }) self.image_recorder = ImageRecorder(stream=self.camera) self.image_recorder.recording = True self.image_recorder.autosave = False else: self.camera = None
def plot_board(self): clear_output() options = self._board_state['words'] options.sort() spy_selector = widgets.Dropdown(options=options, description='Select Target', disabled=False, value=None) display(spy_selector) spy_selector.observe(self._selection_change) kill_button = widgets.Button(description='Eliminate') output = widgets.Output() display(kill_button, output) kill_button.on_click(self._kill_button_clicked) fig, ax = plt.subplots(figsize=(8, 6)) ax.axis('tight') ax.axis('off') table = ax.table(cellText=self._board, loc='center', cellLoc='center', cellColours=self._get_board_colors()) table.set_fontsize(14) table.scale(1.5, 3.5) plt.show() et_button = widgets.Button(description='End Turn') output = widgets.Output() display(et_button, output) et_button.on_click(self._et_button_clicked)
def modeltransform_wait(job_id: str, client: Client, output: widgets.Output, wait_interval: int = DEFAULT_WAIT_INTERVAL, wait_timeout: int = DEFAULT_WAIT_TIMEOUT): job_id_output = widgets.Output() update_status_output = widgets.Output() with output: display(job_id_output, update_status_output) with job_id_output: print(f'Wait called on endpoint creation job {job_id}') with update_status_output: beginning_time = datetime.datetime.utcnow() while datetime.datetime.utcnow() - beginning_time < ( datetime.timedelta(seconds=wait_timeout)): update_status_output.clear_output() status_res = client.modeltransform_status(job_id) status_res.raise_for_status() status = status_res.json() if status['status'] in ['Completed', 'Failed', 'Stopped']: print('modeltransform is finished') return status else: print(f'Status is {status["status"]}') print(f'Waiting for {wait_interval} before checking again...') time.sleep(wait_interval)
def wait_for_endpoint(job_id: str, config: Configuration, request_param_generator, output: widgets.Output, wait_interval: int = DEFAULT_WAIT_INTERVAL, wait_timeout: int = DEFAULT_WAIT_TIMEOUT): job_id_output = widgets.Output() update_status_output = widgets.Output() with output: display(job_id_output, update_status_output) with job_id_output: print(f'Wait called on endpoint creation job {job_id}') with update_status_output: beginning_time = datetime.datetime.utcnow() while datetime.datetime.utcnow() - beginning_time < ( datetime.timedelta(seconds=wait_timeout)): update_status_output.clear_output() status = get_endpoint_status(config.host, str(config.port), config.ssl, request_param_generator, job_id) if status['status'] in ['InService', 'Failed']: print('Endpoint creation is finished') return status else: print(f'Status is {status["status"]}') print(f'Waiting for {wait_interval} before checking again...') time.sleep(wait_interval)
def wait_for_export(export_url: str, job_id: str, output: widgets.Output, export_ssl: bool = True, wait_interval: int = DEFAULT_WAIT_INTERVAL, wait_timeout: int = DEFAULT_WAIT_TIMEOUT, creds: Credentials = None): job_id_output = widgets.Output() update_widget_output = widgets.Output() with output: display(job_id_output, update_widget_output) with job_id_output: print(f'Wait called on export job {job_id}') with update_widget_output: beginning_time = datetime.datetime.utcnow() while datetime.datetime.utcnow() - beginning_time < ( datetime.timedelta(seconds=wait_timeout)): update_widget_output.clear_output() print('Checking for latest status...') export_status = get_export_status(export_url, export_ssl, job_id, creds) if export_status['status'] in ['succeeded', 'failed']: print('Export is finished') return export_status else: print(f'Status is {export_status["status"]}') print(f'Waiting for {wait_interval} before checking again...') time.sleep(wait_interval)
def create_textinputquiz_widget(description, text_description, correct_answer, a2, hint): ##grid for option table correct_answer = correct_answer ##float ##str alternativ = widgets.Text(value='', placeholder='', description='', disabled=False, layout=(Layout(width='auto')) ) ##question description description_out = widgets.Output(layout=Layout(width='auto')) with description_out: print(description) ##description before text widget text_description_out = widgets.Output(layout=Layout(width='auto')) with text_description_out: print(text_description) ##description after text widget e.g. units a2_out = widgets.Output(layout=Layout(width='auto')) with a2_out: print(a2) ## feedback_out = widgets.Output() def check_selection(b): a = alternativ.value if a == correct_answer: s = "You are right! The first level 2 magic word is 'JOHN'" else: s = "It seems like you got the wrong result. Check the hint!" with feedback_out: feedback_out.clear_output() print(s) return check = widgets.Button(description="check") check.on_click(check_selection) ## hint_out = widgets.Output() def hint_selection(b): with hint_out: print(hint) with feedback_out: feedback_out.clear_output() print(hint) hintbutton = widgets.Button(description="hint") hintbutton.on_click(hint_selection) return widgets.VBox([description_out, widgets.HBox([text_description_out, alternativ, a2_out]), widgets.HBox([hintbutton, check]), feedback_out], layout=Layout(display='flex', flex_flow='column', align_items='stretch', width='auto'))
def create_mcq(description, options, correct_answer, hint): if correct_answer not in options: options.append(correct_answer) correct_answer_index = options.index(correct_answer) radio_options = [(words, i) for i, words in enumerate(options)] alternativ = widgets.RadioButtons( options=radio_options, description='', layout={'width': 'max-content'}, disabled=False, indent=False, align='center', ) description_out = widgets.Output(layout=Layout(width='auto')) with description_out: print(description) feedback_out = widgets.Output() def check_selection(b): a = int(float(alternativ.value)) if a == correct_answer_index: s = '\x1b[6;30;42m' + "correct" + '\x1b[0m' + "\n" else: s = '\x1b[5;30;41m' + "try again" + '\x1b[0m' + "\n" with feedback_out: feedback_out.clear_output() print(s) return check = widgets.Button(description="check") check.on_click(check_selection) # hint_out = widgets.Output() # def hint_selection(b): # with hint_out: # print(hint) # with feedback_out: # feedback_out.clear_output() # print(hint) #hintbutton = widgets.Button(description="hint") #hintbutton.on_click(hint_selection) return widgets.VBox( [description_out, alternativ, widgets.HBox([check]), feedback_out], layout=Layout(display='flex', flex_flow='column', align_items='stretch', width='auto'))
def reset(self): self._input_grids = [] self._wrappers_input_grids = [] self._obj_store = {} self._value_traces = {} self._value_trackers = {} self._interactions = [] self._constants = [] for i, obj in enumerate(self.inputs): grid_id = f"I{i}" value_trackers, value_traces = self._get_value_trackers_and_traces( obj, grid_id) self._value_traces.update(value_traces) self._value_trackers.update(value_trackers) self._input_grids.append( InputGridWidget(session=self, grid_id=grid_id, df=obj, value_trackers=value_trackers)) self._wrappers_input_grids.append( ShowHideWidget(f"Input {i + 1}", self._input_grids[-1].get_widget())) self._output_grid = OutputGridWidget(grid_id="O", session=self) self._scratch_grid = ScratchGridWidget(grid_id="S", session=self) self._synthesis_output_widget = SynthesisOutputWidget( session=self, allow_composition=self._allow_composition) self._wrapper_output_grid = ShowHideWidget( 'Partial Output', self._output_grid.get_widget()) self._wrapper_scratch_grid = ShowHideWidget( 'Scratch', self._scratch_grid.get_widget()) self._synthesize_button = widgets.Button(description='Synthesize') self._synthesize_button.button_style = 'success' self._synthesize_output = widgets.Output() self._synthesize_solution_output = widgets.Output() self._synthesize_button.on_click(self._onclick_synthesize) self._output_reset_button = widgets.Button(description="Reset") self._output_reset_button.on_click(self._reset_output) self._output_reset_button.button_style = 'info' for i, obj in enumerate(self.inputs): self._obj_store[f"I{i}"] = obj self._explanation_widget = widgets.Text( description=r'\(f\)', disabled=True, style={'description_width': '9px'}, )
def create_textinputquiz_widget(description, text_description, correct_answer, a2, hint): ##grid for option table correct_answer = correct_answer ##float ##str alternativ = widgets.Text(value = '', placeholder = '', description = '', disabled = False, layout=(Layout(width = 'auto')) ) ##question description description_out = widgets.Output(layout=Layout(width='auto')) with description_out: print(description) ##description before text widget text_description_out = widgets.Output(layout=Layout(width='auto')) with text_description_out: print (text_description) ##description after text widget e.g. units a2_out = widgets.Output(layout=Layout(width='auto')) with a2_out: print(a2) ## feedback_out = widgets.Output() def check_selection(b): a = alternativ.value if a==correct_answer: s = '\x1b[6;30;42m' + "correct" + '\x1b[0m' +"\n" #green color else: s = '\x1b[5;30;41m' + "try again" + '\x1b[0m' +"\n" #red color with feedback_out: feedback_out.clear_output() print(s) return check = widgets.Button(description="check") check.on_click(check_selection) ## hint_out = widgets.Output() def hint_selection(b): with hint_out: print(hint) with feedback_out: feedback_out.clear_output() print(hint) hintbutton = widgets.Button(description="hint") hintbutton.on_click(hint_selection) return widgets.VBox([description_out, widgets.HBox([text_description_out, alternativ, a2_out]), widgets.HBox([hintbutton, check]), feedback_out], layout=Layout(display='flex', flex_flow='column', align_items='stretch', width='auto'))
def instantiate_objects(self): self.out_graph = widgets.Output() self.out_url = widgets.Output() self.out_func = widgets.Output() self.btn_gen = widgets.Button(description="Generate Vis") self.btn_add = widgets.Button(description="Add Mapping") self.btn_rem = widgets.Button(description="Remove Mapping") self.btn_clear_assigned = widgets.Button(description="Clear") self.sel_cols = widgets.Select(options=[], disabled=False) self.sel_fields = widgets.Select(options=[], disabled=False) self.sel_assigned = widgets.Select(options=[], disabled=False) self.lbl_cols = widgets.Label(value="Columns") self.chk_incidx = widgets.Checkbox(value=False, description='Inc. Index', disabled=False, indent=False) self.lbl_fields = widgets.Label(value="Fields") self.lbl_assigned = widgets.Label(value="Assigned") self.lbl_core = widgets.Label(value="Visualization Core") self.lbl_title = widgets.Label(value="Chart Title:") self.txt_title = widgets.Text(value="My Chart") self.txt_xaxis = widgets.Text(value="") self.txt_yaxis = widgets.Text(value="") self.lbl_xaxis = widgets.Label(value="X Axis") self.lbl_yaxis = widgets.Label(value="Y Axis") self.lbl_charth = widgets.Label(value="Chart Height:") self.lbl_chartw = widgets.Label(value="Chart Width:") self.txt_charth = widgets.Text(value="750") self.txt_chartw = widgets.Text(value="2000") self.lbl_break = widgets.Label( value= "---------------------------------------------------------------------------------" ) self.sel_df = widgets.Select(options=[], description='Data Frame:', disabled=False) self.drp_charts = widgets.Dropdown(options=[], description='Chart Type:', disabled=False)
def start_synthesis(inputs: List[Any], domain: str = 'pandas_lite', engine: SynthesisEngine = None): if engine is None and domain is None: raise AssertionError( f"At least one of engine and domain has to be provided to start_synthesis." ) if engine is not None: domain = engine.config.name try: domain_class, domain_ui_class, session_class = DOMAIN_DICT[domain] except KeyError: raise ValueError(f"Domain {domain} not supported") if engine is None: engine: SynthesisEngine = _get_engine(domain) output = widgets.Output() session: UISession = session_class(session_id=uuid.uuid4().hex, domain=domain_class(), domain_ui=domain_ui_class(), engine=engine, inputs=inputs, output_widget=output) SESSION_DICT[session.session_id] = session display(output) with output: session.display()
def run(self): #print('Running pipeline...') #B=widgets.Button(description='next iteration') #def on_click(b): # self.next_iteration() # if self._job_monitor: # self._job_monitor.refresh() #B.on_click(on_click) #display(B) #self._job_monitor.widget().clearJobs() self._status_out = widgets.Output() display(self._status_out) self._last_status_string = '' self.next_iteration() while True: ret = self.next_iteration() if not ret: break time.sleep(1) #IPython.get_ipython().kernel.do_one_iteration() self._is_finished = True print('Finished pipeline.')
def __init__(self, image_size: int = 1200): self.debug_output = widgets.Output(layout=widgets.Layout( margin='20px 0 0 0')) self.quiz = widgets.VBox() super().__init__((self.quiz, self.debug_output))
def get_optimal_bifurcation_point(self, verbose=False): self.make_steps(verbose) out = widgets.Output(layout={'border': '1px solid black'}) current_step = self.steps[-1] out.append_stdout(f'Location: ({round(current_step.x, 3)}, {round(current_step.y,3)}) \t'\ + f' M alpha: {round(self.m_alpha[-1], 3)}\t Total Cost: {round(self.cost[-1])} \t Theta: {round(self.theta[-1])}') return out
def setup(problem_id: str): output = widgets.Output() with output: display(Markdown(HINTS_DICT[problem_id])) w = ShowHideWidget("Show Hints", output) w.display()
def __init__(self, data, params): self.data = data self.which = params['which'] self.initial = params['initial'] self.nz = params['nz'] self.edge_cut = params['edge_cut'] if self.which == 'Lif': assert '.lif' in self.data, ( 'Input format does not correspond to a lif file') reader = Reader(self.data) self.files = reader.getSerieInfo() assert len(self.files) != 0, 'Lif file is empty' self.output_widget = widgets.Output() self.widget = widgets.VBox() self.selection = None self.main() self.display_lif(self.selection) elif self.which == 'Images': self.fmt = params['fmt'] assert self.fmt in self.data, ( 'Input format does not correspond to a tiff file') imgs = Images(self.data, self.initial, self.nz, self.edge_cut) self.xyz = imgs.read_images() self.display_tiff()
def latex_tab(db, output): b_table = widgets.Button(description="Display Latex Table") w_rows = wdg.SelectMultiple(header="Select Rows:", options=db.rm.exp_params, db_vars=db.vars, var="latex_rows") w_cols = wdg.SelectMultiple(header="Select Columns:", options=db.rm.score_keys, db_vars=db.vars, var="latex_columns") button = widgets.VBox([ widgets.HBox([w_rows.get_widget(), w_cols.get_widget()]), widgets.HBox([b_table]), ]) output_plot = widgets.Output() with output: display(button) display(output_plot) def on_clicked(b): output_plot.clear_output() with output_plot: db.update_rm() score_table = db.rm.get_latex_table(columns=w_cols.update(), rows=w_rows.update(), caption="Results") print(score_table) b_table.on_click(on_clicked)
def issuer_choice(data_file): from ipywidgets import widgets from IPython.display import display, clear_output import pandas as pd # def myfunc(issuer): # return data.loc[issuer]['ticker'] def on_button_clicked(b): ticker = data.loc[w.value]['ticker'] with output: clear_output() print('Ticker CIQ: ' + ticker) clear_output() display(w) display(button, output) #, output2) # print('Ticker CIQ: ' + ticker) data_handler(data_file,ticker) data = pd.read_csv('data/ticker_list.csv', sep=',', index_col = 1, encoding = "latin-1") w = widgets.Dropdown(options=list(data.index), description='Emisor:') button = widgets.Button(description="Obtener CIQ") output = widgets.Output() # w.observe(on_button_clicked, names='value') display(w) display(button, output) #, output2) button.on_click(on_button_clicked)
def i_delete_app(): """ Delete selected Balsam app """ from balsam.core.models import ApplicationDefinition as App from ipywidgets import widgets, interact_manual from IPython.display import display, clear_output import os print(f'Balsam database: {os.environ["BALSAM_DB_PATH"]}') allapps = [app.name for app in App.objects.all()] idelete = widgets.Button(value=False, description='delete app', disabled=False, button_style='danger', tooltip='Delete app', icon='') iapps = widgets.Dropdown(options=allapps, description='app') output = widgets.Output() display(iapps, idelete, output) def delete_clicked(b): with output: clear_output() delete_app(iapps.value) idelete.on_click(delete_clicked) return
def overlayViewer(im4d, overlay3d, zz=0, tt=0, th=0, oa=1, im_range=None, o_range=None): tt_enable = True if im4d.ndim == 3: im4d = im4d[:,:,:,np.newaxis] tt_enable = False out = widgets.Output() zz_slider = widgets.IntSlider(min=0, max=im4d.shape[2]-1, step=1, value=zz) tt_slider = widgets.IntSlider(min=0, max=im4d.shape[3]-1, step=1, value=tt) oa_slider = widgets.FloatSlider(min=0, max=1, step=0.1, value=oa) if issubclass(overlay3d.dtype.type, np.integer) or overlay3d.dtype == np.bool: th = 1 th_slider = widgets.IntSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=1, value=th) th_slider.visible = False oa_slider.visible = True else: th_slider = widgets.FloatSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=0.01, value=th) oa_slider.visible = False overlay_button = widgets.ToggleButton(description='Overlay', value=True) if not tt_enable: tt_slider.visible = False with warnings.catch_warnings(): warnings.simplefilter('ignore') w = widgets.interactive(overlayShow, recon=widgets.fixed(im4d), overlay3d=widgets.fixed(overlay3d), zz=zz_slider, tt=tt_slider, th=th_slider, oa=oa_slider, oe=overlay_button, im_range=widgets.fixed(im_range), o_range=widgets.fixed(o_range), out=widgets.fixed(out)) wo = widgets.HBox(children=(w,out)) display(wo)
def create_pairdensity_plot_widget(ls): """Create a pairwise density widget. Parameters ---------- ls : :class:`~lens.Summary` Lens `Summary`. Returns ------- :class:`ipywidgets.Widget` Jupyter widget to explore pairdensity plots. """ numeric_columns = ls._report["column_summary"]["_columns"] dropdown1 = widgets.Dropdown(options=numeric_columns, description="First:") dropdown2 = widgets.Dropdown(options=numeric_columns, description="Second:") if len(numeric_columns) > 1: dropdown1.value, dropdown2.value = numeric_columns[:2] plot_area = widgets.Output() for dropdown in [dropdown1, dropdown2]: dropdown.observe( lambda x: _update_pairdensity_plot(ls, dropdown1, dropdown2, plot_area), names="value", type="change", ) _update_pairdensity_plot(ls, dropdown1, dropdown2, plot_area) return widgets.VBox([dropdown1, dropdown2, plot_area], padding=PADDING)
def create_correlation_plot_widget(ls): """Return a widget with correlation plot. Parameters ---------- ls : :class:`~lens.Summary` Lens `Summary`. Returns ------- :class:`ipywidgets.Widget` Jupyter widget to explore correlation matrix plot. """ plot_area = widgets.Output() update_plot( plot_correlation_mpl, [ls], plot_area, height=PLOT_WIDTH, width=PLOT_WIDTH * 1.3, ) return plot_area
def notebook_play(self): # Define inputs move = widgets.Text(description="Next move") button = widgets.Button(description="Send") inputs = widgets.HBox([move, button]) # Define output and display everything output = widgets.Output() display(inputs, output) with output: print("Next is WHITE") display(self.board) # Define interactions def on_button_clicked(b): with output: output.clear_output() try: self.move(move.value) print(self.get_turn_description()) display(self.board) except Exception as e: raise e print(e) display(self.board) button.on_click(on_button_clicked)
def __init__(self, label: str, fn: Callable[[], None], show_event: str='click', default_visible: bool = False): """Hide and show the content by clicking the button Parameters ---------- label: str label of the button fn: Callable[[], None] function that renders the content show_event: 'click' | 'hover' how the content will be shown default_visible: bool should the content show at first """ self.el_btn = Button(description=label, disabled=False, button_style='') self.el_container = widgets.Output() if show_event == 'hover': self.el_btn.on_mouseenter(self._show) self.el_btn.on_mouseleave(self._hide) else: assert show_event == 'click' self.el_btn.on_click(self._on_toggle_visibility) if not default_visible: self._hide(None) else: self._show(None) self.el_root = widgets.VBox([self.el_btn.widget, self.el_container]) with self.el_container: fn()
def render(self, draw_control=None, caption=None): self.out = widgets.Output() self.imgoverlays() self.dc = None options = ['None'] self.m.add_layer(self.leafletimg[list(self.grassimg.keys())[-1]]) if len(self.grassimg) >= 2: self.maplist = widgets.Dropdown( options=options + list(self.grassimg.keys()), value=list(self.grassimg.keys())[-1], description='Select Layer:', ) self.maplist.observe(self.on_value_change, names='value') display(self.maplist) if draw_control: self.dc = DrawControl() self.dc.on_draw(handle_draw) self.m.add_control(self.dc) display(self.m) self.lastdraw = widgets.Button( description='Print last draw', disabled=False, button_style='', # 'success', 'info', 'warning', 'danger' or '' tooltip='Print last draw', #icon='check' ) self.lastdraw.on_click(self.on_button_clicked1) if not draw_control: self.lastdraw.disabled = True display(widgets.HBox([self.lastdraw, self.out])) if caption: display( HTML("<center><b>Figure %s:</b> %s<center>" % (caption[0], caption[1]))) return {'map': self.m, 'drawer': self.dc}
def show_obs_plot_widget(data, display_fn): from IPython import display from ipywidgets import widgets text_wid = widgets.IntText(value=0, placeholder='Frame number', description='Frame number:', disabled=False) slider_wid = widgets.IntSlider(value=0, min=0, max=len(data), step=1, description='Frames:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') widgets.jslink((text_wid, 'value'), (slider_wid, 'value')) output_widget = widgets.Output(layout={'height': '250px'}) def on_value_change(change): frame_idx = change['new'] display_fn(frame_idx) slider_wid.observe(on_value_change, names='value') frame_box = widgets.HBox([output_widget]) control_box = widgets.HBox([text_wid, slider_wid]) # Controls main_box = widgets.VBox([frame_box, control_box]) display.display(main_box) display_fn(0)
def make_course_ids_input(): """ Make box and buttons for course id entry. On submit button click, class ids updates with the value in the text box """ t = widgets.Text(description='Class id') submit = widgets.Button(description='Add id', button_style='success') reset = widgets.Button(description='Reset ids') out = widgets.Output(layout={'border': '1px solid black'}) def handle_add(change): InteractiveConfiguration.add_course_id(t.value) # Clear the box t.value = '' show_class_ids() def handle_reset(change): InteractiveConfiguration.reset_course_ids() show_class_ids() def show_class_ids(): out.clear_output() with out: print(' ----Canvas class ids---- ') for cid in InteractiveConfiguration.course_ids: print(cid) submit.on_click(handle_add) reset.on_click(handle_reset) button_box = widgets.HBox([reset, submit]) input_box = widgets.VBox([t, button_box]) display(widgets.HBox([input_box, out]))
def explaining(data, rf, X_train, sov_lab_encoder, le, feat_key): from ipywidgets import widgets from IPython.display import display, clear_output, Markdown def on_button_clicked(b): with output: clear_output() per1n = list(data.columns).index(per1.value) per2n = list(data.columns).index(per2.value) # print('Números de periodos:' + '[' + str(per1n) + ',' + str(per2n) + ']') display(Markdown('Explicación de resultados:')) explain_tree(data, [per1n,per2n], rf, X_train, sov_lab_encoder, le , feat_key) button = widgets.Button(description="Explicar trimestres escogidos") output = widgets.Output() per1 = widgets.Dropdown( options=list(data.columns), description='Periodo 1:') per2 = widgets.Dropdown( options=list(data.columns), description='Periodo 2:') box = widgets.VBox([per1, per2]) display(box) display(button, output) button.on_click(on_button_clicked) # interact(myfunc, Emisor=list(data.index))
def latex_tab(db, output): b_table = widgets.Button(description="Display Latex Table") # d_avg_across_columns = widgets.Text( # value=str(db.vars.get('avg_across', 'None')), # description='avg_across:', # disabled=False # ) hparam_txt = widgets.Label(value="Select Rows:", layout=widgets.Layout(width='300px'),) try: db.latex_rows_widget = widgets.SelectMultiple(options=db.rm.exp_params, value=list(db.vars.get('latex_rows'))) except: db.latex_rows_widget = widgets.SelectMultiple(options=db.rm.exp_params, value=[db.rm.exp_params[0]]) metrics_txt = widgets.Label(value="Select Columns:", layout=db.layout_label,) try: db.latex_cols_widget = widgets.SelectMultiple(value=list(db.vars.get('latex_columns')), options=db.rm_original.score_keys) except: db.latex_cols_widget = widgets.SelectMultiple(value=[db.rm_original.score_keys[0]], options=db.rm_original.score_keys) button = widgets.VBox([ widgets.HBox([hparam_txt, metrics_txt]), widgets.HBox([db.latex_rows_widget, db.latex_cols_widget]), widgets.HBox([b_table]), ]) output_plot = widgets.Output() with output: display(button) display(output_plot) def on_clicked(b): output_plot.clear_output() with output_plot: db.update_rm() db.vars['latex_rows'] = list(db.latex_rows_widget.value) db.vars['latex_columns'] = list(db.latex_cols_widget.value) # print('cols', db.hparam_dict) # stop score_table = db.rm.get_latex_table(columns=db.vars.get('latex_columns'), rows=db.vars.get('latex_rows'), caption='Results') print(score_table) b_table.on_click(on_clicked)
def display(self): path_selection_output = widgets.Output() grading_output = widgets.Output() summary_output = widgets.Output() with path_selection_output: # info print('System Overview') self.dashboard_path() with grading_output: # Grading self.dashboard_grading() tab = widgets.Tab( children=[path_selection_output, grading_output, summary_output]) tab.set_title(0, 'Path') tab.set_title(1, 'Grading') tab.set_title(2, 'Summary') display(tab)