def __init__(self, cat, **kwargs):
            self.cat = cat
            super().__init__(cats=[self.cat], **kwargs)
            self.panel = pn.Column(
                pn.Row(
                    pn.panel(ICONS['logo']),
                    pn.Row(
                        pn.Column(
                            self.select.panel,
                            self.control_panel,
                            margin=0
                        ),
                        self.description.panel,
                        margin=0
                    ),
                ),
                self.plot.panel
            ) 

def setup(self):
        self._setup_watchers()
        self.children = [
            pn.Column(
                pn.Row(
                    pn.Column(
                        self.select.panel,
                        self.control_panel,
                        margin=0,
                    ),
                    self.description.panel,
                    margin=0,
                ),
                self.plot.panel,
                margin=0,
                width_policy='max'
            )
        ] 

def __init__(self, cats=None):
        self.source = SourceGUI()
        self.cat = CatGUI(cats=cats, done_callback=self.done_callback)
        self.panel = pn.Column(
            pn.Row(
                pn.panel(ICONS['logo']),
                pn.Column(
                    self.cat.select.panel,
                    self.cat.control_panel,
                    margin=0, width_policy='max'),
                pn.Column(
                    self.source.select.panel,
                    self.source.control_panel,
                    margin=0, width_policy='max'
                ),
                self.source.description.panel,
                margin=0, width_policy='max'
            ),
            pn.Row(self.cat.search.panel, self.cat.add.panel,
                   self.source.plot.panel, width_policy='max'),
            width_policy='max'
        )
        super(GUI, self).__init__() 

def test_embed_select_str_link(document, comm):
    select = Select(options=['A', 'B', 'C'])
    string = Str()
    def link(target, event):
        target.object = event.new
    select.link(string, callbacks={'value': link})
    panel = Row(select, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document)
    _, state = document.roots
    assert set(state.state) == {'A', 'B', 'C'}
    for k, v in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % k 

def test_embed_float_slider_explicit_values(document, comm):
    select = FloatSlider()
    string = Str()
    def link(target, event):
        target.object = event.new
    select.link(string, callbacks={'value': link})
    panel = Row(select, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document, states={select: [0.1, 0.7, 1]})
    _, state = document.roots
    assert set(state.state) == {0, 1, 2}
    states = {0: 0.1, 1: 0.7, 2: 1}
    for (k, v) in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % states[k] 

def test_embed_select_explicit_values(document, comm):
    select = Select(options=['A', 'B', 'C'])
    string = Str()
    def link(target, event):
        target.object = event.new
    select.link(string, callbacks={'value': link})
    panel = Row(select, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document, states={select: ['A', 'B']})
    _, state = document.roots
    assert set(state.state) == {'A', 'B'}
    for k, v in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % k 

def test_embed_select_str_link_with_secondary_watch(document, comm):
    select = Select(options=['A', 'B', 'C'])
    string = Str()
    select.link(string, value='object')
    string.param.watch(print, 'object')
    panel = Row(select, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document)
    _, state = document.roots
    assert set(state.state) == {'A', 'B', 'C'}
    for k, v in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % k 

def test_embed_checkbox_str_link(document, comm):
    checkbox = Checkbox()
    string = Str()
    def link(target, event):
        target.object = event.new
    checkbox.link(string, callbacks={'value': link})
    panel = Row(checkbox, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document)
    _, state = document.roots
    assert set(state.state) == {'false', 'true'}
    for k, v in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % k.title() 

def panel(self):
        return pn.Row(self.map_view) 

def panel(self):
        return pn.Row(self.param, self.map_view(), self.table_view()) 

def panel(self):
        return pn.Row(self.map_view, self.table_view) 

def panel(self):
        return pn.Row(self.map_view, self.table_view) 

def panel(self):
        return pn.Row(self.param, self._polys.options(width=800, height=600)) 

def panel(self):
        return pn.Row(self.param, self.view()) 

def panel(self):
        map_view = self.annot.map_view().opts(height=600, width=600) * gvts.EsriImagery

        return pn.Row(pn.Column(map_view, pn.panel(self.param, parameters=['create'], show_name=False)),
                      pn.Column(self.annot.point_table,
                                pn.panel(self.param, parameters=['node_spacing'], show_name=False))) 

