test_holoviews.py at 4e3439d ⋅ holoviz/panel

from __future__ import absolute_import

import datetime as dt
from collections import OrderedDict

import pytest
import numpy as np

try:
    import holoviews as hv
except Exception:
    hv = None

from bokeh.models import (Row as BkRow, Column as BkColumn, GlyphRenderer,
                          Scatter, Line, GridBox, Select as BkSelect,
                          Slider as BkSlider, Spacer as BkSpacer,
                          ColumnDataSource)
from bokeh.plotting import Figure

from panel.layout import Column, Row
from panel.pane import Pane, PaneBase, HoloViews
from panel.widgets import FloatSlider, DiscreteSlider, Select
from panel.tests.util import hv_available, mpl_available


@hv_available
def test_get_holoviews_pane_type():
    curve = hv.Curve([1, 2, 3])
    assert PaneBase.get_pane_type(curve) is HoloViews


@pytest.mark.usefixtures("hv_mpl")
@mpl_available
@hv_available
def test_holoviews_pane_mpl_renderer(document, comm):
    curve = hv.Curve([1, 2, 3])
    pane = Pane(curve)

    # Create pane
    row = pane.get_root(document, comm=comm)
    assert isinstance(row, BkRow)
    assert len(row.children) == 1
    model = row.children[0]
    assert pane._models[row.ref['id']][0] is model
    assert model.text.startswith('&lt;img src=')

    # Replace Pane.object
    scatter = hv.Scatter([1, 2, 3])
    pane.object = scatter
    new_model = row.children[0]
    assert model.text != new_model.text

    # Cleanup
    pane._cleanup(row)
    assert pane._models == {}


@pytest.mark.usefixtures("hv_mpl")
@pytest.mark.usefixtures("hv_bokeh")
@mpl_available
@hv_available
def test_holoviews_pane_switch_backend(document, comm):
    curve = hv.Curve([1, 2, 3])
    pane = Pane(curve)

    # Create pane
    row = pane.get_root(document, comm=comm)
    assert isinstance(row, BkRow)
    assert len(row.children) == 1
    model = row.children[0]
    assert pane._models[row.ref['id']][0] is model
    assert model.text.startswith('&lt;img src=')

    # Replace Pane.object
    pane.backend = 'bokeh'
    model = row.children[0]
    assert isinstance(model, Figure)

    # Cleanup
    pane._cleanup(row)
    assert pane._models == {}


@pytest.mark.usefixtures("hv_bokeh")
@hv_available
def test_holoviews_pane_bokeh_renderer(document, comm):
    curve = hv.Curve([1, 2, 3])
    pane = Pane(curve)

    # Create pane
    row = pane.get_root(document, comm=comm)
    assert isinstance(row, BkRow)
    assert len(row.children) == 1
    model = row.children[0]
    assert isinstance(model, Figure)
    assert pane._models[row.ref['id']][0] is model
    renderers = [r for r in model.renderers if isinstance(r, GlyphRenderer)]
    assert len(renderers) == 1
    assert isinstance(renderers[0].glyph, Line)

    # Replace Pane.object
    scatter = hv.Scatter([1, 2, 3])
    pane.object = scatter
    model = row.children[0]
    assert isinstance(model, Figure)
    renderers = [r for r in model.renderers if isinstance(r, GlyphRenderer)]
    assert len(renderers) == 1
    assert isinstance(renderers[0].glyph, Scatter)
    assert pane._models[row.ref['id']][0] is model

    # Cleanup
    pane._cleanup(row)
    assert pane._models == {}


@pytest.mark.usefixtures("hv_bokeh")
@hv_available
def test_holoviews_pane_initialize_empty(document, comm):
    pane = HoloViews()

    # Create pane
    row = pane.get_root(document, comm=comm)

    assert isinstance(row, BkRow)
    assert len(row.children) == 1
    model = row.children[0]
    assert isinstance(model, BkSpacer)

    pane.object = hv.Curve([1, 2, 3])
    model = row.children[0]
    assert isinstance(model, Figure)


@hv_available
def test_holoviews_widgets_from_dynamicmap(document, comm):
    range_dim = hv.Dimension('A', range=(0, 10.))
    range_step_dim = hv.Dimension('B', range=(0, 10.), step=0.2)
    range_default_dim = hv.Dimension('C', range=(0, 10.), default=3)
    value_dim = hv.Dimension('D', values=['a', 'b', 'c'])
    value_default_dim = hv.Dimension('E', values=['a', 'b', 'c', 'd'], default='b')
    value_numeric_dim = hv.Dimension('F', values=[1, 3, 10], default=3)
    kdims = [range_dim, range_step_dim, range_default_dim,
             value_dim, value_default_dim, value_numeric_dim]
    dmap = hv.DynamicMap(lambda A, B, C, D, E, F: hv.Curve([]), kdims=kdims)
    widgets, _ = HoloViews.widgets_from_dimensions(dmap)

    assert len(widgets) == len(kdims)

    assert isinstance(widgets[0], FloatSlider)
    assert widgets[0].name == 'A'
    assert widgets[0].start == range_dim.range[0]
    assert widgets[0].end == range_dim.range[1]
    assert widgets[0].value == range_dim.range[0]
    assert widgets[0].step == 0.1

    assert isinstance(widgets[1], FloatSlider)
    assert widgets[1].name == 'B'
    assert widgets[1].start == range_step_dim.range[0]
    assert widgets[1].end == range_step_dim.range[1]
    assert widgets[1].value == range_step_dim.range[0]
    assert widgets[1].step == range_step_dim.step

    assert isinstance(widgets[2], FloatSlider)
    assert widgets[2].name == 'C'
    assert widgets[2].start == range_default_dim.range[0]
    assert widgets[2].end == range_default_dim.range[1]
    assert widgets[2].value == range_default_dim.default
    assert widgets[2].step == 0.1

    assert isinstance(widgets[3], Select)
    assert widgets[3].name == 'D'
    assert widgets[3].options == value_dim.values
    assert widgets[3].value == value_dim.values[0]

    assert isinstance(widgets[4], Select)
    assert widgets[4].name == 'E'
    assert widgets[4].options == value_default_dim.values
    assert widgets[4].value == value_default_dim.default

    assert isinstance(widgets[5], DiscreteSlider)
    assert widgets[5].name == 'F'
    assert widgets[5].options == OrderedDict([(str(v), v) for v in value_numeric_dim.values])
    assert widgets[5].value == value_numeric_dim.default


