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
