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)
