def bkapp(doc): def update_plot(attrname, old_value, new_value): disease = disease_selector.value smooth = int(smooth_selector.value) src = models.get_disease_totals_by_name(disease, smooth) source.data.update(src.data) chart.title.text = disease disease_selector.label = disease smooth_selector.label = str(smooth) doc.title = "Epidemic - {}".format(disease) # request args = doc.session_context.request.arguments get_param = lambda param, default: args.get( param, [bytes(str(default), encoding='utf')])[0].decode('utf-8') disease = get_param('disease', DEFAULT_DISEASE) smooth = get_param('smooth', 2) ## Components # Widgets disease_selector = Dropdown(label=disease, value=disease, menu=list(zip(DISEASES, DISEASES))) smooth_selector = Dropdown(label=smooth, value=smooth, menu=[(str(i), str(i)) for i in range(1, 9)]) picker = RadioButtonGroup(labels=['Total Cases', 'Cases by Region'], width=300) # Sources source = ColumnDataSource( ) # models.get_disease_data_by_name(disease,smooth) # Events disease_selector.on_change('value', update_plot) smooth_selector.on_change('value', update_plot) # Figures chart = make_plot(source, disease) ranger = make_range_tool(chart) chart_range = make_range_plot(source, ranger) # controls = column(widgetbox(disease_selector, smooth_selector, picker), height=280) charts_col = column(chart, chart_range, width=1024) doc.add_root(row(charts_col, controls)) doc.title = "Epidemic - {}".format(disease) update_plot(None, None, None)
def getDropdown(): menu = [("Clustering 1", "item_1"), ("Clustering 2", "item_2"), None, ("Clustering 3", "item_3")] dropdown = Dropdown(label="Choose clustering to explore", type="warning", menu=menu) return dropdown
def _timeseries_widgets(col_1, col_2, col_max, col_min, n_bins, aggregate, callback): col_1_time = pd.to_datetime(col_1) if col_max is None: col_max = col_1_time.max() if col_min is None: col_min = col_1_time.min() slider = Slider(start=1, end=100, value=n_bins, step=1, title="Bins") slider.on_change('value', callback) range_select = DateRangeSlider(start=col_1_time.min(), end=col_1_time.max(), value=(col_min, col_max), step=1, title='Range', format='%R %F') range_select.on_change('value', callback) dropdown = Dropdown(value=aggregate, label=aggregate, button_type="default", menu=[('mean', 'mean'), ('count', 'count'), ('sum', 'sum'), ('max', 'max'), ('min', 'min')]) dropdown.on_change('value', callback) return slider, range_select, dropdown
def ddownexample_tab(): from bokeh.models.widgets import Dropdown from bokeh.layouts import widgetbox from bokeh.layouts import layout from bokeh.models.widgets import Panel # menu = [(x, x) for x in df["opp_type"].unique()] menu = [("chris", "Chris"), ("marie", "Marie"), ("david", "David"), ("michael", "Michael")] # button_type: default, primary, success, warning, danger, link dropdown = Dropdown(label="Select sibling", button_type="success", menu=menu) def printddval(attr, old, new): print(dropdown.value) dropdown.on_change('value', printddval) mylayout = [widgetbox(dropdown)] tab = Panel(child=layout([mylayout]), title="Dropdown example") return tab
def _scatter_widgets(col_1, col_2, aggregate, callback): dropdown = Dropdown(value=aggregate, label=aggregate, button_type="default", menu=[('mean', 'mean'), ('last', 'last'), ('sum', 'sum'), ('max', 'max'), ('min', 'min')]) dropdown.on_change('value', callback) return dropdown
def dropdown_example(): output_file('dropdown.html') menu = [('Item 1', 'item_1'), ('Item 2', 'item_2'), None, ('Item 3', 'item_3')] dropdown = Dropdown(label='Dropdown button', button_type='warning', menu=menu) show(widgetbox(dropdown))
def __init__(self): super().__init__() self.state = "New York" self.menu = STATES self.state_selection = Dropdown(menu=self.menu, label=self.state, sizing_mode="stretch_width")
def trend_tab(data, ticker): #pg_title = Paragraph() #pg_title.text = '[ '+ticker+' ] PRICE TREND' def make_plot(data_src): p = figure(x_axis_type="datetime", title=ticker + ' Closing Price Trend', plot_width=800, plot_height=400) p.grid.grid_line_alpha = 0.3 p.xaxis.axis_label = 'Trading Date' p.yaxis.axis_label = '[ ' + ticker + ' ] Close Price' p.line(data_src['Date'], data_src['Close'], line_width=2, legend_label=ticker) p.legend.location = "top_left" return p def update(attr, old, new): # ticker ticker = dropdown.value #'SCOM' ticker_file = ticker + '.csv' # Read data into dataframes data_df = pd.read_csv(join(dirname(__file__), 'data', ticker_file), parse_dates=True).dropna() data_df['Date'] = pd.to_datetime(data_df['Date']) src.data.update(data_df.data) # Set dropdown stocks_list = [("Safaricom Plc", "SCOM"), ("Nation Media Group Plc", "NMG"), None, ("Kenya Power & Lighting Company", "KPLC")] dropdown = Dropdown(label="NSE Stocks List", menu=stocks_list) dropdown.on_change('value', update) dropdown.on_click(update) p = make_plot(data) # Create a row layout layout = row(widgetbox(dropdown, align='center'), p) # Make a tab with the layout tab = Panel(child=layout, title='Stock Price Trend') return tab
def __init__(self, renderer): self.file_input = Dropdown(label="Select dataset", menu=[]) for dataset_name in SQLDBInformer(DbConn({})).get_all_schemas(): if dataset_name in set(["information_schema", "performance_schema", "sys", "defaultDB", "mysql"]): continue if dataset_name[:3] == "pg_": continue self.file_input.menu.append(dataset_name) self.run_id_dropdown = Dropdown(label="select run id here", menu=[]) self.ground_truth_id_dropdown = Dropdown(label="select ground truth id here", menu=[]) self.score_slider = RangeSlider(start=0, end=1, value=(0, 1), step=.1, callback_policy='mouseup', title="score range") self.max_elements_slider = Slider(start=1000, end=100000, value=10000, step=1000, callback_policy='mouseup', title="max render") self.range_link_radio = RadioGroup(labels=["Link read plot to x-range", "Link read plot to y-range"], active=0, orientation="horizontal") self.full_render_button = Button(label="render without limit") self.render_mems_button = Button(label="render MEMs") self.delete_button = Button(label="Delete Dataset") self.force_read_id = TextInput(value="", title="Render reads with ids (comma seperated list):") self.file_input.on_change("value", lambda x,y,z: self.file_input_change(renderer)) self.run_id_dropdown.on_change("value", lambda x,y,z: self.run_id_change(renderer)) self.ground_truth_id_dropdown.on_change("value", lambda x,y,z: self.ground_id_change(renderer)) self.score_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer)) self.max_elements_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer)) self.full_render_button.on_event(ButtonClick, lambda x: self.full_render(renderer)) self.render_mems_button.on_event(ButtonClick, lambda x: self.render_mems_button_event(renderer)) self.delete_button.on_event(ButtonClick, lambda x: self.delete_button_event(renderer)) self.force_read_id.on_change("value", lambda x,y,z: self.forced_read_ids_change(renderer)) self.spinner_div = Div(text=html_file("spinner"), sizing_mode="scale_both", visible=False) self.condition = threading.Condition() self.subset_buttons = CheckboxButtonGroup(labels=["Render false-positives", "Render false-negatives", "Render true-positives", "Compute Stats"], active=[0, 1, 2]) self.subset_buttons.on_click(lambda x: self.forced_read_ids_change(renderer)) self.blur_slider = Slider(start=0, end=500, value=100, step=1, callback_policy='mouseup', title="Blur") self.blur_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer))
def init_dropdown_widget(cls, update_value_callback, update_options_callback, on_change_callback, value=None, options=None): if not value: value = cls.get_value_or_none(update_value_callback) if not options: options = cls.get_value_or_none(update_options_callback) dropdown_button = Dropdown(label=value, menu=options) #on_change is set after the object is created due to dependencies return DropdownWidget(dropdown_button, update_value_callback, update_options_callback, on_change_callback)
def assemble_global_widgets(self): model_menu = [(self.rf_clf_name, self.rf_clf_name), None, (self.xgb_clf_name, self.xgb_clf_name)] model_dropdown = Dropdown(label="Model", button_type="warning", menu=model_menu, value=self.xgb_clf_name) threshold_slider = Slider(start=0, end=1, value=0.5, step=.01, title="Threshold value") return model_dropdown, threshold_slider
def __init__(self, main): self.row = pn.Row(pn.pane.Str("loading")) plot_options = [ "Basic Plot", "Selected Source Info", ] + list(extension_plots.get_plot_dict().keys()) self._plot_selection = Dropdown(label="Choose plot type:", menu=plot_options) self._plot_selection.on_click( partial( self._update_main_contents, main=main, ), )
def __init__(self): super().__init__() self.state = "New York, Washington" self.menu = COUNTIES self.state_selection = Dropdown(menu=self.menu, label=self.state, sizing_mode="stretch_width") self.data_getter = RadioGroup( labels=[ "Cases", "Deaths", ], active=0, sizing_mode="stretch_width", )
def assemble_global_widgets(self): model_menu = [(self.rf_clf.__name__, self.rf_clf.__name__), None, (self.xgb_clf.__name__, self.xgb_clf.__name__)] model_dropdown = Dropdown(label="Model", button_type="warning", menu=model_menu, value=self.xgb_clf.__name__) vis_x_axis = self.test min_date, max_date = vis_x_axis.index.min(), vis_x_axis.index.max() time_period_slider = DateRangeSlider(title="Time Period", value=(min_date, max_date), start=min_date, end=max_date, step=1) return model_dropdown, time_period_slider
def initialize(): text_output = Paragraph(text='Status', width=300, height=100) DATA_STORE.update({'text_output': text_output}) retrieve_data(initial=True) df = DATA_STORE['data'] symbols = sorted(list(set(df.index.get_level_values(level=0)))) if DATA_STORE['valid_symbols'] is None: DATA_STORE.update({'valid_symbols': symbols}) set_data_symbol() menu = [*zip(symbols, symbols)] dropdown = Dropdown(label='Select Symbol', button_type='primary', menu=menu) dropdown.on_change('value', dropdown_callback) bucket_input = TextInput(value='mlsl-mle-ws', title='S3 Bucket:') key_input = TextInput(value='training-data/crypto_test_preds.csv', title='S3 Key:') profile_input = TextInput(value='kyle_general', title='Boto Profile:') text_button = Button(label='Pull Data') text_button.on_event(ButtonClick, text_button_callback) default_button = Button(label='Reset Defaults') default_button.on_event(ButtonClick, default_button_callback) DATA_STORE.update({ 'dropdown': dropdown, 's3_bucket_input': bucket_input, 's3_key_input': key_input, 'text_button': text_button, 'boto_profile_input': profile_input, 'default_button': default_button })
def create_panel(controller): # im logo logo = figure() logo = config_fig_logo(logo, controller.cfg.app_name) logo.css_classes = ['panel_logo'] # title title = Div(text='Optimización y Mantenimiento de la Agenda', css_classes=['panel_title'], width=680) # modules selection menu = get_user_modules(controller.user.profile) panel_menu = Dropdown( label='Módulos', button_type="primary", menu=menu, css_classes=['panel_menu'], name='panel_menu', width=150, ) panel_menu.on_click(controller.module_selection) # widget widget = layout([[logo, title, panel_menu]], sizing_mode='fixed') widget.name = 'header' return widget
"console.log('toggle(inactive): active=' + this.active, this.toString())" )) toggle_active = Toggle(label="Toggle button (initially active)", button_type="success", active=True) toggle_active.js_on_click( CustomJS( code= "console.log('toggle(active): active=' + this.active, this.toString())" )) menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")] dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu) dropdown.js_on_click( CustomJS(code="console.log('dropdown: click ' + this.toString())")) dropdown.js_on_event( "menu_item_click", CustomJS(code="console.log('dropdown: ' + this.item, this.toString())")) dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", disabled=True, menu=menu) dropdown_disabled.js_on_click( CustomJS( code="console.log('dropdown(disabled): click ' + this.toString())")) dropdown_disabled.js_on_event( "menu_item_click",
def radio_button_group_handler(active): print("radio_button_group_handler: %s" % active) button = Button(label="Push button", icon=Icon(icon_name="check"), type="primary") button.on_click(button_handler) toggle = Toggle(label="Toggle button", type="success") toggle.on_click(toggle_handler) menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")] dropdown = Dropdown(label="Dropdown button", type="warning", menu=menu) dropdown.on_click(dropdown_handler) menu = [("Item 1", "foo"), ("Item 2", "bar"), None, ("Item 3", "baz")] split = Dropdown(label="Split button", type="danger", menu=menu, default_value="baz") split.on_click(split_handler) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_group.on_click(checkbox_group_handler) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_group.on_click(radio_group_handler)
# Then set the source DF to have different numbers. source.data = source.from_df(data[['date','pft0']]) # pass in dataframe of data created above source_static.data = source.data menu = [x for x in os.listdir(DATA_DIR) if len(x.split("_")) == 3] menu = set([(i.split("_")[0], i.split("_")[0]) for i in menu]) # get rid of duplicates that come from different stages, (i.e. NPP_monthly_eq.nc NPP_monthly_sp.nc) menu = [i for i in menu] # Make sure its a list #menu = [("NPP", "NPP"), ("VEGC", "VEGC"), ("INGPP", "INGPP")] #from IPython import embed; embed() variable_dropdown = Dropdown(label="Choose Variable", button_type="warning", menu=menu, default_value='NPP') #, value="NPP") variable_dropdown.on_change('value', update) # Set up widgets # variable_multiselect = MultiSelect( # title="Choose varibales", # value=['VEGC'], # The keys that are chosen # options=[('NPP','NPP'),('VEGC','VEGC')]) # The key value pairs of what is available. Keys are shown to the user. #stage_checkboxgroup = CheckboxGroup(labels=["pr","eq","sp","tr","sc"], active=[]) # <- Code to determine available stages? #timeres_radiobuttongroup = RadioButtonGroup(labels=["daily", "monthly", "yearly"], active=0) # <- code to determine available time rez? # Setup data: one structure for ALL the data (static), the other for the selected data source = ColumnDataSource(data=dict(date=[], pft0=[]))
def _create_ui_components() -> (Figure, ColumnDataSource): # pylint: disable=too-many-statements global asp_table_source, asp_filter_src, op_table_source, op_filter_src global stats, aspects, tabs, lexicons_dropdown stats = pd.DataFrame(columns=['Quantity', 'Score']) aspects = pd.Series([]) def new_col_data_src(): return ColumnDataSource({'file_contents': [], 'file_name': []}) large_text = HTMLTemplateFormatter(template='''<div><%= value %></div>''') def data_column(title): return TableColumn(field=title, title='<span class="header">' + title + '</span>', formatter=large_text) asp_table_columns = [ data_column('Term'), data_column('Alias1'), data_column('Alias2'), data_column('Alias3') ] op_table_columns = [ data_column('Term'), data_column('Score'), data_column('Polarity') ] asp_table_source = empty_table('Term', 'Alias1', 'Alias2', 'Alias3') asp_filter_src = empty_table('Term', 'Alias1', 'Alias2', 'Alias3') asp_src = new_col_data_src() op_table_source = empty_table('Term', 'Score', 'Polarity', 'Polarity') op_filter_src = empty_table('Term', 'Score', 'Polarity', 'Polarity') op_src = new_col_data_src() asp_table = DataTable(source=asp_table_source, selectable='checkbox', columns=asp_table_columns, editable=True, width=600, height=500) op_table = DataTable(source=op_table_source, selectable='checkbox', columns=op_table_columns, editable=True, width=600, height=500) asp_examples_box = _create_examples_table() op_examples_box = _create_examples_table() asp_layout = layout([[asp_table, asp_examples_box]]) op_layout = layout([[op_table, op_examples_box]]) asp_tab = Panel(child=asp_layout, title="Aspect Lexicon") op_tab = Panel(child=op_layout, title="Opinion Lexicon") tabs = Tabs(tabs=[asp_tab, op_tab], width=700, css_classes=['mytab']) lexicons_menu = [("Open", "open"), ("Save", "save")] lexicons_dropdown = Dropdown(label="Edit Lexicons", button_type="success", menu=lexicons_menu, width=140, height=31, css_classes=['mybutton']) train_menu = [("Parsed Data", "parsed"), ("Raw Data", "raw")] train_dropdown = Dropdown(label="Extract Lexicons", button_type="success", menu=train_menu, width=162, height=31, css_classes=['mybutton']) inference_menu = [("Parsed Data", "parsed"), ("Raw Data", "raw")] inference_dropdown = Dropdown(label="Classify", button_type="success", menu=inference_menu, width=140, height=31, css_classes=['mybutton']) text_status = TextInput(value="Select training data", title="Train Run Status:", css_classes=['statusText']) text_status.visible = False train_src = new_col_data_src() infer_src = new_col_data_src() with open(join(dirname(__file__), "dropdown.js")) as f: args = dict(clicked=lexicons_dropdown, asp_filter=asp_filter_src, op_filter=op_filter_src, asp_src=asp_src, op_src=op_src, tabs=tabs, text_status=text_status, train_src=train_src, infer_src=infer_src, train_clicked=train_dropdown, infer_clicked=inference_dropdown, opinion_lex_generic="") code = f.read() args['train_clicked'] = train_dropdown train_dropdown.js_on_change('value', CustomJS(args=args, code=code)) args['train_clicked'] = inference_dropdown inference_dropdown.js_on_change('value', CustomJS(args=args, code=code)) args['clicked'] = lexicons_dropdown lexicons_dropdown.js_on_change('value', CustomJS(args=args, code=code)) def update_filter_source(table_source, filter_source): df = table_source.to_df() sel_inx = sorted(table_source.selected.indices) df = df.iloc[sel_inx, 1:] new_source = ColumnDataSource(df) filter_source.data = new_source.data def update_examples_box(data, examples_box, old, new): examples_box.source.data = {'Examples': []} unselected = list(set(old) - set(new)) selected = list(set(new) - set(old)) if len(selected) <= 1 and len(unselected) <= 1: examples_box.source.data.update({ 'Examples': [str(data.iloc[unselected[0], i]) for i in range(4, 24)] if len(unselected) != 0 else [str(data.iloc[selected[0], i]) for i in range(4, 24)] }) def asp_selected_change(_, old, new): global asp_filter_src, asp_table_source, aspects_data update_filter_source(asp_table_source, asp_filter_src) update_examples_box(aspects_data, asp_examples_box, old, new) def op_selected_change(_, old, new): global op_filter_src, op_table_source, opinions_data update_filter_source(op_table_source, op_filter_src) update_examples_box(opinions_data, op_examples_box, old, new) def read_csv(file_src, headers=False, index_cols=False, readCSV=True): if readCSV: raw_contents = file_src.data['file_contents'][0] if len(raw_contents.split(",")) == 1: b64_contents = raw_contents else: # remove the prefix that JS adds b64_contents = raw_contents.split(",", 1)[1] file_contents = base64.b64decode(b64_contents) return pd.read_csv(io.BytesIO(file_contents), encoding="ISO-8859-1", keep_default_na=False, na_values={None}, engine='python', index_col=index_cols, header=0 if headers else None) return file_src def read_parsed_files(file_content, file_name): try: # remove the prefix that JS adds b64_contents = file_content.split(",", 1)[1] file_content = base64.b64decode(b64_contents) with open(SENTIMENT_OUT / file_name, 'w') as json_file: data_dict = json.loads(file_content.decode("utf-8")) json.dump(data_dict, json_file) except Exception as e: print(str(e)) # pylint: disable=unused-argument def train_file_callback(attr, old, new): global train_data SENTIMENT_OUT.mkdir(parents=True, exist_ok=True) train = TrainSentiment(parse=True, rerank_model=None) if len(train_src.data['file_contents']) == 1: train_data = read_csv(train_src, index_cols=0) file_name = train_src.data['file_name'][0] raw_data_path = SENTIMENT_OUT / file_name train_data.to_csv(raw_data_path, header=False) print(f'Running_SentimentTraining on data...') train.run(data=raw_data_path) else: f_contents = train_src.data['file_contents'] f_names = train_src.data['file_name'] raw_data_path = SENTIMENT_OUT / train_src.data['file_name'][ 0].split('/')[0] if not os.path.exists(raw_data_path): os.makedirs(raw_data_path) for f_content, f_name in zip(f_contents, f_names): read_parsed_files(f_content, f_name) print(f'Running_SentimentTraining on data...') train.run(parsed_data=raw_data_path) text_status.value = "Lexicon extraction completed" with io.open(AcquireTerms.acquired_aspect_terms_path, "r") as fp: aspect_data_csv = fp.read() file_data = base64.b64encode(str.encode(aspect_data_csv)) file_data = file_data.decode("utf-8") asp_src.data = { 'file_contents': [file_data], 'file_name': ['nameFile.csv'] } out_path = RerankTerms.out_dir / 'generated_opinion_lex_reranked.csv' with io.open(out_path, "r") as fp: opinion_data_csv = fp.read() file_data = base64.b64encode(str.encode(opinion_data_csv)) file_data = file_data.decode("utf-8") op_src.data = { 'file_contents': [file_data], 'file_name': ['nameFile.csv'] } def show_analysis() -> None: global stats, aspects, plot, source, tabs plot, source = _create_plot() events_table = _create_events_table() # pylint: disable=unused-argument def _events_handler(attr, old, new): _update_events(events_table, events_type.active) # Toggle display of in-domain / All aspect mentions events_type = RadioButtonGroup( labels=['All Events', 'In-Domain Events'], active=0) analysis_layout = layout([[plot], [events_table]]) # events_type display toggle disabled # analysis_layout = layout([[plot],[events_type],[events_table]]) analysis_tab = Panel(child=analysis_layout, title="Analysis") tabs.tabs.insert(2, analysis_tab) tabs.active = 2 events_type.on_change('active', _events_handler) source.selected.on_change('indices', _events_handler) # pylint: disable=no-member # pylint: disable=unused-argument def infer_file_callback(attr, old, new): # run inference on input data and current aspect/opinion lexicons in view global infer_data, stats, aspects SENTIMENT_OUT.mkdir(parents=True, exist_ok=True) df_aspect = pd.DataFrame.from_dict(asp_filter_src.data) aspect_col_list = ['Term', 'Alias1', 'Alias2', 'Alias3'] df_aspect = df_aspect[aspect_col_list] df_aspect.to_csv(SENTIMENT_OUT / 'aspects.csv', index=False, na_rep="NaN") df_opinion = pd.DataFrame.from_dict(op_filter_src.data) opinion_col_list = ['Term', 'Score', 'Polarity', 'isAcquired'] df_opinion = df_opinion[opinion_col_list] df_opinion.to_csv(SENTIMENT_OUT / 'opinions.csv', index=False, na_rep="NaN") solution = SentimentSolution() if len(infer_src.data['file_contents']) == 1: infer_data = read_csv(infer_src, index_cols=0) file_name = infer_src.data['file_name'][0] raw_data_path = SENTIMENT_OUT / file_name infer_data.to_csv(raw_data_path, header=False) print(f'Running_SentimentInference on data...') text_status.value = "Running classification on data..." stats = solution.run(data=raw_data_path, aspect_lex=SENTIMENT_OUT / 'aspects.csv', opinion_lex=SENTIMENT_OUT / 'opinions.csv') else: f_contents = infer_src.data['file_contents'] f_names = infer_src.data['file_name'] raw_data_path = SENTIMENT_OUT / infer_src.data['file_name'][ 0].split('/')[0] if not os.path.exists(raw_data_path): os.makedirs(raw_data_path) for f_content, f_name in zip(f_contents, f_names): read_parsed_files(f_content, f_name) print(f'Running_SentimentInference on data...') text_status.value = "Running classification on data..." stats = solution.run(parsed_data=raw_data_path, aspect_lex=SENTIMENT_OUT / 'aspects.csv', opinion_lex=SENTIMENT_OUT / 'opinions.csv') aspects = pd.read_csv(SENTIMENT_OUT / 'aspects.csv', encoding='utf-8')['Term'] text_status.value = "Classification completed" show_analysis() # pylint: disable=unused-argument def asp_file_callback(attr, old, new): global aspects_data, asp_table_source aspects_data = read_csv(asp_src, headers=True) # Replaces None values by empty string aspects_data = aspects_data.fillna('') new_source = ColumnDataSource(aspects_data) asp_table_source.data = new_source.data asp_table_source.selected.indices = list(range(len(aspects_data))) # pylint: disable=unused-argument def op_file_callback(attr, old, new): global opinions_data, op_table_source, lexicons_dropdown, df_opinion_generic df = read_csv(op_src, headers=True) # Replaces None values by empty string df = df.fillna('') # Placeholder for generic opinion lexicons from the given csv file df_opinion_generic = df[df['isAcquired'] == 'N'] # Update the argument value for the callback customJS lexicons_dropdown.js_property_callbacks.get( 'change:value')[0].args['opinion_lex_generic'] \ = df_opinion_generic.to_dict(orient='list') opinions_data = df[df['isAcquired'] == 'Y'] new_source = ColumnDataSource(opinions_data) op_table_source.data = new_source.data op_table_source.selected.indices = list(range(len(opinions_data))) # pylint: disable=unused-argument def txt_status_callback(attr, old, new): print("Previous label: " + old) print("Updated label: " + new) text_status.on_change("value", txt_status_callback) asp_src.on_change('data', asp_file_callback) # pylint: disable=no-member asp_table_source.selected.on_change('indices', asp_selected_change) op_src.on_change('data', op_file_callback) op_table_source.selected.on_change('indices', op_selected_change) # pylint: disable=no-member train_src.on_change('data', train_file_callback) infer_src.on_change('data', infer_file_callback) return layout( [[_create_header(train_dropdown, inference_dropdown, text_status)], [tabs]])
def plotDataset(ds,template='dataset.html',title='Dataset',color=None,*args, **kwargs): ds = ds.copy() ds.data.columns = ds.data.columns.astype(str) # ts = TimeSeries(ds.data) numlines=len(ds.data.columns) if color is None: color = ds.meta[ds.meta.columns[0]] label = color color = colorby(color) # print color # source = ColumnDataSource(data=ds.data) source = ColumnDataSource(dict(xs=[ds.data.index.values]*ds.data.shape[1], ys = [ds.data[name].values for name in ds.data], yslog = [np.log2(ds.data[name].values) for name in ds.data], color=color, label=label)) labelsource = ColumnDataSource(ds.meta) colorsource = ColumnDataSource({k:colorby(ds.meta[k]) for k in ds.meta.columns.tolist()}) # if color is None: # # color = viridis(numlines) # color = colorby(range(numlines)) # else: # # v = viridis(max(color)+1) # # color = [v[c] for c in color] # color = colorby(color) fig = figure(title=title,plot_width=97*8,) # plot = Plot() # fig.line(ds.data.index.values, ds.data, line_width=2) # fig.multi_line(xs=[ds.data.index.values]*ds.data.shape[1], # ys = [ds.data[name].values for name in ds.data], # line_color=color, # line_width=5) fig.multi_line('xs', 'ys', color='color', legend='label', source=source) fig.legend.location = "top_left" # glyph = MultiLine(xs="xs", ys="ys", line_color="", line_width=2) # fig.add_glyph(source, glyph) # plot.add_glyph(source, glyph) callback = CustomJS(args=dict(source=source,colorsource=colorsource,labelsource=labelsource), code=""" var data = source.get('data'); var data2 = colorsource.get('data'); var data3 = labelsource.get('data'); var f = cb_obj.get('value') color = data['color'] color2 = data2[f] label = data['label'] label2 = data3[f] for (i = 0; i < color.length; i++) { color[i] = color2[i] label[i] = label2[i] } source.trigger('change'); """) logcallback = CustomJS(args=dict(source=source), code=""" var data = source.get('data'); data['ys'] = data['yslog'] source.trigger('change'); """) menu = [(c,c) for c in ds.meta.columns] dropdown = Dropdown(label="Color by", button_type="warning", menu=menu, callback=callback) # layout = vform(dropdown, fig) layout = column(dropdown, fig) js_resources = INLINE.render_js() css_resources = INLINE.render_css() # script, div = components(ts) script, div = components(layout) # script, div = components(fig) html = render_template( template, plot_script=script, plot_div=div, js_resources=js_resources, css_resources=css_resources, *args, **kwargs ) return encode_utf8(html)
T1_input = TextInput(value='3.0', title="Input t" u"\u2080 " u"\u2264 t " u"\u2081 " u"\u2264 5:", width=200) Amp_input = TextInput(value='1.0', title="Input -3 " u"\u2264 Amplitude " u"\u2264 3:", width=200) User_Func = TextInput(value=None, title="Input function f(t):", width=200) Resolution = TextInput(value='60', title="Input resolution:", width=200) sample_fun_input_f = Dropdown(label="Choose a sample function f(t)", menu=sample_f_names, width=200) Wavelet_fun_input = Dropdown(label="Choose a wavelet function " u"\u03A8 (t)", menu=sample_Wavelet_names, width=200) a_param = Slider(title="Scaling parameter 'a'", value=1.0, start=0.5, end=5.0, step=0.1, width=200) b_param = Slider(title="Shifting parameter 'b'", value=0.0, start=-10.0, end=10.0,
title="ROI Prefix", width=int(total_width / 4), height=50) accept_ROI_button = Button(label="Accept ROI Inputs", width=int(total_width / 4), height=32, margin=[23, 0, 0, 0]) accept_ROI_button.on_click(accept_ROI_path_and_prefix) # initiate ROI figure stiff ROI_fig = figure(tools=TOOLS, width=int(total_width / 2), height=550) drop_menu = [("dim1", '0'), ("dim2", '1'), ("dim3", '2')] choose_dim = Dropdown(label="choose dimension to slide", menu=drop_menu, value='0', width=int(total_width / 2), height=50) slider = Slider(start=0, end=100, step=1, value=40, width=int(total_width / 2), height=50) def remove_brain(old_brain): for glyph in old_brain: ROI_fig.renderers.remove(glyph)
def modify_doc(doc): # Bokeh renderers that hold current viz as its state hvplot = renderer.get_plot(dmap, doc) timeseriesPlot = renderer.get_plot(dmap_time_series, doc) def animate_update(): year = slider.value + 1 if year > end: year = start slider.value = year callback_id = None def animate(): global callback_id if button.label == '► Play': button.label = '❚❚ Pause' callback_id = doc.add_periodic_callback(animate_update, 75) else: button.label = '► Play' doc.remove_periodic_callback(callback_id) def slider_update(attrname, old, new): # Notify the HoloViews stream of the slider update year = 2000 + (new // 12) month = (new % 12) + 1 stream.event(time_step=cftime.DatetimeNoLeap(year,month,1)) slider.title = "{}-{}".format(year,month) def variable_update(event): global path, fram_data, curr_var, min_range, max_range, control_path, control_data, global_data, global_path, gv_geo_plot, curr_dataset, curr_intervention, DATA_DICT path = './iceClinic/data/f09_g16.B.cobalt.FRAM.MAY.{}.200005-208106.nc'.format(event.item) control_path = './iceClinic/data/f09_g16.B.cobalt.CONTROL.MAY.{}.200005-208106.nc'.format(event.item) global_path = './iceClinic/data/f09_g16.B.cobalt.GLOBAL.MAY.{}.200005-208106.nc'.format(event.item) curr_var = event.item fram_data = xr.open_dataset(path) control_data = xr.open_dataset(control_path) global_data = xr.open_dataset(global_path) DATA_DICT = {'CONTROL': control_data, 'FRAM' : fram_data, 'GLOBAL' : global_data} curr_dataset = DATA_DICT[curr_intervention] dataset = gv.Dataset(curr_dataset) stateBasemap = gv.Feature(feature.STATES) gv_geo_plot = dataset.to(gv.Image, ['lon', 'lat'], curr_var, dynamic=True).opts(title = '{} Intervention, {} data'.format(curr_intervention, curr_var), cmap=CMAP_DICT[curr_var], colorbar=True, backend='bokeh', projection = crs.PlateCarree()) *gf.coastline() * gf.borders() * stateBasemap.opts(fill_alpha=0,line_width=0.5) #control_min_range, control_max_range = getMinMax(control_data, curr_var) #print(control_min_range, control_max_range) fram_min_range, fram_max_range = getMinMax(fram_data, curr_var) global_min_range, global_max_range = getMinMax(global_data, curr_var) min_range = min(fram_min_range, global_min_range) max_range = max(fram_max_range,global_max_range) gv_geo_plot = gv_geo_plot.redim(**{curr_var:hv.Dimension(curr_var, range=(min_range, max_range))}) var_stream.event(var=event.item) def lat_update(attr, old, new): if int(new) in range(-90,90): lat_stream.event(lat=int(new)) def lon_update(attr, old, new): if int(new) in range(-180,180): new_lon = int(new) + 180 lon_stream.event(lon=new_lon) def intervention_update(event): global curr_var, DATA_DICT, control_data, curr_intervention, gv_geo_plot, min_range, max_range curr_intervention = event.item curr_ds = DATA_DICT[event.item] dataset = gv.Dataset(curr_ds) gv_geo_plot = dataset.to(gv.Image, ['lon', 'lat'], curr_var, dynamic=True).opts(title = '{} Intervention, {} data'.format(curr_intervention, curr_var), cmap=CMAP_DICT[curr_var], colorbar=True, backend='bokeh', projection = crs.PlateCarree()) *gf.coastline() * gf.borders() * stateBasemap.opts(fill_alpha=0,line_width=0.5) gv_geo_plot = gv_geo_plot.redim(**{curr_var:hv.Dimension(curr_var, range=(min_range, max_range))}) intervention_stream.event(intervention=event.item) #Time_slider #Note: It starts as 5 because the datasets start in June 2000, the fifth month with zero indexing start, end = 5, 900 slider = Slider(start=start, end=end, value=start, step=1, title="Date", show_value=False) slider.on_change('value', slider_update) #Variable Dropdown menu = [("Temperature", "TS"), ("Precipitation", "PRECT"), ("Fire Weather", "FWI"), ("Precipitation Index", "SPI")] dropdown = Dropdown(label="Select Variable", button_type="primary", menu=menu) dropdown.on_click(variable_update) #Intervention Dropdown intervention_menu = [("Control", "CONTROL"), ("Fram", "FRAM"), ("Global", "GLOBAL")] intervention_dropdown = Dropdown(label="Select Intervention Type", button_type="primary", menu=intervention_menu) intervention_dropdown.on_click(intervention_update) #Lat Text Input lat_input = TextInput(value="45", title="Latitude:") lat_input.on_change("value", lat_update) #Lon Text Input lon_input = TextInput(value="122", title="Longitude:") lon_input.on_change("value", lon_update) #Slider Play Button button = Button(label='► Play', width=60) button.on_click(animate) #Code to generate the layout lat_lon_text = Div(text="<b>Note:</b> Latitude ranges from -90 to 90 and longitude from -180 to 180") spacer = Div(height=200) logo = figure(x_range=(0, 10), y_range=(0, 10), plot_width=300, plot_height=300) logo.image_url( url=['./iceClinic/static/logo.png'], x=0, y=0, w=10, h=10, anchor="bottom_left") logo.toolbar.logo, logo.toolbar_location = None, None logo.xaxis.visible, logo.yaxis.visible = None, None logo.xgrid.grid_line_color, logo.ygrid.grid_line_color = None, None # Combine the holoviews plot and widgets in a layout logo = row(logo, align='center') options_row = row(slider, button, align='center') left_plot_row= row(hvplot.state, align='center') left_column = column(left_plot_row, options_row, dropdown, intervention_dropdown, sizing_mode='stretch_width', align='center') coords_row = row(lat_input, lon_input, align='center') right_plot_row = row(timeseriesPlot.state, align='center') right_column = column(right_plot_row, coords_row, lat_lon_text) graphs = row(left_column, right_column, sizing_mode="stretch_width", align='center') plot = column(logo, graphs, spacer, sizing_mode='stretch_width', align='center') curdoc().add_root(plot)
CustomJS( code="console.log('toggle_inactive: ' + this.active, this.toString())") ) toggle_active = Toggle(label="Toggle button (initially active)", button_type="success", active=True) toggle_active.on_click(lambda value: print('toggle_active: %s' % value)) toggle_active.js_on_click( CustomJS( code="console.log('toggle_active: ' + this.active, this.toString())")) menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")] dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu) dropdown.on_click(lambda value: print('dropdown: %s' % value)) dropdown.js_on_click( CustomJS(code="console.log('dropdown: ' + this.value, this.toString())")) dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", menu=menu) dropdown_disabled.on_click( lambda value: print('dropdown_disabled: %s' % value)) dropdown_disabled.js_on_click( CustomJS( code="console.log('dropdown_disabled: ' + this.value, this.toString())" )) #dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default")
plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6) # Set up widgets text = TextInput(title="Custom function", value='Enter f(x)') offset = Slider(title="offset", value=0.0, start=-5.0, end=5.0, step=0.1) amplitude = Slider(title="amplitude", value=1.0, start=-3.0, end=3.0, step=0.01) Speed = Slider(title="Speed", value=100, start=100, end=250) Delay = Slider(title="Delay", value=1, start=1, end=100) CurveList = [("Sin", "C1"), ("Poly", "C2"), ("Abs", "C3"), ("Custom", "C4")] dropdown = Dropdown(label="Curve Lists", button_type="warning", menu=CurveList) button = Button(label="Run ", button_type="success") button1 = Button(label="Stop ", button_type="success") # Set up callbacks def update_title(attrname, old, new): plot.title.text = text.value x = np.linspace(-4 * np.pi, 4 * np.pi, N) text.on_change('value', update_title) div = Div(width=1000)
lg_id_message = Div( text='<b><p style="color: green;">League accessed successfully.</p></b>') september_month = 9 today = datetime.today() if today.month < september_month: default_yr = str(today.year - 1) else: default_yr = str(today.year) league_obj, num_teams, week_num, owners, owners_list, team_objs, weeks, owner_to_idx = retrieve_lg_info( int(lg_id_input.value), default_yr) team1_dd = Dropdown(label='Team 1 - Select', menu=owners_list) team2_dd = Dropdown(label='Team 2 - Select', menu=owners_list) comp_button = Button(label='Compare', button_type='danger') week_slider = RangeSlider(title='Weeks', start=1, end=week_num, value=(1, week_num), step=1) year_input = TextInput(value=str(default_yr), title='Season:') plot1 = initialize_sc_figure(league_obj, week_num) plot2 = initialize_ew_figure(league_obj, week_num) plot1_wrap = column(children=[plot1]) plot2_wrap = column(children=[plot2])
#%% from bokeh.io import output_notebook, show from bokeh.models.widgets import Dropdown output_notebook() menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")] dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu) show(dropdown)
''' import numpy as np import pandas as pd from bokeh.io import curdoc from bokeh.layouts import row, column, widgetbox, gridplot from bokeh.models import ColumnDataSource, Legend from bokeh.models.widgets import Slider, TextInput, Button, Dropdown, CheckboxButtonGroup, RadioButtonGroup from bokeh.plotting import figure # Set up widgets #menu_T = [('160', "TStamp 160"), ('180', "TStamp 180"), ('200', "TStamp 200")] t_stampList = range(30, 1320, 10) menu_T = [(str(t), "TStamp " + str(t)) for t in t_stampList] menu_C = [('1.0', "Class 1"), ('-1.0', "Class -1")] dropdown1 = Dropdown(label="Select Time Stamp", button_type="success", menu=menu_T) dropdown2 = Dropdown(label="Select Class", button_type="primary", menu=menu_C) dropdown3 = Dropdown(label="Select Time Stamp", button_type="success", menu=menu_T) dropdown4 = Dropdown(label="Select Class", button_type="primary", menu=menu_C) dropdown5 = Dropdown(label="Select Time Stamp", button_type="success", menu=menu_T) dropdown6 = Dropdown(label="Select Class", button_type="primary", menu=menu_C) class_1 = '1.0' class_2 = '1.0' class_3 = '-1.0' t_stamp1 = '160' t_stamp2 = '200'
#Step 2: Make the columns columns = [ TableColumn(field="criteria", title=""), TableColumn(field="land", title="Land Area (ha)"), TableColumn(field="Nuse", title="N use (kg)"), TableColumn(field="prod", title="Production (kg)"), ] data_table = DataTable(source=source, columns=columns, width=500) #Button to change crop menu_crop = [("Sorghum", "sorghum"), ("Maize", "maize"), ("Cassava", "cassava"), ("Groundnuts", "groundnuts"), ("Sesame", "sesame")] dd_crop = Dropdown(label="Crop", button_type="primary", menu=menu_crop, value='maize') dd_crop.on_change('value', update) #Make another div for crop cc1/cc2 criteria if (dffilt['cc1'] > 0).any(): cc1_crop = 'Myopic elasticity calibration criteria met' else: cc1_crop = 'Myopic elasticity calibration criteria not met' if (dffilt['cc2'] < 0).any(): cc2_crop = 'No dominant response criteria met' else: cc2_crop = 'No dominant response criteria not met' div2 = Div(text='<p> Maize </p><p>' + cc1_crop + '</p><p>' + cc2_crop +