@hv_available
def test_holoviews_with_widgets(document, comm):
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    hv_pane = HoloViews(hmap)
    layout = hv_pane.get_root(document, comm)
    model = layout.children[0]
    assert len(hv_pane.widget_box.objects) == 2
    assert hv_pane.widget_box.objects[0].name == 'X'
    assert hv_pane.widget_box.objects[1].name == 'Y'

    assert hv_pane._models[layout.ref['id']][0] is model

    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['A', 'B'])
    hv_pane.object = hmap
    assert len(hv_pane.widget_box.objects) == 2
    assert hv_pane.widget_box.objects[0].name == 'A'
    assert hv_pane.widget_box.objects[1].name == 'B'


@hv_available
def test_holoviews_updates_widgets(document, comm):
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    hv_pane = HoloViews(hmap)
    layout = hv_pane.get_root(document, comm)

    hv_pane.widgets = {'X': Select}
    assert isinstance(hv_pane.widget_box[0], Select)
    assert isinstance(layout.children[1].children[0].children[0], BkSelect)

    hv_pane.widgets = {'X': DiscreteSlider}
    assert isinstance(hv_pane.widget_box[0], DiscreteSlider)
    assert isinstance(layout.children[1].children[0].children[0], BkColumn)
    assert isinstance(layout.children[1].children[0].children[0].children[1], BkSlider)

@hv_available
def test_holoviews_widgets_update_plot(document, comm):
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    hv_pane = HoloViews(hmap, backend='bokeh')
    layout = hv_pane.get_root(document, comm)

    cds = layout.children[0].select_one(ColumnDataSource)
    assert cds.data['y'] == np.array([0])
    hv_pane.widget_box[0].value = 1
    hv_pane.widget_box[1].value = chr(65+1)
    assert cds.data['y'] == np.array([1])


@hv_available
def test_holoviews_with_widgets_not_shown(document, comm):
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    hv_pane = HoloViews(hmap, show_widgets=False)
    layout_obj = Column(hv_pane, hv_pane.widget_box)
    layout = layout_obj.get_root(document, comm)
    model = layout.children[0]
    assert len(hv_pane.widget_box.objects) == 2
    assert hv_pane.widget_box.objects[0].name == 'X'
    assert hv_pane.widget_box.objects[1].name == 'Y'

    assert hv_pane._models[layout.ref['id']][0] is model

    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['A', 'B'])
    hv_pane.object = hmap
    assert len(hv_pane.widget_box.objects) == 2
    assert hv_pane.widget_box.objects[0].name == 'A'
    assert hv_pane.widget_box.objects[1].name == 'B'


@hv_available
def test_holoviews_layouts(document, comm):
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    hv_pane = HoloViews(hmap, backend='bokeh')
    layout = hv_pane.layout
    model = layout.get_root(document, comm)

    for center in (True, False):
        for loc in HoloViews.param.widget_location.objects:
            hv_pane.param.set_param(center=center, widget_location=loc)
            if center:
                if loc.startswith('left'):
                    assert len(layout) == 4
                    widgets, hv_obj = layout[0], layout[2]
                    wmodel, hv_model = model.children[0],  model.children[2]
                elif loc.startswith('right'):
                    assert len(layout) == 4
                    hv_obj, widgets = layout[1], layout[3]
                    wmodel, hv_model = model.children[3],  model.children[1]
                elif loc.startswith('top'):
                    assert len(layout) == 3
                    col = layout[1]
                    cmodel = model.children[1]
                    assert isinstance(col, Column)
                    widgets, hv_col = col
                    hv_obj = hv_col[1]
                    wmodel, hv_model = cmodel.children[0],  cmodel.children[1].children[1]
                elif loc.startswith('bottom'):
                    col = layout[1]
                    cmodel = model.children[1]
                    assert isinstance(col, Column)
                    hv_col, widgets = col
                    hv_obj = hv_col[1]
                    wmodel, hv_model = cmodel.children[1],  cmodel.children[0].children[1]
            else:
                if loc.startswith('left'):
                    assert len(layout) == 2
                    widgets, hv_obj = layout
                    wmodel, hv_model = model.children
                elif loc.startswith('right'):
                    assert len(layout) == 2
                    hv_obj, widgets = layout
                    hv_model, wmodel = model.children
                elif loc.startswith('top'):
                    assert len(layout) == 1
                    col = layout[0]
                    cmodel = model.children[0]
                    assert isinstance(col, Column)
                    widgets, hv_obj = col
                    wmodel, hv_model = cmodel.children
                elif loc.startswith('bottom'):
                    assert len(layout) == 1
                    col = layout[0]
                    cmodel = model.children[0]
                    assert isinstance(col, Column)
                    hv_obj, widgets = col
                    hv_model, wmodel = cmodel.children
            assert hv_pane is hv_obj
            assert isinstance(hv_model, Figure)

            if loc in ('left', 'right', 'top', 'bottom',
                       'top_right', 'right_bottom', 'bottom_right',
                       'left_bottom'):
                box = widgets[1]
                boxmodel = wmodel.children[1]
            else:
                box = widgets[0]
                boxmodel = wmodel.children[0]
            assert hv_pane.widget_box is box
            assert isinstance(boxmodel, BkColumn)
            assert isinstance(boxmodel.children[0], BkColumn)
            assert isinstance(boxmodel.children[0].children[1], BkSlider)
            assert isinstance(boxmodel.children[1], BkSelect)


