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 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]