def test_without_widgets(self, test_plot, test_glplot, test_table, test_widget): assert beb._use_widgets([test_plot]) is False assert beb._use_widgets([test_plot, test_glplot]) is False d = Document() d.add_root(test_plot) d.add_root(test_glplot) assert beb._use_widgets([d]) is False
def test_compute_remove_root_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() d.remove_root(root1) after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict(references=[], events= [ {'kind': 'RootRemoved', 'model': {'id': None, 'type': 'SomeModelInTestDocument'}} ]) expected['events'][0]['model']['id'] = root1._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual([], d2.roots)
def test_width(self): p = figure(plot_width=200, plot_height=300) d = Document() d.add_root(p) util.set_single_plot_width_height(d, 400, None) assert p.plot_width == 400 assert p.plot_height == 300
def test_compute_one_attribute_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = SomeModelInTestDocument(foo=43) root1.child = child1 d.add_root(root1) before = d.to_json() root1.foo = 47 after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict( references=[], events=[ { "attr": u"foo", "kind": "ModelChanged", "model": {"id": None, "type": "SomeModelInTestDocument"}, "new": 47, } ], ) expected["events"][0]["model"]["id"] = root1._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(root1.foo, d2.roots[0].foo)
def test_application_doesnt_validate_document_due_to_env_var(check_integrity, monkeypatch): monkeypatch.setenv("BOKEH_VALIDATE_DOC", "false") a = Application() d = Document() d.add_root(figure()) a.initialize_document(d) assert not check_integrity.called
def test_compute_remove_root_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() d.remove_root(root1) after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict( references=[], events=[{"kind": "RootRemoved", "model": {"id": None, "type": "SomeModelInTestDocument"}}] ) expected["events"][0]["model"]["id"] = root1._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual([], d2.roots)
def test_compute_add_root_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root2 = SomeModelInTestDocument(foo=57) d.add_root(root2) after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = { "references": [{"attributes": {"child": None, "foo": 57}, "id": None, "type": "SomeModelInTestDocument"}], "events": [{"kind": "RootAdded", "model": {"id": None, "type": "SomeModelInTestDocument"}}], } expected["references"][0]["id"] = root2._id expected["events"][0]["model"]["id"] = root2._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(2, len(d2.roots)) self.assertEqual(42, d2.roots[0].foo) self.assertEqual(57, d2.roots[1].foo)
def test_with_doc(self, test_plot, test_table): from bokeh.models import Button d = Document() d.add_root(test_plot) d.add_root(test_table) assert beb._any([d], lambda x: isinstance(x, object)) is True assert beb._any([d], lambda x: isinstance(x, Button)) is False
def test_compute_one_attribute_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = SomeModelInTestDocument(foo=43) root1.child = child1 d.add_root(root1) before = d.to_json() root1.foo = 47 after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict(references=[], events=[ {'attr': u'foo', 'kind': 'ModelChanged', 'model': {'id': None, 'type': 'SomeModelInTestDocument'}, 'new': 47} ]) expected['events'][0]['model']['id'] = root1._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(root1.foo, d2.roots[0].foo)
def test_layout(self): p = figure(plot_width=200, plot_height=300) d = Document() d.add_root(row(p)) with pytest.warns(UserWarning) as warns: util.set_single_plot_width_height(d, 400, 500) assert len(warns) == 1 assert warns[0].message.args[0] == _SIZE_WARNING
def index(): plot = figure() plot.circle([1,2], [3,4]) document = Document() document.add_root(plot) session = push_session(document) script = autoload_server(None, session_id=session.id) return render_template('index.html', bokeh_script=script)
def go(self): """Displays the application""" document = Document() document.title = "UT330 UI" document.add_root(self.tabs) session = push_session(document) session.show() session.loop_until_closed()
def test_compute_two_attribute_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root1.foo = 47 child1.bar = 57 after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict( references=[], events=[ { "attr": u"bar", "kind": "ModelChanged", "model": {"id": None, "type": "AnotherModelInTestDocument"}, "new": 57, }, { "attr": u"foo", "kind": "ModelChanged", "model": {"id": None, "type": "SomeModelInTestDocument"}, "new": 47, }, ], ) expected["events"][0]["model"]["id"] = child1._id expected["events"][1]["model"]["id"] = root1._id # order is undefined, so fix our expectation if needed self.assertEqual(2, len(patch["events"])) if patch["events"][0]["model"]["type"] == "AnotherModelInTestDocument": pass else: tmp = expected["events"][0] expected["events"][0] = expected["events"][1] expected["events"][1] = tmp self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(root1.foo, d2.roots[0].foo) self.assertEqual(root1.child.bar, d2.roots[0].child.bar)
def get_bokeh_script(user, plot, suffix): from .models import UserSession document = Document() document.add_root(plot) document.title = suffix with closing(push_session(document)) as session: # Save the session id to a UserSession UserSession.objects.create(user=user, bokeh_session_id=session.id) # Get the script to pass into the template script = autoload_server(None, session_id=session.id) return script
def test_with_doc_in_child_raises_error(self): doc = Document() p1 = Model() p2 = SomeModelInTestObjects(child=Model()) doc.add_root(p2.child) assert p1.document is None assert p2.document is None assert p2.child.document is doc with pytest.raises(RuntimeError): with bes._ModelInDocument([p1, p2]): assert p1.document is not None assert p2.document is not None assert p1.document is doc assert p2.document is doc
def test_with_doc_in_child_raises_error(self): doc = Document() p1 = Model() p2 = SomeModelInTestObjects(child=Model()) doc.add_root(p2.child) self.assertIs(p1.document, None) self.assertIs(p2.document, None) self.assertIs(p2.child.document, doc) with self.assertRaisesRegexp(RuntimeError, p2._id): with _ModelInDocument([p1, p2]): self.assertIsNot(p1.document, None) self.assertIsNot(p2.document, None) self.assertIs(p1.document, doc) self.assertIs(p2.document, doc)
def get_bokeh_script(plot): from .models import UserSession document = Document() document.add_root(plot) with closing(push_session(document, url=bokeh_url)) as session: # Save the session id UserSession.objects.create(user=User.objects.get(), bokehSessionId=session.id) # Get the script to pass into the template script = autoload_server(None, session_id=session.id, url=bokeh_url) return script
def test_compute_two_attribute_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root1.foo=47 child1.bar=57 after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = dict(references=[], events=[ {'attr': u'bar', 'kind': 'ModelChanged', 'model': {'id': None, 'type': 'AnotherModelInTestDocument'}, 'new': 57}, {'attr': u'foo', 'kind': 'ModelChanged', 'model': {'id': None, 'type': 'SomeModelInTestDocument'}, 'new': 47} ]) expected['events'][0]['model']['id'] = child1._id expected['events'][1]['model']['id'] = root1._id # order is undefined, so fix our expectation if needed self.assertEqual(2, len(patch['events'])) if patch['events'][0]['model']['type'] == 'AnotherModelInTestDocument': pass else: tmp = expected['events'][0] expected['events'][0] = expected['events'][1] expected['events'][1] = tmp self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(root1.foo, d2.roots[0].foo) self.assertEqual(root1.child.bar, d2.roots[0].child.bar)
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 test_entire_doc_is_not_used(self): from bokeh.document import Document from bokeh.models import Button fig = figure() fig.x([0], [0]) button = Button(label="Button") d = Document() d.add_root(fig) d.add_root(button) out = bes.file_html([fig], CDN) # this is a very coarse test but it will do assert "bokeh-widgets" not in out
def test_uses_precedent_from_child(self): doc = Document() p1 = Model() p2 = SomeModelInTestObjects(child=Model()) doc.add_root(p2.child) self.assertIs(p1.document, None) self.assertIs(p2.document, None) self.assertIs(p2.child.document, doc) with _ModelInDocument([p1, p2]): self.assertIsNot(p1.document, None) self.assertIsNot(p2.document, None) self.assertIs(p1.document, doc) self.assertIs(p2.document, doc) self.assertIs(p1.document, None) self.assertIs(p2.document, None) self.assertIsNot(p2.child.document, None) self.assertIs(p2.child.document, doc)
def test_uses_precedent(self): # it's deliberate that the doc is on p2, so _ModelInDocument # has to be smart about looking for a doc anywhere in the list # before it starts inventing new documents doc = Document() p1 = Model() p2 = Model() doc.add_root(p2) assert p1.document is None assert p2.document is not None with bes._ModelInDocument([p1, p2]): assert p1.document is not None assert p2.document is not None assert p1.document is doc assert p2.document is doc assert p1.document is None assert p2.document is not None
def test_uses_precedent(self): # it's deliberate that the doc is on p2, so _ModelInDocument # has to be smart about looking for a doc anywhere in the list # before it starts inventing new documents doc = Document() p1 = Model() p2 = Model() doc.add_root(p2) self.assertIs(p1.document, None) self.assertIsNot(p2.document, None) with _ModelInDocument([p1, p2]): self.assertIsNot(p1.document, None) self.assertIsNot(p2.document, None) self.assertIs(p1.document, doc) self.assertIs(p2.document, doc) self.assertIs(p1.document, None) self.assertIsNot(p2.document, None)
def make_document(doc: Document): if self._on_session_destroyed is not None: doc.on_session_destroyed(self._on_session_destroyed) # set document title doc.title = self._title # set document template now = datetime.now() env = Environment(loader=PackageLoader('btplotting', 'templates')) templ = env.get_template(self._html_template) templ.globals['now'] = now.strftime('%Y-%m-%d %H:%M:%S') doc.template = templ doc.template_variables['stylesheet'] = generate_stylesheet( self._scheme) model = self._model_factory_fnc(doc) doc.add_root(model)
def test_get_one_by_name(self) -> None: d = Document() dm = d.models assert len(dm) == 0 m1 = Div(name="foo") m2 = Div(name="foo") m3 = Div(name="bar") d.add_root(m1) d.add_root(m2) d.add_root(m3) with pytest.raises(ValueError): dm.get_one_by_name("foo") assert dm.get_one_by_name("bar") is m3 assert dm.get_one_by_name("baz") is None
def make_document(doc: Document): if self._on_session_destroyed is not None: doc.on_session_destroyed(self._on_session_destroyed) # set document title doc.title = self._title # set document template env = Environment( loader=PackageLoader('backtrader_plotting.bokeh', 'templates')) doc.template = env.get_template(self._html_template) doc.template_variables['stylesheet'] = utils.generate_stylesheet( self._scheme) # get root model model = self._model_factory_fnc(doc) doc.add_root(model)
def test_compute_add_root_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root2 = SomeModelInTestDocument(foo=57) d.add_root(root2) after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = { 'references': [{ 'attributes': { 'child': None, 'foo': 57 }, 'id': None, 'type': 'SomeModelInTestDocument' }], 'events': [{ 'kind': 'RootAdded', 'model': { 'id': None, 'type': 'SomeModelInTestDocument' } }] } expected['references'][0]['id'] = root2._id expected['events'][0]['model']['id'] = root2._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(2, len(d2.roots)) self.assertEqual(42, d2.roots[0].foo) self.assertEqual(57, d2.roots[1].foo)
def modify_document(self, doc: Document) -> None: plots = [] line_renderers = [] # type: List for watchers in self._line_watchers: plot = figure(plot_width=350, plot_height=350, x_axis_label='time', x_axis_type='datetime', y_axis_label='value') for i, line_watcher in enumerate(watchers): data_source = line_watcher.make_data_source() plot.step('time', 'value', source=data_source, mode='after', legend=line_watcher.sensor.name, color=PALETTE[i]) plot.legend.location = 'top_left' plots.append(plot) line_renderers.extend(plot.x_range.renderers) # Create a single data range so that all line plots show the same time window data_range = DataRange1d() data_range.renderers = line_renderers data_range.follow = 'end' data_range.default_span = timedelta(seconds=1) data_range.follow_interval = timedelta(seconds=120) for plot in plots: plot.x_range = data_range for histogram_watcher in self._histogram_watchers: plot = figure(plot_width=350, plot_height=350, x_axis_label=histogram_watcher.sensor.name, y_axis_label='frequency') data_source = histogram_watcher.make_data_source() plot.quad(top='top', bottom='bottom', left='left', right='right', source=data_source) plots.append(plot) doc.add_root(gridplot(plots, ncols=3)) logger.debug('Created document with %d plots', len(plots)) self._docs.add(doc)
def plot_code_iterator(self): """ Iterator over the single bokeh plot :return: Tuple of js-script code for the plot and number of invalid values """ for index, dummy in enumerate(self.__conf.filter_args): if self.__index is not None and self.__index != index: continue document = Document() document.title = self.__conf.description self.__factors, self.__values, num_invalid = \ self.create_x_y_values(index) plot = self.__create_control_chart_hist(index) document.add_root(plot) session_id = self.__save_user_session(document, index) script = autoload_server(None, session_id=session_id) yield script, num_invalid
def test_compute_add_root_patch(): d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root2 = SomeModelInTestDocument(foo=57) d.add_root(root2) after = d.to_json() patch = bdu.compute_patch_between_json(before, after) expected = { 'references': [{ 'attributes': { 'child': None, 'foo': 57 }, 'id': None, 'type': 'SomeModelInTestDocument' }], 'events': [{ 'kind': 'RootAdded', 'model': { 'id': None, 'type': 'SomeModelInTestDocument' } }] } expected['references'][0]['id'] = root2._id expected['events'][0]['model']['id'] = root2._id assert expected == patch d2 = Document.from_json(before) d2.apply_json_patch(patch) assert len(d2.roots) == 2 assert d2.roots[0].foo == 42 assert d2.roots[1].foo == 57
def test_theming_a_document_before_adding_root(self) -> None: theme = Theme(json={'attrs': {'ThemedModel': {'string': 'w00t'}}}) obj = ThemedModel() doc = Document() assert 'hello' == obj.string doc.theme = theme assert doc.theme is theme changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.add_root(obj) assert 'w00t' == obj.string doc.remove_root(obj) assert 'hello' == obj.string assert [('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')] == changes['calls']
def modify_doc(doc: Document): source = ColumnDataSource(data=data_holder.get_data()) _keys = data_holder.get_keys() plot = figure(plot_height=600, plot_width=1200, title='Sequence Diagram', x_axis_type='datetime', y_range=_keys, tools="xwheel_zoom,xpan,box_zoom,hover,reset", active_scroll="xwheel_zoom", active_drag="xpan") glyph = HBar(y="who", left="t_start_ms", right="t_end_ms", height=0.4, fill_color="green", fill_alpha=0.2) plot.add_glyph(source, glyph) labels = LabelSet(x="t_start_ms", y="who", text="func", text_font_size="8pt", source=source, text_align='left') plot.add_layout(labels) plot.hover.tooltips = [ ("func", "@func"), ("in", "@in"), ("out", "@out"), # ("msg", "@msg"), ] def callback(): #source.stream(new_data=data_holder.get_data(), rollover=1000) # todo: how to use stream source.data = ColumnDataSource(data=data_holder.get_data()).data doc.add_periodic_callback(callback, 1000) doc.add_root(plot)
def test_theming_a_document_before_adding_root(self): theme = Theme(json={'attrs': {'ThemedModel': {'string': 'w00t'}}}) obj = ThemedModel() doc = Document() self.assertEqual('hello', obj.string) doc.theme = theme self.assertIs(doc.theme, theme) changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.add_root(obj) self.assertEqual('w00t', obj.string) doc.remove_root(obj) self.assertEqual('hello', obj.string) self.assertEqual([('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')], changes['calls'])
def test_setting_document_theme_to_none(self): theme = Theme(json={'attrs': {'ThemedModel': {'string': 'w00t'}}}) obj = ThemedModel() doc = Document() doc.add_root(obj) changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.theme = theme self.assertEqual('w00t', obj.string) # setting to None reverts to default theme doc.theme = None self.assertIsNot(doc.theme, None) self.assertEqual('hello', obj.string) self.assertEqual([('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')], changes['calls'])
def test_len(self) -> None: d = Document() dm = d.models assert len(dm) == 0 r1 = Row(children=[Div()]) r2 = Row(children=[Div(), Div()]) d.add_root(r1) assert len(dm) == 2 d.add_root(r2) assert len(dm) == 5 d.remove_root(r1) assert len(dm) == 3 d.remove_root(r2) assert len(dm) == 0
def figure_data(self, plot, fmt='html', doc=None, **kwargs): model = plot.state doc = Document() if doc is None else doc for m in model.references(): m._document = None doc.add_root(model) comm_id = plot.comm.id if plot.comm else None # Bokeh raises warnings about duplicate tools and empty subplots # but at the holoviews level these are not issues logger = logging.getLogger(bokeh.core.validation.check.__file__) logger.disabled = True try: div = notebook_div(model, comm_id) except: logger.disabled = False raise logger.disabled = False plot.document = doc return div
def dco_intergrate(sorted_group_dict_top): # 构建图表数据结构。 按照每行两个图(1个线上,1个线下)的结构去存储。 plot_list = [] for x in sorted_group_dict_top: # print(x) data = x[1] p1, p2 = make_plot(data) plot_list.append([p1, p2]) grid = gridplot(plot_list, toolbar_location=None) div = Div(text=""" <h1>Data review tools</h1> <p>快速审阅数据的整体情况。</p> <p>左边是线上数据,右边是原始数据。</p> """) doc = Document() doc.add_root(column(div, grid, sizing_mode="scale_width")) return doc
def test_setting_document_theme_to_none(self) -> None: theme = Theme(json={'attrs': {'ThemedModel': {'string': 'w00t'}}}) obj = ThemedModel() doc = Document() doc.add_root(obj) changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.theme = theme assert 'w00t' == obj.string # setting to None reverts to default theme doc.theme = None assert doc.theme is not None assert 'hello' == obj.string assert [('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')] == changes['calls']
class BokehDocument(InstancesMixin): def __init__(self, title='Live Trending'): self.document = Document(title=title) self.plots = [] logging.getLogger("requests").setLevel(logging.INFO) logging.getLogger("bokeh").setLevel(logging.INFO) def add_plot(self, new_plot, linked_x_axis=True): self.document.clear() new_plot.x_range.bounds = None new_plot.y_range.bounds = None for key, plot in enumerate(self.plots): if new_plot.title == plot.title: self.plots.pop(key) self.plots.append(new_plot) break else: self.plots.append(new_plot) if linked_x_axis: for plot in self.plots[1:]: plot.x_range = self.plots[0].x_range plot.x_range.bounds = None plot.y_range.bounds = None if len(self.plots) > 1: number_of_rows = int(round(len(self.plots) / 2)) rows = [] number_of_columns = 2 i = 0 for each in range(number_of_rows): rows.append( list(plot for plot in self.plots[i:i + number_of_columns])) i += number_of_columns layout = gridplot(rows) else: print('Layout...') layout = VBox(children=self.plots) self.document.add_root(layout) def add_periodic_callback(self, cb, update=100): self.document.add_periodic_callback(cb, update)
def sea_surface_handler(doc: Document) -> None: df = sea_surface_temperature.copy() source = ColumnDataSource(data=df) plot = figure(x_axis_type="datetime", y_range=(0, 25), y_axis_label="Temperature (Celsius)", title="Sea Surface Temperature at 43.18, -70.43") plot.line("time", "temperature", source=source) def callback(attr: str, old: Any, new: Any) -> None: if new == 0: data = df else: data = df.rolling(f"{new}D").mean() source.data = dict(ColumnDataSource(data=data).data) slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days") slider.on_change("value", callback) doc.theme = theme doc.add_root(column(slider, plot))
def test_with_plaintext(self, test_plot, test_glplot, test_table, test_widget, test_mathtext, test_plaintext) -> None: assert beb._use_mathjax([test_plaintext]) is False assert beb._use_mathjax([test_plot, test_plaintext]) is False assert beb._use_mathjax([test_plot, test_glplot, test_plaintext]) is False assert beb._use_mathjax([test_plot, test_widget, test_plaintext]) is False assert beb._use_mathjax([test_plot, test_widget, test_table, test_plaintext]) is False assert beb._use_mathjax([test_plot, test_mathtext, test_plaintext]) is True d = Document() d.add_root(test_plot) d.add_root(test_table) d.add_root(test_widget) d.add_root(test_plaintext) assert beb._use_mathjax([d]) is False
def splom(data_csv): # read csv colors = [] # 0 for original, 1 for aug scores = [] with open(data_csv, newline='') as csvfile: datareader = csv.reader(csvfile) index = 0 for row in datareader: if "Generated" in row[0]: colors.append('red') else: colors.append('blue') scores.append(row[2:]) scores = np.array(scores) # make splom plots = [] for y in range(len(scores[0])): row = [] for x in range(len(scores[0])): xax = (y == len(scores[0]) - 1) yax = (x == 0) xscores = [float(item) for item in list(scores[:, x])] yscores = [float(item) for item in list(scores[:, y])] source = ColumnDataSource(dict(x=xscores, y=yscores, colors=colors)) plot = make_plot(source, x, y, xax, yax) row.append(plot) plots.append(row) grid = gridplot(plots) doc = Document() doc.add_root(grid) doc.validate() filename = "augmentation_splom.html" with open(filename, "w") as f: f.write(file_html(doc, INLINE, "Data SPLOM")) print("Wrote %s" % filename) view(filename)
def test_compute_add_root_patch(self): from bokeh.document import Document d = Document() root1 = SomeModelInTestDocument(foo=42) child1 = AnotherModelInTestDocument(bar=43) root1.child = child1 d.add_root(root1) before = d.to_json() root2 = SomeModelInTestDocument(foo=57) d.add_root(root2) after = d.to_json() patch = Document._compute_patch_between_json(before, after) expected = { 'references' : [ { 'attributes': {'child': None, 'foo': 57}, 'id': None, 'type': 'SomeModelInTestDocument'} ], 'events' : [ { 'kind': 'RootAdded', 'model': {'id': None, 'type': 'SomeModelInTestDocument'} } ] } expected['references'][0]['id'] = root2._id expected['events'][0]['model']['id'] = root2._id self.assertDictEqual(expected, patch) d2 = Document.from_json(before) d2.apply_json_patch(patch) self.assertEqual(2, len(d2.roots)) self.assertEqual(42, d2.roots[0].foo) self.assertEqual(57, d2.roots[1].foo)
class BokehDocument(InstancesMixin): def __init__(self, title = 'Live Trending'): self.document = Document(title = title) self.plots = [] logging.getLogger("requests").setLevel(logging.INFO) logging.getLogger("bokeh").setLevel(logging.INFO) def add_plot(self, new_plot, linked_x_axis = True): self.document.clear() new_plot.x_range.bounds = None new_plot.y_range.bounds = None for key, plot in enumerate(self.plots): if new_plot.title == plot.title: self.plots.pop(key) self.plots.append(new_plot) break else: self.plots.append(new_plot) if linked_x_axis: for plot in self.plots[1:]: plot.x_range = self.plots[0].x_range plot.x_range.bounds = None plot.y_range.bounds = None if len(self.plots) > 1: number_of_rows = int(round(len(self.plots) / 2)) rows = [] number_of_columns = 2 i = 0 for each in range(number_of_rows): rows.append(list(plot for plot in self.plots[i:i+number_of_columns])) i += number_of_columns layout = gridplot(rows) else: print('Layout...') layout = VBox(children=self.plots) self.document.add_root(layout) def add_periodic_callback(self, cb, update = 100): self.document.add_periodic_callback(cb,update)
def test_plot_dict_returned_when_wrap_plot_info_is_false(self, mock_make_id): doc = Document() plot1 = figure() plot1.circle([], []) doc.add_root(plot1) plot2 = figure() plot2.circle([], []) doc.add_root(plot2) expected_plotdict_1 = RenderRoot(elementid="ID", id="ID") expected_plotdict_2 = RenderRoot(elementid="ID", id="ID") _, plotdict = bes.components(plot1, wrap_plot_info=False) assert plotdict == expected_plotdict_1 _, plotids = bes.components((plot1, plot2), wrap_plot_info=False) assert plotids == (expected_plotdict_1, expected_plotdict_2) _, plotiddict = bes.components({'p1': plot1, 'p2': plot2}, wrap_plot_info=False) assert plotiddict == {'p1': expected_plotdict_1, 'p2': expected_plotdict_2}
def test_destroy(self) -> None: d = Document() dm = d.models assert len(dm) == 0 m1 = Div() m2 = Div() m3 = Div() d.add_root(m1) d.add_root(m2) d.add_root(m3) for m in [m1, m2, m3]: assert m._document is d assert dm.destroy() is None assert not hasattr(dm, "_models") assert not hasattr(dm, "_models_by_name") for m in [m1, m2, m3]: assert m._document is None
def test_theming_a_document_before_adding_root(self): theme = Theme(json={ 'attrs' : { 'ThemedModel' : { 'string' : 'w00t' } } }) obj = ThemedModel() doc = Document() assert 'hello' == obj.string doc.theme = theme assert doc.theme is theme changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.add_root(obj) assert 'w00t' == obj.string doc.remove_root(obj) assert 'hello' == obj.string assert [('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')] == changes['calls']
def test_setting_document_theme_to_none(self): theme = Theme(json={ 'attrs' : { 'ThemedModel' : { 'string' : 'w00t' } } }) obj = ThemedModel() doc = Document() doc.add_root(obj) changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.theme = theme assert 'w00t' == obj.string # setting to None reverts to default theme doc.theme = None assert doc.theme is not None assert 'hello' == obj.string assert [('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')] == changes['calls']
def test_with_mathstring(self, test_plot, test_glplot, test_table, test_widget, test_mathtext, test_mathstring_axis_label, test_mathstring_major_label_overrides) -> None: assert beb._use_mathjax([test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_glplot, test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_widget, test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_widget, test_table, test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_mathtext, test_mathstring_axis_label]) is True assert beb._use_mathjax([test_plot, test_mathstring_major_label_overrides]) is True d = Document() d.add_root(test_plot) d.add_root(test_table) d.add_root(test_widget) d.add_root(test_mathstring_axis_label) assert beb._use_mathjax([d]) is True
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_setting_document_theme_to_none(self): theme = Theme(json={ 'attrs' : { 'ThemedModel' : { 'string' : 'w00t' } } }) obj = ThemedModel() doc = Document() doc.add_root(obj) changes = dict(calls=[]) def record_trigger(attr, old, new_): changes['calls'].append((attr, old, new_)) obj.on_change('string', record_trigger) doc.theme = theme self.assertEqual('w00t', obj.string) # setting to None reverts to default theme doc.theme = None self.assertIsNot(doc.theme, None) self.assertEqual('hello', obj.string) self.assertEqual([('string', 'hello', 'w00t'), ('string', 'w00t', 'hello')], changes['calls'])
def test_seen(self) -> None: d = Document() dm = d.models assert len(dm) == 0 m1 = Div(id="m1") m2 = Div(id="m2") d.add_root(m1) d.add_root(m2) assert not dm.seen("m1") assert not dm.seen("m2") d.remove_root(m2) assert not dm.seen("m1") assert dm.seen("m2") d.remove_root(m1) assert dm.seen("m1") assert dm.seen("m2")
def test_without_gl(self, test_plot, test_glplot, test_table, test_widget): assert beb._use_gl([test_plot]) is False assert beb._use_gl([test_plot, test_table]) is False assert beb._use_gl([test_plot, test_widget]) is False d = Document() d.add_root(test_plot) d.add_root(test_table) d.add_root(test_widget) assert beb._use_gl([d]) is False
def spotify_graph_handler(doc: Document) -> None: plot_handler = PlotHandler() def playlist_input_handler(attr, old, new): root_layout = curdoc().get_model_by_name('main_layout') sub_layouts = root_layout.children sub_layouts[-1] = plot_handler.get_plot(RequestType.Playlist, new) playlist_input = TextInput(value="", title="Playlist:") playlist_input.on_change("value", playlist_input_handler) def artist_input_handler(attr, old, new): root_layout = curdoc().get_model_by_name('main_layout') sub_layouts = root_layout.children sub_layouts[-1] = plot_handler.get_plot(RequestType.SingleArtist, new) artist_input = TextInput(value="", title="Artist:") artist_input.on_change("value", artist_input_handler) doc.add_root( column(playlist_input, artist_input, plot_handler.plot, name='main_layout'))
def test_recompute(self) -> None: d = Document() dm = d.models assert len(dm) == 0 r1 = Row(children=[Div(id="d1", name="dr1")]) r2 = Row(children=[Div(id="d2", name="dr2"), Div(id="d3", name="dr2")]) d.add_root(r1) d.add_root(r2) assert set(dm._models_by_name._dict) == {"dr1", "dr2"} for m in dm: assert m._document is d d.remove_root(r1) for m in dm: assert m._document is d assert r1._document is None assert r1.children[0]._document is None assert set(dm._models_by_name._dict) == {"dr2"}
def test_with_tables(self, test_plot, test_glplot, test_table, test_widget) -> None: assert beb._use_tables([test_table]) is True assert beb._use_tables([test_table, test_plot]) is True assert beb._use_tables([test_table, test_plot, test_glplot]) is True assert beb._use_tables([test_table, test_widget, test_table, test_glplot]) is True d = Document() d.add_root(test_plot) d.add_root(test_table) d.add_root(test_widget) d.add_root(test_glplot) assert beb._use_tables([d]) is True