@hv_available
def test_holoviews_widgets_from_holomap():
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    widgets, _ = HoloViews.widgets_from_dimensions(hmap)

    assert isinstance(widgets[0], DiscreteSlider)
    assert widgets[0].name == 'X'
    assert widgets[0].options == OrderedDict([(str(i), i) for i in range(3)])
    assert widgets[0].value == 0

    assert isinstance(widgets[1], Select)
    assert widgets[1].name == 'Y'
    assert widgets[1].options == ['A', 'B', 'C']
    assert widgets[1].value == 'A'


@hv_available
def test_holoviews_date_slider_widgets_from_holomap():
    hmap = hv.HoloMap({dt.datetime(2016, 1, i+1): hv.Curve([i]) for i in range(3)}, kdims=['X'])

    widgets, _ = HoloViews.widgets_from_dimensions(hmap)

    assert isinstance(widgets[0], DiscreteSlider)
    assert widgets[0].name == 'X'
    assert widgets[0].options == OrderedDict([
        ('2016-01-01 00:00:00', dt.datetime(2016, 1, 1)),
        ('2016-01-02 00:00:00', dt.datetime(2016, 1, 2)),
        ('2016-01-03 00:00:00', dt.datetime(2016, 1, 3))])
    assert widgets[0].value == dt.datetime(2016, 1, 1)


@hv_available
def test_holoviews_widgets_explicit_widget_type_override():
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    widgets, _ = HoloViews.widgets_from_dimensions(hmap, widget_types={'X': Select})

    assert isinstance(widgets[0], Select)
    assert widgets[0].name == 'X'
    assert widgets[0].options == OrderedDict([(str(i), i) for i in range(3)])
    assert widgets[0].value == 0


@hv_available
def test_holoviews_widgets_invalid_widget_type_override():
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    with pytest.raises(ValueError):
        HoloViews.widgets_from_dimensions(hmap, widget_types={'X': 1})


@hv_available
def test_holoviews_widgets_explicit_widget_instance_override():
    hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])

    widget = Select(options=[1, 2, 3], value=3)
    widgets, _ = HoloViews.widgets_from_dimensions(hmap, widget_types={'X': widget})

    assert widgets[0] is widget


