def render_model(model, comm=None):
if not isinstance(model, Model):
raise ValueError("notebook_content expects a single Model instance")
target = model.ref['id']
(docs_json, [render_item]) = standalone_docs_json_and_render_items([model])
div = div_for_render_item(render_item)
render_item = render_item.to_json()
script = DOC_NB_JS.render(
docs_json=serialize_json(docs_json),
render_items=serialize_json([render_item]),
)
bokeh_script, bokeh_div = encode_utf8(script), encode_utf8(div)
html = "<div id='{id}'>{html}</div>".format(id=target, html=bokeh_div)
# Publish bokeh plot JS
msg_handler = bokeh_msg_handler.format(plot_id=target)
if comm:
comm_js = comm.js_template.format(plot_id=target, comm_id=comm.id, msg_handler=msg_handler)
bokeh_js = '\n'.join([comm_js, bokeh_script])
else:
bokeh_js = bokeh_script
data = {'text/html': html, 'application/javascript': bokeh_js}
return ({'text/html': mimebundle_to_html(data), EXEC_MIME: ''},
{EXEC_MIME: {'id': target}})
def _plot_to_json(plot):
"""Convert plot to JSON objects necessary for rendering with `bokehJS`.
Parameters
----------
plot : bokeh.plotting.figure.Figure
Bokeh plot object to be rendered.
Returns
-------
(str, str)
Returns (docs_json, render_items) json for the desired plot.
"""
render_items = [{'docid': plot._id, 'elementid': make_id()}]
doc = Document()
doc.add_root(plot)
docs_json_inner = doc.to_json()
docs_json = {render_items[0]['docid']: docs_json_inner}
docs_json = serialize_json(docs_json)
render_items = serialize_json(render_items)
custom_model_js = bundle_all_models()
return docs_json, render_items, custom_model_js
def test_datashader_image_nan():
'''Test the datashader image stretch function works correctly
if the inputs 2D arraysi containing NaNs in both coordinates and
values.
Tests the modification made in commit 05962ec'''
x = numpy.array(
[[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[-32.12598, -32.07721, -32.02848, numpy.nan, numpy.nan, numpy.nan],
[-32.15292, -32.104084, -32.055298, numpy.nan, numpy.nan, numpy.nan],
[-32.17996, -32.13106, -32.08221, numpy.nan, numpy.nan, numpy.nan]])
y = numpy.array(
[[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[-40.60027, -40.596905, -40.593544, numpy.nan, numpy.nan, numpy.nan],
[-40.643642, -40.640266, -40.636898, numpy.nan, numpy.nan, numpy.nan],
[-40.68706, -40.683674, -40.680298, numpy.nan, numpy.nan, numpy.nan]])
z = numpy.array(
[[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan],
[276.23, 273.04, 270.75, numpy.nan, numpy.nan, numpy.nan],
[277.12, 273.55, 270.82, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, 273.24, 270.16998, numpy.nan, numpy.nan, numpy.nan],
[numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan, numpy.nan]])
result = geo.stretch_image(x, y, z)
#this will fail on a ValueError if the NaNs above are handled improperly
serialize_json(result)
#Should be returning NumPy masked arrays
assert numpy.ma.is_masked(result['image'][0])
def render_model(model, comm=None):
if not isinstance(model, Model):
raise ValueError("notebook_content expects a single Model instance")
from ..config import panel_extension as pnext
target = model.ref['id']
(docs_json, [render_item]) = standalone_docs_json_and_render_items([model], True)
div = div_for_render_item(render_item)
render_item = render_item.to_json()
requirements = [pnext._globals[ext] for ext in pnext._loaded_extensions
if ext in pnext._globals]
ipywidget = 'ipywidgets_bokeh' in sys.modules
script = DOC_NB_JS.render(
docs_json=serialize_json(docs_json),
render_items=serialize_json([render_item]),
requirements=requirements,
ipywidget=ipywidget
)
bokeh_script, bokeh_div = script, div
html = "<div id='{id}'>{html}</div>".format(id=target, html=bokeh_div)
data = {'text/html': html, 'application/javascript': bokeh_script}
return ({'text/html': mimebundle_to_html(data), EXEC_MIME: ''},
{EXEC_MIME: {'id': target}})
def render_model(model, comm=None):
if not isinstance(model, Model):
raise ValueError("notebook_content expects a single Model instance")
target = model.ref['id']
(docs_json, [render_item]) = standalone_docs_json_and_render_items([model],
True)
div = div_for_render_item(render_item)
render_item = render_item.to_json()
script = DOC_NB_JS.render(
docs_json=serialize_json(docs_json),
render_items=serialize_json([render_item]),
)
bokeh_script, bokeh_div = script, div
html = "<div id='{id}'>{html}</div>".format(id=target, html=bokeh_div)
data = {'text/html': html, 'application/javascript': bokeh_script}
return ({
'text/html': mimebundle_to_html(data),
EXEC_MIME: ''
}, {
EXEC_MIME: {
'id': target
}
})
def test_notebook_content(self, mock_standalone_docs_json_and_render_items):
(docs_json, render_items) = ("DOC_JSON", [dict(docid="foo", elementid="bar", modelid="bat")])
mock_standalone_docs_json_and_render_items.return_value = (docs_json, render_items)
expected_script = DOC_JS.render(docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
expected_div = PLOT_DIV.render(elementid=render_items[0]['elementid'])
(script, div, _) = embed.notebook_content(_embed_test_plot)
self.assertEqual(script, expected_script)
self.assertEqual(div, expected_div)
def test_notebook_content(self, mock_sdjari, test_plot):
(docs_json, render_items) = ("DOC_JSON", [dict(docid="foo", elementid="bar", modelid="bat")])
mock_sdjari.return_value = (docs_json, render_items)
expected_script = DOC_NB_JS.render(docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
expected_div = PLOT_DIV.render(elementid=render_items[0]['elementid'])
(script, div, _) = ben.notebook_content(test_plot)
assert script == expected_script
assert div == expected_div
def test_notebook_content_with_notebook_comms_target(self, mock_sdjari, test_plot):
(docs_json, render_items) = ("DOC_JSON", [dict(docid="foo", elementid="bar", modelid="bat")])
mock_sdjari.return_value = (docs_json, render_items)
comms_target = "NOTEBOOK_COMMS_TARGET"
## assert that NOTEBOOK_COMMS_TARGET is added to render_items bundle
assert 'notebook_comms_target' not in render_items[0]
(script, _, _) = ben.notebook_content(test_plot, notebook_comms_target=comms_target)
assert 'notebook_comms_target' in render_items[0]
## assert that NOTEBOOK_COMMS_TARGET ends up in generated script
expected_script = DOC_NB_JS.render(docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
assert script == expected_script
def test_notebook_content_with_notebook_comms_target(self, mock_standalone_docs_json_and_render_items):
(docs_json, render_items) = ("DOC_JSON", [dict(docid="foo", elementid="bar", modelid="bat")])
mock_standalone_docs_json_and_render_items.return_value = (docs_json, render_items)
comms_target = "NOTEBOOK_COMMS_TARGET"
## assert that NOTEBOOK_COMMS_TARGET is added to render_items bundle
self.assertTrue('notebook_comms_target' not in render_items[0])
(script, _, _) = embed.notebook_content(_embed_test_plot, notebook_comms_target=comms_target)
self.assertTrue('notebook_comms_target' in render_items[0])
## assert that NOTEBOOK_COMMS_TARGET ends up in generated script
expected_script = DOC_JS.render(docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
self.assertEqual(script, expected_script)
def test_notebook_content(self, mock_sdjari, test_plot):
(docs_json,
render_items) = ("DOC_JSON",
[dict(docid="foo", elementid="bar", modelid="bat")])
mock_sdjari.return_value = (docs_json, render_items)
expected_script = DOC_NB_JS.render(
docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
expected_div = PLOT_DIV.render(elementid=render_items[0]['elementid'])
(script, div, _) = ben.notebook_content(test_plot)
assert script == expected_script
assert div == expected_div
def feature_scatterplot(fset_path, features_to_plot):
"""Create scatter plot of feature set.
Parameters
----------
fset_path : str
Path to feature set to be plotted.
features_to_plot : list of str
List of feature names to be plotted.
Returns
-------
(str, str)
Returns (docs_json, render_items) json for the desired plot.
"""
fset, data = featurize.load_featureset(fset_path)
fset = fset[features_to_plot]
colors = cycle(palette[5])
plots = np.array([[figure(width=300, height=200)
for j in range(len(features_to_plot))]
for i in range(len(features_to_plot))])
for (j, i), p in np.ndenumerate(plots):
if (j == i == 0):
p.title.text = "Scatterplot matrix"
p.circle(fset.values[:,i], fset.values[:,j], color=next(colors))
p.xaxis.minor_tick_line_color = None
p.yaxis.minor_tick_line_color = None
p.ygrid[0].ticker.desired_num_ticks = 2
p.xgrid[0].ticker.desired_num_ticks = 4
p.outline_line_color = None
p.axis.visible = None
plot = gridplot(plots.tolist(), ncol=len(features_to_plot), mergetools=True, responsive=True, title="Test")
# Convert plot to json objects necessary for rendering with bokeh on the
# frontend
render_items = [{'docid': plot._id, 'elementid': make_id()}]
doc = Document()
doc.add_root(plot)
docs_json_inner = doc.to_json()
docs_json = {render_items[0]['docid']: docs_json_inner}
docs_json = serialize_json(docs_json)
render_items = serialize_json(render_items)
return docs_json, render_items
def output_defaults_module(filename, defaults):
output = serialize_json(defaults, indent=4, separators=[',', ':'])
coffee_template = \
"""
all_defaults = %s;
get_defaults = (name) ->
if name of all_defaults
all_defaults[name]
else
null
all_view_model_names = () ->
Object.keys(all_defaults)
module.exports = {
get_defaults: get_defaults
all_view_model_names: all_view_model_names
}
"""
try:
os.makedirs(os.path.dirname(filename))
except OSError as e:
pass
f = codecs.open(filename, 'w', 'utf-8')
f.write(coffee_template % output)
f.close()
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def send(self, code, data): #{5}
comm = Comm(target_name=str(self.uid),
data={
"code": code,
"data": json_encoder.serialize_json(data)
})
comm.close()
def output_defaults_module(filename, defaults):
output = serialize_json(defaults, indent=2)
ts_template = """\
const all_defaults: {[key: string]: any} = %s
export function get_defaults(name: string): {[key: string]: any} | null {
if (name in all_defaults) {
return all_defaults[name]
} else {
return null
}
}
export function all_view_model_names(): string[] {
return Object.keys(all_defaults)
}
"""
try:
os.makedirs(os.path.dirname(filename))
except OSError:
pass
f = codecs.open(filename, 'w', 'utf-8')
f.write(ts_template % output)
f.close()
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def html_for_render_items(docs_json,
render_items,
template=None,
template_variables={}):
json_id = make_id()
json = escape(serialize_json(docs_json), quote=False)
json = wrap_in_script_tag(json, "application/json", json_id)
script = wrap_in_script_tag(script_for_render_items(json_id, render_items))
context = template_variables.copy()
context.update(
dict(
title='',
plot_script=json + script,
docs=render_items,
base=NB_TEMPLATE_BASE,
macros=MACROS,
))
if len(render_items) == 1:
context["doc"] = context["docs"][0]
context["roots"] = context["doc"].roots
if template is None:
template = NB_TEMPLATE_BASE
elif isinstance(template, string_types):
template = _env.from_string("{% extends base %}\n" + template)
return template.render(context)
def output_defaults_module(filename, defaults):
output = serialize_json(defaults, indent=2)
coffee_template = """\
all_defaults = %s
get_defaults = (name) ->
if name of all_defaults
all_defaults[name]
else
null
all_view_model_names = () ->
Object.keys(all_defaults)
module.exports = {
get_defaults: get_defaults
all_view_model_names: all_view_model_names
}
"""
try:
os.makedirs(os.path.dirname(filename))
except OSError as e:
pass
f = codecs.open(filename, 'w', 'utf-8')
f.write(coffee_template % output)
f.close()
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def get(self, name):
# self.set_header("Cache-control", "max-age=31536000")
for dataset in CONFIG["datasets"]:
if dataset["name"] == name:
path = dataset["file_name"]
obj = lib.image_data(name, path)
self.set_header("Content-Type", "application/json")
self.write(serialize_json(obj))
def output_defaults_module(filename: str, defaults: Any) -> None:
dest = join(dest_dir, ".generated_defaults", filename)
os.makedirs(dirname(dest), exist_ok=True)
output = serialize_json(defaults, indent=2)
with open(dest, "w", encoding="utf-8") as f:
f.write(output)
print(f"Wrote {filename} with {len(defaults)} models")
def output_defaults_module(filename, defaults):
output = serialize_json(defaults, indent=2)
try:
os.makedirs(os.path.dirname(filename))
except OSError:
pass
f = codecs.open(filename, 'w', 'utf-8')
f.write(output)
f.close()
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def output_defaults_module(filename, defaults):
output = serialize_json(defaults, indent=2)
try:
os.makedirs(os.path.dirname(filename))
except OSError:
pass
f = codecs.open(filename, 'w', 'utf-8')
f.write(output)
f.close()
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def test_notebook_content_with_notebook_comms_target(
self, mock_sdjari, test_plot):
(docs_json,
render_items) = ("DOC_JSON",
[dict(docid="foo", elementid="bar", modelid="bat")])
mock_sdjari.return_value = (docs_json, render_items)
comms_target = "NOTEBOOK_COMMS_TARGET"
## assert that NOTEBOOK_COMMS_TARGET is added to render_items bundle
assert 'notebook_comms_target' not in render_items[0]
(script, _,
_) = ben.notebook_content(test_plot,
notebook_comms_target=comms_target)
assert 'notebook_comms_target' in render_items[0]
## assert that NOTEBOOK_COMMS_TARGET ends up in generated script
expected_script = DOC_NB_JS.render(
docs_json=serialize_json(docs_json),
render_items=serialize_json(render_items))
assert script == expected_script
async def points(dataset_id: int,
timestamp_ms: int,
settings: config.Settings = Depends(config.get_settings)):
time = np.datetime64(timestamp_ms, 'ms')
dataset = by_id(settings.datasets, dataset_id)
dataset_name = dataset.label
path = core.get_path(settings, dataset_name)
obj = core.get_points(path, time)
content = serialize_json(obj)
response = Response(content=content, media_type="application/json")
# response.headers["Cache-Control"] = "max-age=31536000"
return response
async def natural_earth_feature(category: str,
name: str,
scale: str = "110m",
minlat: float = -90,
minlon: float = -180,
maxlat: float = 90,
maxlon: float = 180):
extent = (minlon, maxlon, minlat, maxlat)
obj = load_feature(category, name, scale, extent)
content = serialize_json(obj)
response = Response(content=content, media_type="application/json")
# response.headers["Cache-Control"] = "max-age=31536000"
return response
def output_defaults_module(filename, defaults):
dest = os.path.join(dest_dir, ".generated_defaults", filename)
try:
os.makedirs(os.path.dirname(dest))
except OSError:
pass
output = serialize_json(defaults, indent=2)
with io.open(dest, "w", encoding="utf-8") as f:
f.write(output)
print("Wrote %s with %d model classes" % (filename, len(defaults)))
def output_defaults_module(filename, defaults):
dest = os.path.join(dest_dir, ".generated_defaults", filename)
try:
os.makedirs(os.path.dirname(dest))
except OSError:
pass
output = serialize_json(defaults, indent=2)
with open(dest, "w", encoding="utf-8") as f:
f.write(output)
print("Wrote %s with %d models" % (filename, len(defaults)))
def serialize(self, models):
"""
Serializes any Bokeh plot objects passed to it as a list.
"""
documents = {plot.document for plot in self.plots}
for doc in documents:
if hasattr(doc, 'last_comms_handle'):
handle = doc.last_comms_handle
else:
handle = _CommsHandle(get_comms(doc.last_comms_target),
doc, None)
doc.last_comms_handle = handle
msg = compute_static_patch(doc, models)
handle.comms.send(serialize_json(msg))
return 'Complete'
async def axis(dataset_id: int,
data_var: str,
dim_name: str,
query: Optional[str] = None,
settings: config.Settings = Depends(config.get_settings)):
"""GET dimension values related to particular data_var"""
if query is not None:
query = json.loads(query)
dataset = by_id(settings.datasets, dataset_id)
driver = drivers.from_spec(dataset.driver)
settings = dataset.driver.settings
obj = driver.points(settings, data_var, dim_name, query=query)
content = serialize_json(obj)
response = Response(content=content, media_type="application/json")
# response.headers["Cache-Control"] = "max-age=31536000"
return response
def serialize(self, models):
"""
Serializes any Bokeh plot objects passed to it as a list.
"""
documents = {plot.document for plot in self.plots}
for doc in documents:
json = None
if hasattr(doc, 'last_comms_handle'):
handle = doc.last_comms_handle
else:
json = doc.to_json()
handle = _CommsHandle(get_comms(doc.last_comms_target), doc,
json)
doc.last_comms_handle = handle
msg = compute_static_patch(doc, models, json)
handle.comms.send(serialize_json(msg))
return 'Complete'
def plot_gmap():
"""Return a google maps plot centered at sydney cbd"""
map_options = GMapOptions(lat=syd_lat,
lng=syd_lon,
zoom=14,
map_type="roadmap",
styles=serialize_json(map_style))
plot = GMapPlot(x_range=Range1d(),
y_range=Range1d(),
api_key=gmap_key,
map_options=map_options,
plot_height=1000,
plot_width=1300,
toolbar_location="left")
plot.add_tools(PanTool(), ZoomInTool(), ZoomOutTool())
return plot
async def data_tiles(dataset_id: int,
data_var: str,
Z: int,
X: int,
Y: int,
query: Optional[str] = None,
settings: config.Settings = Depends(config.get_settings)):
"""GET data tile from dataset at particular time"""
if query is not None:
query = json.loads(query)
dataset = by_id(settings.datasets, dataset_id)
driver = drivers.from_spec(dataset.driver)
settings = dataset.driver.settings
data = driver.data_tile(settings, data_var, Z, X, Y, query=query)
obj = {"dataset_id": dataset_id, "tile": [X, Y, Z], "data": data}
content = serialize_json(obj)
response = Response(content=content, media_type="application/json")
# response.headers["Cache-Control"] = "max-age=31536000"
return response
def __call__(self, obj, fmt=None):
"""
Render the supplied HoloViews component using the appropriate
backend. The output is not a file format but a suitable,
in-memory byte stream together with any suitable metadata.
"""
plot, fmt = self._validate(obj, fmt)
info = {'file-ext': fmt, 'mime_type': MIME_TYPES[fmt]}
if isinstance(plot, tuple(self.widgets.values())):
return plot(), info
elif fmt == 'html':
html = self.figure_data(plot)
html = "<div style='display: table; margin: 0 auto;'>%s</div>" % html
return self._apply_post_render_hooks(html, obj, fmt), info
elif fmt == 'json':
plotobjects = [h for handles in plot.traverse(lambda x: x.current_handles)
for h in handles]
patch = compute_static_patch(plot.document, plotobjects)
data = dict(root=plot.state._id, patch=patch)
return self._apply_post_render_hooks(serialize_json(data), obj, fmt), info
def __call__(self, obj, fmt=None):
"""
Render the supplied HoloViews component using the appropriate
backend. The output is not a file format but a suitable,
in-memory byte stream together with any suitable metadata.
"""
plot, fmt = self._validate(obj, fmt)
info = {'file-ext': fmt, 'mime_type': MIME_TYPES[fmt]}
if isinstance(plot, tuple(self.widgets.values())):
return plot(), info
elif fmt == 'html':
html = self.figure_data(plot)
html = "<div style='display: table; margin: 0 auto;'>%s</div>" % html
return self._apply_post_render_hooks(html, obj, fmt), info
elif fmt == 'json':
plotobjects = [
h for handles in plot.traverse(lambda x: x.current_handles)
for h in handles
]
patch = compute_static_patch(plot.document, plotobjects)
data = dict(root=plot.state._id, patch=patch)
return self._apply_post_render_hooks(serialize_json(data), obj,
fmt), info
for leaf in leaves(all_tree, model_class):
klass = leaf[0]
vm_name = klass.__view_model__
if vm_name in all_json:
continue
defaults = {}
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=BokehDeprecationWarning)
instance = klass()
props_with_values = instance.query_properties_with_values(
lambda prop: prop.readonly or prop.serialized)
for name, default in props_with_values.items():
if isinstance(default, Model):
struct = default.struct
raw_attrs = default._to_json_like(include_defaults=True)
attrs = loads(serialize_json(raw_attrs))
struct['attributes'] = attrs
del struct['id'] # there's no way the ID will match bokehjs
default = struct
elif isinstance(default, float) and default == float('inf'):
default = None
defaults[name] = default
all_json[vm_name] = defaults
def output_defaults_module(filename, defaults):
dest = os.path.join(dest_dir, ".generated_defaults", filename)
try:
os.makedirs(os.path.dirname(dest))
except OSError:
class BokehModel(DOMWidget):
_model_name = Unicode("BokehModel").tag(sync=True)
_model_module = Unicode(_module_name).tag(sync=True)
_model_module_version = Unicode(_module_version).tag(sync=True)
_view_name = Unicode("BokehView").tag(sync=True)
_view_module = Unicode(_module_name).tag(sync=True)
_view_module_version = Unicode(_module_version).tag(sync=True)
render_bundle = Dict().tag(sync=True,
to_json=lambda obj, _: serialize_json(obj))
@property
def _document(self):
return self._model.document
def __init__(self, model, **kwargs):
assert isinstance(model, LayoutDOM)
self.update_from_model(model)
super(BokehModel, self).__init__(**kwargs)
self.on_msg(self._sync_model)
def close(self):
if self._document is not None:
self._document.remove_on_change(self)
@classmethod
def _model_to_traits(cls, model):
if model.document is None:
document = Document()
document.add_root(model)
(docs_json, [render_item
]) = standalone_docs_json_and_render_items([model], True)
render_bundle = dict(
docs_json=docs_json,
render_items=[render_item.to_json()],
div=div_for_render_item(render_item),
)
return render_bundle
def update_from_model(self, model):
self._model = model
self.render_bundle = self._model_to_traits(model)
self._document.on_change_dispatch_to(self)
def _document_patched(self, event):
if event.setter is self:
return
msg = Protocol("1.0").create("PATCH-DOC", [event])
self.send({"msg": "patch", "payload": msg.header_json})
self.send({"msg": "patch", "payload": msg.metadata_json})
self.send({"msg": "patch", "payload": msg.content_json})
for header, buffer in msg.buffers:
self.send({"msg": "patch", "payload": json.dumps(header)})
self.send({"msg": "patch"}, [buffer])
def _sync_model(self, _, content, _buffers):
if content.get("event", "") != "jsevent":
return
new, old, attr = content["new"], content["old"], content["attr"]
submodel = self._model.select_one({"id": content["id"]})
descriptor = submodel.lookup(content['attr'])
try:
descriptor._real_set(submodel, old, new, setter=self)
except Exception:
return
for cb in submodel._callbacks.get(attr, []):
cb(attr, old, new)
return [leaf] + leaves(tail, underneath)
all_json = {}
for leaf in leaves(all_tree, model_class):
klass = leaf[0]
vm_name = klass.__view_model__
if vm_name in all_json:
continue
defaults = {}
instance = klass()
for name, default in instance.properties_with_values().items():
if isinstance(default, Model):
ref = default.ref
raw_attrs = default._to_json_like(include_defaults=True)
attrs = loads(serialize_json(raw_attrs, sort_keys=True))
ref['attributes'] = attrs
del ref['id'] # there's no way the ID will match coffee
default = ref
elif isinstance(default, float) and default == float('inf'):
default = None
defaults[name] = default
all_json[vm_name] = defaults
widgets_json = {}
for leaf_widget in leaves(all_tree, widget_class):
klass = leaf_widget[0]
vm_name = klass.__view_model__
if vm_name not in widgets_json:
widgets_json[vm_name] = all_json[vm_name]
del all_json[vm_name]
class BokehModel(DOMWidget):
_model_name = Unicode("BokehModel").tag(sync=True)
_model_module = Unicode(_module_name).tag(sync=True)
_model_module_version = Unicode(_module_version).tag(sync=True)
_view_name = Unicode("BokehView").tag(sync=True)
_view_module = Unicode(_module_name).tag(sync=True)
_view_module_version = Unicode(_module_version).tag(sync=True)
combine_events = Bool(False).tag(sync=True)
render_bundle = Dict().tag(sync=True,
to_json=lambda obj, _: serialize_json(obj))
@property
def _document(self):
return self._model.document
def __init__(self, model, **kwargs):
assert isinstance(model, LayoutDOM)
self.update_from_model(model)
super(BokehModel, self).__init__(**kwargs)
self.on_msg(self._sync_model)
def close(self):
super().close()
if self._document is not None:
self._document.remove_on_change(self)
@classmethod
def _model_to_traits(cls, model):
if model.document is None:
document = Document()
document.add_root(model)
(docs_json, [render_item
]) = standalone_docs_json_and_render_items([model], True)
render_bundle = dict(
docs_json=docs_json,
render_items=[render_item.to_json()],
div=div_for_render_item(render_item),
)
return render_bundle
def update_from_model(self, model):
self._model = model
self.render_bundle = self._model_to_traits(model)
self._document.on_change_dispatch_to(self)
def _document_patched(self, event):
if event.setter is self:
return
msg = Protocol().create("PATCH-DOC", [event])
self.send({"msg": "patch", "payload": msg.header_json})
self.send({"msg": "patch", "payload": msg.metadata_json})
self.send({"msg": "patch", "payload": msg.content_json})
for header, buffer in msg.buffers:
self.send({"msg": "patch", "payload": json.dumps(header)})
self.send({"msg": "patch"}, [buffer])
def _sync_model(self, _, content, _buffers):
if content.get("event", "") != "jsevent":
return
kind = content.get("kind")
if kind == 'ModelChanged':
hint = content.get("hint")
if hint:
cds = self._model.select_one(
{"id": hint["column_source"]["id"]})
if "patches" in hint:
# Handle ColumnsPatchedEvent
cds.patch(hint["patches"], setter=self)
elif "data" in hint:
# Handle ColumnsStreamedEvent
cds._stream(hint["data"],
rollover=hint["rollover"],
setter=self)
return
# Handle ModelChangedEvent
new, old, attr = content["new"], content["old"], content["attr"]
submodel = self._model.select_one({"id": content["id"]})
descriptor = submodel.lookup(content['attr'])
try:
descriptor._set(submodel, old, new, hint=hint, setter=self)
except Exception:
return
for cb in submodel._callbacks.get(attr, []):
cb(attr, old, new)
elif kind == 'MessageSent':
self._document.callbacks.trigger_json_event(content["msg_data"])
return [leaf] + leaves(tail, underneath)
all_json = {}
for leaf in leaves(all_tree, model_class):
klass = leaf[0]
vm_name = klass.__view_model__
if vm_name in all_json:
continue
defaults = {}
instance = klass()
props_with_values = instance.query_properties_with_values(lambda prop: prop.readonly or prop.serialized)
for name, default in props_with_values.items():
if isinstance(default, Model):
ref = default.ref
raw_attrs = default._to_json_like(include_defaults=True)
attrs = loads(serialize_json(raw_attrs))
ref['attributes'] = attrs
del ref['id'] # there's no way the ID will match bokehjs
default = ref
elif isinstance(default, float) and default == float('inf'):
default = None
defaults[name] = default
all_json[vm_name] = defaults
widgets_json = {}
for leaf_widget in leaves(all_tree, widget_class):
klass = leaf_widget[0]
vm_name = klass.__view_model__
if vm_name not in widgets_json:
widgets_json[vm_name] = all_json[vm_name]
del all_json[vm_name]
def test_json_encoder_dict_no_sort():
val0 = {float("nan"): 0, "key_1": 1, "abc": 2, "key_0": 3}
rep0 = Serializer().serialize(val0)
assert serialize_json(rep0) == """\
def test_json_encoder():
val0 = [
None, True, False, -128, -1, 0, 1, 128,
float("nan"), {
"key_0": b"uvw"
}
]
rep0 = Serializer().serialize(val0)
assert rep0.buffers is not None and len(rep0.buffers) == 1
assert serialize_json(rep0.content) == """\
[null,true,false,-128,-1,0,1,128,{"type":"number","value":"nan"},{"type":"map","entries":[["key_0",{"type":"bytes","data":"dXZ3"}]]}]\
"""
assert serialize_json(rep0) == """\
[null,true,false,-128,-1,0,1,128,{"type":"number","value":"nan"},{"type":"map","entries":[["key_0",{"type":"bytes","data":{"id":"%s"}}]]}]\
""" % rep0.buffers[0].id
assert serialize_json(rep0.content, pretty=True) == """\
[
null,
true,
false,
-128,
-1,
0,
1,
128,
{
"type": "number",
"value": "nan"
},
{
"type": "map",
"entries": [
[
"key_0",
{
"type": "bytes",
"data": "dXZ3"
}
]
]
}
]\
"""
assert serialize_json(rep0, pretty=True) == """\
[
null,
true,
false,
-128,
-1,
0,
1,
128,
{
"type": "number",
"value": "nan"
},
{
"type": "map",
"entries": [
[
"key_0",
{
"type": "bytes",
"data": {
"id": "%s"
}
}
]
]
}
]\
""" % rep0.buffers[0].id
else:
return [leaf] + leaves(tail, underneath)
all_json = {}
for leaf in leaves(all_tree, model_class):
klass = leaf[0]
vm_name = klass.__view_model__
if vm_name in all_json:
continue
defaults = {}
instance = klass()
for name, default in instance.properties_with_values().items():
if isinstance(default, Model):
ref = default.ref
raw_attrs = default._to_json_like(include_defaults=True)
attrs = loads(serialize_json(raw_attrs, sort_keys=True))
ref['attributes'] = attrs
del ref['id'] # there's no way the ID will match coffee
default = ref
elif isinstance(default, float) and default == float('inf'):
default = None
defaults[name] = default
all_json[vm_name] = defaults
widgets_json = {}
for leaf_widget in leaves(all_tree, widget_class):
klass = leaf_widget[0]
vm_name = klass.__view_model__
if vm_name not in widgets_json:
widgets_json[vm_name] = all_json[vm_name]
del all_json[vm_name]
