def __init__(self, io): # create the widgets connectivity = v.Select(label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]['value']) res = v.TextField(label=cm.acc.res, type='number', v_model=None, hint=cm.acc.res_hint) thresholds = cw.Thresholds(label=cm.acc.thresholds) options = v.Select(label=cm.acc.options, items=cp.acc_options, v_model=cp.acc_options[0]['value']) # bind to the io self.output = sw.Alert() \ .bind(connectivity, io, 'connectivity') \ .bind(res, io, 'res') \ .bind(thresholds.save, io, 'thresholds') \ .bind(options, io, 'options') # extra js behaviour res.on_event('focusout', self._on_focus_out) super().__init__(io=io, output=self.output, inputs=[connectivity, res, thresholds, options])
def __init__(self, model): # create the widgets connectivity = v.Select( label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]["value"], ) prescision = v.Select( label=cm.fad.prescision, items=cp.prescision, v_model=cp.prescision[0]["value"], ) options = v.Select( label=cm.acc.options, items=cp.fad_options, v_model=cp.fad_options[0]["value"], ) # bind to the io ( model.bind(connectivity, "connectivity") .bind(prescision, "prescision") .bind(options, "options") ) super().__init__( model=model, inputs=[connectivity, prescision, options], )
def __init__(self, cases): """ Widget definition for models. Parameters ========== cases: dict the keys of this dictionary are the name of the model, the values of this dictionary are an instance of the model. This widget is composed by a menu where you can choose the dimension and the model. This widget is also composed by a main widget where a description of the model is given. """ self.cases = cases default_category = next(iter(self.cases)) ## ## The menu ## # widget to select the model self.select_category = v.Select( items=list(self.cases.keys()), v_model=default_category, label='Category', ) self.select_model = v.Select( items=[], v_model=None, label='Model' ) self.menu = [self.select_category, self.select_model] ## ## The main ## self.description = HTML() self.tabs = v.Tabs( v_model=None, children=[ v.Tab(children=['Description']), v.TabItem(children=[self.description]), ] ) self.main = [self.tabs] # Add the widget events self.select_category.observe(self.change_category, 'v_model') self.select_model.observe(self.change_model, 'v_model') # update the category to fix the default model self.change_category(None)
def __init__(self, io): # create the widgets connectivity = v.Select(label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]['value']) res = v.TextField(label=cm.acc.res, type='number', v_model=None, hint=cm.acc.res_hint) windows = cw.Windows(label=cm.frag.windows) options = v.Select(label=cm.acc.options, items=cp.fad_options, v_model=cp.fad_options[0]['value']) prescision = v.Select(label=cm.fad.prescision, items=cp.prescision, v_model=cp.prescision[0]['value']) # bind to the io self.output = sw.Alert() \ .bind(connectivity, io, 'connectivity') \ .bind(res, io, 'res') \ .bind(windows.save, io, 'window_size') \ .bind(options, io, 'options') \ .bind(prescision, io, 'prescision') # extra js behaviour res.on_event('focusout', self._on_focus_out) super().__init__( io=io, inputs=[connectivity, res, windows, options, prescision], output=self.output)
def __init__(self, io): # create the widgets algorithm = v.Select(label=cm.p223.algo, items=cp.algo, v_model=cp.algo[0]['value']) kdim = v.TextField(label=cm.lm.kdim, type='number', hint=cm.frag.invalid_window, v_model=None) prescision = v.Select(label=cm.fad.prescision, items=cp.prescision, v_model=cp.prescision[0]['value']) # bind to the io self.output = sw.Alert() \ .bind(algorithm, io, 'algorithm') \ .bind(kdim, io, 'kdim') \ .bind(prescision, io, 'prescision') # create extra js behaviour kdim.on_event('focusout', self._on_focusout) super().__init__(io=io, inputs=[ algorithm, kdim, prescision, ], output=self.output)
def __init__(self): self.label = v.TextField(label='label', v_model='') self.line_style = v.Select(label='Line style', items=[{ 'text': v, 'value': k } for k, v in Line2D.lineStyles.items()], v_model=plot_config['linestyle']) self.line_width = IntField(label='linewidth', v_model=plot_config['linewidth']) self.marker = v.Select(label='Marker', items=[{ 'text': v, 'value': k } for k, v in Line2D.markers.items()], v_model=plot_config['marker']) self.marker_size = IntField(label='Marker size', v_model=plot_config['markersize']) self.alpha = FloatField(label='alpha', v_model=plot_config['alpha']) self.color = v.ColorPicker(v_model=plot_config['colors'][0]) self.widget = [ self.label, self.line_style, self.line_width, self.marker, self.marker_size, self.alpha, v.Row(children=[self.color], justify='center'), ]
def __init__(self, model): # create the widgets connectivity = v.Select( label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]["value"], ) res = v.TextField( label=cm.acc.res, type="number", v_model=None, hint=cm.acc.res_hint ) thresholds = cw.Thresholds(label=cm.acc.thresholds) options = v.Select( label=cm.acc.options, items=cp.acc_options, v_model=cp.acc_options[0]["value"], ) big_3_pink = v.Switch(label=cm.acc.big3pink, v_model=True) # bind to the ( model.bind(connectivity, "connectivity") .bind(res, "res") .bind(thresholds.save, "thresholds") .bind(options, "options") .bind(big_3_pink, "big_3_pink") ) # extra js behaviour res.on_event("focusout", self._on_focus_out) super().__init__( model=model, inputs=[connectivity, res, thresholds, options, big_3_pink] )
def __init__(self, label='vector_file', **kwargs): # save the df for column naming (not using a gdf as geometry are useless) self.df = None # set the 3 wigets self.w_file = FileInput(['.shp', '.geojson', '.gpkg', '.kml'], label=label) self.w_column = v.Select(_metadata={'name': 'column'}, items=self.column_base_items, label='Column', v_model='ALL') self.w_value = v.Select(_metadata={'name': 'value'}, items=[], label='Value', v_model=None) su.hide_component(self.w_value) # create the Col Field self.children = [self.w_file, self.w_column, self.w_value] self.v_model = self.default_v_model super().__init__(**kwargs) # events self.w_file.observe(self._update_file, 'v_model') self.w_column.observe(self._update_column, 'v_model') self.w_value.observe(self._update_value, 'v_model')
def __init__(self, label="Table file"): self.fileInput = FileInput(['.csv', '.txt'], label=label) self.IdSelect = v.Select(_metadata={'name': 'id_column'}, items=[], label='Id', v_model=None) self.LngSelect = v.Select(_metadata={'name': 'lng_column'}, items=[], label='Longitude', v_model=None) self.LatSelect = v.Select(_metadata={'name': 'lat_column'}, items=[], label='Latitude', v_model=None) super().__init__(v_model=self.default_v_model, children=[ self.fileInput, self.IdSelect, self.LngSelect, self.LatSelect ]) # link the dropdowns jslink((self.IdSelect, 'items'), (self.LngSelect, 'items')) jslink((self.IdSelect, 'items'), (self.LatSelect, 'items')) # link the widget with v_model self.fileInput.observe(self._on_file_input_change, 'v_model') self.IdSelect.observe(self._on_select_change, 'v_model') self.LngSelect.observe(self._on_select_change, 'v_model') self.LatSelect.observe(self._on_select_change, 'v_model')
def __init__(self, phys_fields, *args, **kwargs): self.phys_fields = phys_fields self.select_field = v.Select(label='Fields', v_model=[], items=['all'] + phys_fields, required=True, multiple=True) self.select_when = v.Select(label='When', v_model=None, items=[t.value for t in SaveType], required=True) self.when_properties = v.TextField(label='when save the fields?', v_model=None, required=True) self.select_field.observe(self.select_fields_rules, 'v_model') self.select_field.observe(self.select_fields_all, 'v_model') self.select_when.observe(self.select_when_rules, 'v_model') self.select_when.observe(self.when_properties_rules, 'v_model') self.when_properties.observe(self.when_properties_rules, 'v_model') self.fields = [ self.select_field, self.select_when, self.when_properties ] super().__init__(v_model='valid', children=[ self.select_field, self.select_when, self.when_properties, ])
def __init__(self, model, aoi_model, viz_tile, export_tile, **kwargs): # Define the model and the aoi_model as class attribute so that they can be manipulated in its custom methods self.model = model self.aoi_model = aoi_model # LINK to the result tile self.viz_tile = viz_tile self.export_tile = export_tile # WIDGETS self.year_beg = v.Select( label=cm.process.slider_b, v_model=None, items=[i for i in range(pm.max_year, pm.min_year - 1, -1)], ) self.year_end = v.Select( label=cm.process.slider_e, v_model=None, items=[i for i in range(pm.max_year, pm.min_year - 1, -1)], ) self.type_tmf = v.RadioGroup( row=True, v_model=pm.layer_select[0]["value"], children=[ v.Radio(key=e["key"], label=e["label"], value=e["value"]) for e in pm.layer_select ], ) # self.type_tmf.observe(self._on_change, 'v_model') # Create the alert alert self.model.bind(self.year_beg, "year_beg").bind( self.year_end, "year_end").bind(self.type_tmf, "type_tmf") # construct the Tile with the widget we have initialized super().__init__( id_= "process_widget", # the id will be used to make the Tile appear and disapear title=cm.process. title, # the Title will be displayed on the top of the tile inputs=[self.year_beg, self.year_end, self.type_tmf], btn=sw.Btn(cm.process.validate, "mdi-check", disabled=False, class_="ma-5"), alert=sw.Alert(), ) # now that the Tile is created we can link it to a specific function self.btn.on_event("click", self._on_run)
def __init__(self, aoi_model, model, **kwargs): # gather the model self.aoi_model = aoi_model self.model = model # widgets self.stats = v.Select( label=ms.export.stats, v_model=model.stats, items=pm.stats, chips=True, multiple=True, ) self.temps = v.Select( label=ms.export.temps, v_model=model.temps, items=pm.temps, chips=True, multiple=True, ) self.scale = v.TextField(label=ms.export.scale, v_model=30) # create buttons self.asset_btn = sw.Btn(ms.export.asset_btn, "mdi-download", disabled=True, class_="ma-5") self.sepal_btn = sw.Btn(ms.export.sepal_btn, "mdi-download", disabled=True, class_="ma-5") # bindings self.model.bind(self.stats, "stats").bind(self.temps, "temps").bind(self.scale, "scale") # note that btn and output are not a madatory attributes super().__init__( id_="export_widget", title=ms.export.title, inputs=[self.stats, self.temps, self.scale], alert=sw.Alert(), btn=v.Layout(row=True, children=[self.asset_btn, self.sepal_btn]), ) # link the btn self.asset_btn.on_event("click", self._on_asset_click) self.sepal_btn.on_event("click", self._on_sepal_click)
def __init__(self, label='', **kwargs): self.class_ = 'd-flex align-center mb-2' self.disabled = True self.row = True self.label = label super().__init__(**kwargs) self.w_prev = v.Btn(_metadata={'name': 'previous'}, x_small=True, children=[ v.Icon(left=True, children=['mdi-chevron-left']), 'prev' ]) self.w_next = v.Btn( _metadata={'name': 'next'}, x_small=True, children=[v.Icon(children=['mdi-chevron-right']), 'nxt']) self.w_list = v.Select(class_='ma-2', label=self.label, items=self.items, v_model='') self.children = [self.w_prev, self.w_list, self.w_next] link((self.w_list, 'items'), (self, 'items')) link((self.w_list, 'v_model'), (self, 'v_model')) self.w_prev.on_event('click', self.prev_next_event) self.w_next.on_event('click', self.prev_next_event)
def __init__(self, io): # create the widgets connectivity = v.Select(label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]['value']) edge_width = v.Slider(label=cm.mspa.edge_width, min=1, max=30, v_model=1) transition = v.Switch(label=cm.mspa.transition, false_value=0, true_value=1, v_model=1) int_ext = v.Switch(label=cm.mspa.int_ext, false_value=0, true_value=1, v_model=1) # bind to the io self.output = sw.Alert() \ .bind(connectivity, io, 'connectivity') \ .bind(edge_width, io, 'edge_width') \ .bind(transition, io, 'transition') \ .bind(int_ext, io, 'int_ext') super().__init__( io=io, inputs=[connectivity, edge_width, transition, int_ext], output=self.output)
def __init__(self, viz): super(type(self), self).__init__(column=True) self.viz = viz self.ds = self.viz.state.ds column_names = self.ds.get_column_names() self.x = v.Select(items=column_names, v_model=self.viz.state.x_expression, label='x axis') widgets.link((self.viz.state, 'x_expression'), (self.x, 'v_model')) self.y = v.Select(items=column_names, v_model=self.viz.state.y_expression, label='y axis') widgets.link((self.viz.state, 'y_expression'), (self.y, 'v_model')) self.normalize = v.Checkbox(label='normalize', v_model=self.viz.normalize) widgets.link((self.viz, 'normalize'), (self.normalize, 'v_model')) self.children = [self.x, self.y, self.normalize]
def __init__(self, io, nb_class): # gather the io self.io = io # create the widgets self.file = sw.FileInput(['.tif', '.tiff']) self.classes = [ v.Select(label=cp.convert[nb_class]['label'][i], items=None, v_model=None, chips=True, multiple=True) for i in range(nb_class) ] requirements = sw.Markdown(cm.requirement[nb_class]) # bind it to the io self.output = sw.Alert().bind(self.file, self.io, 'file') for i in range(nb_class): self.output.bind(self.classes[i], self.io, cp.convert[nb_class]['io'][i]) # create the btn btn = sw.Btn("Convert the imag classes") super().__init__(self.io.tile_id, "Select map classes", inputs=[requirements, self.file] + self.classes, output=self.output, btn=btn) # bind js event btn.on_event('click', self._on_click) self.file.observe(self._on_change, 'v_model')
def __init__(self): self.prev = v.Btn(_metadata={'increm': -1}, x_small=True, class_='ml-2 mr-2', color=sc.secondary, children=[ v.Icon(children=['mdi-chevron-left']), cm.dynamic_select.prev ]) self.next = v.Btn(_metadata={'increm': 1}, x_small=True, class_='ml-2 mr-2', color=sc.secondary, children=[ cm.dynamic_select.next, v.Icon(children=['mdi-chevron-right']) ]) self.select = v.Select(dense=True, label=cm.dynamic_select.label, v_model=None) super().__init__(v_model=None, align_center=True, row=True, class_='ma-1', children=[self.prev, self.select, self.next]) # js behaviour jslink((self, 'v_model'), (self.select, 'v_model')) self.prev.on_event('click', self._on_click) self.next.on_event('click', self._on_click)
def __init__(self, aoi_model, model, **kwargs): # gather the model self.aoi_model = aoi_model self.model = model # widgets self.measure = v.Select(label=ms.selection.measure, v_model=None, items=pm.measures) self.annual = v.Switch(class_="ml-5", label=ms.selection.annual, v_model=False) # add the map self.m = sm.SepalMap() # create an output alert self.model.bind(self.measure, "measure").bind(self.annual, "annual") # construct the Tile with the widget we have initialized super().__init__( id_= "visualization_widget", # the id will be used to make the Tile appear and disapear title=ms.visualization. title, # the Title will be displayed on the top of the tile inputs=[self.measure, self.annual, self.m], alert=sw.Alert(), ) self.measure.observe(self._on_change, "v_model") self.annual.observe(self._on_change, "v_model")
def construct_selects_container(selects_meta: dict, title=None): """ Constructs a group of selector dropdowns Accepts: - selects_meta: dict Mapping from the select labels to their respective lists from which the selection will be pre-populated - title: str Label which will be added as a p tag at the top of the section container Returns: - selects_container Container object with each select as a child """ selects_list = [ v.Select(label=label, items=prepop_list, v_model="") for label, prepop_list in selects_meta.items() ] if title is not None: assert isinstance(title, str), f"Title must be a string, not {type(title)}" selects_list = [v.Html(tag="p", children=[title])] + selects_list selects_container = v.Container(children=selects_list) return selects_container
def __init__(self, test_case_widget, lb_scheme_widget): self.responses = {} self.responses_list = v.Select(label='Responses', v_model=[], items=[], multiple=True) def update_responses(change): test_case = test_case_widget.get_case() lb_scheme = lb_scheme_widget.get_case() self.responses = build_responses_list(test_case, lb_scheme) self.responses_list.items = ['all'] + list(self.responses.keys()) def select_all(change): if 'all' in self.responses_list.v_model: self.responses_list.v_model = list(self.responses.keys()) update_responses(None) self.responses_list.observe(select_all, 'v_model') test_case_widget.select_case.observe(update_responses, 'v_model') lb_scheme_widget.select_case.observe(update_responses, 'v_model') self.widget = self.responses_list
def __init__(self, test_case_widget, lb_scheme_widget, discret_widget, **kwargs): self.test_case_widget = test_case_widget self.lb_scheme_widget = lb_scheme_widget self.discret_widget = discret_widget self.params, self.relax_params = None, None self.select_param = v.Select(label='Parameters', v_model=None, items=[]) self.select_relax = v.Select(label='relaxation rates', v_model=[], items=[], multiple=True, class_='d-none') self.srt_relax = v.Switch(label='Single relaxation time', v_model=True, class_='d-none') self.sigma = v.Switch(label='Using sigma', v_model=False, class_='d-none') self.in_log = v.Switch(label='Using log10', v_model=False, class_='d-none') self.minmax = v.Layout() self.update_select_fields(None) test_case_widget.select_case.observe(self.update_select_fields, 'v_model') lb_scheme_widget.select_case.observe(self.update_select_fields, 'v_model') discret_widget['dx'].observe(self.update_select_fields, 'v_model') self.fields = [ self.select_param, self.select_relax, self.srt_relax, self.sigma, self.in_log, self.minmax ] super().__init__(v_model='valid', children=self.fields) self.select_param.observe(self.select_param_changed, 'v_model') self.select_relax.observe(self.select_relax_all, 'v_model') self.select_relax.observe(self.check_changes, 'v_model') self.in_log.observe(self.check_changes, 'v_model') self.sigma.observe(self.check_changes, 'v_model')
def __init__(self, model, aoi_model, viz_tile, export_tile, **kwargs): # Define the model and the aoi_model as class attribute so that they can be manipulated in its custom methods self.model = model self.aoi_model = aoi_model # Link to the result tile self.viz_tile = viz_tile self.export_tile = export_tile # widgets self.year = v.Select(label=ms.process.slider, v_model=None, items=pm.years[::-1]) self.filter = v.Select(label=ms.process.filter, v_model=None, items=pm.speckle_filters) self.ls_mask = v.Switch(class_="ml-5", label=ms.process.ls_mask, v_model=True) self.dB = v.Switch(class_="ml-5", label=ms.process.dB, v_model=True) # it also has the embeded `bind` method that link mutable variable to component v_model # bind return self so it can be chained to bind everything in one statement. # args are (widget, model, model_attribute_name) self.model.bind(self.year, "year").bind(self.filter, "filter").bind( self.ls_mask, "ls_mask").bind(self.dB, "dB") # construct the Tile with the widget we have initialized super().__init__( id_= "process_widget", # the id will be used to make the Tile appear and disapear title=ms.process. title, # the Title will be displayed on the top of the tile inputs=[self.year, self.filter, self.ls_mask, self.dB], # self.asset, btn=sw.Btn(ms.process.process), alert=sw.Alert(), ) # now that the Tile is created we can link it to a specific function self.btn.on_event("click", self._on_run)
def __init__(self, model): # create the widgets options = v.Select(label=cm.spa.nb_classes, items=cp.spa_options, v_model=None) # bind to the io model.bind(options, "options") super().__init__(model=model, inputs=[options])
def __init__(self, io): # create the widgets connectivity = v.Select(label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]['value']) options = v.Select(label=cm.acc.options, items=cp.dist_options, v_model=cp.dist_options[0]['value']) # bind to the io self.output = sw.Alert() \ .bind(connectivity, io, 'connectivity') \ .bind(options, io, 'options') super().__init__(io=io, inputs=[connectivity, options], output=self.output)
def __init__(self, table, **kwargs): self.table = table update = v.Btn(children=['update']) close = v.Btn(children=['close']) self.form = [ IntField(label='linewidth', v_model=plot_config['linewidth']), v.Select(label='Line style', items=[{ 'text': v, 'value': k } for k, v in Line2D.lineStyles.items()], v_model=plot_config['linestyle']), v.Select(label='Marker', items=[{ 'text': v, 'value': k } for k, v in Line2D.markers.items()], v_model=plot_config['marker']), IntField(label='Marker size', v_model=plot_config['markersize']), FloatField(label='alpha', v_model=plot_config['alpha']), v.ColorPicker(v_model=plot_config['colors'][0]), ] self.dialog = v.Dialog( width='500', v_model=False, children=[ v.Card(children=[ v.CardTitle(class_='headline gray lighten-2', primary_title=True, children=['Plot properties']), v.CardText(children=self.form), v.CardActions(children=[v.Spacer(), update, close]) ]), ]) def close_btn(widget, event, data): self.dialog.v_model = False update.on_event('click', self.update_btn) close.on_event('click', close_btn) super().__init__(**kwargs)
def __init__(self, aoi_model, model, viz_tile, export_tile, **kwargs): # gather the model self.aoi_model = aoi_model self.model = model self.viz_tile = viz_tile self.export_tile = export_tile # widgets w_time_title = v.Html(tag="H3", class_="mt-3", children=[ms.selection.time_range]) self.start_picker = sw.DatePicker(label=ms.selection.start) self.end_picker = sw.DatePicker(label=ms.selection.end) w_time_range = v.Layout(row=True, children=[self.start_picker, self.end_picker]) w_collection_title = v.Html(tag="H3", class_="mt-3", children=[ms.selection.collection]) self.sensors = v.Select( label=ms.selection.sensor, items=pm.sensors, v_model=None, chips=True, multiple=True, ) self.t2 = v.Switch(class_="ml-5", label=ms.selection.t2, v_model=False) self.sr = v.Switch(class_="ml-5", label=ms.selection.sr, v_model=False) self.model.bind(self.start_picker, "start").bind(self.end_picker, "end").bind( self.sensors, "sensors").bind(self.t2, "t2").bind(self.sr, "sr") # construct the Tile with the widget we have initialized super().__init__( id_= "selection_widget", # the id will be used to make the Tile appear and disapear title=ms.selection. title, # the Title will be displayed on the top of the tile inputs=[ w_time_title, w_time_range, w_collection_title, self.sensors, self.t2, self.sr, ], btn=sw.Btn(ms.selection.btn), alert=sw.Alert(), ) # now that the Tile is created we can link it to a specific function self.btn.on_event("click", self._on_run)
def __init__(self, class_path=Path("~").expanduser() / "downloads", *args, **kwargs): """Stand-alone tile composed by a select widget containing .csv reclassify files found in the class_path, and a ClassTable to edit and/or create a new classification table, Args: class_path (str) (optional): Folder path containing classification tables """ super().__init__(*args, **kwargs) self.title = v.CardTitle( children=["Edit or create new classifications"]) self.class_path = class_path self.w_class_file = v.Select( label="Select a classes file", items=self.get_items(), v_model="", dense=True, ) self.ct = ClassTable( out_path=self.class_path, schema={ "id": "number", "code": "number", "description": "string" }, ).hide() use_btn = sw.Btn("Get table") self.children = [ self.title, v.Flex( class_="ml-2 d-flex", children=[ self.w_class_file, use_btn, ], ), self.ct, ] self.get_classes_files() # Events # Listen Class table save dialog to refresh the classes widget self.ct.save_dialog.observe(self._refresh_files, "reload") # Get the corresponding table use_btn.on_event("click", self.get_class_table)
def __init__(self, io): # create the widgets connectivity = v.Select(label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]) # bind to the io self.output = sw.Alert() \ .bind(connectivity, io, 'connectivity') super().__init__(io=io, inputs=[connectivity], output=self.output)
def __init__(self, model): # create the widgets connectivity = v.Select( label=cm.acc.connectivity, items=cp.connectivity, v_model=cp.connectivity[0]["value"], ) # bind to the io model.bind(connectivity, "connectivity") super().__init__(model=model, inputs=[connectivity])
def __init__(self, io, nb_class): # gather the io self.io = io # create the download layout self.down_test = sw.Btn(cm.bin.default.btn, icon="mdi-cloud-download-outline", small=True, outlined=True, class_="ma-5") tooltip = sw.Tooltip(widget=self.down_test, tooltip=cm.bin.default.tooltip) # create the widgets self.file = sw.FileInput(['.tif', '.tiff']) self.classes = [ v.Select(label=cp.convert[nb_class]['label'][i], items=None, v_model=None, chips=True, small_chips=True, multiple=True, dense=True, deletable_chips=True) for i in range(len(cp.convert[nb_class]['label'])) ] requirements = sw.Markdown(cm.requirement[nb_class]) # bind it to the io self.output = sw.Alert().bind(self.file, self.io, 'file') for i in range(len(cp.convert[nb_class]['label'])): self.output.bind(self.classes[i], self.io, cp.convert[nb_class]['io'][i]) # create the btn btn = sw.Btn(cm.bin.btn) super().__init__( self.io.tile_id, cm.bin.title, inputs=[tooltip, v.Divider(), requirements, self.file] + self.classes, output=self.output, btn=btn) # bind js event btn.on_event('click', self._on_click) self.file.observe(self._on_change, 'v_model') self.down_test.on_event('click', self._on_download)