@hv_available
def test_holoviews_linked_axes(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([1, 2, 3])

    layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is p2.x_range
    assert p1.y_range is p2.y_range


@hv_available
def test_holoviews_linked_axes_merged_ranges(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([0, 1, 2, 3, 4])

    layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is p2.x_range
    assert p1.y_range is p2.y_range
    assert p1.y_range.start == -0.4
    assert p1.y_range.end == 4.4


@hv_available
def test_holoviews_linked_x_axis(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([1, 2, 3], vdims='y2')

    layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is p2.x_range
    assert p1.y_range is not p2.y_range


@hv_available
def test_holoviews_axiswise_not_linked_axes(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([1, 2, 3]).opts(axiswise=True, backend='bokeh')

    layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is not p2.x_range
    assert p1.y_range is not p2.y_range


@hv_available
def test_holoviews_shared_axes_opt_not_linked_axes(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([1, 2, 3]).opts(shared_axes=False, backend='bokeh')

    layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is not p2.x_range
    assert p1.y_range is not p2.y_range


@hv_available
def test_holoviews_not_linked_axes(document, comm):
    c1 = hv.Curve([1, 2, 3])
    c2 = hv.Curve([1, 2, 3])

    layout = Row(
        HoloViews(c1, backend='bokeh'),
        HoloViews(c2, backend='bokeh', linked_axes=False)
    )

    row_model = layout.get_root(document, comm=comm)

    p1, p2 = row_model.select({'type': Figure})

    assert p1.x_range is not p2.x_range
    assert p1.y_range is not p2.y_range


@hv_available
def test_holoviews_link_across_panes(document, comm):
    from bokeh.models.tools import RangeTool
    from holoviews.plotting.links import RangeToolLink

    c1 = hv.Curve([])
    c2 = hv.Curve([])

    RangeToolLink(c1, c2)

    layout = Row(Pane(c1, backend='bokeh'), Pane(c2, backend='bokeh'))
    row = layout.get_root(document, comm=comm)

    assert len(row.children) == 2
    p1, p2 = row.children

    assert isinstance(p1, Figure)
    assert isinstance(p2, Figure)

    range_tool = row.select_one({'type': RangeTool})
    assert isinstance(range_tool, RangeTool)
    assert range_tool.x_range == p2.x_range


@hv_available
def test_holoviews_link_after_adding_item(document, comm):
    from bokeh.models.tools import RangeTool
    from holoviews.plotting.links import RangeToolLink

    c1 = hv.Curve([])
    c2 = hv.Curve([])

    RangeToolLink(c1, c2)

    layout = Row(Pane(c1, backend='bokeh'))
    row = layout.get_root(document, comm=comm)

    assert len(row.children) == 1
    p1, = row.children

    assert isinstance(p1, Figure)
    range_tool = row.select_one({'type': RangeTool})
    assert range_tool is None

    layout.append(Pane(c2, backend='bokeh'))
    _, p2 = row.children
    assert isinstance(p2, Figure)
    range_tool = row.select_one({'type': RangeTool})
    assert isinstance(range_tool, RangeTool)
    assert range_tool.x_range == p2.x_range


@hv_available
def test_holoviews_link_within_pane(document, comm):
    from bokeh.models.tools import RangeTool
    from holoviews.plotting.links import RangeToolLink

    c1 = hv.Curve([])
    c2 = hv.Curve([])

    RangeToolLink(c1, c2)

    pane = Pane(Pane(hv.Layout([c1, c2]), backend='bokeh'))
    column = pane.get_root(document, comm=comm)

    assert len(column.children) == 1
    subcolumn = column.children[0]
    assert isinstance(subcolumn, BkColumn)
    assert len(subcolumn.children) == 2
    toolbar, subsubcolumn = subcolumn.children
    assert isinstance(subsubcolumn, GridBox)
    assert len(subsubcolumn.children) == 2
    (p1, _, _), (p2, _, _) = subsubcolumn.children

    assert isinstance(p1, Figure)
    assert isinstance(p2, Figure)

    range_tool = subsubcolumn.select_one({'type': RangeTool})
    assert isinstance(range_tool, RangeTool)
    assert range_tool.x_range == p2.x_range


@hv_available
def test_holoviews_property_override(document, comm):
    c1 = hv.Curve([])

    pane = Pane(c1, backend='bokeh', background='red',
                css_classes=['test_class'])
    model = pane.get_root(document, comm=comm)

    assert model.background == 'red'
    assert model.css_classes == ['test_class']

Read our documentation on viewing source code .

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

1	2	from __future__ import absolute_import
2
3	2	import datetime as dt
4	2	from collections import OrderedDict
5
6	2	import pytest
7	2	import numpy as np
8
9	2	try:
10	2	import holoviews as hv
11	0	except Exception:
12	0	hv = None
13
14	2	from bokeh.models import (Row as BkRow, Column as BkColumn, GlyphRenderer,
15		Scatter, Line, GridBox, Select as BkSelect,
16		Slider as BkSlider, Spacer as BkSpacer,
17		ColumnDataSource)
18	2	from bokeh.plotting import Figure
19
20	2	from panel.layout import Column, Row
21	2	from panel.pane import Pane, PaneBase, HoloViews
22	2	from panel.widgets import FloatSlider, DiscreteSlider, Select
23	2	from panel.tests.util import hv_available, mpl_available
24
25
26	2	@hv_available
27		def test_get_holoviews_pane_type():
28	2	curve = hv.Curve([1, 2, 3])
29	2	assert PaneBase.get_pane_type(curve) is HoloViews
30
31
32	2	@pytest.mark.usefixtures("hv_mpl")
33	2	@mpl_available
34	2	@hv_available
35		def test_holoviews_pane_mpl_renderer(document, comm):
36	2	curve = hv.Curve([1, 2, 3])
37	2	pane = Pane(curve)
38
39		# Create pane
40	2	row = pane.get_root(document, comm=comm)
41	2	assert isinstance(row, BkRow)
42	2	assert len(row.children) == 1
43	2	model = row.children[0]
44	2	assert pane._models[row.ref['id']][0] is model
45	2	assert model.text.startswith('<img src=')
46
47		# Replace Pane.object
48	2	scatter = hv.Scatter([1, 2, 3])
49	2	pane.object = scatter
50	2	new_model = row.children[0]
51	2	assert model.text != new_model.text
52
53		# Cleanup
54	2	pane._cleanup(row)
55	2	assert pane._models == {}
56
57
58	2	@pytest.mark.usefixtures("hv_mpl")
59	2	@pytest.mark.usefixtures("hv_bokeh")
60	2	@mpl_available
61	2	@hv_available
62		def test_holoviews_pane_switch_backend(document, comm):
63	2	curve = hv.Curve([1, 2, 3])
64	2	pane = Pane(curve)
65
66		# Create pane
67	2	row = pane.get_root(document, comm=comm)
68	2	assert isinstance(row, BkRow)
69	2	assert len(row.children) == 1
70	2	model = row.children[0]
71	2	assert pane._models[row.ref['id']][0] is model
72	2	assert model.text.startswith('<img src=')
73
74		# Replace Pane.object
75	2	pane.backend = 'bokeh'
76	2	model = row.children[0]
77	2	assert isinstance(model, Figure)
78
79		# Cleanup
80	2	pane._cleanup(row)
81	2	assert pane._models == {}
82
83
84	2	@pytest.mark.usefixtures("hv_bokeh")
85	2	@hv_available
86		def test_holoviews_pane_bokeh_renderer(document, comm):
87	2	curve = hv.Curve([1, 2, 3])
88	2	pane = Pane(curve)
89
90		# Create pane
91	2	row = pane.get_root(document, comm=comm)
92	2	assert isinstance(row, BkRow)
93	2	assert len(row.children) == 1
94	2	model = row.children[0]
95	2	assert isinstance(model, Figure)
96	2	assert pane._models[row.ref['id']][0] is model
97	2	renderers = [r for r in model.renderers if isinstance(r, GlyphRenderer)]
98	2	assert len(renderers) == 1
99	2	assert isinstance(renderers[0].glyph, Line)
100
101		# Replace Pane.object
102	2	scatter = hv.Scatter([1, 2, 3])
103	2	pane.object = scatter
104	2	model = row.children[0]
105	2	assert isinstance(model, Figure)
106	2	renderers = [r for r in model.renderers if isinstance(r, GlyphRenderer)]
107	2	assert len(renderers) == 1
108	2	assert isinstance(renderers[0].glyph, Scatter)
109	2	assert pane._models[row.ref['id']][0] is model
110
111		# Cleanup
112	2	pane._cleanup(row)
113	2	assert pane._models == {}
114
115
116	2	@pytest.mark.usefixtures("hv_bokeh")
117	2	@hv_available
118		def test_holoviews_pane_initialize_empty(document, comm):
119	2	pane = HoloViews()
120
121		# Create pane
122	2	row = pane.get_root(document, comm=comm)
123
124	2	assert isinstance(row, BkRow)
125	2	assert len(row.children) == 1
126	2	model = row.children[0]
127	2	assert isinstance(model, BkSpacer)
128
129	2	pane.object = hv.Curve([1, 2, 3])
130	2	model = row.children[0]
131	2	assert isinstance(model, Figure)
132
133
134	2	@hv_available
135		def test_holoviews_widgets_from_dynamicmap(document, comm):
136	2	range_dim = hv.Dimension('A', range=(0, 10.))
137	2	range_step_dim = hv.Dimension('B', range=(0, 10.), step=0.2)
138	2	range_default_dim = hv.Dimension('C', range=(0, 10.), default=3)
139	2	value_dim = hv.Dimension('D', values=['a', 'b', 'c'])
140	2	value_default_dim = hv.Dimension('E', values=['a', 'b', 'c', 'd'], default='b')
141	2	value_numeric_dim = hv.Dimension('F', values=[1, 3, 10], default=3)
142	2	kdims = [range_dim, range_step_dim, range_default_dim,
143		value_dim, value_default_dim, value_numeric_dim]
144	2	dmap = hv.DynamicMap(lambda A, B, C, D, E, F: hv.Curve([]), kdims=kdims)
145	2	widgets, _ = HoloViews.widgets_from_dimensions(dmap)
146
147	2	assert len(widgets) == len(kdims)
148
149	2	assert isinstance(widgets[0], FloatSlider)
150	2	assert widgets[0].name == 'A'
151	2	assert widgets[0].start == range_dim.range[0]
152	2	assert widgets[0].end == range_dim.range[1]
153	2	assert widgets[0].value == range_dim.range[0]
154	2	assert widgets[0].step == 0.1
155
156	2	assert isinstance(widgets[1], FloatSlider)
157	2	assert widgets[1].name == 'B'
158	2	assert widgets[1].start == range_step_dim.range[0]
159	2	assert widgets[1].end == range_step_dim.range[1]
160	2	assert widgets[1].value == range_step_dim.range[0]
161	2	assert widgets[1].step == range_step_dim.step
162
163	2	assert isinstance(widgets[2], FloatSlider)
164	2	assert widgets[2].name == 'C'
165	2	assert widgets[2].start == range_default_dim.range[0]
166	2	assert widgets[2].end == range_default_dim.range[1]
167	2	assert widgets[2].value == range_default_dim.default
168	2	assert widgets[2].step == 0.1
169
170	2	assert isinstance(widgets[3], Select)
171	2	assert widgets[3].name == 'D'
172	2	assert widgets[3].options == value_dim.values
173	2	assert widgets[3].value == value_dim.values[0]
174
175	2	assert isinstance(widgets[4], Select)
176	2	assert widgets[4].name == 'E'
177	2	assert widgets[4].options == value_default_dim.values
178	2	assert widgets[4].value == value_default_dim.default
179
180	2	assert isinstance(widgets[5], DiscreteSlider)
181	2	assert widgets[5].name == 'F'
182	2	assert widgets[5].options == OrderedDict([(str(v), v) for v in value_numeric_dim.values])
183	2	assert widgets[5].value == value_numeric_dim.default
184
185
186	2	@hv_available
187		def test_holoviews_with_widgets(document, comm):
188	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
189
190	2	hv_pane = HoloViews(hmap)
191	2	layout = hv_pane.get_root(document, comm)
192	2	model = layout.children[0]
193	2	assert len(hv_pane.widget_box.objects) == 2
194	2	assert hv_pane.widget_box.objects[0].name == 'X'
195	2	assert hv_pane.widget_box.objects[1].name == 'Y'
196
197	2	assert hv_pane._models[layout.ref['id']][0] is model
198
199	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['A', 'B'])
200	2	hv_pane.object = hmap
201	2	assert len(hv_pane.widget_box.objects) == 2
202	2	assert hv_pane.widget_box.objects[0].name == 'A'
203	2	assert hv_pane.widget_box.objects[1].name == 'B'
204
205
206	2	@hv_available
207		def test_holoviews_updates_widgets(document, comm):
208	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
209
210	2	hv_pane = HoloViews(hmap)
211	2	layout = hv_pane.get_root(document, comm)
212
213	2	hv_pane.widgets = {'X': Select}
214	2	assert isinstance(hv_pane.widget_box[0], Select)
215	2	assert isinstance(layout.children[1].children[0].children[0], BkSelect)
216
217	2	hv_pane.widgets = {'X': DiscreteSlider}
218	2	assert isinstance(hv_pane.widget_box[0], DiscreteSlider)
219	2	assert isinstance(layout.children[1].children[0].children[0], BkColumn)
220	2	assert isinstance(layout.children[1].children[0].children[0].children[1], BkSlider)
221
222	2	@hv_available
223		def test_holoviews_widgets_update_plot(document, comm):
224	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
225
226	2	hv_pane = HoloViews(hmap, backend='bokeh')
227	2	layout = hv_pane.get_root(document, comm)
228
229	2	cds = layout.children[0].select_one(ColumnDataSource)
230	2	assert cds.data['y'] == np.array([0])
231	2	hv_pane.widget_box[0].value = 1
232	2	hv_pane.widget_box[1].value = chr(65+1)
233	2	assert cds.data['y'] == np.array([1])
234
235
236	2	@hv_available
237		def test_holoviews_with_widgets_not_shown(document, comm):
238	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
239
240	2	hv_pane = HoloViews(hmap, show_widgets=False)
241	2	layout_obj = Column(hv_pane, hv_pane.widget_box)
242	2	layout = layout_obj.get_root(document, comm)
243	2	model = layout.children[0]
244	2	assert len(hv_pane.widget_box.objects) == 2
245	2	assert hv_pane.widget_box.objects[0].name == 'X'
246	2	assert hv_pane.widget_box.objects[1].name == 'Y'
247
248	2	assert hv_pane._models[layout.ref['id']][0] is model
249
250	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['A', 'B'])
251	2	hv_pane.object = hmap
252	2	assert len(hv_pane.widget_box.objects) == 2
253	2	assert hv_pane.widget_box.objects[0].name == 'A'
254	2	assert hv_pane.widget_box.objects[1].name == 'B'
255
256
257	2	@hv_available
258		def test_holoviews_layouts(document, comm):
259	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
260
261	2	hv_pane = HoloViews(hmap, backend='bokeh')
262	2	layout = hv_pane.layout
263	2	model = layout.get_root(document, comm)
264
265	2	for center in (True, False):
266	2	for loc in HoloViews.param.widget_location.objects:
267	2	hv_pane.param.set_param(center=center, widget_location=loc)
268	2	if center:
269	2	if loc.startswith('left'):
270	2	assert len(layout) == 4
271	2	widgets, hv_obj = layout[0], layout[2]
272	2	wmodel, hv_model = model.children[0], model.children[2]
273	2	elif loc.startswith('right'):
274	2	assert len(layout) == 4
275	2	hv_obj, widgets = layout[1], layout[3]
276	2	wmodel, hv_model = model.children[3], model.children[1]
277	2	elif loc.startswith('top'):
278	2	assert len(layout) == 3
279	2	col = layout[1]
280	2	cmodel = model.children[1]
281	2	assert isinstance(col, Column)
282	2	widgets, hv_col = col
283	2	hv_obj = hv_col[1]
284	2	wmodel, hv_model = cmodel.children[0], cmodel.children[1].children[1]
285	2	elif loc.startswith('bottom'):
286	2	col = layout[1]
287	2	cmodel = model.children[1]
288	2	assert isinstance(col, Column)
289	2	hv_col, widgets = col
290	2	hv_obj = hv_col[1]
291	2	wmodel, hv_model = cmodel.children[1], cmodel.children[0].children[1]
292		else:
293	2	if loc.startswith('left'):
294	2	assert len(layout) == 2
295	2	widgets, hv_obj = layout
296	2	wmodel, hv_model = model.children
297	2	elif loc.startswith('right'):
298	2	assert len(layout) == 2
299	2	hv_obj, widgets = layout
300	2	hv_model, wmodel = model.children
301	2	elif loc.startswith('top'):
302	2	assert len(layout) == 1
303	2	col = layout[0]
304	2	cmodel = model.children[0]
305	2	assert isinstance(col, Column)
306	2	widgets, hv_obj = col
307	2	wmodel, hv_model = cmodel.children
308	2	elif loc.startswith('bottom'):
309	2	assert len(layout) == 1
310	2	col = layout[0]
311	2	cmodel = model.children[0]
312	2	assert isinstance(col, Column)
313	2	hv_obj, widgets = col
314	2	hv_model, wmodel = cmodel.children
315	2	assert hv_pane is hv_obj
316	2	assert isinstance(hv_model, Figure)
317
318	2	if loc in ('left', 'right', 'top', 'bottom',
319		'top_right', 'right_bottom', 'bottom_right',
320		'left_bottom'):
321	2	box = widgets[1]
322	2	boxmodel = wmodel.children[1]
323		else:
324	2	box = widgets[0]
325	2	boxmodel = wmodel.children[0]
326	2	assert hv_pane.widget_box is box
327	2	assert isinstance(boxmodel, BkColumn)
328	2	assert isinstance(boxmodel.children[0], BkColumn)
329	2	assert isinstance(boxmodel.children[0].children[1], BkSlider)
330	2	assert isinstance(boxmodel.children[1], BkSelect)
331
332
333	2	@hv_available
334		def test_holoviews_widgets_from_holomap():
335	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
336
337	2	widgets, _ = HoloViews.widgets_from_dimensions(hmap)
338
339	2	assert isinstance(widgets[0], DiscreteSlider)
340	2	assert widgets[0].name == 'X'
341	2	assert widgets[0].options == OrderedDict([(str(i), i) for i in range(3)])
342	2	assert widgets[0].value == 0
343
344	2	assert isinstance(widgets[1], Select)
345	2	assert widgets[1].name == 'Y'
346	2	assert widgets[1].options == ['A', 'B', 'C']
347	2	assert widgets[1].value == 'A'
348
349
350	2	@hv_available
351		def test_holoviews_date_slider_widgets_from_holomap():
352	2	hmap = hv.HoloMap({dt.datetime(2016, 1, i+1): hv.Curve([i]) for i in range(3)}, kdims=['X'])
353
354	2	widgets, _ = HoloViews.widgets_from_dimensions(hmap)
355
356	2	assert isinstance(widgets[0], DiscreteSlider)
357	2	assert widgets[0].name == 'X'
358	2	assert widgets[0].options == OrderedDict([
359		('2016-01-01 00:00:00', dt.datetime(2016, 1, 1)),
360		('2016-01-02 00:00:00', dt.datetime(2016, 1, 2)),
361		('2016-01-03 00:00:00', dt.datetime(2016, 1, 3))])
362	2	assert widgets[0].value == dt.datetime(2016, 1, 1)
363
364
365	2	@hv_available
366		def test_holoviews_widgets_explicit_widget_type_override():
367	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
368
369	2	widgets, _ = HoloViews.widgets_from_dimensions(hmap, widget_types={'X': Select})
370
371	2	assert isinstance(widgets[0], Select)
372	2	assert widgets[0].name == 'X'
373	2	assert widgets[0].options == OrderedDict([(str(i), i) for i in range(3)])
374	2	assert widgets[0].value == 0
375
376
377	2	@hv_available
378		def test_holoviews_widgets_invalid_widget_type_override():
379	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
380
381	2	with pytest.raises(ValueError):
382	2	HoloViews.widgets_from_dimensions(hmap, widget_types={'X': 1})
383
384
385	2	@hv_available
386		def test_holoviews_widgets_explicit_widget_instance_override():
387	2	hmap = hv.HoloMap({(i, chr(65+i)): hv.Curve([i]) for i in range(3)}, kdims=['X', 'Y'])
388
389	2	widget = Select(options=[1, 2, 3], value=3)
390	2	widgets, _ = HoloViews.widgets_from_dimensions(hmap, widget_types={'X': widget})
391
392	2	assert widgets[0] is widget
393
394
395	2	@hv_available
396		def test_holoviews_linked_axes(document, comm):
397	2	c1 = hv.Curve([1, 2, 3])
398	2	c2 = hv.Curve([1, 2, 3])
399
400	2	layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))
401
402	2	row_model = layout.get_root(document, comm=comm)
403
404	2	p1, p2 = row_model.select({'type': Figure})
405
406	2	assert p1.x_range is p2.x_range
407	2	assert p1.y_range is p2.y_range
408
409
410	2	@hv_available
411		def test_holoviews_linked_axes_merged_ranges(document, comm):
412	2	c1 = hv.Curve([1, 2, 3])
413	2	c2 = hv.Curve([0, 1, 2, 3, 4])
414
415	2	layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))
416
417	2	row_model = layout.get_root(document, comm=comm)
418
419	2	p1, p2 = row_model.select({'type': Figure})
420
421	2	assert p1.x_range is p2.x_range
422	2	assert p1.y_range is p2.y_range
423	2	assert p1.y_range.start == -0.4
424	2	assert p1.y_range.end == 4.4
425
426
427	2	@hv_available
428		def test_holoviews_linked_x_axis(document, comm):
429	2	c1 = hv.Curve([1, 2, 3])
430	2	c2 = hv.Curve([1, 2, 3], vdims='y2')
431
432	2	layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))
433
434	2	row_model = layout.get_root(document, comm=comm)
435
436	2	p1, p2 = row_model.select({'type': Figure})
437
438	2	assert p1.x_range is p2.x_range
439	2	assert p1.y_range is not p2.y_range
440
441
442	2	@hv_available
443		def test_holoviews_axiswise_not_linked_axes(document, comm):
444	2	c1 = hv.Curve([1, 2, 3])
445	2	c2 = hv.Curve([1, 2, 3]).opts(axiswise=True, backend='bokeh')
446
447	2	layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))
448
449	2	row_model = layout.get_root(document, comm=comm)
450
451	2	p1, p2 = row_model.select({'type': Figure})
452
453	2	assert p1.x_range is not p2.x_range
454	2	assert p1.y_range is not p2.y_range
455
456
457	2	@hv_available
458		def test_holoviews_shared_axes_opt_not_linked_axes(document, comm):
459	2	c1 = hv.Curve([1, 2, 3])
460	2	c2 = hv.Curve([1, 2, 3]).opts(shared_axes=False, backend='bokeh')
461
462	2	layout = Row(HoloViews(c1, backend='bokeh'), HoloViews(c2, backend='bokeh'))
463
464	2	row_model = layout.get_root(document, comm=comm)
465
466	2	p1, p2 = row_model.select({'type': Figure})
467
468	2	assert p1.x_range is not p2.x_range
469	2	assert p1.y_range is not p2.y_range
470
471
472	2	@hv_available
473		def test_holoviews_not_linked_axes(document, comm):
474	2	c1 = hv.Curve([1, 2, 3])
475	2	c2 = hv.Curve([1, 2, 3])
476
477	2	layout = Row(
478		HoloViews(c1, backend='bokeh'),
479		HoloViews(c2, backend='bokeh', linked_axes=False)
480		)
481
482	2	row_model = layout.get_root(document, comm=comm)
483
484	2	p1, p2 = row_model.select({'type': Figure})
485
486	2	assert p1.x_range is not p2.x_range
487	2	assert p1.y_range is not p2.y_range
488
489
490	2	@hv_available
491		def test_holoviews_link_across_panes(document, comm):
492	2	from bokeh.models.tools import RangeTool
493	2	from holoviews.plotting.links import RangeToolLink
494
495	2	c1 = hv.Curve([])
496	2	c2 = hv.Curve([])
497
498	2	RangeToolLink(c1, c2)
499
500	2	layout = Row(Pane(c1, backend='bokeh'), Pane(c2, backend='bokeh'))
501	2	row = layout.get_root(document, comm=comm)
502
503	2	assert len(row.children) == 2
504	2	p1, p2 = row.children
505
506	2	assert isinstance(p1, Figure)
507	2	assert isinstance(p2, Figure)
508
509	2	range_tool = row.select_one({'type': RangeTool})
510	2	assert isinstance(range_tool, RangeTool)
511	2	assert range_tool.x_range == p2.x_range
512
513
514	2	@hv_available
515		def test_holoviews_link_after_adding_item(document, comm):
516	2	from bokeh.models.tools import RangeTool
517	2	from holoviews.plotting.links import RangeToolLink
518
519	2	c1 = hv.Curve([])
520	2	c2 = hv.Curve([])
521
522	2	RangeToolLink(c1, c2)
523
524	2	layout = Row(Pane(c1, backend='bokeh'))
525	2	row = layout.get_root(document, comm=comm)
526
527	2	assert len(row.children) == 1
528	2	p1, = row.children
529
530	2	assert isinstance(p1, Figure)
531	2	range_tool = row.select_one({'type': RangeTool})
532	2	assert range_tool is None
533
534	2	layout.append(Pane(c2, backend='bokeh'))
535	2	_, p2 = row.children
536	2	assert isinstance(p2, Figure)
537	2	range_tool = row.select_one({'type': RangeTool})
538	2	assert isinstance(range_tool, RangeTool)
539	2	assert range_tool.x_range == p2.x_range
540
541
542	2	@hv_available
543		def test_holoviews_link_within_pane(document, comm):
544	2	from bokeh.models.tools import RangeTool
545	2	from holoviews.plotting.links import RangeToolLink
546
547	2	c1 = hv.Curve([])
548	2	c2 = hv.Curve([])
549
550	2	RangeToolLink(c1, c2)
551
552	2	pane = Pane(Pane(hv.Layout([c1, c2]), backend='bokeh'))
553	2	column = pane.get_root(document, comm=comm)
554
555	2	assert len(column.children) == 1
556	2	subcolumn = column.children[0]
557	2	assert isinstance(subcolumn, BkColumn)
558	2	assert len(subcolumn.children) == 2
559	2	toolbar, subsubcolumn = subcolumn.children
560	2	assert isinstance(subsubcolumn, GridBox)
561	2	assert len(subsubcolumn.children) == 2
562	2	(p1, _, _), (p2, _, _) = subsubcolumn.children
563
564	2	assert isinstance(p1, Figure)
565	2	assert isinstance(p2, Figure)
566
567	2	range_tool = subsubcolumn.select_one({'type': RangeTool})
568	2	assert isinstance(range_tool, RangeTool)
569	2	assert range_tool.x_range == p2.x_range
570
571
572	2	@hv_available
573		def test_holoviews_property_override(document, comm):
574	2	c1 = hv.Curve([])
575
576	2	pane = Pane(c1, backend='bokeh', background='red',
577		css_classes=['test_class'])
578	2	model = pane.get_root(document, comm=comm)
579
580	2	assert model.background == 'red'
581	2	assert model.css_classes == ['test_class']