def create_selectors_players(self, graph):
        """
        Converts the sliders generated by hvplot into selectors/players.

        This is applicable only when both `x` and `y` are present in variable
        coordinates. It converts any sliders generated by hvplot into
        selectors/players and moves them to the bottom of graph.
        """
        if len(self.data[self.var].dims) > 2 and self.kwargs['extract along']:
            self.taps_graph = hv.DynamicMap(self.create_taps_graph,
                                            streams=[self.tap_stream,
                                                     self.clear_points])
            self.clear_series_button.disabled = False
            graph = graph * self.taps_graph
        else:
            self.clear_series_button.disabled = True
        graph = pn.Row(graph)

        self.output[0] = look_for_class(graph, pn.pane.HoloViews)[0]
        sliders = look_for_class(graph, pn.widgets.Widget)
        for slider in sliders:
            for dim in self.kwargs['dims_to_select_animate']:
                long_name = self.data[dim].long_name if hasattr(
                    self.data[dim], 'long_name') else None
                if slider.name == dim or slider.name == long_name:
                    if self.kwargs[dim] == 'select':
                        selector = convert_widget(slider, pn.widgets.Select)
                    else:
                        selector = convert_widget(slider, pn.widgets.DiscretePlayer)
                    self.index_selectors.append(selector)

        for selector in self.index_selectors:
            if isinstance(selector, pn.widgets.Select):
                self.output[1].append(selector)
            else:
                player = player_with_name_and_value(selector)
                self.output[1].append(player) 

def __init__(self, data):
        super().__init__()
        self.data = data
        self.name = 'Variables'
        self.select = pn.widgets.Select(
            min_width=100, max_width=200, width_policy='max',
            name=self.name)
        self.set_variables()

        self._register(self.select, "variable_selected")

        self.panel = pn.Row(self.select) 

def __init__(self, data):
        super().__init__()
        self.data = data

        dim_header = pn.pane.Markdown('### Plot Dimensions', margin=(0, 20, 0, 20))
        self.x = pn.widgets.Select(name='x', width=240, margin=(0, 20, 5, 20))
        self.y = pn.widgets.Select(name='y', width=240, margin=(0, 20, 20, 20))

        agg_header = pn.pane.Markdown('### Aggregations', margin=(0, 20, 0, 20))
        self.agg_selectors = pn.Column()
        self.agg_opts = ['select', 'animate', 'mean', 'max',
                         'min', 'median', 'std', 'count']
        self.series_col = pn.Column()
        self.are_var_coords = False

        self._register(self.x, 'x')
        self._register(self.y, 'y')

        self.connect('x', self.change_y)
        self.connect('y', self.change_dim_selectors)

        self.panel = pn.Column(
            pn.pane.Markdown(TEXT, margin=(0, 10)),
            pn.Row(
                pn.WidgetBox(dim_header, self.x, self.y,
                             background=(240, 240, 240)),
                pn.Spacer(),
                pn.WidgetBox(agg_header, self.agg_selectors,
                             background=(240, 240, 240))
            ),
            self.series_col,
            name='Axes') 

def kwargs(self):
        # Column(name='Axes')
        #     [0] Row
        #         [0] Column(background='rgb(175,175,175)')
        #             [0] Markdown(str)
        #             [1] Select(name='x', width=200)
        #             [2] Select(name='y', width=200)
        #         [1] Spacer()
        #         [2] Column(background='rgb(175,175,175)')
        #             [0] Markdown(str)
        #             [1] Column()
        #     [1] Column
        #         [0] Select()
        out = {p.name: p.value for p in self.panel[1][0][1:]}  # since panel[0][0][1] is Markdown
        selectors = {p.name: p.value for p in self.panel[1][2][1]}  # remaining_dims
        out.update(selectors)
        dims_to_select_animate = [dim for dim, agg in selectors.items() if agg in ['select', 'animate']]
        dims_to_agg = [dim for dim in selectors
                       if dim not in dims_to_select_animate]
        out.update({'dims_to_agg': dims_to_agg})
        out.update({'dims_to_select_animate': sorted(dims_to_select_animate)})
        out.update({'are_var_coords': self.are_var_coords})
        # remaining_dims = dims_to_agg + dims_to_select_animate
        out.update({'remaining_dims': self.remaining_dims})
        out.update({p.name: p.value for p in self.series_col})
        return out 

def __init__(self):
        super().__init__()
        self.frame_height = pn.widgets.IntSlider(name='frame_height', value=300, start=100,
                                                 end=1200)
        self.frame_width = pn.widgets.IntSlider(name='frame_width', value=450, start=100,
                                                end=1200)
        self.cmap = pn.widgets.Select(name='cmap', value='Inferno',
                                      options=list_cmaps())
        self.colorbar = pn.widgets.Checkbox(name='colorbar', value=True, width=150)
        # colormap_limits
        self.lower_limit = pn.widgets.TextInput(name='cmap lower limit',
                                                width=140)
        self.upper_limit = pn.widgets.TextInput(name='cmap upper limit',
                                                width=140)
        self.use_all_data = pn.widgets.Checkbox(name='compute min/max from all data', value=False)

        scaling_ops = ['linear', 'exp', 'log', 'reciprocal', 'square', 'sqrt']
        self.color_scale = pn.widgets.Select(name='color_scale',
                                             value='linear',
                                             options=scaling_ops)
        self.rasterize = pn.widgets.Checkbox(name='rasterize', value=True, width=150)

        self._register(self.use_all_data, 'clear_cmap_limits')
        self._register(self.color_scale, 'clear_cmap_limits')
        self.connect('clear_cmap_limits', self.setup)

        self.panel = pn.Column(
            pn.pane.Markdown(TEXT, margin=(0, 10)),
            pn.Row(self.frame_height, self.frame_width),
            pn.Row(self.cmap, self.color_scale),
            pn.Row(self.lower_limit, self.upper_limit),
            pn.Row(self.use_all_data, self.colorbar, self.rasterize),
            name='Style'
        ) 

