class Trace(nowidget.Trait): collector = traitlets.Any() trace = traitlets.Any() traces = traitlets.List() max_dict_size = traitlets.Integer(1000) def log(self, trace): self.traces.append(trace) def flush(self): self.flushed = True def __enter__(self): self.trace = monkeytype.tracing.trace_calls( self, self.max_dict_size, lambda c: c.co_filename.startswith( '<ipython-input-') ) self.toggle(True) self.trace.__enter__() def __exit__(self, type=None, object=None, traceback=None): self.toggle(False) self.trace.__exit__(type, object, traceback) def stub(self, line=None, cell=None): # if line is None: return {k: v.render() for k, v in monkeytype.stubs.build_module_stubs_from_traces( self.traces, self.max_dict_size).items()} on = __enter__ off = __exit__
class Grid(tr.HasTraits): x = tr.Any() y = tr.Any() z = tr.Any() theta = tr.Any() phi = tr.Any() nomega = tr.Int() def __init__(self): super().__init__() self.init_dims() self.init_logic() def init_dims(self): ns = 20 na = 20 self.x = SpaceDim(-5, 5, ns) self.y = SpaceDim(-5, 5, ns) self.z = SpaceDim(0, 10, ns) self.theta = AngleDim(0, 2 * np.pi, na) self.phi = AngleDim(0, np.pi, int(np.floor(na / 2))) self.calculate_nomega() def calculate_nomega(self, *args): self.nomega = self.theta.num * (self.phi.num - 2) + 2 def init_logic(self): self.theta.observe(self.calculate_nomega, names='num') self.phi.observe(self.calculate_nomega, names='num')
class TableGlue(TableBase): data = traitlets.Any() # Glue data object apply_filter = traitlets.Any() # callback def __len__(self): return self.data.shape[0] def _get_headers(self): components = [str(k) for k in self.data.main_components + self.data.derived_components] return [{'text': k, 'value': k, 'sortable': False} for k in components] def _get_items(self): page = self.options['page'] - 1 page_size = self.options['itemsPerPage'] i1 = page * page_size i2 = min(len(self), (page + 1) * page_size) view = slice(i1, i2) masks = {k.label: k.to_mask(view) for k in self.data.subsets} items = [] for i in range(i2 - i1): item = {'__row__': i + i1} # special key for the row number for selection in self.selections: selected = masks[selection][i] item[selection] = bool(selected) for j, component in enumerate(self.data.main_components + self.data.derived_components): item[str(component)] = self.format(self.data[component][i + i1]) items.append(item) return items def vue_apply_filter(self, data): self.apply_filter()
class SelectionEditor(v.VuetifyTemplate): df = traitlets.Any() input = traitlets.Any() adder = traitlets.Any() on_close = traitlets.Any() components = traitlets.Dict(None, allow_none=True).tag( sync=True, **widgets.widget.widget_serialization) @traitlets.default('components') def _components(self): return {'component-input': self.input, 'adder': self.adder} @traitlets.default('input') def _input(self): return ExpressionSelectionTextArea(df=self.df) @traitlets.default('adder') def _adder(self): return ColumnSelectionAdder(df=self.df, component=self.input) template = traitlets.Unicode(''' <v-layout column> <component-input></component-input> <v-layout pa-4> <adder></adder> </v-layout> </v-layout>''').tag(sync=True)
class Fn(Base): """ Turns a `source` into a `value` """ source = T.Any(allow_none=True).tag(sync=True) value = T.Any(allow_none=True).tag(sync=True) _observed_traits = ["source"] def __init__(self, *args, **kwargs): for i, arg in enumerate(args): kwargs[self._observed_traits[i]] = arg super(Fn, self).__init__(**kwargs) self.observe(self.the_observer, self._observed_traits) self.the_observer(None) def the_observer(self, *_): """ Base observer that updates value and/or error """ with self.hold_trait_notifications(): try: self.value = None self.value = self.the_function( **{t: getattr(self, t) for t in self._observed_traits}) self.error = "" except Exception as err: self.error = f"{err}"
class ToolsToolbar(v.VuetifyTemplate): interact_value = traitlets.Unicode(tools_items_default[0]['value'], allow_none=True).tag(sync=True) interact_items = traitlets.Any(tools_items_default).tag(sync=True) transform_value = traitlets.Unicode( transform_items_default[0]).tag(sync=True) transform_items = traitlets.List( traitlets.Unicode(), default_value=transform_items_default).tag(sync=True) supports_transforms = traitlets.Bool(True).tag(sync=True) supports_normalize = traitlets.Bool(True).tag(sync=True) z_normalize = traitlets.Bool(False, allow_none=True).tag(sync=True) normalize = traitlets.Bool(False).tag(sync=True) selection_mode_items = traitlets.Any(selection_items_default).tag( sync=True) selection_mode = traitlets.Unicode('replace').tag(sync=True) @traitlets.default('template') def _template(self): return load_template('vue/tools-toolbar.vue') @observe('z_normalize') def _observe_normalize(self, change): self.normalize = bool(self.z_normalize)
class VirtualColumnEditor(v.VuetifyTemplate): df = traitlets.Any() editor = traitlets.Any() adder = traitlets.Any() on_close = traitlets.Any() column_name = traitlets.Unicode('mycolumn').tag(sync=True) components = traitlets.Dict(None, allow_none=True).tag( sync=True, **widgets.widget.widget_serialization) @traitlets.default('components') def _components(self): return {'editor': self.editor, 'adder': self.adder} @traitlets.default('editor') def _editor(self): return ExpressionTextArea(df=self.df, rows=1) @traitlets.default('adder') def _adder(self): return ColumnExpressionAdder(df=self.df, component=self.editor) template = traitlets.Unicode(''' <v-layout column style="position: relative"> <v-text-field placeholder="e.g. mycolumn" label="Column name" v-model='column_name' prepend-icon='edit'>test</v-text-field> <editor></editor> <div style="position: absolute; right: 20px; bottom: 30px; opacity: 0.8"> <adder></adder> </div> </v-layout>''').tag(sync=True) def save_column(self): if self.editor.valid: self.df[self.column_name] = self.editor.v_model if self.on_close: self.on_close()
def __init__(self, use_iloc: bool = False, index: 'Any' = None, column: 'Any' = None, owner: pd.DataFrame = None, out: ipw.Output = ipw.Output(), **kwargs): super().__init__(**kwargs) self.use_iloc = use_iloc self.owner = owner self.out = out self.add_traits( value=tra.Any(), index=tra.Any(), column=tra.Any(), ) self.index = index self.column = column self.observe(self.update, names=[ 'column', 'index', ]) self.on_click(self.click) self.update(self.getvalue())
class VizHistogramState(VizBaseState): x_expression = traitlets.Unicode() x_slice = traitlets.CInt(None, allow_none=True) type = traitlets.CaselessStrEnum(['count', 'min', 'max', 'mean'], default_value='count') aux = traitlets.Unicode(None, allow_none=True) groupby = traitlets.Unicode(None, allow_none=True) groupby_normalize = traitlets.Bool(False, allow_none=True) x_min = traitlets.CFloat(None, allow_none=True) x_max = traitlets.CFloat(None, allow_none=True) grid = traitlets.Any().tag(**serialize_numpy) grid_sliced = traitlets.Any().tag(**serialize_numpy) x_centers = traitlets.Any().tag(**serialize_numpy) x_shape = traitlets.CInt(None, allow_none=True) #centers = traitlets.Any() def __init__(self, ds, **kwargs): super(VizHistogramState, self).__init__(ds, **kwargs) self.observe(lambda x: self.signal_slice.emit(self), ['x_slice']) self.observe(lambda x: self.calculate_limits(), ['x_expression', 'type', 'aux']) # no need for recompute # self.observe(lambda x: self.calculate_grid(), ['groupby', 'shape', 'groupby_normalize']) # self.observe(lambda x: self.calculate_grid(), ['groupby', 'shape', 'groupby_normalize']) self.observe(lambda x: self._update_grid(), ['x_min', 'x_max', 'shape']) if self.x_min is None and self.x_max is None: self.calculate_limits() else: self._calculate_centers() def bin_parameters(self): yield self.x_expression, self.x_shape or self.shape, (self.x_min, self.x_max), self.x_slice def state_get(self): # return {name: self.trait_metadata('grid', 'serialize', ident)(getattr(self, name) for name in self.trait_names()} state = {} for name in self.trait_names(): serializer = self.trait_metadata(name, 'serialize', ident) value = serializer(getattr(self, name)) state[name] = value return state def state_set(self, state): for name in self.trait_names(): if name in state: deserializer = self.trait_metadata(name, 'deserialize', ident) value = deserializer(state[name]) setattr(self, name, value) def calculate_limits(self): self._calculate_limits('x', 'x_expression') self.signal_regrid.emit(None) # TODO this is also called in the ctor, unnec work def limits_changed(self, change): self.signal_regrid.emit(None) # TODO this is also called in the ctor, unnec work @vaex.jupyter.debounced() def _update_grid(self): self._calculate_centers() self.signal_regrid.emit(None)
class OneHotEncoder(Transformer): '''Encode categorical columns according ot the One-Hot scheme. Example: >>> import vaex >>> df = vaex.from_arrays(color=['red', 'green', 'green', 'blue', 'red']) >>> df # color 0 red 1 green 2 green 3 blue 4 red >>> encoder = vaex.ml.OneHotEncoder(features=['color']) >>> encoder.fit_transform(df) # color color_blue color_green color_red 0 red 0 0 1 1 green 0 1 0 2 green 0 1 0 3 blue 1 0 0 4 red 0 0 1 ''' # title = Unicode(default_value='One-Hot Encoder', read_only=True).tag(ui='HTML') prefix = traitlets.Unicode(default_value='', help=help_prefix).tag(ui='Text') one = traitlets.Any(1, help='Value to encode when a category is present.') zero = traitlets.Any(0, help='Value to encode when category is absent.') uniques_ = traitlets.List(traitlets.List(), help='The unique elements found in each feature.').tag(output=True) def fit(self, df): '''Fit OneHotEncoder to the DataFrame. :param df: A vaex DataFrame. ''' uniques = [] for i in self.features: expression = _ensure_strings_from_expressions(i) unique = df.unique(expression) unique = np.sort(unique) # this can/should be optimized with @delay uniques.append(unique.tolist()) self.uniques_ = uniques def transform(self, df): '''Transform a DataFrame with a fitted OneHotEncoder. :param df: A vaex DataFrame. :return: A shallow copy of the DataFrame that includes the encodings. :rtype: DataFrame ''' copy = df.copy() # for each feature, add a virtual column for each unique entry for i, feature in enumerate(self.features): for j, value in enumerate(self.uniques_[i]): column_name = self.prefix + feature + '_' + str(value) copy.add_virtual_column(column_name, 'where({feature} == {value}, {one}, {zero})'.format( feature=feature, value=repr(value), one=self.one, zero=self.zero)) return copy
class MyClass(tl.HasTraits): a = tl.Any() b = tl.Any(default_value=0) c = tl.Any() @tl.default("c") def _default_b(self): return "test"
def load_ipython_extension(shell): import traitlets shell.add_traits(last_parent=traitlets.Any(), cell_ids=traitlets.Set(), id=traitlets.Any()) shell.events.register(pre_run_cell.__name__, pre_run_cell) Kernel.patch()
class IOPWidget(ipw.VBox): iops = tr.Any() vsf_vals = tr.Any() def __init__(self, iops): super().__init__() self.iops = iops self.init_vals() self.init_elements() self.init_layout() self.init_logic() def init_elements(self): self.title = ipw.HTML("<h3>Optical Properties</h3>") self.aw_slider = ipw.FloatSlider(min=0,max=10000, description='$a_w$') self.ak_slider = ipw.FloatSlider(min=0,max=10000, description='$a_k$') self.b_slider = ipw.FloatSlider(min=0,max=10, description='$b$') self.vsf_plot = HandDrawFigure( self, 'vsf_vals', xdim=self.iops.grid.phi, labels={ 'title': 'Volume Scattering Function', 'xlabel': 'theta', 'ylabel': 'VSF' }, ylim=[0,2], ) def init_logic(self): tr.link((self.iops, 'a_water'), (self.aw_slider, 'value')) tr.link((self.iops, 'a_kelp'), (self.ak_slider, 'value')) tr.link((self.iops, 'b'), (self.b_slider, 'value')) self.observe(self.set_iops_vsf, names='vsf_vals') def init_vals(self): # This should be a copy, just to set the inital value self.vsf_vals = self.iops.vsf_vals def set_iops_vsf(self, *args): self.iops.set_vsf(self.vsf_vals) def set_widget_vsf(self, *args): self.vsf_vals = self.iops.vsf def init_layout(self): self.children = [ self.title, ipw.HBox([ ipw.VBox([ self.aw_slider, self.b_slider, self.ak_slider, ]), self.vsf_plot ]) ]
class VizHeatmapState(VizBase2dState): groupby_normalize = traitlets.Bool(False, allow_none=True) grid = traitlets.Any().tag(**serialize_numpy) grid_sliced = traitlets.Any().tag(**serialize_numpy) x_centers = traitlets.Any().tag(**serialize_numpy) #centers = traitlets.Any() def __init__(self, ds, **kwargs): self.ds = ds super(VizHeatmapState, self).__init__(ds, **kwargs)
class SingleOutput(Output): """Value widget to display a single output. This widget can capture and display stdout, stderr, and rich output into a value called 'value'. To use it, create an instance of it and display it. """ value = traitlets.Any() def __init__(self, value=None, **kwargs): """ Initialization of the singleoutput widget Parameter ---------- value : (type=int) the element we want to show """ super().__init__(**kwargs) self.value = value @traitlets.observe("value") def _observe_value(self, change): """ Display the current value in a row of widget output area. Parameter ---------- change: (type=list) check if the new value is modify to the last value. """ self.clear_output(wait=True) with self: display(change["new"])
class ExpressionSelectionTextArea(ExpressionTextArea): # selection is v_model selection_name = traitlets.Any('default') def __init__(self, **kwargs): super().__init__(**kwargs) # self.update_selection() @traitlets.default('v_model') def _v_model(self): columns = self.df.get_column_names(strings=False) return columns[0] + ' == 0' @traitlets.default('label') def _label(self): return "Filter by custom expression" @traitlets.default('placeholder') def _placeholder(self): return "Enter a custom (boolean) expression" @traitlets.default('prepend_icon') def _prepend_icon(self): return 'filter_list' @traitlets.observe('v_model') def update_custom_selection(self, change): if self.check_expression(): self.update_selection() def update_selection(self): self.df.select(self.v_model, name=self.selection_name)
class SpaceDim(tr.HasTraits): minval = tr.Float() maxval = tr.Float() num = tr.Int() vals = tr.Any() def __init__(self, minval, maxval, num): super().__init__() self.minval = minval self.maxval = maxval self.num = num self.init_logic() self.update() # Deal only with num for simplicity def spacing_from_num(self): self.spacing = (self.maxval - self.minval) / self.num def assign_linspace(self): self.vals = np.arange(self.minval, self.maxval, self.spacing) def update(self, *args): self.spacing_from_num() self.assign_linspace() def init_logic(self): self.observe(self.update, names=['minval', 'maxval', 'num'])
class AngleDim(tr.HasTraits): num = tr.Int() minval = tr.Float() maxval = tr.Float() vals = tr.Any() def __init__(self, minval, maxval, num): super().__init__() self.minval = minval self.maxval = maxval self.num = num self.update() self.init_logic() def assign_legendre(self): self.vals = self.affine_transform(vals=leggauss(self.num)[0], oldmin=-1, oldmax=1, newmin=self.minval, newmax=self.maxval) #def angular_integral(self): # pass def affine_transform(self, vals, oldmin, oldmax, newmin, newmax): return newmin + (newmin - newmax) / (oldmin - oldmax) * (vals - oldmin) def update(self, *args): self.assign_legendre() def init_logic(self): self.observe(self.update, names='num')
class Foo(traitlets.HasTraits): value = traitlets.Any() bar = traitlets.Int() baz = traitlets.Unicode() class_val = 0 def __init__(self, init_value): self.class_val = init_value def set_value(self, input): self.value = input @traitlets.observe('value') def _observe_value(self, change): print("class value change") #print("value = ", value) print(change['old']) print(change['new']) print("self.value = ", self.value) @traitlets.observe('baz') def _observe_bar(self, change): #pass print("class func") #self.value = self.baz print(change['old']) print(change['new'])
class DataArray(ViewBase): """Will display a DataArray interactively, with an optional custom display_function. By default, it will simply display(...) the DataArray, using xarray's default display mechanism. """ model = traitlets.Instance(model.DataArray) clear_output = traitlets.Bool(True, help="Clear output each time the data changes") display_function = traitlets.Any(display) matplotlib_autoshow = traitlets.Bool(True, help="Will call plt.show() inside output context if open figure handles exist") numpy_errstate = traitlets.Dict({'all': 'ignore'}, help="Default numpy errstate during display to avoid showing error messsages, see :py:data:`numpy.errstate`_ ") def __init__(self, **kwargs): super().__init__(**kwargs) self.output = widgets.Output() self.output_data_array = widgets.Output() self.children = (self.progress_widget, self.output_data_array, self.output) self.model.observe(self.update_output, ['grid', 'grid_sliced']) self.update_output() def update_output(self, change=None): if self.clear_output: self.output_data_array.clear_output(wait=True) with self.output_data_array, np.errstate(**self.numpy_errstate): grid = self.model.grid_sliced if grid is None: grid = self.model.grid if grid is not None: self.display_function(grid) # make sure show is called inside the output widget if self.matplotlib_autoshow and 'matplotlib' in sys.modules: import matplotlib.pyplot as plt if plt.get_fignums(): plt.show()
class Camera(traitlets.HasTraits): value = traitlets.Any() DEFAULT_CAMERA_CLASS = 'OpenCvGstCamera' @staticmethod def default_camera_class(): from .opencv_gst_camera import OpenCvGstCamera return OpenCvGstCamera @staticmethod def instance(*args, **kwargs): return Camera.default_camera_class()(*args, **kwargs) def widget(self): if hasattr(self, '_widget'): return self._widget # cache widget, so we don't duplicate links from ipywidgets import Image from jetbot.image import bgr8_to_jpeg image = Image() traitlets.dlink((self, 'value'), (image, 'value'), transform=bgr8_to_jpeg) self._widget = image return image
class BasicJupyterToolbar(v.VuetifyTemplate): template = load_template('basic_jupyter_toolbar.vue', __file__) active_tool = traitlets.Instance(glue.viewers.common.tool.Tool, allow_none=True, default_value=None) tools_data = traitlets.Dict(default_value={}).tag(sync=True) active_tool_id = traitlets.Any().tag(sync=True) def __init__(self, viewer): self.output = viewer.output_widget self.tools = {} if viewer._default_mouse_mode_cls is not None: self._default_mouse_mode = viewer._default_mouse_mode_cls(viewer) self._default_mouse_mode.activate() else: self._default_mouse_mode = None super().__init__() @traitlets.observe('active_tool_id') def _on_change_v_model(self, change): if change.new is not None: if isinstance(self.tools[change.new], CheckableTool): self.active_tool = self.tools[change.new] else: # In this case it is a non-checkable tool and we should # activate it but not keep the tool checked in the toolbar self.tools[change.new].activate() self.active_tool_id = None else: self.active_tool = None @traitlets.observe('active_tool') def _on_change_active_tool(self, change): if change.old: change.old.deactivate() else: if self._default_mouse_mode: self._default_mouse_mode.deactivate() if change.new: change.new.activate() self.active_tool_id = change.new.tool_id else: self.active_tool_id = None if self._default_mouse_mode is not None: self._default_mouse_mode.activate() def add_tool(self, tool): self.tools[tool.tool_id] = tool # TODO: we should ideally just incorporate this check into icon_path directly. if os.path.exists(tool.icon): path = tool.icon else: path = icon_path(tool.icon, icon_format='svg') self.tools_data = { **self.tools_data, tool.tool_id: { 'tooltip': tool.tool_tip, 'img': read_icon(path, 'svg+xml') } }
class ColumnExpressionAdder(ColumnPicker): component = traitlets.Any() target = traitlets.Unicode('v_model') def vue_menu_click(self, data): value = getattr(self.component, self.target) setattr(self.component, self.target, value + ' + ' + str(self.items[data]))
class Camera(SingletonConfigurable): value = traitlets.Any() thread_stop = True def __init__(self, *args, **kwargs): self.value = np.empty((224, 224, 3), dtype=np.uint8) super(Camera, self).__init__(*args, **kwargs) self.cap = cv2.VideoCapture(0) re, image = self.cap.read() if not re: raise RuntimeError('Could not read image from camera.') self.value = image self.start() def _capture_frames(self): while self.thread_stop: re, image = self.cap.read() if re: self.value = image else: break def start(self): self.thread = threading.Thread(target=self._capture_frames) self.thread.start() def close(self): self.cap.release() cv2.destroyAllWindows() self.thread_stop = False
class Camera(SingletonConfigurable): value = traitlets.Any() # config width = traitlets.Integer(default_value=224).tag(config=True) height = traitlets.Integer(default_value=224).tag(config=True) fps = traitlets.Integer(default_value=21).tag(config=True) capture_width = traitlets.Integer(default_value=3280).tag(config=True) capture_height = traitlets.Integer(default_value=2464).tag(config=True) def __init__(self, *args, **kwargs): self.value = np.empty((self.height, self.width, 3), dtype=np.uint8) super(Camera, self).__init__(*args, **kwargs) try: self.cap = cv2.VideoCapture(self._gst_str(), cv2.CAP_GSTREAMER) re, image = self.cap.read() if not re: raise RuntimeError('Could not read image from camera.') self.value = image self.start() except: self.stop() raise RuntimeError( 'Could not initialize camera. Please see error trace.') atexit.register(self.stop) def _capture_frames(self): while True: re, image = self.cap.read() if re: self.value = image else: break def _gst_str(self): return 'nvarguscamerasrc ! video/x-raw(memory:NVMM), width=%d, height=%d, format=(string)NV12, framerate=(fraction)%d/1 ! nvvidconv ! video/x-raw, width=(int)%d, height=(int)%d, format=(string)BGRx ! videoconvert ! appsink' % ( self.capture_width, self.capture_height, self.fps, self.width, self.height) def start(self): if not self.cap.isOpened(): self.cap.open(self._gst_str(), cv2.CAP_GSTREAMER) if not hasattr(self, 'thread') or not self.thread.isAlive(): self.thread = threading.Thread(target=self._capture_frames) self.thread.start() def stop(self): if hasattr(self, 'cap'): self.cap.release() if hasattr(self, 'thread'): self.thread.join() def restart(self): self.stop() self.start()
class RTSPCamera(Camera): capture_fps = traitlets.Integer(default_value=30) capture_width = traitlets.Integer(default_value=640) capture_height = traitlets.Integer(default_value=480) capture_source = traitlets.Any(default_value='rtsp://localhost:8080') def __init__(self, *args, **kwargs): super(RTSPCamera, self).__init__(*args, **kwargs) try: self.cap = cv2.VideoCapture(self._gst_str(), cv2.CAP_GSTREAMER) re , image = self.cap.read() if not re: raise RuntimeError('Could not read image from camera.') except: raise RuntimeError( 'Could not initialize camera. Please see error trace.') atexit.register(self.cap.release) def _gst_str(self): return 'rtspsrc location={} latency=0 ! rtph264depay ! h264parse ! omxh264dec ! videorate ! videoscale ! video/x-raw,framerate={}/1,width={},height={} ! videoconvert ! video/x-raw,format=(string)BGR ! queue ! appsink sync=false'.format(self.capture_source, self.capture_fps, self.capture_width, self.capture_height) def _read(self): re, image = self.cap.read() if re: image_resized = cv2.resize(image,(int(self.width),int(self.height))) return image_resized else: raise RuntimeError('Could not read image from camera')
class ColumnSelectionAdder(ColumnPicker): component = traitlets.Any() target = traitlets.Unicode('v_model') def vue_menu_click(self, data): value = getattr(self.component, self.target) setattr(self.component, self.target, value + ' & ({} == 0)'.format(self.items[data]))
class SelectionToggleList(v.VuetifyTemplate): df = traitlets.Any().tag(sync_ref=True) title = traitlets.Unicode('Choose selections').tag(sync=True) selection_names = traitlets.List(traitlets.Unicode()).tag(sync=True) value = traitlets.List(traitlets.Unicode()).tag(sync=True) def __init__(self, **kwargs): super().__init__(**kwargs) self.df.signal_selection_changed.connect(self._on_change_selection) def _on_change_selection(self, df, name): new_names = [ name for name in self.df.selection_histories.keys() if not name.startswith('__') and df.has_selection(name) ] self.selection_names = new_names self.value = [v for v in self.value if v in self.selection_names] @traitlets.default('selection_names') def _selection_names(self): return [ name for name in self.df.selection_histories.keys() if not name.startswith('__') ] @traitlets.default('template') def _template(self): return load_template('vue/selection_toggle_list.vue') @traitlets.default('components') def _components(self): return vaex_components
class Data(BaseObject): """Wrapper for Vega-Lite Data definition. Attributes ---------- format: DataFormat An object that specifies the format for the data file or values. url: Unicode A URL from which to load the data set. values: List(Any) Pass array of objects instead of a url to a file. """ format = T.Instance( DataFormat, allow_none=True, default_value=None, help= """An object that specifies the format for the data file or values.""") url = T.Unicode(allow_none=True, default_value=None, help="""A URL from which to load the data set.""") values = T.List( T.Any(), allow_none=True, default_value=None, help="""Pass array of objects instead of a url to a file.""") def __init__(self, format=None, url=None, values=None, **kwargs): kwds = dict(format=format, url=url, values=values) kwargs.update({k: v for k, v in kwds.items() if v is not None}) super(Data, self).__init__(**kwargs)
class MyNode(Node): a = tl.Any().tag(attr=True) @tl.default("a") def _default_a(self): self.definition return 10