def __init__(self, features=None, labels=None, options=(), classifier=None, display_func=None, eval_method=None, reorder=None, shuffle_prop=0.1, hints=None, keyboard_shortcuts=False, *args, **kwargs): """ A class for labelling your data. This class is designed to label data for (semi-)supervised learning algorithms. It allows you to label data, periodically re-train your algorithm and assess its performance, and determine which data points to label next based on your model's predictions. """ super().__init__(features=features, labels=labels, display_func=display_func, options=options, keyboard_shortcuts=keyboard_shortcuts, hints=hints, *args, **kwargs) self.queue = SimpleLabellingQueue(features, labels) self.shuffle_prop = shuffle_prop self.classifier = validation.valid_classifier(classifier) if self.classifier is not None: self.retrain_button = widgets.Button( description="Retrain", disabled=False, button_style="", tooltip="Click me", icon="refresh", ) self.retrain_button.on_click(self.retrain) self.model_performance = widgets.HTML(value="") self.top_bar.children = ( widgets.HBox( [*self.top_bar.children], layout=widgets.Layout(width="50%"), ), widgets.HBox( [self.retrain_button, self.model_performance], layout=widgets.Layout(width="50%"), ), ) if eval_method is None: self.eval_method = partial( sklearn.model_selection.cross_validate, cv=3, # n_jobs=-1, return_train_score=False, ) elif not callable(eval_method): raise ValueError("The eval_method needs to be a callable.") else: self.eval_method = eval_method if reorder is not None and isinstance(reorder, str): if reorder not in prioritisation.functions: raise NotImplementedError( "Unknown reordering function '{}'.".format(reorder)) self.reorder = prioritisation.functions[reorder] elif reorder is not None and callable(reorder): self.reorder = reorder elif reorder is None: self.reorder = None else: raise ValueError( "The reorder argument needs to be either a function or the " "name of a function listed in superintendent.prioritisation.") self._annotation_loop = self._annotation_iterator() next(self._annotation_loop) self._compose()
def makeWidgets(): studyList = [ 'ACC', 'BLCA', 'BRCA', 'CESC', 'CHOL', 'COAD', 'DLBC', 'ESCA', 'GBM', 'HNSC', 'KICH', 'KIRC', 'KIRP', 'LAML', 'LGG', 'LIHC', 'LUAD', 'LUSC', 'MESO', 'OV', 'PAAD', 'PCPG', 'PRAD', 'READ', 'SARC', 'SKCM', 'STAD', 'TGCT', 'THCA', 'THYM', 'UCEC', 'UCS', 'UVM' ] study = widgets.Dropdown(options=studyList, value='UCEC', description='', disabled=False) FeatureList1 = [ 'Gene Expression', 'Somatic Copy Number', 'MicroRNA Expression', 'Clinical Numeric' ] #FeatureList2 = [ 'Gene Expression', 'Somatic Mutation Spearman','Somatic Mutation t-test', 'Somatic Copy Number', 'Clinical Numeric', 'Clinical Categorical', 'MicroRNA Expression'] ; FeatureList2 = [ 'Gene Expression', 'Somatic Mutation', 'Somatic Copy Number', 'Clinical Numeric', 'MicroRNA Expression' ] feature1 = widgets.Dropdown(options=FeatureList1, value='Gene Expression', description='', disabled=False) gene_names = widgets.Text(value='IGF2, ADAM6', placeholder='Type gene names ', description='', disabled=False) feature2 = widgets.Dropdown(options=FeatureList2, value='Gene Expression', description='', disabled=False) significance = widgets.SelectionSlider( options=['0.05', '0.01', '0.005', '0.001'], value='0.01', description='', disabled=False, continuous_update=False, orientation='horizontal', readout=True) size = widgets.IntSlider(value=25, min=5, max=50, description='') # the n most variable genes cohortlist = widgets.FileUpload( accept= '', # Accepted file extension e.g. '.txt', '.pdf', 'image/*', 'image/*,.pdf' multiple=False # True to accept multiple files upload else False ) feature1_title = widgets.HTML('<em>Select Feature1 </em>') display(widgets.HBox([feature1_title, feature1])) genes_title = widgets.HTML('<em>Feature1 labels </em>') display(widgets.HBox([genes_title, gene_names])) feature2_title = widgets.HTML('<em>Select Feature2 </em>') display(widgets.HBox([feature2_title, feature2])) study_title = widgets.HTML('<em>Select a study </em>') display(widgets.HBox([study_title, study])) significance_title = widgets.HTML('<em>Significance level </em>') display(widgets.HBox([significance_title, significance])) size_title = widgets.HTML('<em>Minimum number of samples</em>') display(widgets.HBox([size_title, size])) cohort_title = widgets.HTML('<em>Cohort list</em>') display(widgets.HBox([cohort_title, cohortlist])) return ([ study, feature1, feature2, gene_names, size, cohortlist, significance ])
def __init__(self, datasource): self._datasource = datasource self._info = None if isinstance(self._datasource, connections.EventCollection): self._info = self._datasource.getInfo() components = [] self._filter = widgets.Text(description="Filter", layout=widgets.Layout(width="50%")) b = widgets.Button(description="Set", layout=widgets.Layout(width="50px")) b.on_click(self.filter) self._buttons = None if isinstance(self._datasource, connections.EventCollection): iconLayout = widgets.Layout(width="40px") self._nextButton = widgets.Button(icon="fa-step-forward", layout=iconLayout) self._prevButton = widgets.Button(icon="fa-step-backward", layout=iconLayout) self._firstButton = widgets.Button(icon="fa-backward", layout=iconLayout) self._lastButton = widgets.Button(icon="fa-forward", layout=iconLayout) self._playPauseButton = widgets.Button( icon="fa-pause", layout=widgets.Layout(width="40px", margin="0px 0px 0px 20px")) if self._datasource._paused: self._playPauseButton.icon = "fa-play" self._nextButton.on_click(self.next) self._prevButton.on_click(self.prev) self._firstButton.on_click(self.first) self._lastButton.on_click(self.last) self._playPauseButton.on_click(self.playPause) #self._buttons = widgets.HBox([self._nextButton,self._prevButton,self._firstButton,self._lastButton],layout=widgets.Layout(width="200px")) self._buttons = widgets.HBox([ self._nextButton, self._prevButton, self._firstButton, self._lastButton, self._playPauseButton ], layout=widgets.Layout(width="300px")) if self._datasource._pages == 1: self._buttons.layout.display = "none" else: self._buttons.layout.display = "block" components.append(self._buttons) w = "80%" justify = "flex-end" if self._info == None or self._datasource._pages == 1: w = "100%" justify = "center" self._filterBox = widgets.HBox([self._filter, b], layout=widgets.Layout( width=w, justify_content=justify)) components.append(self._filterBox) #self._panel = widgets.HBox(components,layout=widgets.Layout(width="100%",border="1px solid #d8d8d8")) self._panel = widgets.HBox(components, layout=widgets.Layout(width="100%")) self._filter.value = self._datasource.getFilter()
def __init__(self): # dropdown menu for setting asset self.asset = ipywidgets.Dropdown( options=['atlas-local', 'atlas-s3', 'nsidc-s3'], value='atlas-s3', description='Asset:', disabled=False, ) # dropdown menu for setting data release self.release = ipywidgets.Dropdown( options=['003', '004'], value='004', description='Release:', disabled=False, ) # dropdown menu for setting surface type # 0-land, 1-ocean, 2-sea ice, 3-land ice, 4-inland water surface_type_options = [ 'Land', 'Ocean', 'Sea ice', 'Land ice', 'Inland water' ] self.surface_type = ipywidgets.Dropdown( options=surface_type_options, value='Land', description='Surface Type:', disabled=False, ) # slider for setting length of ATL06-SR segment in meters self.length = ipywidgets.IntSlider(value=40, min=5, max=200, step=5, description='Length:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') # slider for setting step distance for successive segments in meters self.step = ipywidgets.IntSlider(value=20, min=5, max=200, step=5, description='Step:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') # slider for setting confidence level for PE selection # eventually would be good to switch this to a IntRangeSlider with value=[0,4] self.confidence = ipywidgets.IntSlider(value=4, min=0, max=4, step=1, description='Confidence:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') # selection for land surface classifications land_options = [ 'atl08_noise', 'atl08_ground', 'atl08_canopy', 'atl08_top_of_canopy', 'atl08_unclassified' ] self.land_class = ipywidgets.SelectMultiple(options=land_options, description='Land Class:', disabled=False) # slider for setting maximum number of iterations # (not including initial least-squares-fit selection) self.iteration = ipywidgets.IntSlider(value=1, min=0, max=20, step=1, description='Iterations:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') # slider for setting minimum along track spread self.spread = ipywidgets.FloatSlider(value=20, min=1, max=100, step=0.1, description='Spread:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='0.1f') # slider for setting minimum photon event (PE) count self.count = ipywidgets.IntSlider(value=10, min=1, max=50, step=1, description='PE Count:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d') # slider for setting minimum height of PE window in meters self.window = ipywidgets.FloatSlider(value=3, min=0.5, max=10, step=0.1, description='Window:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='0.1f') # slider for setting maximum robust dispersion in meters self.sigma = ipywidgets.FloatSlider(value=5, min=1, max=10, step=0.1, description='Sigma:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='0.1f') # dropdown menu for setting map projection for polygons # Global: Web Mercator (EPSG:3857) # North: Alaska Polar Stereographic (EPSG:5936) # South: Polar Stereographic South (EPSG:3031) projection_list = ['Global', 'North', 'South'] self.projection = ipywidgets.Dropdown( options=projection_list, value='Global', description='Projection:', disabled=False, ) # button and label for output file selection self.file = copy.copy(self.filename) self.savebutton = ipywidgets.Button(description="Save As") self.savelabel = ipywidgets.Text(value=self.file, disabled=False) # connect fileselect button with action self.savebutton.on_click(self.saveas_file) self.savelabel.observe(self.set_savefile) # create hbox of file selection self.filesaver = ipywidgets.HBox([self.savebutton, self.savelabel]) # button and label for input file selection self.loadbutton = ipywidgets.Button(description="File select") self.loadlabel = ipywidgets.Text(value='', disabled=False) # connect fileselect button with action self.loadbutton.on_click(self.select_file) self.loadlabel.observe(self.set_loadfile) # create hbox of file selection self.fileloader = ipywidgets.HBox([self.loadbutton, self.loadlabel])
disabled=False) w_exportname = widgets.Text(value='users/<username>/<path>', placeholder=' ', disabled=False) w_location = widgets.Text(value='Jülich', placeholder=' ', description='', disabled=False) w_goto = widgets.Button(description="GoTo", disabled=False) w_collect = widgets.Button(description="Collect", disabled=True) w_preview = widgets.Button(description="Preview", disabled=True) w_export = widgets.Button(description='Export to assets', disabled=True) w_dates1 = widgets.VBox([w_startdate1, w_enddate1, w_iterations]) w_dates2 = widgets.VBox([w_startdate2, w_enddate2, w_scale]) w_dates = widgets.HBox([w_platform, w_dates1, w_dates2]) w_exp = widgets.HBox([w_export, w_exportname]) w_go = widgets.HBox([w_collect, w_preview, w_exp]) w_txt = widgets.HBox([w_text, w_goto, w_location]) box = widgets.VBox([w_txt, w_dates, w_go]) def on_widget_change(b): w_preview.disabled = True w_export.disabled = True w_platform.observe(on_widget_change, names='value') w_startdate1.observe(on_widget_change, names='value') w_enddate1.observe(on_widget_change, names='value') w_startdate2.observe(on_widget_change, names='value')
def __init__(self): with open('popular_virus_names.json', 'r') as f: popular_viruses_keys = json.load(f) self._virus_dropdown = self._create_indicator_dropdown( popular_viruses_keys, 0) self._plot_container = widgets.Output() _app_container = widgets.VBox([ widgets.HBox([self._virus_dropdown]), self._plot_container, ], layout=widgets.Layout( align_items='center', flex='3 0 auto')) self.container = widgets.VBox([ widgets.HTML(('<h1>Development indicators</h1>' '<h1> </h1>' '<h3>Select virus of interest</h3>'), layout=widgets.Layout(margin='0 0 2em 0')), widgets.HBox([ _app_container, ]) ], layout=widgets.Layout( flex='1 1 auto', margin='0 auto 0 auto', max_width='1024px')) # Loading and preprocessing data. n_viruses = 5 n_entries = 10 # n_viruses = 87 # n_entries = 100 viruses_full = load_viruses() patients_identity_full, patients_entries_full = load_patients() self.viruses = { k: viruses_full[k] for k in popular_viruses_keys[:n_viruses] } random_idx = np.arange(patients_entries_full.shape[0]) np.random.shuffle(random_idx) random_idx = random_idx[:n_entries] patients_entries = patients_entries_full[random_idx] self.patients_identity = patients_identity_full[random_idx] aligner = Align.PairwiseAligner() aligner.open_gap_score = -1 aligner.extend_gap_score = -1 aligner.target_end_gap_score = 0.0 aligner.query_end_gap_score = 0.0 def comp_al_score(patients_vdna): patients_entries, virus_dna = patients_vdna return compute_virus_alignment_score(patients_entries, virus_dna, aligner) tuples_to_process = [(patients_entries, v_dna) for v_dna in self.viruses.values()] # with Pool(8) as p: # alignements_scors_list = p.map( # comp_al_score, # tuples_to_process # ) alignements_scors_list = list( map(lambda x: comp_al_score(x), tuples_to_process)) self.result = np.array(alignements_scors_list).T patients_results = dict() for patient_id, entry in zip(self.patients_identity, self.result): if patient_id not in patients_results: patients_results[patient_id] = [] else: patients_results[patient_id] += [entry] for k in patients_results.keys(): patients_results[k] = np.array(patients_results[k]) patients_means_per_virus = dict() for k in patients_results.keys(): patients_means_per_virus[k] = np.median(patients_results[k], axis=0)
def __init__(self, m_desc, FuseEdges=False, pick_start=False, max_width=10.0, accept_color='chartreuse3', reject_color='red', neutral_color='dodgerblue2'): # Options self.color_accept = accept_color self.color_reject = reject_color self.color_neutral = neutral_color self.max_width = max_width self.fuse = FuseEdges # DFA specific option self.valid_input = True self.machine = m_desc self.machine_obj = dotObj_nfa(self.machine, FuseEdges=FuseEdges) self.copy_source = reformat_edge_labels(set_graph_size(self.machine_obj.source, max_width), additional=' color=black arrowsize=1 penwidth=1') # Set things we need for the animation self.machine_steps = [] self.feed_steps = [] self.from_nodes = self.machine['Q0'] self.to_nodes = self.machine['Q0'] self.animated = False # Setup the widgets # Top row for user input self.user_input = widgets.Text(value='', placeholder='Sigma: {{{}}}'.format(','.join(sorted(self.machine['Sigma']))), description='Input:', layout=Layout(width='500px') ) self.user_input.observe(self.on_input_change, names='value') self.alternate_start = widgets.SelectMultiple(options=sorted(self.machine['Q']), value=tuple(self.machine['Q0']), rows=5, description='Start States:', disabled=False, layout=Layout(width='200px') ) self.generate_button = widgets.Button(description="Animate", button_style='primary', disabled=False ) self.generate_button.on_click(self.generate_animation) # Bottom row for player controls self.play_controls = widgets.Play(interval=950, value=0, min=0, max=100, step=1, description="Press play" ) self.play_controls.observe(self.on_play_step, names='value') self.speed_control = widgets.IntSlider(value=1, min=1, max=10, step=1, description='Speed:', disabled=False, continuous_update=False, orientation='horizontal', readout=True, readout_format='d' ) self.speed_control.observe(self.on_speed_change, names='value') # Create the controls for stepping through the animation self.backward = widgets.Button(icon='step-backward', layout=Layout(width='40px'), disabled=True ) self.forward = widgets.Button(icon='step-forward', layout=Layout(width='40px'), disabled=True ) self.backward.on_click(self.on_backward_click) self.forward.on_click(self.on_forward_click) # set the widget to display the machine self.machine_display = widgets.Output() with self.machine_display: display(Source(self.copy_source)) # set the widget to display the feed self.feed_display = widgets.Output() # arrange the widgets in the display area row1 = widgets.HBox([self.user_input, self.generate_button]) if pick_start: row1 = widgets.HBox([self.user_input, self.alternate_start, self.generate_button]) row2 = widgets.HBox([self.play_controls, self.backward, self.forward, self.speed_control]) w = widgets.VBox([row1, self.machine_display, self.feed_display, row2]) display(w) self.play_controls.disabled = True self.forward.disabled = True self.backward.disabled = True self.speed_control.disabled = True
value='id_text', description='Sort By: ') out = widgets.Output() def submit_search(change): # "linking function with output" with out: # what happens when we press the button clear_output() display(search(text.value)) # when maxhits is set larger than 250, default becomes no links def update_maxhits(change): links.value = maxhits.value < 250 submit_search(change) # linking button and function together using a button's method button.on_click(submit_search) text.on_submit(submit_search) sortby.observe(submit_search, 'value') maxhits.observe(update_maxhits, 'value') #links.observe(submit_search, 'value') # displaying button and its output together col1 = widgets.VBox([text, links, button]) col2 = widgets.VBox([maxhits, sortby]) box = widgets.HBox([col1, col2]) disp = widgets.VBox([box, out])
def cloud_hunt(ctx=None): """ Displays a UI to build LQL queries to do threat hunting. """ global lw_ctx # To be able to pass the grid to widget functions. tables = utils.load_yaml_file("tables.yaml") table_filters = utils.load_yaml_file("filters.yaml") options = [DEFAULT_TABLE_PICK] options.extend([x.get("display_name") for x in tables]) options.append(DEFAULT_CUSTOM_PICK) table_list = ipywidgets.Dropdown(options=options, value=DEFAULT_TABLE_PICK, description="", disabled=False) table_list.observe(_generate_table_filters) table_box = ipywidgets.HBox() table_box.children = (ipywidgets.Label("Pick a table: "), table_list) verify_button = ipywidgets.Button( value=False, description="Verify Query", disabled=False, tooltip="Build the LQL query and verify it", icon="check") verify_button.on_click(_verify_button) execute_button = ipywidgets.Button( value=False, description="Execute Query", button_style="success", disabled=False, tooltip="Build the LQL query and execute it") execute_button.on_click(_execute_button) box_layout = ipywidgets.Layout(display="flex", flex_flow="column", align_items="stretch", width="1000px") title = ipywidgets.HTML( value=("<div align=\"center\"><h1>Cloud Hunting</h1><i>Assistant to " "build LQL queries to perform threat hunting within your " "environment.</i><br/><br/></div>")) start_time, end_time = utils.get_start_and_end_time(ctx) start_widget = ipywidgets.Text(value=start_time, placeholder="YYYY-MM-DDTHH:MM:SSZ", description="", disabled=False) end_widget = ipywidgets.Text(value=end_time, placeholder="YYYY-MM-DDTHH:MM:SSZ", description="", disabled=False) filter_box = ipywidgets.VBox() result_label = ipywidgets.HTML() grid = ipywidgets.Box(children=[ title, table_box, ipywidgets.HBox(children=[ ipywidgets.Label("Start Time:"), start_widget, ipywidgets.Label("End Time:"), end_widget ]), filter_box, ipywidgets.HBox(children=(verify_button, execute_button)), result_label, ], layout=box_layout) ctx.add_state("query_builder", "query_table_box", table_box) ctx.add_state("query_builder", "query_start_widget", start_widget) ctx.add_state("query_builder", "query_end_widget", end_widget) ctx.add_state("query_builder", "query_filter_box", filter_box) ctx.add_state("query_builder", "query_label", result_label) ctx.add_state("query_builder", "query_tables", tables) ctx.add_state("query_builder", "query_filters", table_filters) lw_ctx = ctx query_builder.lw_ctx = ctx display(grid) # noqa: F821
def __init__(self, n_channels=2, *args, **kwargs): """Parameters ---------- n_channels Number of channels present on the images *args, **kwargs Passed to superclass constructor """ fig, ax = plt.subplots() self.image_display = ImageDisplay(ax) # Create boxes for entering ROI dimensions dt_children = [] self._mpl_rois = [] for i in range(n_channels): color = self.colors[i] alpha = 0.3 c = _ExtentsInput(color, alpha) c.observe(self._roi_extents_changed, "extents") dt_children.append(c) r = mpl.widgets.RectangleSelector(self.image_display.ax, self._roi_drawn, interactive=True, rectprops={ "facecolor": color, "alpha": alpha }, useblit=True) r.active = False self._mpl_rois.append(r) self._dimension_tabs = ipywidgets.Tab(dt_children) self._dimension_tabs.observe(self._active_channel_changed, "selected_index") # Checkbox to force same size on all channels self._same_size_box = ipywidgets.Checkbox(description="Same size", value=True) traitlets.link((self, "same_size"), (self._same_size_box, "value")) # Buttons for splitting horizontally and vertically self._split_hor_button = ipywidgets.Button( description="split horizontally") self._split_hor_button.on_click(self._split_hor) self._split_ver_button = ipywidgets.Button( description="split vertically") self._split_ver_button.on_click(self._split_ver) # Button for swapping channels (i.e., reversing their order) self._swap_button = ipywidgets.Button(description="swap channels") self._swap_button.on_click(self._swap_chan) super().__init__([ self._dimension_tabs, ipywidgets.HBox([ self._split_hor_button, self._split_ver_button, self._swap_button, self._same_size_box ]), self.image_display ]) self._n_channels = n_channels self.channel_names = [ "channel {}".format(i) for i in range(n_channels) ] self._update_extents_lock = threading.Lock() self._update_rois_lock = threading.Lock() self._active_channel_changed()
def label_images(path_to_images, path_to_annotations): ''' Provides user-interactive environment for labeling smiles and open mouth on images. Images have to be pre-processed with process_folder() function. Parameters ---------- path_to_images : str Path to folder with images to label. path_to_annotations : str Path to annotaions csv file. ''' # Create ImageList() object imgs = ImageList(path_to_images, path_to_annotations) # Get initial state for buttons labels = imgs.get_labels() # Create image and buttons widgets image_frame = widgets.Image(value=imgs.get_image(), width=400, height=400) title = widgets.Label(value=imgs.filename()) button_next = widgets.Button(description='', tooltip='Next image', icon='forward') button_prev = widgets.Button(description='', tooltip='Previous image', icon='backward') button_save = widgets.Button(description='', tooltip='Save changes', icon='save') button_del = widgets.Button(description='', tooltip='Delete image', icon='trash') button_smile = widgets.ToggleButton(value=bool(labels['smile']), description='Smile', tooltip='Label smile', icon='smile-o') button_mouth_open = widgets.ToggleButton(value=bool(labels['mouth_open']), description='Mouth open', tooltip='Label mouth open', icon='circle-o') # Distribute buttons in table column_1 = widgets.VBox([button_prev, widgets.Label()]) column_2 = widgets.VBox([button_smile, button_save]) column_3 = widgets.VBox([button_mouth_open, button_del]) column_4 = widgets.VBox([button_next, widgets.Label()]) buttons = widgets.HBox([column_1, column_2, column_3, column_4]) def change_image(action): # Save current labels imgs.set_labels((button_smile.value, button_mouth_open.value)) # Change current image image_frame.value = action() # Read labels labels = imgs.get_labels() button_smile.value, button_mouth_open.value = bool( labels['smile']), bool(labels['mouth_open']) # Add filename title.value = imgs.filename() # Configure on_click events button_next.on_click(lambda x: change_image(imgs.forward)) button_prev.on_click(lambda x: change_image(imgs.backward)) button_del.on_click(lambda x: change_image(imgs.delete)) button_save.on_click(lambda x: imgs.set_labels( (button_smile.value, button_mouth_open.value))) # Display widgets display(buttons) display(image_frame) display(title)
def _run(self, workers, progress): self.TStart = time.time() pool = None if workers > 0: pool = multiprocessing.Pool(processes=workers) pbar = None if progress: from IPython.display import display import ipywidgets lbl = ipywidgets.Label(self._dataset, layout=ipywidgets.Layout(width="70%")) info = ipywidgets.Label("- kevt/s", layout=ipywidgets.Layout( width="10%", display='flex', justify_content='flex-end')) pbar = ipywidgets.IntProgress( min=0, max=len(self._filelist), layout=ipywidgets.Layout(width="17%")) cancel = ipywidgets.Button(tooltip='Abort processing', icon='times', button_style='danger', layout=ipywidgets.Layout(width="3%")) def abort(b): if pool is not None: pool.terminate() b.disabled = True cancel.on_click(abort) bar = ipywidgets.HBox([lbl, info, pbar, cancel]) display(bar) try: jobs = (JobDummy(fname, self._treename, self._user_params, self._eventsdef, self._worker) for fname in self._filelist) if pool is not None: res = set(pool.apply_async(job) for job in jobs) while True: finished = set() for r in res: if r.ready(): if not r.successful(): raise r.get() out = r.get() with self._user_callback.lock: self._user_callback.on_streams_update(*out) self.EventsProcessed += out[0] self._filesProcessed += 1 finished.add(r) res -= finished finished = None if progress: pbar.value = self._filesProcessed info.value = "{:>5.0f} kevt/s".format( self.EventsProcessed / (time.time() - self.TStart) / 1000) if cancel.disabled: break if len(res) == 0: if progress: cancel.disabled = True break time.sleep(0.2) else: for job in jobs: out = job() with self._user_callback.lock: self._user_callback.on_streams_update(*out) self.EventsProcessed += out[0] self._filesProcessed += 1 if progress: pbar.value = self._filesProcessed info.value = "{:>5.0f} kevt/s".format( self.EventsProcessed / (time.time() - self.TStart) / 1000) if cancel.disabled: break if progress: cancel.disabled = True except Exception: if pool is not None: pool.terminate() if progress: cancel.disabled = True info.value = "Exception" raise pool = None self.TFinish = time.time()
def __init__(self, base_project="physionet-data.", db="mimic_core", exclude="iii", query_size=1000, *args, **kwargs): self.base_project = base_project self.current_db = None self.df = None self.qs = query_size self.credentials, self.pid = get_gcreds() self.dbs = ["mimic_core", "mimic_derived", "mimic_hosp", "mimic_icu"] self.conn = get_client(self.credentials, self.pid) if not os.path.exists(".mimic_info.yaml"): print("This will take a bit of time...") self.dbs.sort() self.info = {} for d in self.dbs: print("processing database %s" % d) db = self.conn.database(self.base_project + d) tables = db.list_tables() tmp = {t: int(db.table(t).count().execute()) for t in tables} self.info[d] = tmp clear_output() print("Completed") with open(".mimic_info.yaml", "w") as f0: yaml.dump(self.info, f0) else: with open(".mimic_info.yaml") as f0: self.info = yaml.safe_load(f0) self.sdbs = ipw.Dropdown(options=[None] + self.dbs[:], value=None, description="Select DB") self.sdbs.observe(self.set_db, "value") self.stable = ipw.Dropdown(description="Select Table") self.stable.observe(self.set_table, "value") if self.qs: step = self.qs else: step = 1 self.offset = ipw.IntSlider(description="offset", step=self.qs, continuous_update=False) self.offset.observe(self.update_offset, "value") self.out = ipw.Output() children = kwargs.get("children", []) self.graph_type = ipw.Dropdown( options=[None, "describe", "categorical", "numeric"], value=None, description="Viz Type") self.kind = ipw.Dropdown(options=[ "count", "swarm", "box", "boxen", "violin", "bar", "point" ], value="count") opts = [None] self.xsel = ipw.Dropdown(options=opts, value=None, description="x") self.ysel = ipw.Dropdown(options=opts, value=None, description="y") self.hsel = ipw.Dropdown(options=opts, value=None, description="hue") self.rsel = ipw.Dropdown(options=opts, value=None, description="row var") self.csel = ipw.Dropdown(options=opts, value=None, description="col var") self.graph_type.observe(self.disp_plot, "value") self.kind.observe(self.disp_plot, "value") self.xsel.observe(self.disp_plot, "value") self.ysel.observe(self.disp_plot, "value") self.hsel.observe(self.disp_plot, "value") self.rsel.observe(self.disp_plot, "value") self.csel.observe(self.disp_plot, "value") self.plot_out = ipw.Output() tmp = ipw.HBox([ self.graph_type, self.kind, ipw.VBox([self.xsel, self.ysel]), ipw.VBox([self.hsel, self.rsel, self.csel]) ]) children = [ ipw.HBox([self.sdbs, self.stable, self.offset]), self.out, tmp, self.plot_out ] + children super(BQBrowser, self).__init__(children=children) self.disp_df() self.disp_plot()
def make_backend_widget(backend_item: BackendWithProviders) -> wid.HBox: """ Construct a backend widget for a given device. Args: backend_item: A ``BackendWithProviders`` instance containing the backend instance and a list of providers from which the backend can be accessed. Returns: The widget with backend information. """ backend = backend_item.backend backend_providers = backend_item.providers status = backend.status() config = backend.configuration() props = backend.properties().to_dict() next_resrv = get_next_reservation(backend) name_str = "<font size='5' face='monospace'>%s</font>" backend_name = wid.HTML(value=name_str % backend.name()) qubits_wid = wid.HTML(value=STAT_FONT_TITLE.format("Qubits:")) qubits_val_wid = wid.HTML(value=STAT_FONT_VALUE.format(config.n_qubits)) status_wid = wid.HTML(value=STAT_FONT_TITLE.format("Status:")) color = '#000000' status_msg = status.status_msg if status_msg == 'active': color = '#34BC6E' if next_resrv: status_msg += ' [R]' if status_msg in ['maintenance', 'internal']: color = '#FFB000' status_val_wid = wid.HTML( value=STAT_FONT_VALUE_COLOR.format(color=color, msg=status_msg)) left_labels = wid.VBox(children=[qubits_wid, status_wid]) left_values = wid.VBox(children=[qubits_val_wid, status_val_wid], layout=wid.Layout(margin="1px 0px 0px 0px")) left_stats = wid.HBox(children=[left_labels, left_values], layout=wid.Layout(width='175px')) version_wid = wid.HTML(value=STAT_FONT_TITLE.format("Version:")) version_val_wid = wid.HTML(value=STAT_FONT_VALUE.format( config.backend_version), layout=wid.Layout(margin="3px 0px 0px 0px")) queue_wid = wid.HTML(value=STAT_FONT_TITLE.format("Queue:")) queue_val_wid = wid.HTML(value=STAT_FONT_VALUE.format(status.pending_jobs), layout=wid.Layout(margin="5px 0px 0px 0px")) right_labels = wid.VBox(children=[version_wid, queue_wid]) right_values = wid.VBox(children=[version_val_wid, queue_val_wid]) right_stats = wid.HBox(children=[right_labels, right_values], layout=wid.Layout(width='auto', margin="0px 0px 0px 20px")) stats = wid.HBox(children=[left_stats, right_stats]) # Backend reservation. reservation_title = wid.HTML(value=STAT_FONT_TITLE.format("Reservation:")) if next_resrv: start_dt_str = duration_difference(next_resrv.start_datetime) reservation_val = RESERVATION_STR.format(start_dt=start_dt_str, duration=next_resrv.duration) else: reservation_val = RESERVATION_NONE reservation_val_wid = wid.HTML(value=reservation_val) reservation_wid = wid.HBox( children=[reservation_title, reservation_val_wid]) providers_label = wid.HTML(value=STAT_FONT_TITLE.format("Providers:")) providers_list = provider_buttons(backend_providers) device_stats = wid.VBox(children=[ backend_name, stats, reservation_wid, providers_label, providers_list ], layout=wid.Layout(width='auto', margin="0px 20px 0px 0px")) n_qubits = config.n_qubits qubit_size = 15 line_width = 3 if n_qubits < 10: qubit_size = 18 line_width = 4 if n_qubits >= 27: qubit_size = 12 line_width = 3 if n_qubits > 50: qubit_size = 12 line_width = 3 _gmap = iplot_gate_map(backend, figsize=(150, 150), qubit_size=qubit_size, line_width=line_width, qubit_color='#031981', line_color='#031981', label_qubits=False, as_widget=True) gmap = wid.Box(children=[_gmap], layout=wid.Layout( width='auto', justify_content='center', align_content='center', )) # Get basic device stats t1_units = props['qubits'][0][0]['unit'] avg_t1 = round(sum([q[0]['value'] for q in props['qubits']]) / n_qubits, 1) avg_t2 = round(sum([q[1]['value'] for q in props['qubits']]) / n_qubits, 1) if n_qubits != 1: sum_cx_err = 0 num_cx = 0 for gate in props['gates']: if gate['gate'] == 'cx': for param in gate['parameters']: if param['name'] == 'gate_error': # Value == 1.0 means gate effectively off if param['value'] != 1.0: sum_cx_err += param['value'] num_cx += 1 if num_cx: avg_cx_err = round(sum_cx_err / (num_cx) * 100, 2) else: avg_cx_err = 100.0 avg_meas_err = 0 for qub in props['qubits']: for item in qub: if item['name'] == 'readout_error': avg_meas_err += item['value'] avg_meas_err = round(avg_meas_err / n_qubits * 100, 2) t12_label = wid.HTML( value="<font size='2'>Avg. T<sub>1</sub> / T<sub>2</sub></font>:") t12_str = "<font size='3' face='monospace'>{t1}/{t2}</font><font size='2'> {units}</font>" t12_wid = wid.HTML( value=t12_str.format(t1=avg_t1, t2=avg_t2, units=t1_units)) meas_label = wid.HTML(value="<font size='2'>Avg. Readout Err.:</font>") meas_str = "<font size='3' face='monospace'>{merr}</font><font size='2'> %</font>" meas_wid = wid.HTML(value=meas_str.format(merr=avg_meas_err)) cx_str = "<font size='3' face='monospace'>{cx_err}</font><font size='2'> %</font>" if n_qubits != 1: cx_label = wid.HTML(value="<font size='2'>Avg. CX Err.:</font>") cx_wid = wid.HTML(value=cx_str.format(cx_err=avg_cx_err)) quant_vol = 'None' try: quant_vol = config.quantum_volume except AttributeError: pass qv_label = wid.HTML(value="<font size='2'>Quantum Volume:</font>") qv_str = "<font size='3' face='monospace'>{qv}</font><font size='2'></font>" qv_wid = wid.HTML(value=qv_str.format(qv=quant_vol), layout=wid.Layout(margin="-1px 0px 0px 0px")) if n_qubits != 1: left_wids = [t12_label, cx_label, meas_label, qv_label] right_wids = [t12_wid, cx_wid, meas_wid, qv_wid] else: left_wids = [t12_label, meas_label, qv_label] right_wids = [t12_wid, meas_wid, qv_wid] left_wid = wid.VBox(children=left_wids, layout=wid.Layout(margin="2px 0px 0px 0px")) right_wid = wid.VBox(children=right_wids, layout=wid.Layout(margin="0px 0px 0px 3px")) stats = wid.HBox(children=[left_wid, right_wid]) gate_map = wid.VBox(children=[gmap, stats], layout=wid.Layout(width='230px', justify_content='center', align_content='center', margin="-25px 0px 0px 0px")) out = wid.HBox(children=[device_stats, gate_map], layout=wid.Layout(width='auto', height='auto', padding="5px 5px 5px 5px", justify_content='space-between', max_width='700px', border='1px solid #212121')) # Attach information to the backend panel for later updates. out._backend = backend # pylint: disable=protected-access out._status_val_wid = status_val_wid out._queue_val_wid = queue_val_wid out._reservation_val_wid = reservation_val_wid return out
defaultloc = 'chr5:142,903,034-142,906,867' defaultgeneid = 'Actb' defaultrefseqid = 'NM_007393' defaultstrand = "-" #### Accordian Change File Locations #### w_default_folder = widgets.Text( description='RnaSeq Folder', value=default_track_folder, ) w_default_folder.width="80%" w_default_folder_valid = widgets.Valid(value=True) hboxdefaultfolder = widgets.HBox([w_default_folder,w_default_folder_valid]) page1 = widgets.VBox(children=[hboxdefaultfolder]) accord = widgets.Accordion(children=[page1], width="80%") display(accord) accord.set_title(1, 'Defaults') #### Define Widgets ### lookuptype_widget = widgets.RadioButtons( options={'By location':'location','By geneid (3\'UTR only)':"geneid"}, value='location', description='Lookup:', disabled=False )
def widget(self): # Alright let's set this all up. grid_contents = [] for i, view in enumerate(self.grid_views): visible = ipywidgets.Checkbox(value=view.visible, description=f"Level {i}") ipywidgets.jslink((visible, "value"), (view, "visible")) color_picker = ipywidgets.ColorPicker(value=view.material.color, concise=True) ipywidgets.jslink((color_picker, "value"), (view.material, "color")) line_slider = ipywidgets.FloatSlider(value=view.material.linewidth, min=0.0, max=10.0) ipywidgets.jslink((line_slider, "value"), (view.material, "linewidth")) grid_contents.extend([visible, color_picker, line_slider]) dropdown = ipywidgets.Dropdown( options=["inferno", "viridis", "plasma", "magma", "cividis"], value="inferno", description="Colormap:", disable=False, ) traitlets.link((dropdown, "value"), (self, "grid_colormap")) button = ipywidgets.Button(description="Add Keyframe") def on_button_clicked(b): self.position_list = self.position_list + [ self.renderer.camera.position ] select.options += ((f"Position {len(self.position_list)}", self.renderer.camera.position), ) button.on_click(on_button_clicked) select = ipywidgets.Select(options=[], description="Positions:", disabled=False) def on_selection_changed(change): self.renderer.camera.position = tuple(change["new"]) select.observe(on_selection_changed, ["value"]) return ipywidgets.HBox([ self.renderer, button, select, ipywidgets.VBox([ dropdown, ipywidgets.GridBox( grid_contents, layout=ipywidgets.Layout( width=r"60%", grid_template_columns=r"30% 10% auto", align_items="stretch", ), ), ]), ])
def __init__(self, df): """ + initialize class with dataframe + initiatlive all ipywidgets """ self.df = df self.split_param = ' - * - ' self.creative_types = ('traffic driver', 'interactive non video', 'branded driver', 'video', 'interactive video', 'no match') self.df['advert_order'] = self.df[ 'Advertiser'] + self.split_param + self.df['Order'] self.AO_dropdown = ipywidgets.Dropdown( options=sorted(set(self.df['advert_order'])), value=list(sorted(set(self.df['advert_order'])))[0], disabled=False) self.site_dropdown = ipywidgets.Dropdown(options=['qz', 'wrk', 'zty'], value='qz', disabled=False) self.placement_dropdown = ipywidgets.Dropdown(options=[ 'engage mobile', 'engage desktop', 'marquee mobile', 'marquee desktop', 'inline mobile', 'inline desktop' ], value='engage mobile', disabled=False) self.creative_type_dropdown = ipywidgets.Dropdown( options=self.creative_types, value=self.creative_types[0], disabled=False) self.metric_measurement = ipywidgets.Dropdown( options=['DFP CTR', '3P CTR', 'Viewability', 'VSR', 'IR'], value='DFP CTR', disabled=False) self.d1_DatePicker = ipywidgets.DatePicker(disabled=False) self.d2_DatePicker = ipywidgets.DatePicker(disabled=False) #CNV - creative.name.version self.CNV_multiple = ipywidgets.SelectMultiple( options=sorted(set( self.df['creative.name.version'].fillna('None'))), value=[], rows=3, description='creative.name.version', disabled=False, layout=ipywidgets.Layout(width='50%', height='280px')) self.aggregate_checkbox = ipywidgets.Checkbox( value=False, description='Display aggregate', disabled=False) self.button = ipywidgets.Button(description="CHART IT !", layout=ipywidgets.Layout( width='100%', height='55px')) self.left_box = ipywidgets.VBox([ self.AO_dropdown, self.site_dropdown, self.placement_dropdown, self.creative_type_dropdown, self.metric_measurement, self.d1_DatePicker, self.d2_DatePicker, self.aggregate_checkbox, self.button ]) self.display = ipywidgets.HBox([self.left_box, self.CNV_multiple])
def __get_tab0(self): return widgets.HBox([ widgets.VBox([self.norm_selector, self.norm_selector.value[1]]), self.norm_btn_wgt ])
], _titles={i: t for i, t in enumerate(titles)}, layout=tab_layout) homedir = os.getcwd() tool_title = widgets.Label(r'\(\textbf{pc4sbml2}\)') if nanoHUB_flag or hublib_flag: # define this, but don't use (yet) remote_cb = widgets.Checkbox( indent=False, value=False, description='Submit as Batch Job to Clusters/Grid') top_row = widgets.HBox(children=[read_config, tool_title]) gui = widgets.VBox(children=[top_row, tabs, run_button.w]) fill_gui_params(read_config.options['DEFAULT']) else: top_row = widgets.HBox(children=[tool_title]) gui = widgets.VBox(children=[top_row, tabs, run_button]) fill_gui_params("data/PhysiCell_settings.xml") # pass in (relative) directory where output data is located output_dir = "tmpdir" # svg.update(output_dir) sub.update_dropdown_fields( "data") # WARNING: generates multiple "<Figure size...>" stdout! # animate_tab.update_dropdown_fields("data")
def widget(self): return widgets.VBox([ widgets.HBox( [self.axis_pos, self.index_slider, self.axis_selector]), self.out_main, self.out ])
width='auto', margin='0px 0px 0px 0px') slot_middle = widgets.Box(children=items, layout=box_layout) slot = widgets.VBox(children=[slot_top, slot_middle, slot_bottom], layout=widgets.Layout(display='flex', flex_flow='column', align_items='center', width='auto', margin='0px 0px 0px 0px')) slot._stored_ints = [] imgs = [ 'waiting.png', 'bell.png', 'cherry.png', 'grape.png', 'lemon.png', 'orange.png', 'strawberry.png', 'watermelon.png', 'seven.png' ] slot._images = {} for kk, img in enumerate(imgs): slot._images[kk - 1] = open(script_dir + "/symbols/%s" % img, "rb").read() gen = widgets.ToggleButtons( options=['Simulator', 'ibmq_5_tenerife', 'ANU QRNG'], description='', disabled=False, button_style='') out = widgets.Output() opts = widgets.HBox(children=[gen, out], layout=widgets.Layout(border='1px solid black'))
def __init__(self, data, slcs=(slice(None, ), ), title=None, norm=None, fig_handle=None, time_in_title=True, **kwargs): self._data, self._slcs, self.im_xlt, self.time_in_title = data, slcs, None, time_in_title # # # -------------------- Tab0 -------------------------- items_layout = Layout(flex='1 1 auto', width='auto') # normalization # general parameters: vmin, vmax, clip self.if_vmin_auto = widgets.Checkbox(value=True, description='Auto', layout=items_layout) self.if_vmax_auto = widgets.Checkbox(value=True, description='Auto', layout=items_layout) self.vmin_wgt = widgets.FloatText(value=np.min(data), description='vmin:', continuous_update=False, disabled=self.if_vmin_auto.value, layout=items_layout) self.vlogmin_wgt = widgets.FloatText(value=self.eps, description='vmin:', continuous_update=False, disabled=self.if_vmin_auto.value, layout=items_layout) self.vmax_wgt = widgets.FloatText(value=np.max(data), description='vmax:', continuous_update=False, disabled=self.if_vmin_auto.value, layout=items_layout) self.if_clip_cm = widgets.Checkbox(value=True, description='Clip', layout=items_layout) # PowerNorm specific self.gamma = widgets.FloatText(value=1, description='gamma:', continuous_update=False, layout=items_layout) # SymLogNorm specific self.linthresh = widgets.FloatText(value=self.eps, description='linthresh:', continuous_update=False, layout=items_layout) self.linscale = widgets.FloatText(value=1.0, description='linscale:', continuous_update=False, layout=items_layout) # build the widgets tuple ln_wgt = (LogNorm, widgets.VBox([ widgets.HBox([self.vlogmin_wgt, self.if_vmin_auto]), widgets.HBox([self.vmax_wgt, self.if_vmax_auto]), self.if_clip_cm ])) n_wgt = (Normalize, widgets.VBox([ widgets.HBox([self.vmin_wgt, self.if_vmin_auto]), widgets.HBox([self.vmax_wgt, self.if_vmax_auto]), self.if_clip_cm ])) pn_wgt = (PowerNorm, widgets.VBox([ widgets.HBox([self.vmin_wgt, self.if_vmin_auto]), widgets.HBox([self.vmax_wgt, self.if_vmax_auto]), self.if_clip_cm, self.gamma ])) sln_wgt = (SymLogNorm, widgets.VBox([ widgets.HBox([self.vmin_wgt, self.if_vmin_auto]), widgets.HBox([self.vmax_wgt, self.if_vmax_auto]), self.if_clip_cm, self.linthresh, self.linscale ])) # find out default value for norm_selector norm_avail = { 'Log': ln_wgt, 'Normalize': n_wgt, 'Power': pn_wgt, 'SymLog': sln_wgt } self.norm_selector = widgets.Dropdown(options=norm_avail, value=norm_avail.get( norm, n_wgt), description='Normalization:') # additional care for LorNorm() self.__handle_lognorm() # re-plot button self.norm_btn_wgt = widgets.Button(description='Apply', disabled=False, tooltip='set colormap', icon='refresh') tab0 = self.__get_tab0() # # # -------------------- Tab1 -------------------------- # title if not title: title = osh5vis.default_title(data, show_time=self.time_in_title) self.if_reset_title = widgets.Checkbox(value=True, description='Auto') self.title = widgets.Text(value=title, placeholder='data', continuous_update=False, description='Title:', disabled=self.if_reset_title.value) # x label self.if_reset_xlabel = widgets.Checkbox(value=True, description='Auto') self.xlabel = widgets.Text(value=osh5vis.axis_format( data.axes[1].long_name, data.axes[1].units), placeholder='x', continuous_update=False, description='X label:', disabled=self.if_reset_xlabel.value) # y label self.if_reset_ylabel = widgets.Checkbox(value=True, description='Auto') self.ylabel = widgets.Text(value=osh5vis.axis_format( data.axes[0].long_name, data.axes[0].units), placeholder='y', continuous_update=False, description='Y label:', disabled=self.if_reset_ylabel.value) # colorbar self.if_reset_cbar = widgets.Checkbox(value=True, description='Auto') self.cbar = widgets.Text(value=data.units.tex(), placeholder='a.u.', continuous_update=False, description='Colorbar:', disabled=self.if_reset_cbar.value) tab1 = widgets.VBox([ widgets.HBox([self.title, self.if_reset_title]), widgets.HBox([self.xlabel, self.if_reset_xlabel]), widgets.HBox([self.ylabel, self.if_reset_ylabel]), widgets.HBox([self.cbar, self.if_reset_cbar]) ]) # # # -------------------- Tab2 -------------------------- self.setting_instructions = widgets.Label( value="Enter invalid value to reset", layout=items_layout) self.apply_range_btn = widgets.Button(description='Apply', disabled=False, tooltip='set range', icon='refresh') self.axis_lim_wgt = widgets.HBox( [self.setting_instructions, self.apply_range_btn]) # x axis self.x_min_wgt = widgets.FloatText(value=self._data.axes[1].min, description='xmin:', continuous_update=False, layout=items_layout) self.x_max_wgt = widgets.FloatText(value=self._data.axes[1].max, description='xmax:', continuous_update=False, layout=items_layout) self.x_step_wgt = widgets.FloatText(value=self._data.axes[1].increment, continuous_update=False, description='$\Delta x$:', layout=items_layout) self.xaxis_lim_wgt = widgets.HBox( [self.x_min_wgt, self.x_max_wgt, self.x_step_wgt]) # y axis self.y_min_wgt = widgets.FloatText(value=self._data.axes[0].min, description='ymin:', continuous_update=False, layout=items_layout) self.y_max_wgt = widgets.FloatText(value=self._data.axes[0].max, description='ymax:', continuous_update=False, layout=items_layout) self.y_step_wgt = widgets.FloatText(value=self._data.axes[0].increment, continuous_update=False, description='$\Delta y$:', layout=items_layout) self.yaxis_lim_wgt = widgets.HBox( [self.y_min_wgt, self.y_max_wgt, self.y_step_wgt]) tab2 = widgets.VBox( [self.axis_lim_wgt, self.xaxis_lim_wgt, self.yaxis_lim_wgt]) # # # -------------------- Tab3 -------------------------- tab3 = self.if_lineout_wgt = widgets.Checkbox( value=False, description='X/Y Lineouts (incomplete feature)', layout=items_layout) # # # -------------------- Tab4 -------------------------- user_cmap = kwargs.pop('cmap', 'jet') self.cmap_selector = widgets.Dropdown(options=self.colormaps_available, value=user_cmap, description='Colormap:') self.cmap_reverse = widgets.Checkbox(value=False, description='Reverse', layout=items_layout) tab4 = widgets.HBox([self.cmap_selector, self.cmap_reverse]) # construct the tab self.tab = widgets.Tab() self.tab.children = [tab0, tab1, tab2, tab3, tab4] [self.tab.set_title(i, tt) for i, tt in enumerate(self.tab_contents)] # display(self.tab) # link and activate the widgets self.if_reset_title.observe(self.__update_title, 'value') self.if_reset_xlabel.observe(self.__update_xlabel, 'value') self.if_reset_ylabel.observe(self.__update_ylabel, 'value') self.if_reset_cbar.observe(self.__update_cbar, 'value') self.norm_btn_wgt.on_click(self.update_norm) self.if_vmin_auto.observe(self.__update_vmin, 'value') self.if_vmax_auto.observe(self.__update_vmax, 'value') self.norm_selector.observe(self.__update_norm_wgt, 'value') self.cmap_selector.observe(self.update_cmap, 'value') self.cmap_reverse.observe(self.update_cmap, 'value') self.title.observe(self.update_title, 'value') self.xlabel.observe(self.update_xlabel, 'value') self.ylabel.observe(self.update_ylabel, 'value') self.cbar.observe(self.update_cbar, 'value') self.y_max_wgt.observe(self.__update_y_max, 'value') self.y_min_wgt.observe(self.__update_y_min, 'value') self.x_max_wgt.observe(self.__update_x_max, 'value') self.x_min_wgt.observe(self.__update_x_min, 'value') self.x_step_wgt.observe(self.__update_delta_x, 'value') self.y_step_wgt.observe(self.__update_delta_y, 'value') self.apply_range_btn.on_click(self.update_plot_area) self.if_lineout_wgt.observe(self.toggle_lineout, 'value') # plotting and then setting normalization colors self.out = Output() self.out_main = Output() self.observer_thrd, self.cb = None, None self.fig = plt.figure() if fig_handle is None else fig_handle self.ax = self.fig.add_subplot(111) with self.out_main: self.im, self.cb = self.plot_data() display(self.fig)
def execute_notebook(notebook_filename, notebook_save_filename, params): log = UserMessages() with open(notebook_filename) as file_handler: notebook = nbformat.read(file_handler, as_version=4) b_errors = False execute_preprocessor = ExecutePreprocessor( timeout=args.get('cell_timeout'), allow_errors=args.get('allow_errors')) kernel_manager = None kernel_comm = None progress_bar = args.get('enable_progress_bar') if params: for nb_cell in notebook.cells: if nb_cell.cell_type == 'code': new_cell_source = utils.substitute_params( nb_cell.source, params) nb_cell.source = new_cell_source break try: if progress_bar: progress_bar = widgets.IntProgress( value=0, min=0, max=len(notebook.cells), step=1, bar_style= 'info', # 'success', 'info', 'warning', 'danger' or '' orientation='horizontal') kernel_manager, kernel_comm = start_new_kernel( kernel_name=notebook['metadata']['kernelspec'] ['name']) execute_preprocessor.km = kernel_manager execute_preprocessor.kc = kernel_comm execute_preprocessor.nb = notebook display_label = notebook_filename if notebook_save_filename: display_label = display_label + ' : ' + notebook_save_filename display( widgets.HBox( [widgets.Label(display_label), progress_bar])) for idx, nb_cell in enumerate(notebook.cells): execute_preprocessor.preprocess_cell( nb_cell, resources={'metadata': {}}, cell_index=idx) progress_bar.value = idx + 1 else: log.info("Running Notebook: " + notebook_filename) execute_preprocessor.preprocess( notebook, {'metadata': {}}) except CellExecutionError: b_errors = True if progress_bar: progress_bar.bar_style = 'danger' raise except AttributeError: b_errors = True if progress_bar: progress_bar.bar_style = 'danger' raise finally: if notebook_save_filename: with open(notebook_save_filename, mode='wt') as file_handler: nbformat.write(notebook, file_handler) if kernel_manager or kernel_comm: kernel_comm.stop_channels() kernel_manager.shutdown_kernel() if not b_errors: if progress_bar: progress_bar.bar_style = 'success' else: log.info(notebook_filename + " was executed successfully.") elif b_errors and not progress_bar: log.error(notebook_filename + " execution failed.")
def create_gui(geometry=None, callback=None, opts_choice=None, opts_range=None, opts_color=None, initial_values=None, layout=None, height=400, width=400, background='gray', orthographic=False, camera_position=[0, 0, -10], view=(10, -10, -10, 10), fov=50, add_objects=True, add_labels=True, show_object_info=False, otype_column=None, jslink=True): """ creates simple gui to visualise 3d geometry, with a callback to update geometry according to option widgets Properties ---------- geometry : pandas3js.models.GeometricCollection callback : function callback(GeometricCollection, options_dict) opts_choice : None or dict {opt_name:(initial, list)} create dropdown boxes with callbacks to callback opts_range : None or dict {opt_name:(initial, list)} create select slider with callbacks to callback opts_color : None or list {opt_name:init_color,...} create select color palette with callbacks to callback inital_values : None or dict initial values for options (default is first value of list) layout : None or list (tab_name,[option_name, ...]) pairs, if nested list, then these will be vertically aligned by default all go in 'Other' tab height : int renderer height width : int renderer width background : str renderer background color (html) orthographic : bool use orthographic camera (True) or perspective (False) camera_position : tuple position of camera in scene view : tuple initial view extents (top,bottom,left,right) (orthographic only) fov : float camera field of view (perspective only) add_objects : bool add objects to scene add_labels : bool add object labels to scene show_object_info : bool if True, show coordinate of object under mouse (currently only works for Perspective) jslink : bool if True, where possible, create client side links http://ipywidgets.readthedocs.io/en/latest/examples/Widget%20Events.html#The-difference-between-linking-in-the-kernel-and-linking-in-the-client Returns ------- gui : widgets.Box containing rendered scene and option widgets gcollect : pandas3js.GeometricCollection the collection of current geometric objects options_view : dict_items a view of the current options values Examples -------- >>> import pandas3js as pjs >>> import pandas as pd >>> data = {1:{'id':[0],'position':[(0,0,0)], ... 'c1':'red','c2':'blue'}, ... 2:{'id':[0],'position':[(1,2,3)], ... 'c1':'red','c2':'blue'}} ... >>> def callback(geometry,options): ... df = pd.DataFrame(data[options['config']]) ... ctype = options.get('color','c1') ... df['color'] = df[ctype] ... df['label'] = 'myobject' ... df['otype'] = 'pandas3js.models.Sphere' ... geometry.change_by_df(df[['id','position','otype', ... 'color','label']],otype_column='otype') ... >>> gui, collect, opts = pjs.views.create_gui(callback=callback, ... opts_choice={'color':['c1','c2']}, ... opts_range={'config':[1,2]}) ... >>> [pjs.utils.obj_to_str(c) for c in gui.children] ['ipywidgets.widgets.widget_selectioncontainer.Tab', 'pythreejs.pythreejs.Renderer'] >>> collect.trait_df().loc[0] color red groups (all,) id 0 label myobject label_color red label_transparency 1 label_visible False other_info otype pandas3js.models.idobject.Sphere position (0.0, 0.0, 0.0) radius 1 transparency 1 visible True Name: 0, dtype: object >>> config_select = gui.children[0].children[1].children[1].children[1] >>> pjs.utils.obj_to_str(config_select) 'ipywidgets.widgets.widget_selection.SelectionSlider' >>> config_select.value = 2 >>> collect.trait_df().loc[0] color red groups (all,) id 0 label myobject label_color red label_transparency 1 label_visible False other_info otype pandas3js.models.idobject.Sphere position (1.0, 2.0, 3.0) radius 1 transparency 1 visible True Name: 0, dtype: object >>> color_select = gui.children[0].children[1].children[1].children[0] >>> pjs.utils.obj_to_str(color_select) 'ipywidgets.widgets.widget_selection.ToggleButtons' >>> color_select.value = 'c2' >>> collect.trait_df().loc[0] color blue groups (all,) id 0 label myobject label_color red label_transparency 1 label_visible False other_info otype pandas3js.models.idobject.Sphere position (1.0, 2.0, 3.0) radius 1 transparency 1 visible True Name: 0, dtype: object """ ## intialise options init_vals = {} if initial_values is None else initial_values opts_choice = {} if opts_choice is None else opts_choice all_options = { label: init_vals[label] if label in init_vals else options[0] for label, options in opts_choice.items() } opts_range = {} if opts_range is None else opts_range all_options.update({ label: init_vals[label] if label in init_vals else options[0] for label, options in opts_range.items() }) opts_color = {} if opts_color is None else opts_color all_options.update({ label: init_vals[label] if label in init_vals else init for label, init in opts_color.items() }) if len(all_options ) != len(opts_choice) + len(opts_range) + len(opts_color): raise ValueError( 'options in opts_choice, opts_slide, and opts_color are not unique' ) ## intialise layout layout = [] if layout is None else layout layout_dict = OrderedDict(layout) if len(layout_dict) != len(layout): raise ValueError('layout tab names are not unique') ## initialise renderer if geometry is None: gcollect = pjs.models.GeometricCollection() else: gcollect = geometry scene = pjs.views.create_js_scene_view(gcollect, add_objects=add_objects, add_labels=add_labels, jslink=jslink) camera, renderer = pjs.views.create_jsrenderer( scene, orthographic=orthographic, camera_position=camera_position, view=view, fov=fov, height=height, width=width, background=background) ## create minimal callback if callback is None: def callback(geometry, options): return ## initialise geometry in renderer with renderer.hold_trait_notifications(): callback(gcollect, all_options) ## Create controls and callbacks controls = {} # a check box for showing labels if add_labels: toggle = widgets.Checkbox(value=False, description='View Label:') def handle_toggle(change): for obj in gcollect.idobjects: obj.label_visible = change.new toggle.observe(handle_toggle, names='value') controls['View Label'] = toggle # zoom sliders for orthographic if orthographic: top, bottom, left, right = view axiszoom = widgets.FloatSlider( value=0, min=-10, max=10, step=0.1, description='zoom', continuous_update=True, ) def handle_axiszoom(change): if change.new > 1: zoom = 1. / change.new elif change.new < -1: zoom = -change.new else: zoom = 1 with renderer.hold_trait_notifications(): camera.left = zoom * left camera.right = zoom * right camera.top = zoom * top camera.bottom = zoom * bottom axiszoom.observe(handle_axiszoom, names='value') controls['Orthographic Zoom'] = axiszoom # add additional options dd_min = 4 # min amount of options before switch to toggle buttons for label in opts_choice: options = opts_choice[label] initial = init_vals[label] if label in init_vals else options[0] assert initial in list( options), "initial value {0} for {1} not in range: {2}".format( initial, label, list(options)) if (len(options) == 2 and True in options and False in options and isinstance(options[0], bool) and isinstance(options[1], bool)): ddown = widgets.Checkbox(value=initial, description=label) elif len(options) < dd_min: ddown = widgets.ToggleButtons(options=list(options), description=label, value=initial) else: ddown = widgets.Dropdown(options=list(options), description=label, value=initial) handle = _create_callback(renderer, ddown, callback, gcollect, all_options) ddown.observe(handle, names='value') controls[label] = ddown for label in opts_range: options = opts_range[label] initial = init_vals[label] if label in init_vals else options[0] assert initial in list( options), "initial value {0} for {1} not in range: {2}".format( initial, label, list(options)) slider = widgets.SelectionSlider(description=label, value=initial, options=list(options), continuous_update=False) handle = _create_callback(renderer, slider, callback, gcollect, all_options) slider.observe(handle, names='value') controls[label] = slider for label in opts_color: option = init_vals[label] if label in init_vals else opts_color[label] color = widgets.ColorPicker(description=label, value=option, concise=False) handle = _create_callback(renderer, color, callback, gcollect, all_options) color.observe(handle, names='value') controls[label] = slider # add mouse hover information box # TODO doesn't work for orthographic https://github.com/jovyan/pythreejs/issues/101 if not orthographic and show_object_info: # create information box click_picker = tjs.Picker(root=scene.children[0], event='mousemove') infobox = widgets.HTMLMath() def change_info(change): if click_picker.object: infobox.value = 'Object Coordinate: ({1:.3f}, {2:.3f}, {3:.3f})<br>{0}'.format( click_picker.object.other_info, *click_picker.object.position) else: infobox.value = '' click_picker.observe(change_info, names=['object']) renderer.controls = renderer.controls + [click_picker] renderer = widgets.HBox([renderer, infobox]) if not controls: return (renderer, gcollect, all_options.viewitems() if hasattr( all_options, 'viewitems') else all_options.items() ) # python 2/3 compatability ## layout tabs and controls tabs = OrderedDict() for tab_name, clist in layout_dict.items(): vbox_list = [] for cname in clist: if isinstance(cname, list): hbox_list = [controls.pop(subcname) for subcname in cname] vbox_list.append(widgets.HBox(hbox_list)) else: vbox_list.append(controls.pop(cname)) tabs[tab_name] = widgets.VBox(vbox_list) if 'Orthographic Zoom' in controls: tabs.setdefault('View', widgets.Box()) tabs['View'] = widgets.VBox( [tabs['View'], controls.pop('Orthographic Zoom')]) if 'View Label' in controls: tabs.setdefault('View', widgets.Box()) tabs['View'] = widgets.VBox([tabs['View'], controls.pop('View Label')]) # deal with remaining controls if controls: vbox_list = [] for cname in natural_sort(controls): vbox_list.append(controls.pop(cname)) tabs.setdefault('Other', widgets.Box()) tabs['Other'] = widgets.VBox([tabs['Other'], widgets.VBox(vbox_list)]) options = widgets.Tab(children=tuple(tabs.values())) for i, name in enumerate(tabs): options.set_title(i, name) return (widgets.VBox([options, renderer]), gcollect, all_options.viewitems() if hasattr(all_options, 'viewitems') else all_options.items() ) # python 2/3 compatability
def __init__(self, backend, dataset, x, y=None, z=None, w=None, grid=None, limits=None, shape=128, what="count(*)", f=None, vshape=16, selection=None, grid_limits=None, normalize=None, colormap="afmhot", figure_key=None, fig=None, what_kwargs={}, grid_before=None, vcount_limits=None, controls_selection=False, **kwargs): super(PlotBase, self).__init__(x=x, y=y, z=z, w=w, what=what, vcount_limits=vcount_limits, grid_limits=grid_limits, f=f, **kwargs) self.backend = backend self.vgrids = [None, None, None] self.vcount = None self.dataset = dataset self.limits = self.get_limits(limits) self.shape = shape self.selection = selection #self.grid_limits = grid_limits self.normalize = normalize self.colormap = colormap self.what_kwargs = what_kwargs self.grid_before = grid_before self.figure_key = figure_key self.fig = fig self.vshape = vshape self._new_progressbar() self.output = widgets.Output() # with self.output: if 1: self._cleanups = [] self.progress = widgets.FloatProgress(value=0.0, min=0.0, max=1.0, step=0.01) self.progress.layout.width = "95%" self.progress.layout.max_width = '500px' self.progress.description = "progress" self.backend.create_widget(self.output, self, self.dataset, self.limits) self.control_widget = widgets.VBox() # self.create_tools() self.widget = widgets.VBox([ self.control_widget, self.backend.widget, self.progress, self.output ]) if grid is None: self.update_grid() else: self.grid = grid self.widget_f = widgets.Dropdown( options=[('identity', 'identity'), ('log', 'log'), ('log10', 'log10'), ('log1p', 'log1p')]) widgets.link((self, 'f'), (self.widget_f, 'value')) self.observe(lambda *__: self.update_image(), 'f') self.add_control_widget(self.widget_f) self.widget_grid_limits_min = widgets.FloatSlider( value=0, min=0, max=100, step=0.1, description='vmin%') self.widget_grid_limits_max = widgets.FloatSlider( value=100, min=0, max=100, step=0.1, description='vmax%') widgets.link((self.widget_grid_limits_min, 'value'), (self, 'grid_limits_min')) widgets.link((self.widget_grid_limits_max, 'value'), (self, 'grid_limits_max')) #widgets.link((self.widget_grid_limits_min, 'f'), (self.widget_f, 'value')) self.observe(lambda *__: self.update_image(), ['grid_limits_min', 'grid_limits_max']) self.add_control_widget(self.widget_grid_limits_min) self.add_control_widget(self.widget_grid_limits_max) self.widget_grid_limits = None selections = vaex.dataset._ensure_list(self.selection) selections = [_translate_selection(k) for k in selections] selections = [k for k in selections if k] self.widget_selection_active = widgets.ToggleButtons( options=list(zip(selections, selections)), description='selection') self.controls_selection = controls_selection if self.controls_selection: self.add_control_widget(self.widget_selection_active) modes = ['replace', 'and', 'or', 'xor', 'subtract'] self.widget_selection_mode = widgets.ToggleButtons( options=modes, description='mode') self.add_control_widget(self.widget_selection_mode) self.widget_selection_undo = widgets.Button(options=modes, description='undo', icon='arrow-left') self.widget_selection_redo = widgets.Button(options=modes, description='redo', icon='arrow-right') self.add_control_widget( widgets.HBox([ widgets.Label('history', layout={'width': '80px'}), self.widget_selection_undo, self.widget_selection_redo ])) def redo(*ignore): selection = _translate_selection( self.widget_selection_active.value) self.dataset.selection_redo(name=selection) check_undo_redo() self.widget_selection_redo.on_click(redo) def undo(*ignore): selection = _translate_selection( self.widget_selection_active.value) self.dataset.selection_undo(name=selection) check_undo_redo() self.widget_selection_undo.on_click(undo) def check_undo_redo(*ignore): selection = _translate_selection( self.widget_selection_active.value) self.widget_selection_undo.disabled = not self.dataset.selection_can_undo( selection) self.widget_selection_redo.disabled = not self.dataset.selection_can_redo( selection) self.widget_selection_active.observe(check_undo_redo, 'value') check_undo_redo() callback = self.dataset.signal_selection_changed.connect( check_undo_redo) callback = self.dataset.signal_selection_changed.connect( lambda *x: self.update_grid()) def _on_limits_change(*args): self._progressbar.cancel() self.update_grid() self.backend.observe(_on_limits_change, "limits") for attrname in "x y z vx vy vz".split(): def _on_change(*args, attrname=attrname): limits_index = {'x': 0, 'y': 1, 'z': 2}.get(attrname) if limits_index is not None: self.backend.limits[limits_index] = None self.update_grid() self.observe(_on_change, attrname) self.observe(lambda *args: self.update_grid(), "what") self.observe(lambda *args: self.update_image(), "vcount_limits")
# Labels for the velocity slider in Figure 1 speed_label = widgets.HTML(value='<b>Radial Velocity of Source</b>: ') speed_label.layout.width = longspeed_label_width vel_label = widgets.HTML(value='0', positioning='right') vel_label.layout.width = vel_value_width vel_label.layout.align_content = 'center' vunits = widgets.HTML(value='km/s') vunits.width = unit_text_width direction = widgets.HTML(value='') direction.layout.width = longdirection_width # these boxes contain display commands for the velocity of each star fig1controls_box = widgets.HBox([speed_label, vel_label, vunits, direction]) fig1controls_box.layout.width = '400px' # Define Figure 1 figure1 = bq.Figure(title = 'Hydrogen Cloud Absorbtion Spectrum', axes=[ax_x_fig1, ax_y_fig1], animation = 100, marks = [fig1_wide_line, hydrogen_line_lab_simple, hydrogen_line_moving_simple, fig1_Lab_label], padding_y=0, min_aspect_ratio=2.5, max_aspect_ratio=2.5) figure1.layout.width = '500px' # Update the widgets fig1_vel_slider.observe(simple_update, names=['value']) fig1_dval.observe(simple_update, names=['value']) fig1_gval.observe(simple_update, names=['value']) fig1_bval.observe(simple_update, names=['value']) fig1_aval.observe(simple_update, names=['value']) fig1_reset.on_click(simple_reset)
def __init__(self, hdu=None, im=None, wcs=None, show_rainbow=True, *args, **kwargs): super().__init__(*args, **kwargs) # self._4d_idx = 0 # Lock 4th dim to this for now if hdu is not None: self.im = hdu.data self.wcs = WCS(hdu.header) elif im is not None: self.im = im self.wcs = wcs else: print("Provide a 3D HDU or image and wcs object") self.nddata = NDData(self.im, wcs=self.wcs) self.load_nddata(self.nddata, n=0) # get wave info: self.dwave = self.wcs.wcs.cdelt[2] self.wave_start = self.wcs.wcs.crval[2] self.nwave = np.shape(self.im)[0] self.wave_end = self.wave_start + self.nwave * self.dwave self.show_rainbow = show_rainbow #zscale = ZScaleInterval(contrast=0.3, krej=2.5) #vmin, vmax = zscale.get_limits(values=self.im) self.cuts = 'stddev' self.wave_widget = widgets.IntSlider( min=self.wave_start, max=self.wave_end, step=self.dwave, value=self.wave_start, continuous_update=False, ) self.slider = widgets.interactive(self.show_slice, wave=self.wave_widget) self.animate_button = widgets.Button( description="Scan Cube", disabled=False, button_style="success", tooltip="Click this to scan in wavelength dimension", ) # For line profile plot self._cur_islice = None self._cur_ix = None self._cur_iy = None self.line_out = widgets.Output() self.line_plot = None self.plot_xlabel = "Wavelength (A)" self.plot_ylabel = "Flux Density" # (10^-17 erg cm-2 s-1 arcsec-2" if self.show_rainbow: self.set_rainbow() # If plot shows, rerun cell to hide it. ax = plt.gca() self.line_plot = ax self.scan = widgets.Play( value=self.wave_start, min=self.wave_start, max=self.wave_end, step=self.dwave, # interval=500, description="Scan Cube", disabled=False, ) widgets.jslink((self.scan, "value"), (self.wave_widget, "value")) left_panel = widgets.VBox( [widgets.HBox([self.wave_widget, self.scan]), self]) display(widgets.HBox([left_panel, self.line_out]))
def __init__(self, the_workchain=None, job_details=None, presub_calls=[], **kwargs): """ Submit Button :param """ self.the_workchain = the_workchain self.submit_details = {} self.job_details = job_details # list of methods to call after submit button is pressed self.presub_calls = presub_calls self.btn_submit = ipw.Button(description="Submit", disabled=False) self.walltime = ipw.IntText(value=86000, description='walltime', style={'description_width': '120px'}, layout={'width': '30%'}) self.submit_out = ipw.Output() self.job_details['walltime'] = self.walltime.value def set_walltime(c): self.job_details['walltime'] = self.walltime.value def on_btn_submit_press(b): for presub_call in self.presub_calls: presub_call() #self.parse_job_details() keys_defined = self.job_details.keys() with self.submit_out: clear_output() ### CHECK VALIDITY OF INPUTS if 'structure' not in keys_defined: print("Please select a structure.") return if 'cp2k_code' not in keys_defined: print("Please select a computer.") return if len(self.job_details['calc_name']) < 5: print("Please enter a longer calculation description.") return ### ODD CHARGE AND RKS odd_charge = self.job_details['slab_analyzed']['total_charge'] if 'charge' in self.job_details.keys(): odd_charge += self.job_details['charge'] rks = True if 'uks_switch' in self.job_details.keys(): if self.job_details['uks_switch'] == 'UKS': rks = False if odd_charge % 2 > 0 and rks: print("ODD CHARGE AND RKS") return if self.job_details['workchain'] == 'NEBWorkchain': if len(self.job_details['replica_pks'].split()) < 2: print('Please select at least two replica_pks') return if self.job_details['workchain'] == 'PhononsWorkchain': num_calcs = self.job_details['ncalcs'] num_rep = self.job_details['nreplicas'] if not (num_calcs % num_rep) == 0: print('#Calculations', num_calcs) print('#Replicas', num_rep) print( 'Choose #Replicas so that #Calculations % #Replicas is 0.' ) return self.structure = self.job_details['structure'] self.code = self.job_details['cp2k_code'] print("SUBMITTING workchain ", self.the_workchain) print("") self.btn_submit.disabled = True self.parse_job_details() for field in self.submit_details.keys(): #if field != 'slab_analyzed': print(field, self.submit_details.get_dict()[field]) if self.job_details['calc_name'] != 'DO NOT SUBMIT': arg_dict = { 'code': self.code, 'structure': self.structure, 'parameters': self.submit_details } if self.struc_folder is not None: arg_dict['struc_folder'] = self.struc_folder outputs = submit(self.the_workchain, **arg_dict) print(outputs) else: print("TEST NO SUBMISSION") theworkchain = self.the_workchain() outputs = theworkchain.build_calc_inputs( structure=self.structure, input_dict=self.submit_details.get_dict()) print(outputs['parameters'].get_dict()) print("") print("DONE") if self.job_details['calc_name'] != 'DO NOT SUBMIT': the_workcalc = load_node(outputs.pid) the_workcalc.description = self.job_details['calc_name'] self.btn_submit.on_click(on_btn_submit_press) self.walltime.observe(set_walltime, 'value') ### --------------------------------------------------------- ### Define the ipw structure and create parent VBOX children = [ ipw.HBox([self.btn_submit, self.walltime]), self.submit_out ] super(SubmitButton, self).__init__(children=children, **kwargs)
def input_reactions_widget(substances, properties): input_reactions_textbox = widgets.Textarea( value= '# Write reactions using substance \'symbols\'\n# e.g. Calcite (left column) not CaCO3\n# Carefully balance the reactions!\nH2O@ = H+ + OH-', description='', layout=Layout(max_width='max-content', min_width='360px', max_height='max-content', height='340px')) """ Widget with a search field and lots of checkboxes """ search_widget = widgets.Text(description="Search", style={'description_width': '50px'}) subst_dict = { description: widgets.Text(layout={'width': '285px'}, style={'description_width': '100px'}, description=description, value=substances[description].formula(), disabled=True) for description in substances.keys() } box_layout = Layout( #overflow_y='scroll', #border='3px solid black', width='max-content', height='320px', flex_flow='column', display='flex', align_items='stretch', color='blue') substs = [subst_dict[description] for description in substances.keys()] #records] subst_widget = widgets.VBox(substs, layout=box_layout) # Wire the search field to the checkboxes def on_text_change(change): search_input = change['new'] if search_input == '': # Reset search field new_options = [ subst_dict[description] for description in substances.keys() ] else: # Filter by search field using difflib. # close_matches = difflib.get_close_matches(search_input, records, n=5, cutoff=0.0) # close_matches = list(filter(lambda x: search_input in x, records)) close_matches = [ x for x in substances.keys() if re.search( search_input, substances[x].formula(), re.IGNORECASE) ] new_options = [ subst_dict[description] for description in close_matches ] subst_widget.children = new_options props_dict = { description: widgets.Checkbox(description=description, value=False, style={'description_width': '10px'}) for description in properties } props_dict[properties[0]].value = True options_props = [props_dict[description] for description in properties] txt = widgets.Label(value='Properties') props_widget = widgets.VBox(options_props, layout=box_layout) props_txt = widgets.VBox([txt, props_widget]) search_widget.observe(on_text_change, names="value") multi_select = widgets.VBox([search_widget, subst_widget]) multi_data = widgets.HBox( [multi_select, input_reactions_textbox, props_txt]) return multi_data
def __init__(self): # Should now scale for the time of day effect # TAF - Temporal Allocation Factor # Get from up-to-date Tom Tom web site: # https://www.tomtom.com/en_gb/traffic-index/edinburgh-traffic/ # For a typical Wednesday since that seems to be the eveing rush-hour with most congestion # TAF list has % congestion by hour starting at hour 0, midnight # In Jupyter Notebook make this a Figure self.TomTom_congestion = [2, 0, 0, 0, 0, 0, 13, 54, 80, 50, 38, 38, 40, \ 40, 42, 55, 81, 86, 54, 30, 20, 16, 14, 8] #print(sum(TomTom_congestion)) self.trafficstats = {"AADT": 10000, "hour": 12, "vs": 15} # Now adjust for fleet Mix and AADT and Time # Defaults - get from spreadsheet for 2020 # Urban split for England in 2020 below since that's likely to be the most relevant # Use a selection box for this self.fleetmix_2020 = { "electric": 0.5, "petrol": 47.8, "diesel": 33.1, "petrol_lgv": 0.4, "diesel_lgv": 15.0, "rigid": 0.9, "artic": 0.4, "biodiesel": 0.1, "buses": 0.7, "motorcycle": 0.9, "lpg": 0.2 } self.sumt = 0.0 for x in self.fleetmix_2020.values(): self.sumt = self.sumt + x self.sumtt = (str(int(self.sumt))) #print(self.sumtt) self.bft_electric = widgets.BoundedFloatText( value=self.fleetmix_2020["electric"], min=0.1, max=90, step=1, description="electric %", width=50) self.bft_petrol_cars = widgets.BoundedFloatText( value=self.fleetmix_2020["petrol"], min=1, max=99, step=1, description="petrol cars %", width=50) self.bft_diesel_cars = widgets.BoundedFloatText( value=self.fleetmix_2020["diesel"], min=1, max=99, step=1, description="diesel cars %", width=50) self.bft_petrol_lgv = widgets.BoundedFloatText( value=self.fleetmix_2020["petrol_lgv"], min=0.1, max=25.0, step=0.1, description="petrol lgv %", width=50) self.bft_diesel_lgv = widgets.BoundedFloatText( value=self.fleetmix_2020["diesel_lgv"], min=0.1, max=25.0, step=1, description="diesel lgv %", width=50) self.bft_rigid_truck = widgets.BoundedFloatText( value=self.fleetmix_2020["rigid"], min=0.1, max=10.0, step=0.1, description="rigid truck %", width=50) self.bft_artic_truck = widgets.BoundedFloatText( value=self.fleetmix_2020["artic"], min=0.1, max=10.0, step=0.1, description="artic truck %", width=50) self.bft_biodiesel = widgets.BoundedFloatText( value=self.fleetmix_2020["biodiesel"], min=0.1, max=10.0, step=0.1, description="biodiesel %", width=50) self.bft_buses = widgets.BoundedFloatText( value=self.fleetmix_2020["buses"], min=0.1, max=50.0, step=0.1, description="buses %", width=50) self.bft_motorcycles = widgets.BoundedFloatText( value=self.fleetmix_2020["motorcycle"], min=0.1, max=35.0, step=0.1, description="motorcycles %", width=50) self.bft_lpg = widgets.BoundedFloatText( value=self.fleetmix_2020["lpg"], min=0.1, max=35.0, step=0.1, description="LPG %", width=50) self.sumtotal = widgets.Text(value=self.sumtt, description="Total should be 100%", width=50, color='red') self.bft_electric.observe(self.bft_electric_eventhandler, names='value') self.bft_hour = widgets.BoundedIntText(value=self.trafficstats["hour"], min=1, max=24, step=1, description="Hour of Day") self.bft_AADT = widgets.BoundedIntText(value=self.trafficstats["AADT"], min=1000, max=755000, step=2500, description="AADT") self.bft_vs = widgets.BoundedIntText(value=self.trafficstats["vs"], min=10, max=130, step=5, description="Speed (km/h)") self.bft_petrol_cars.observe(self.bft_petrol_cars_eventhandler, names='value') self.bft_diesel_cars.observe(self.bft_diesel_cars_eventhandler, names='value') self.bft_petrol_lgv.observe(self.bft_petrol_lgv_eventhandler, names='value') self.bft_diesel_lgv.observe(self.bft_diesel_lgv_eventhandler, names='value') self.bft_rigid_truck.observe(self.bft_rigid_truck_eventhandler, names='value') self.bft_artic_truck.observe(self.bft_artic_truck_eventhandler, names='value') self.bft_biodiesel.observe(self.bft_biodiesel_eventhandler, names='value') self.bft_buses.observe(self.bft_buses_eventhandler, names='value') self.bft_motorcycles.observe(self.bft_motorcycles_eventhandler, names='value') self.bft_lpg.observe(self.bft_lpg_eventhandler, names='value') self.bft_hour.observe(self.bft_hour_eventhandler, names='value') self.bft_AADT.observe(self.bft_AADT_eventhandler, names='value') self.bft_vs.observe(self.bft_vs_eventhandler, names='value') self.btn = widgets.Button(description='Run RLINE', width=100) self.btn.style.button_color = 'tomato' self.btn.on_click(self.btn_eventhandler) self.h1 = widgets.HBox(children=[ self.bft_electric, self.bft_petrol_cars, self.bft_diesel_cars ]) self.h2 = widgets.HBox(children=[ self.bft_petrol_lgv, self.bft_diesel_lgv, self.bft_rigid_truck ]) self.h3 = widgets.HBox(children=[ self.bft_artic_truck, self.bft_biodiesel, self.bft_buses ]) self.h4 = widgets.HBox( children=[self.bft_motorcycles, self.bft_lpg, self.sumtotal])