def __init__(self, source=None, **kwargs):
            self.source = source
            super().__init__(sources=[self.source], **kwargs)
            self.panel = pn.Column(
                pn.Row(ICONS['logo'], pn.Column(*self.controls)),
                self.description.panel,
                self.plot.panel
            ) 

def __init__(self, **kwargs):
        self.panel = pn.Row(name='URL',
                            width_policy='max', margin=0)
        super().__init__(**kwargs) 

def setup(self):
        self.selectors = [self.fs, self.url]
        self.tabs = pn.Tabs(*map(lambda x: x.panel, self.selectors))
        self.validator = pn.pane.SVG(None, width=25)

        self.watchers = [
            self.widget.param.watch(self.add_cat, 'clicks'),
            self.tabs.param.watch(self.tab_change, 'active'),
            self.fs.main.param.watch(self.remove_error, 'value'),
            self.url.main.param.watch(self.remove_error, 'value'),
        ]

        self.children = [self.tabs, pn.Row(self.widget, self.validator)] 

def __init__(self, cats, done_callback=None, **kwargs):
        self.cats = cats
        self.done_callback = done_callback
        self.panel = pn.Row(name='Search',
                            height_policy='min',
                            width_policy='max',
                            max_width=MAX_WIDTH,
                            margin=0)
        self.inputs = SearchInputs()
        super().__init__(**kwargs) 

def panel(self):
        if not self.logo:
            return self._panel
        return pn.Row(self.logo_panel,
                      self._panel,
                      margin=0) 

def test_embed_select_str_explicit_values_not_found(document, comm):
    select = Select(options=['A', 'B', 'C'])
    string = Str()
    def link(target, event):
        target.object = event.new
    select.link(string, callbacks={'value': link})
    panel = Row(select, string)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    with pytest.raises(ValueError):
        embed_state(panel, model, document, states={select: ['A', 'D']}) 

def test_embed_select_str_link_two_steps(document, comm):
    select = Select(options=['A', 'B', 'C'])
    string1 = Str()
    select.link(string1, value='object')
    string2 = Str()
    string1.link(string2, object='object')
    panel = Row(select, string1, string2)
    with config.set(embed=True):
        model = panel.get_root(document, comm)
    embed_state(panel, model, document)
    _, state = document.roots
    assert set(state.state) == {'A', 'B', 'C'}
    for k, v in state.state.items():
        content = json.loads(v['content'])
        assert 'events' in content
        events = content['events']
        assert len(events) == 2
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[1].ref
        assert event['new'] == '<pre>%s</pre>' % k

        event = events[1]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['model'] == model.children[2].ref
        assert event['new'] == '<pre>%s</pre>' % k 

def test_save_embed_bytesio():
    checkbox = Checkbox()
    string = Str()
    def link(target, event):
        target.object = event.new
    checkbox.link(string, callbacks={'value': link})
    panel = Row(checkbox, string)
    stringio = StringIO()
    panel.save(stringio, embed=True)
    stringio.seek(0)
    utf = stringio.read()
    assert "<pre>False</pre>" in utf
    assert "<pre>True</pre>" in utf 

def test_save_embed(tmpdir):
    checkbox = Checkbox()
    string = Str()
    checkbox.link(string, value='object')
    panel = Row(checkbox, string)
    filename = os.path.join(str(tmpdir), 'test.html')
    panel.save(filename, embed=True)
    assert os.path.isfile(filename) 

def test_save_embed_json(tmpdir):
    checkbox = Checkbox()
    string = Str()
    def link(target, event):
        target.object = event.new
    checkbox.link(string, callbacks={'value': link})
    panel = Row(checkbox, string)
    filename = os.path.join(str(tmpdir), 'test.html')
    panel.save(filename, embed=True, embed_json=True,
               save_path=str(tmpdir))
    assert os.path.isfile(filename)
    paths = glob.glob(os.path.join(str(tmpdir), '*'))
    paths.remove(filename)
    assert len(paths) == 1
    json_files = sorted(glob.glob(os.path.join(paths[0], '*.json')))
    assert len(json_files) == 2

    for jf, v in zip(json_files, ('False', 'True')):
        with open(jf) as f:
            state = json.load(f)
        assert 'content' in state
        assert 'events' in state['content']
        events = json.loads(state['content'])['events']
        assert len(events) == 1
        event = events[0]
        assert event['kind'] == 'ModelChanged'
        assert event['attr'] == 'text'
        assert event['new'] == '<pre>%s</pre>' % v