Esempio n. 1
0
def update_data():
    x, fy, ty = taylor(expr, xs, order, (-2*sy.pi, 2*sy.pi), 200)

    plot.title.text = "%s vs. taylor(%s, n=%d)" % (expr, expr, order)
    legend.items[0].label = value("%s" % expr)
    legend.items[1].label = value("taylor(%s)" % expr)
    source.data = dict(x=x, fy=fy, ty=ty)
    slider.value = order
Esempio n. 2
0
def test_multiple_renderers_correctly_added_to_legend(p, source):
    square = p.square(x='x', y='y', legend='square', source=source)
    circle = p.circle(x='x', y='y', legend='circle', source=source)
    legends = p.select(Legend)
    assert len(legends) == 1
    assert legends[0].items[0].renderers == [square]
    assert legends[0].items[0].label == value('square')
    assert legends[0].items[1].renderers == [circle]
    assert legends[0].items[1].label == value('circle')
Esempio n. 3
0
 def test_element_xaxis_bottom_bare(self):
     curve = Curve(range(10)).options(xaxis='bottom-bare')
     plot = bokeh_renderer.get_plot(curve)
     xaxis = plot.handles['xaxis']
     self.assertEqual(xaxis.axis_label_text_font_size, value('0pt'))
     self.assertEqual(xaxis.major_label_text_font_size, value('0pt'))
     self.assertEqual(xaxis.minor_tick_line_color, None)
     self.assertEqual(xaxis.major_tick_line_color, None)
     self.assertTrue(xaxis in plot.state.below)
Esempio n. 4
0
 def test_element_yaxis_right_bare(self):
     curve = Curve(range(10)).options(yaxis='right-bare')
     plot = bokeh_renderer.get_plot(curve)
     yaxis = plot.handles['yaxis']
     self.assertEqual(yaxis.axis_label_text_font_size, value('0pt'))
     self.assertEqual(yaxis.major_label_text_font_size, value('0pt'))
     self.assertEqual(yaxis.minor_tick_line_color, None)
     self.assertEqual(yaxis.major_tick_line_color, None)
     self.assertTrue(yaxis in plot.state.right)
Esempio n. 5
0
def update():
    try:
        expr = sy.sympify(text.value, dict(x=xs))
    except Exception as exception:
        errbox.text = str(exception)
    else:
        errbox.text = ""
    x, fy, ty = taylor(expr, xs, slider.value, (-2*sy.pi, 2*sy.pi), 200)

    p.title.text = "Taylor (n=%d) expansion comparison for: %s" % (slider.value, expr)
    legend.items[0].label = value("%s" % expr)
    legend.items[1].label = value("taylor(%s)" % expr)
    source.data = dict(x=x, fy=fy, ty=ty)
Esempio n. 6
0
    def _plot_bokeh(self, current_plot, show_legend=True):
        from bokeh import models
        import bokeh.plotting as bkh
        from bokeh.core.properties import value

        lst = []
        row_lst = []
        for plotter in self.plots:
            cur_plot = bkh.figure(title=plotter.title, plot_width=self.one_figsize[0] * self.BOKEH_RESIZE,
                                  plot_height=self.one_figsize[1] * self.BOKEH_RESIZE)
            if plotter.xlim is not None:
                cur_plot.x_range = models.Range1d(start=plotter.xlim[0], end=plotter.xlim[1])
            if plotter.ylim is not None:
                cur_plot.y_range = models.Range1d(start=plotter.ylim[0], end=plotter.ylim[1])
            cur_plot.title_text_font_size = value("{}pt".format(plotter.fontsize))
            cur_plot.xaxis.axis_label = plotter.xlabel
            cur_plot.yaxis.axis_label = plotter.ylabel
            cur_plot.legend.orientation = 'top_right'
            cur_plot = plotter._plot_bokeh(cur_plot, show_legend=show_legend)
            if len(row_lst) >= self.columns:
                lst.append(row_lst)
                row_lst = []
            row_lst.append(cur_plot)
        if len(row_lst) > 0:
            lst.append(row_lst)
        grid = models.GridPlot(children=lst)
        return grid
Esempio n. 7
0
def _get_national_scenario_line_plot(sources, data, parameter=None, y_ticks=None, plot_width=600, grid=True, end_factor=None, y_range=None, include_bau=True):
    if not y_range:
        y_range = get_y_range(data)

    plot = Plot(
        x_range=get_year_range(end_factor),
        y_range=y_range,
        plot_width=plot_width,
        **PLOT_FORMATS
    )
    plot = add_axes(plot, y_ticks, color=dark_grey, grid=grid)
    hit_renderers = []
    line_renderers = {}
    if include_bau:
        sc = scenarios
    else:
        sc = scenarios_no_bau
    for scenario in sc:
        source = sources[scenario]
        line = Line(
            x='t', y=parameter, line_color=scenarios_colors[scenario],
            line_width=2, line_cap='round', line_join='round'
        )
        circle = Circle(
            x='t', y=parameter, size=4,
            line_color=scenarios_colors[scenario], line_width=0.5, line_alpha=deselected_alpha,
            fill_color=scenarios_colors[scenario], fill_alpha=0.6
        )
        # invisible circle used for hovering
        hit_target = Circle(
            x='t', y=parameter, size=20,
            line_color=None, fill_color=None
        )
        scenario_label = Text(
            x=value(source.data['t'][-1] + 0.8), y=value(source.data[parameter][-1] * 0.98), text=value(names[scenario]),
            text_color=scenarios_colors[scenario], text_font_size="8pt",
        )

        hit_renderer = plot.add_glyph(source, hit_target)
        hit_renderers.append(hit_renderer)
        line_renderer = plot.add_glyph(source, line)
        line_renderers[scenario] = line_renderer
        plot.add_glyph(source, circle)
        plot.add_glyph(scenario_label)

    plot.add_tools(HoverTool(tooltips="@%s{0,0} (@t)" % parameter, renderers=hit_renderers))
    return (plot, line_renderers)
Esempio n. 8
0
    def plot_bokeh(self, xlim=None, ylim=None, title=None, figsize=None,
                   xlabel=None, ylabel=None, fontsize=None, show_legend=True):

        """
        Plot data using bokeh library. Use show() method for bokeh to see result.

        :param xlim: x-axis range
        :param ylim: y-axis range
        :type xlim: None or tuple(x_min, x_max)
        :type ylim: None or tuple(y_min, y_max)
        :param title: title
        :type title: None or str
        :param figsize: figure size
        :type figsize: None or tuple(weight, height)
        :param xlabel: x-axis name
        :type xlabel: None or str
        :param ylabel: y-axis name
        :type ylabel: None or str
        :param fontsize: font size
        :type fontsize: None or int
        :param bool show_legend: show or not labels for plots
        """
        global _COLOR_CYCLE_BOKEH
        global _BOKEH_OUTPUT_NOTEBOOK_ACTIVATED
        import bokeh.plotting as bkh
        from bokeh.models import Range1d
        from bokeh.core.properties import value

        figsize = self.figsize if figsize is None else figsize
        xlabel = self.xlabel if xlabel is None else xlabel
        ylabel = self.ylabel if ylabel is None else ylabel
        title = self.title if title is None else title
        xlim = self.xlim if xlim is None else xlim
        ylim = self.ylim if ylim is None else ylim
        fontsize = self.fontsize if fontsize is None else fontsize
        self.fontsize_ = fontsize
        self.show_legend_ = show_legend

        figsize = (figsize[0] * self.BOKEH_RESIZE, figsize[1] * self.BOKEH_RESIZE)

        if not _BOKEH_OUTPUT_NOTEBOOK_ACTIVATED:
            bkh.output_notebook()
            _BOKEH_OUTPUT_NOTEBOOK_ACTIVATED = True

        current_plot = bkh.figure(title=title, plot_width=figsize[0], plot_height=figsize[1])
        _COLOR_CYCLE_BOKEH = itertools.cycle(COLOR_ARRAY_BOKEH)

        if xlim is not None:
            current_plot.x_range = Range1d(start=xlim[0], end=xlim[1])
        if ylim is not None:
            current_plot.y_range = Range1d(start=ylim[0], end=ylim[1])
        current_plot.title_text_font_size = value("{}pt".format(fontsize))
        current_plot.xaxis.axis_label = xlabel
        current_plot.yaxis.axis_label = ylabel
        current_plot.legend.orientation = 'top_right'

        current_plot = self._plot_bokeh(current_plot, show_legend)
        bkh.show(current_plot)
Esempio n. 9
0
def test_legend_item_with_value_label_and_different_data_sources_does_not_raise_a_validation_error():
    legend_item = LegendItem()
    gr_1 = GlyphRenderer(data_source=ColumnDataSource())
    gr_2 = GlyphRenderer(data_source=ColumnDataSource())
    legend_item.label = value('label')
    legend_item.renderers = [gr_1, gr_2]
    with mock.patch('bokeh.core.validation.check.logger') as mock_logger:
        check_integrity([legend_item])
        assert mock_logger.error.call_count == 0
Esempio n. 10
0
def get_energy_mix_by_scenario(df, scenario, plot_width=700):
    plot = Plot(
        x_range=get_year_range(end_factor=15),
        y_range=Range1d(0, 4300),
        plot_width=plot_width,
        **PLOT_FORMATS
    )
    plot = add_axes(plot, [0, 2000, 4000], color=scenarios_colors[scenario])
    source = ColumnDataSource(df)

    for energy_mix_column in energy_mix_columns.keys():
        energy_name = energy_mix_columns[energy_mix_column]
        parameter = '%s_%s' % (scenario, energy_mix_column)
        line = Line(
            x='t', y=parameter, line_color='black',
            line_width=2, line_cap='round', line_join='round', line_alpha=0.8
        )
        circle = Circle(
            x='t', y=parameter, size=4, fill_color='black', fill_alpha=0.6
        )
        # invisible circle used for hovering
        hit_target = Circle(
            x='t', y=parameter, size=10, line_color=None, fill_color=None
        )
        scenario_label = Text(
            x=value(source.data['t'][-1] + 2), y=value(source.data[parameter][-1] - 200),
            text=value(energy_name), text_color='grey', text_font_size='8pt',
        )

        hit_renderer = plot.add_glyph(source, hit_target)
        plot.add_tools(HoverTool(tooltips="%s - @%s{0,0} (@t)" % (energy_name, parameter), renderers=[hit_renderer]))
        plot.add_glyph(source, line)
        plot.add_glyph(source, circle)
        plot.add_glyph(scenario_label)

    return plot
Esempio n. 11
0
def test_vbar_stack_returns_renderers():
    fruits = ['Apples', 'Pears', 'Nectarines', 'Plums', 'Grapes', 'Strawberries']
    years = ["2015", "2016", "2017"]
    colors = ["#c9d9d3", "#718dbf", "#e84d60"]
    data = {'fruits' : fruits,
        '2015'   : [2, 1, 4, 3, 2, 4],
        '2016'   : [5, 3, 4, 2, 4, 6],
        '2017'   : [3, 2, 4, 4, 5, 3]}
    source = ColumnDataSource(data=data)

    p = plt.figure()
    renderers = p.vbar_stack(years, x='fruits', width=0.9, color=colors, source=source,
                         legend=[value(x) for x in years], name=years)
    assert len(renderers) == 3
    assert renderers[0].name == "2015"
    assert renderers[1].name == "2016"
    assert renderers[2].name == "2017"
Esempio n. 12
0
    def add_legend(self, chart_legends):
        """Add the legend to your plot, and the plot to a new Document.

        It also add the Document to a new Session in the case of server output.

        Args:
            legends(List(Tuple(String, List(GlyphRenderer)): A list of
                tuples that maps text labels to the legend to corresponding
                renderers that should draw sample representations for those
                labels.
        """
        location = None
        if self._legend is True:
            location = "top_left"
        else:
            location = self._legend

        items = []
        for legend in chart_legends:
            items.append(LegendItem(label=value(legend[0]), renderers=legend[1]))
        if location:
            legend = Legend(location=location, items=items)
            self.add_layout(legend)
Esempio n. 13
0
def prepare_fig(fig, grid=False, tight=True, minimalist=True,
                xgridlines=None, ygridlines=None, **kwargs):
    if fig is None:
        if 'tools' not in kwargs:
            kwargs['tools'] = TOOLS
        if 'title_text_font_size' not in kwargs:
            kwargs['title_text_font_size'] = value('6pt')

        fig = plotting.figure(**kwargs)
        if minimalist:
            three_ticks(fig)
            disable_minor_ticks(fig)
        if tight:
            tight_layout(fig)
        if not grid:
            disable_grid(fig)
        else:
            if xgridlines is not None:
                fig.xgrid.ticker=FixedTicker(ticks=xgridlines)
            if ygridlines is not None:
                fig.ygrid.ticker=FixedTicker(ticks=ygridlines)

    return fig
Esempio n. 14
0
output_file("bar_dodged.html")

fruits = ['Apples', 'Pears', 'Nectarines', 'Plums', 'Grapes', 'Strawberries']
years = ['2015', '2016', '2017']

data = {'fruits' : fruits,
        '2015'   : [2, 1, 4, 3, 2, 4],
        '2016'   : [5, 3, 3, 2, 4, 6],
        '2017'   : [3, 2, 4, 4, 5, 3]}

source = ColumnDataSource(data=data)

p = figure(x_range=fruits, y_range=(0, 10), plot_height=350, title="Fruit Counts by Year",
           toolbar_location=None, tools="")

p.vbar(x=dodge('fruits', -0.25, range=p.x_range), top='2015', width=0.2, source=source,
       color="#c9d9d3", legend=value("2015"))

p.vbar(x=dodge('fruits',  0.0,  range=p.x_range), top='2016', width=0.2, source=source,
       color="#718dbf", legend=value("2016"))

p.vbar(x=dodge('fruits',  0.25, range=p.x_range), top='2017', width=0.2, source=source,
       color="#e84d60", legend=value("2017"))

p.x_range.range_padding = 0.1
p.xgrid.grid_line_color = None
p.legend.location = "top_left"
p.legend.orientation = "horizontal"

show(p)
Esempio n. 15
0
    def textStamp(self, glyph=chr(0x0f0000)):
        '''Creates a tool that allows arbitrary Unicode text to be "stamped" on the map. Echos to all figures.

        :param glyph: Arbitrary unicode string, usually (but not required to be) a single character.

        returns:
            PointDrawTool with textStamp functionality.
        '''

        starting_font_size = 15  # in pixels
        render_lines = []
        for figure in self.figures:
            render_lines.append(
                figure.text_stamp(x="xs",
                                  y="ys",
                                  source=self.source['text_stamp' + glyph],
                                  text=value(glyph),
                                  text_font='BARC',
                                  text_color="colour",
                                  text_font_size="fontsize"))

        self.source['text_stamp' + glyph].js_on_change(
            'data',
            bokeh.models.CustomJS(args=dict(
                datasource=self.source['text_stamp' + glyph],
                starting_font_size=starting_font_size,
                figure=self.figures[0],
                colourPicker=self.colourPicker,
                widthPicker=self.widthPicker,
                saveArea=self.saveArea),
                                  code="""
                for(var g = 0; g < datasource.data['xs'].length; g++)
                {
                    if(!datasource.data['colour'][g])
                    {
                        datasource.data['colour'][g] = colourPicker.color;
                    }

                    if(!datasource.data['fontsize'][g])
                    {
                        datasource.data['fontsize'][g] = (widthPicker.value * starting_font_size) +'px';
                    }

                    //calculate initial datasize
                    if(!datasource.data['datasize'][g])
                    {
                        var starting_font_proportion = (widthPicker.value * starting_font_size)/(figure.inner_height);
                        datasource.data['datasize'][g] = (starting_font_proportion * (figure.y_range.end - figure.y_range.start));
                    }
                }
                """))
        self.figures[0].y_range.js_on_change(
            'start',
            bokeh.models.CustomJS(args=dict(render_text_stamp=render_lines[0],
                                            figure=self.figures[0]),
                                  code="""
            for(var g = 0; g < render_text_stamp.data_source.data['fontsize'].length; g++)
            {
                 render_text_stamp.data_source.data['fontsize'][g] = (((render_text_stamp.data_source.data['datasize'][g])/ (figure.y_range.end - figure.y_range.start))*figure.inner_height) + 'px';
            }
            render_text_stamp.glyph.change.emit();
            """))
        tool3 = PointDrawTool(
            renderers=[render_lines[0]],
            tags=['barc' + glyph],
        )
        return tool3
Esempio n. 16
0
def make_axis(axis, size, factors, dim, flip=False, rotation=0,
              label_size=None, tick_size=None, axis_height=35):
    factors = list(map(dim.pprint_value, factors))
    nchars = np.max([len(f) for f in factors])
    ranges = FactorRange(factors=factors)
    ranges2 = Range1d(start=0, end=1)
    axis_label = dim_axis_label(dim)

    axis_props = {}
    if label_size:
        axis_props['axis_label_text_font_size'] = value(label_size)
    if tick_size:
        axis_props['major_label_text_font_size'] = value(tick_size)

    tick_px = font_size_to_pixels(tick_size)
    if tick_px is None:
        tick_px = 8
    label_px = font_size_to_pixels(label_size)
    if label_px is None:
        label_px = 10

    rotation = np.radians(rotation)
    if axis == 'x':
        align = 'center'
        # Adjust height to compensate for label rotation
        height = int(axis_height + np.abs(np.sin(rotation)) *
                     ((nchars*tick_px)*0.82)) + tick_px + label_px
        opts = dict(x_axis_type='auto', x_axis_label=axis_label,
                    x_range=ranges, y_range=ranges2, plot_height=height,
                    plot_width=size)
    else:
        # Adjust width to compensate for label rotation
        align = 'left' if flip else 'right'
        width = int(axis_height + np.abs(np.cos(rotation)) *
                    ((nchars*tick_px)*0.82)) + tick_px + label_px
        opts = dict(y_axis_label=axis_label, x_range=ranges2,
                    y_range=ranges, plot_width=width, plot_height=size)

    p = Figure(toolbar_location=None, **opts)
    p.outline_line_alpha = 0
    p.grid.grid_line_alpha = 0

    if axis == 'x':
        p.yaxis.visible = False
        axis = p.xaxis[0]
        if flip:
            p.above = p.below
            p.below = []
            p.xaxis[:] = p.above
    else:
        p.xaxis.visible = False
        axis = p.yaxis[0]
        if flip:
            p.right = p.left
            p.left = []
            p.yaxis[:] = p.right
    axis.major_label_orientation = rotation
    axis.major_label_text_align = align
    axis.major_label_text_baseline = 'middle'
    axis.update(**axis_props)
    return p
Esempio n. 17
0
line_t = Line(x="x", y="ty", line_color="red", line_width=2)
line_t_glyph = plot.add_glyph(source, line_t)
plot.add_layout(line_t_glyph)

xaxis = LinearAxis()
plot.add_layout(xaxis, 'below')

yaxis = LinearAxis()
plot.add_layout(yaxis, 'left')

xgrid = Grid(dimension=0, ticker=xaxis.ticker)
ygrid = Grid(dimension=1, ticker=yaxis.ticker)

legend = Legend(location="top_right")
legend.items = [
    LegendItem(label=value("%s" % expr), renderers=[line_f_glyph]),
    LegendItem(label=value("taylor(%s)" % expr), renderers=[line_t_glyph]),
]
plot.add_layout(legend)

def on_slider_value_change(attr, old, new):
    global order
    order = int(new)
    update_data()

def on_text_value_change(attr, old, new):
    global expr

    try:
        expr = sy.sympify(new, dict(x=xs))
    except Exception as exception:
Esempio n. 18
0
#output_file('折扣商品数量.html')

p1 = figure(x_range=lst_brand,
            plot_width=900,
            plot_height=350,
            title='各个品牌参与双十一活动的商品数量分布',
            tools=[hover1, 'reset, xwheel_zoom, pan, crosshair'])
# 构建绘图空间

p1.vbar_stack(stackers=lst_type,
              x='brand',
              source=source1,
              width=0.9,
              color=colors,
              alpha=0.8,
              legend=[value(x) for x in lst_type],
              muted_color='black',
              muted_alpha=0.2)
# 绘制堆叠图

p1.xgrid.grid_line_color = None
p1.axis.minor_tick_line_color = None
p1.outline_line_color = None
p1.legend.location = "top_right"
p1.legend.orientation = "horizontal"
p1.legend.click_policy = "mute"
# 设置其他参数

show(p1)

data1_brands = result2.copy()
Esempio n. 19
0
text = Text(x="dates", y="times", text="texts", text_align="center")
plot.add_glyph(text_source, text)

xformatter = DatetimeTickFormatter(months="%b %Y")
xaxis = DatetimeAxis(formatter=xformatter)
plot.add_layout(xaxis, 'below')

yaxis = DatetimeAxis()
plot.add_layout(yaxis, 'left')

plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker))
plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker))

legend = Legend(items=[
    LegendItem(label=value('sunrise'), renderers=[sunrise_line_renderer]),
    LegendItem(label=value('sunset'), renderers=[sunset_line_renderer])
])
plot.add_layout(legend)

doc = Document()
doc.add_root(plot)

if __name__ == "__main__":
    doc.validate()
    filename = "daylight.html"
    with open(filename, "w") as f:
        f.write(file_html(doc, INLINE, "Daylight Plot"))
    print("Wrote %s" % filename)
    view(filename)
Esempio n. 20
0
def assembly_chart(df, complements):
    """function to assembly the chart"""
    print('starting the plot...')

    # specify the output file name
    output_file("movigrama_chart.html")
    # force to show only one plot when multiples executions of the code occur
    # otherwise the plots will append each time one new calling is done
    reset_output()

    # create ColumnDataSource objects directly from Pandas data frames
    source = ColumnDataSource(df)

    # use the column DT as index
    df.set_index('DT', inplace=True)

    ###########################################################################
    #
    #  Movigrama Plot
    #
    ###########################################################################

    # build figure of the plot
    p = figure(x_axis_type='datetime',
               x_axis_label='days of moviment',
               y_axis_label='unities movimented',
               plot_width=1230,
               plot_height=500,
               active_scroll='wheel_zoom')

    # TODO Specify X range (not all plots have 365 days of moviment)

    # build the Stock Level bar
    r1 = p.vbar(x='DT',
                bottom=0,
                top='STOCK',
                width=pd.Timedelta(days=1),
                fill_alpha=0.4,
                color='paleturquoise',
                source=source)

    # build the OUT bar
    p.vbar(x='DT',
           bottom=0,
           top='SOMA_SAI',
           width=pd.Timedelta(days=1),
           fill_alpha=0.8,
           color='crimson',
           source=source)

    # build the IN bar
    p.vbar(x='DT',
           bottom=0,
           top='SOMA_ENTRA',
           width=pd.Timedelta(days=1),
           fill_alpha=0.8,
           color='seagreen',
           source=source)

    # edit title
    # adds warehouse title
    p.add_layout(
        Title(text=complements['warehouse'],
              text_font='helvetica',
              text_font_size='10pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="italic"), 'above')
    # adds product title
    p.add_layout(
        Title(text=complements['product'],
              text_font='helvetica',
              text_font_size='10pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="italic"), 'above')
    # adds main title
    p.add_layout(
        Title(text='Movigrama Endicon',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.9,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p.renderers.extend([hline])

    # adapt the range to the plot
    p.x_range.range_padding = 0.1
    p.y_range.range_padding = 0.1

    # format the plot's outline
    p.outline_line_width = 4
    p.outline_line_alpha = 0.1
    p.outline_line_color = 'orangered'

    # format major labels
    p.axis.major_label_text_color = 'gray'
    p.axis.major_label_text_font_style = 'bold'

    # format labels
    p.axis.axis_label_text_color = 'gray'
    p.axis.axis_label_text_font_style = 'bold'

    #    p.xgrid.grid_line_color = None  # disable vertical bars
    #    p.ygrid.grid_line_color = None  # disable horizontal bars

    # change placement of minor and major ticks in the plot
    p.axis.major_tick_out = 10
    p.axis.minor_tick_in = -3
    p.axis.minor_tick_out = 6
    p.axis.minor_tick_line_color = 'gray'

    # format properly the X datetime axis
    p.xaxis.formatter = DatetimeTickFormatter(days=['%d/%m'],
                                              months=['%m/%Y'],
                                              years=['%Y'])

    # iniciate hover object
    hover = HoverTool()
    hover.mode = "vline"  # activate hover by vertical line
    hover.tooltips = [("SUM-IN", "@SOMA_ENTRA"), ("SUM-OUT", "@SOMA_SAI"),
                      ("COUNT-IN", "@TRANSACT_ENTRA"),
                      ("COUNT-OUT", "@TRANSACT_SAI"), ("STOCK", "@STOCK"),
                      ("DT", "@DT{%d/%m/%Y}")]
    # use 'datetime' formatter for 'DT' field
    hover.formatters = {"DT": 'datetime'}
    hover.renderers = [r1]  # display tolltip only to one render
    p.add_tools(hover)

    ###########################################################################
    #
    #  Demand analysis
    #
    ###########################################################################

    # change to positive values
    df['out_invert'] = df['SOMA_SAI'] * -1
    # moving average with n=30 days
    df['MA30'] = df['out_invert'].rolling(30).mean().round(0)
    # moving standard deviation with n=30 days
    df['MA30_std'] = df['out_invert'].rolling(30).std().round(0)
    # lower control limit for 1 sigma deviation
    df['lcl_1sigma'] = (df['MA30'] - df['MA30_std'])
    # upper control limit for 1 sigma deviation
    df['ucl_1sigma'] = (df['MA30'] + df['MA30_std'])

    source = ColumnDataSource(df)

    p1 = figure(plot_width=1230,
                plot_height=500,
                x_range=p.x_range,
                x_axis_type="datetime",
                active_scroll='wheel_zoom')

    # build the Sum_out bar
    r1 = p1.vbar(x='DT',
                 top='out_invert',
                 width=pd.Timedelta(days=1),
                 color='darkred',
                 line_color='salmon',
                 fill_alpha=0.4,
                 source=source)

    # build the moving average line
    p1.line(x='DT', y='MA30', source=source)

    # build the confidence interval
    band = Band(base='DT',
                lower='lcl_1sigma',
                upper='ucl_1sigma',
                source=source,
                level='underlay',
                fill_alpha=1.0,
                line_width=1,
                line_color='black')
    p1.renderers.extend([band])

    # adds title
    p1.add_layout(
        Title(text='Demand Variability',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p1.renderers.extend([hline])

    # format the plot's outline
    p1.outline_line_width = 4
    p1.outline_line_alpha = 0.1
    p1.outline_line_color = 'orangered'

    # format major labels
    p1.axis.major_label_text_color = 'gray'
    p1.axis.major_label_text_font_style = 'bold'

    # format labels
    p1.axis.axis_label_text_color = 'gray'
    p1.axis.axis_label_text_font_style = 'bold'

    # change placement of minor and major ticks in the plot
    p1.axis.major_tick_out = 10
    p1.axis.minor_tick_in = -3
    p1.axis.minor_tick_out = 6
    p1.axis.minor_tick_line_color = 'gray'

    # format properly the X datetime axis
    p1.xaxis.formatter = DatetimeTickFormatter(days=['%d/%m'],
                                               months=['%m/%Y'],
                                               years=['%Y'])

    # iniciate hover object
    hover = HoverTool()
    hover.mode = "vline"  # activate hover by vertical line
    hover.tooltips = [("DEMAND", '@out_invert'), ("UCL 1σ", "@ucl_1sigma"),
                      ("LCL 1σ", "@lcl_1sigma"), ("M AVG 30d", "@MA30"),
                      ("DT", "@DT{%d/%m/%Y}")]
    # use 'datetime' formatter for 'DT' field
    hover.formatters = {"DT": 'datetime'}
    hover.renderers = [r1]  # display tolltip only to one render
    p1.add_tools(hover)

    ###########################################################################
    #
    #  Demand groupped by month
    #
    ###########################################################################

    resample_M = df.iloc[:, 0:6].resample('M').sum()  # resample to month
    # create column date as string
    resample_M['date'] = resample_M.index.strftime('%b/%y').values
    # moving average with n=3 months
    resample_M['MA3'] = resample_M['out_invert'].rolling(3).mean()

    resample_M['MA3'] = np.ceil(resample_M.MA3)  # round up the column MA3
    # resample to month with mean
    resample_M['mean'] = np.ceil(resample_M['out_invert'].mean())
    # resample to month with standard deviation
    resample_M['std'] = np.ceil(resample_M['out_invert'].std())
    # moving standard deviation with n=30 days
    resample_M['MA3_std'] = np.ceil(resample_M['out_invert'].rolling(3).std())
    # lower control limit for 1 sigma deviation
    resample_M['lcl_1sigma'] = resample_M['MA3'] - resample_M['MA3_std']
    # upper control limit for 1 sigma deviation
    resample_M['ucl_1sigma'] = resample_M['MA3'] + resample_M['MA3_std']

    source = ColumnDataSource(resample_M)

    p2 = figure(plot_width=1230,
                plot_height=500,
                x_range=FactorRange(factors=list(resample_M.date)),
                title='demand groupped by month')

    colors = factor_cmap('date',
                         palette=Category20_20,
                         factors=list(resample_M.date))

    p2.vbar(x='date',
            top='out_invert',
            width=0.8,
            fill_color=colors,
            fill_alpha=0.8,
            source=source,
            legend=value('OUT'))

    p2.line(x='date',
            y='MA3',
            color='red',
            line_width=3,
            line_dash='dotted',
            source=source,
            legend=value('MA3'))

    p2.line(x='date',
            y='mean',
            color='blue',
            line_width=3,
            line_dash='dotted',
            source=source,
            legend=value('mean'))

    band = Band(base='date',
                lower='lcl_1sigma',
                upper='ucl_1sigma',
                source=source,
                level='underlay',
                fill_alpha=1.0,
                line_width=1,
                line_color='black')

    labels1 = LabelSet(x='date',
                       y='MA3',
                       text='MA3',
                       level='glyph',
                       y_offset=5,
                       source=source,
                       render_mode='canvas',
                       text_font_size="8pt",
                       text_color='darkred')

    labels2 = LabelSet(x='date',
                       y='out_invert',
                       text='out_invert',
                       level='glyph',
                       y_offset=5,
                       source=source,
                       render_mode='canvas',
                       text_font_size="8pt",
                       text_color='gray')

    low_box = BoxAnnotation(
        top=resample_M['mean'].iloc[0] -
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='red')
    mid_box = BoxAnnotation(
        bottom=resample_M['mean'].iloc[0] -
        resample_M['std'].iloc[0],  # analysis:ignore
        top=resample_M['mean'].iloc[0] +
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='green')
    high_box = BoxAnnotation(
        bottom=resample_M['mean'].iloc[0] +
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='red')

    p2.renderers.extend([band, labels1, labels2, low_box, mid_box, high_box])
    p2.legend.click_policy = "hide"
    p2.legend.background_fill_alpha = 0.4

    p2.add_layout(
        Title(text='Demand Grouped by Month',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p2.renderers.extend([hline])

    # format the plot's outline
    p2.outline_line_width = 4
    p2.outline_line_alpha = 0.1
    p2.outline_line_color = 'orangered'

    # format major labels
    p2.axis.major_label_text_color = 'gray'
    p2.axis.major_label_text_font_style = 'bold'

    # format labels
    p2.axis.axis_label_text_color = 'gray'
    p2.axis.axis_label_text_font_style = 'bold'

    # change placement of minor and major ticks in the plot
    p2.axis.major_tick_out = 10
    p2.axis.minor_tick_in = -3
    p2.axis.minor_tick_out = 6
    p2.axis.minor_tick_line_color = 'gray'

    # iniciate hover object
    # TODO develop hoverTool
    #    hover = HoverTool()
    #    hover.mode = "vline"  # activate hover by vertical line
    #    hover.tooltips = [("SUM-IN", "@SOMA_ENTRA"),
    #                      ("SUM-OUT", "@SOMA_SAI"),
    #                      ("COUNT-IN", "@TRANSACT_ENTRA"),
    #                      ("COUNT-OUT", "@TRANSACT_SAI"),
    #                      ("STOCK", "@STOCK")]
    #    hover.renderers = [r1]  # display tolltip only to one render
    #    p2.add_tools(hover)

    ###########################################################################
    #
    #  Plot figures
    #
    ###########################################################################

    # put the results in a column and show
    show(column(p, p1, p2))

    # show(p)  # plot action

    print('plot finished')
    def plot_with_bokeh(self, figure_width=5, figure_height="auto", tools="auto"):
        """Plot the graphic record using Bokeh.

        Examples
        --------

        >>>


        """
        if not BOKEH_AVAILABLE:
            raise ImportError("``plot_with_bokeh`` requires Bokeh installed.")
        if not PANDAS_AVAILABLE:
            raise ImportError("``plot_with_bokeh`` requires Pandas installed.")

        # Set up default tools
        if tools == "auto":
            tools = [HoverTool(tooltips="@hover_html"), "xpan,xwheel_zoom,reset,tap"]

        # FIRST PLOT WITH MATPLOTLIB AND GATHER INFOS ON THE PLOT
        ax, (features_levels, plot_data) = self.plot(figure_width=figure_width)
        width, height = [int(100 * e) for e in ax.figure.get_size_inches()]
        plt.close(ax.figure)
        if figure_height == "auto":
            height = int(0.5 * height)
        else:
            height = 100 * figure_height
        height = max(height, 185)  # Minimal height to see all icons

        max_y = max(
            [data["annotation_y"] for f, data in plot_data.items()]
            + list(features_levels.values())
        )

        # BUILD THE PLOT ()
        plot = figure(
            plot_width=width,
            plot_height=height,
            tools=tools,
            x_range=Range1d(0, self.sequence_length),
            y_range=Range1d(-1, max_y + 1),
        )
        plot.patches(
            xs="xs",
            ys="ys",
            color="color",
            line_color="#000000",
            source=ColumnDataSource(
                pd.DataFrame.from_records(
                    [
                        self.bokeh_feature_patch(
                            feature.start,
                            feature.end,
                            feature.strand,
                            figure_width=figure_width,
                            level=level,
                            color=feature.color,
                            label=feature.label,
                            hover_html=(
                                feature.html
                                if feature.html is not None
                                else feature.label
                            ),
                        )
                        for feature, level in features_levels.items()
                    ]
                )
            ),
        )

        if plot_data != {}:
            if version.parse(bokeh.__version__) < version.parse("2.3"):
                value_arial = "arial"
            else:  # >= 2.3
                value_arial = value("arial")
            plot.text(
                x="x",
                y="y",
                text="text",
                text_align="center",
                text_font_size="12px",
                text_font=value_arial,
                text_font_style="normal",
                source=ColumnDataSource(
                    pd.DataFrame.from_records(
                        [
                            dict(
                                x=feature.x_center,
                                y=pdata["annotation_y"],
                                text=feature.label,
                                color=feature.color,
                            )
                            for feature, pdata in plot_data.items()
                        ]
                    )
                ),
            )
            plot.segment(
                x0="x0",
                x1="x1",
                y0="y0",
                y1="y1",
                line_width=0.5,
                color="#000000",
                source=ColumnDataSource(
                    pd.DataFrame.from_records(
                        [
                            dict(
                                x0=feature.x_center,
                                x1=feature.x_center,
                                y0=pdata["annotation_y"],
                                y1=pdata["feature_y"],
                            )
                            for feature, pdata in plot_data.items()
                        ]
                    )
                ),
            )

        plot.yaxis.visible = False
        plot.outline_line_color = None
        plot.grid.grid_line_color = None
        plot.toolbar.logo = None

        return plot
# data
categories = ['category1', 'category2', 'category3']
grouped_bar_df = pd.DataFrame({'categories' : categories,
                               '2015': [2, 1, 4],
                               '2016': [5, 3, 3],
                               '2017': [3, 2, 4]})

# plot
grouped_bar = figure(x_range=categories, y_range=(0, 10), plot_height=250)

# offsets bars / bar locations on axis
dodge1 = dodge('categories', -0.25, range=grouped_bar.x_range)
dodge2 = dodge('categories',  0.0,  range=grouped_bar.x_range)
dodge3 = dodge('categories',  0.25, range=grouped_bar.x_range)

grouped_bar.vbar(x=dodge1, top='2015', width=0.2, source=grouped_bar_df, color='gray', legend=value('2015'))
grouped_bar.vbar(x=dodge2, top='2016', width=0.2, source=grouped_bar_df, color='blue', legend=value('2016'))
grouped_bar.vbar(x=dodge3, top='2017', width=0.2, source=grouped_bar_df, color='green', legend=value('2017'))

# format legend
grouped_bar.legend.location = 'top_left'
grouped_bar.legend.orientation = 'horizontal'

show(grouped_bar)
Stacked Area Chart
In [67]:
stacked_area_df = pd.DataFrame({'x': [1, 2, 3, 4, 5],
                                'y1': [1, 2, 4, 3, 4],
                                'y2': [1, 4, 2, 2, 3]})

stacked_area_plot = figure(plot_width=600, plot_height=300)
Esempio n. 23
0
def NewRegistered():
    dfnr = pd.read_csv('BokehApp/Data/NewRegHouses_CLEANED.csv',
                       delimiter=',',
                       index_col='Year_RNH')
    xnr = '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016', '2017', '2018'
    pnr = figure(x_range=xnr,
                 plot_height=350,
                 plot_width=550,
                 title='Number of new properties registered',
                 tools='pan, wheel_zoom, box_zoom, reset')
    sourcenr = ColumnDataSource(
        data=dict(x=xnr, y=dfnr['Ireland'], y1=dfnr['Dublin']))
    pnr.line(x='x',
             y='y',
             line_width=2.5,
             line_color='#440154',
             source=sourcenr,
             legend=value('Ireland'))
    pnr.line(x='x',
             y='y1',
             line_width=2.5,
             line_color='#FDE724',
             source=sourcenr,
             legend=value('Dublin'))
    pnr.circle(x='x',
               y='y',
               size=5,
               color='#B2DD2C',
               source=sourcenr,
               legend=value('Ireland'))
    pnr.circle(x='x',
               y='y1',
               size=5,
               color='#35B778',
               source=sourcenr,
               legend=value('Dublin'))

    hoverpnr = HoverTool()
    hoverpnr.tooltips = [('Ireland', '@y'), ('Dublin', '@y1')]
    pnr.add_tools(hoverpnr)

    pnr.legend.location = 'top_right'
    #pnr.y_range.range_padding = 0.02
    pnr.xgrid.grid_line_color = None
    tick_labels_pnr = {
        '10000': '10K',
        '20000': '20K',
        '30000': '30K',
        '40000': '40K',
        '50000': '50K',
        '60000': '60K'
    }
    pnr.yaxis.major_label_overrides = tick_labels_pnr
    #pnr.legend.background_fill_alpha=None
    pnr.legend.border_line_alpha = 0
    pnr.legend.label_text_font_size = "11px"
    pnr.legend.click_policy = "hide"
    pnr.title.text_font_size = '15px'
    #pti.axis.major_label_text_font_style = 'bold'
    pnr.xaxis.major_label_text_font_style = 'bold'
    pnr.toolbar.autohide = True
    return pnr
def main():

    # reads df from file
    df = pd.read_csv('../../university_ranking.csv', index_col=0)

    output_file('docs/bar-chart-continent-split.html')

    # splits data-frame into top 800 data-frames per year
    df2016 = df.loc[df['year'] == 2016].head(800)
    df2017 = df.loc[df['year'] == 2017].head(800)
    df2018 = df.loc[df['year'] == 2018].head(800)

    dfs = [df2016, df2017, df2018]

    # continent order that I wanted
    continents = ['Europe', 'America', 'Asia', 'Oceania', 'Africa']
    list = []

    # all years
    years = ['2016', '2017', '2018']

    # all continents put into lists
    continents_2016 = df2016['continent'].tolist()
    continents_2017 = df2017['continent'].tolist()
    continents_2018 = df2018['continent'].tolist()

    # all continents counter and put into dictionaries
    count_2016 = dict(Counter(continents_2016))
    count_2017 = dict(Counter(continents_2017))
    count_2018 = dict(Counter(continents_2018))

    # lists of counts in corrrect order as outlined above
    list2016 = [count_2016[key] for key in continents]
    list2017 = [count_2017[key] for key in continents]
    list2018 = [count_2018[key] for key in continents]

    # dictionary with data for making a figure
    data = {
        'continents': continents,
        '2016': list2016,
        '2017': list2017,
        '2018': list2018
    }

    source = ColumnDataSource(data=data)

    p = figure(x_range=continents,
               y_range=(0, 450),
               plot_height=250,
               title="University count per continent per year",
               toolbar_location=None,
               tools="hover",
               tooltips='No. of univesities: @$name')

    p.vbar(x=dodge('continents', -0.25, range=p.x_range),
           top='2016',
           width=0.2,
           source=source,
           color="#c9d9d3",
           legend=value("2016"),
           name='2016')

    p.vbar(x=dodge('continents', 0.0, range=p.x_range),
           top='2017',
           width=0.2,
           source=source,
           color="#718dbf",
           legend=value("2017"),
           name='2017')

    p.vbar(x=dodge('continents', 0.25, range=p.x_range),
           top='2018',
           width=0.2,
           source=source,
           color="#e84d60",
           legend=value("2018"),
           name='2018')

    p.x_range.range_padding = 0.1
    p.xgrid.grid_line_color = None
    p.legend.location = "top_right"
    p.legend.orientation = "horizontal"

    show(p)
Esempio n. 25
0
        elif row['Q47'] == 'Vrouw':
            d_age_s[age]['Female'] += 1

d_age_s = {str(key):d_age_s[key] for key in d_age_s}
sorted_age_gender = sorted(d_age_s)

output_file("participants_age_gender.html")

ages = [age for age in sorted_age_gender]
genders = ["Male", "Female"]
colors = ["#718dbf", "#e84d60"]

data = {'ages' : ages,
        'Male'   : [d_age_s[age]['Male'] for age in sorted_age_gender],
        'Female' : [d_age_s[age]['Female'] for age in sorted_age_gender]}

p = figure(x_range=ages, plot_height=500, plot_width=1000, title="Participants age per gender",
           toolbar_location=None, tools="")

p.vbar_stack(genders, x='ages', width=0.9, color=colors, source=data, legend=[value(x) for x in genders])

p.y_range.start = 0
p.y_range.end = 80
p.x_range.range_padding = 0.01
p.xgrid.grid_line_color = None
p.axis.minor_tick_line_color = None
p.outline_line_color = None
p.legend.location = "top_left"
p.legend.orientation = "horizontal"

show(p)
Esempio n. 26
0
def screen(val: float):
    return value(val, units="screen")
Esempio n. 27
0
         cy1="ym01",
         line_color="#D95F02",
         line_width=2)),
 ("ellipse",
  Ellipse(x="x",
          y="y",
          width=screen(15),
          height=screen(25),
          angle=-0.7,
          fill_color="#1D91C0")),
 ("image_url",
  ImageURL(x="x",
           y="y",
           w=0.4,
           h=0.4,
           url=value("https://static.bokeh.org/logos/logo.png"),
           anchor="center")),
 ("line", Line(x="x", y="y", line_color="#F46D43")),
 ("multi_line",
  MultiLine(xs="xs", ys="ys", line_color="#8073AC", line_width=2)),
 ("multi_polygons",
  MultiPolygons(xs="xsss",
                ys="ysss",
                line_color="#8073AC",
                fill_color="#FB9A99",
                line_width=2)),
 ("patch", Patch(x="x", y="y", fill_color="#A6CEE3")),
 ("patches", Patches(xs="xs", ys="ys", fill_color="#FB9A99")),
 ("quad",
  Quad(left="x", right="xp01", top="y", bottom="ym01",
       fill_color="#B3DE69")),
Esempio n. 28
0
source = ColumnDataSource(data=data)

p = figure(
    x_range=data['fruits'],
    plot_width=800,
    title=
    "Studios Industry Market Share and Percent of Films Released of Top 10 Films (2005)",
    toolbar_location=None,
    tools="")

p.vbar(x=dodge('fruits', -0.25, range=p.x_range),
       top='2015',
       width=0.2,
       source=source,
       color="#c9d9d3",
       legend=value("Market Share (%)"))

p.vbar(x=dodge('fruits', 0.0, range=p.x_range),
       top='2016',
       width=0.2,
       source=source,
       color="#718dbf",
       legend=value("Count of 2005 Films (%)"))

p.x_range.range_padding = 0.1
p.xgrid.grid_line_color = None
p.legend.location = "top_right"
p.legend.orientation = "vertical"
p.xaxis.major_label_orientation = math.pi / 2
p.title.align = 'center'
Esempio n. 29
0
def Transactions():
    df = pd.read_csv('BokehApp/Data/HT_SalesAll.csv', delimiter='\t')
    df.reset_index(inplace=True)
    df = df[['Year','Dublin New', 'Ireland New','Dublin Existing','Ireland Existing']]
    df.set_index('Year', inplace=True)
    varpti = ['Dublin New', 'Ireland New', 'Dublin Existing','Ireland Existing']
    #the value of the y axis has to be in str format
    yearspti = '2010','2011','2012', '2013', '2014', '2015', '2016', '2017', '2018' #df3.index.values.tolist()
    xrange = df.values.max()*1.01
    sourcepti = ColumnDataSource(data=dict(x=yearspti, y=df['Dublin New'], y1=df['Ireland New'],y2=df['Dublin Existing'], y3=df['Ireland Existing']))
    pti = figure(y_range=yearspti, x_range=(0, xrange), plot_height=350, plot_width=550, title='Properties Transactions in Ireland', tools='pan, wheel_zoom, box_zoom, reset')
    pti.hbar(y=dodge('x', -0.2, range=pti.y_range), right='y', height=0.15, source=sourcepti, color='#440154', legend=value('Dublin New'))
    pti.hbar(y=dodge('x', 0, range=pti.y_range), right='y1', height=0.15, source=sourcepti, color='#30678D', legend=value('Ireland New'))
    pti.hbar(y=dodge('x', 0.2, range=pti.y_range), right='y2', height=0.15, source=sourcepti, color='#35B778', legend=value('Dublin Exsiting')) 
    pti.hbar(y=dodge('x', 0.4, range=pti.y_range), right='y3', height=0.15, source=sourcepti, color='#FDE724', legend=value('Ireland Exsiting')) 
    
    hoverpti = HoverTool()
    hoverpti.tooltips=[('Dubin New', '@y'), ('Ireland New', '@y1'), ('Dublin Existing', '@y2'), ('Ireland Existing', '@y3')]
    pti.add_tools(hoverpti)

    pti.legend.location='bottom_right'
    pti.y_range.range_padding = 0.02
    #pti.grid.grid_line_color = None
    pti.grid.grid_line_alpha = 0.6
    pti.grid.grid_line_dash = 'dotted'
    pti.grid.grid_line_dash_offset = 5
    pti.grid.grid_line_width = 2
    tick_labels_pti = {'10000':'10K','20000':'20K','30000':'30K','40000':'40K','50000':'50K'}
    pti.xaxis.major_label_overrides = tick_labels_pti
    pti.legend.background_fill_alpha=None
    pti.legend.border_line_alpha=0
    pti.legend.label_text_font_size = "11px"
    pti.legend.click_policy="hide"
    pti.title.text_font_size = '15px'
    #pti.axis.major_label_text_font_style = 'bold'
    pti.xaxis.major_label_text_font_style = 'bold'
    pti.toolbar.autohide = True
    #pti.outline_line_color=None
    return pti
Esempio n. 30
0
}

source = ColumnDataSource(data=data)

p = figure(x_range=restaurants,
           plot_height=250,
           title="Review Sentiment Counts",
           toolbar_location=None,
           tools="")

p.vbar_stack(sentiments,
             x='restaurants',
             width=0.9,
             color=colors,
             source=source,
             legend=[value(x) for x in sentiments])

p.y_range.start = 0
p.x_range.range_padding = 0.1
p.xgrid.grid_line_color = None
p.axis.minor_tick_line_color = None
p.outline_line_color = None
p.legend.location = "top_left"
p.legend.orientation = "horizontal"

show(p)

output_file("sentiment_graph_2.html")

# restaurants = ['wilbur_mexicana', 'celebrity_hot_pot', 'hashi_izakaya', 'kinka_izakaya', 'sushi_bong', 'uncle_tetsu']
sentiments = ["Positive", "Neutral", "Negative"]
Esempio n. 31
0
source = ColumnDataSource(data=dict(x=[], fy=[], ty=[]))

p = figure(x_range=(-7, 7), y_range=(-100, 200), width=800, height=400)
line_f = p.line(x="x", y="fy", line_color="navy", line_width=2, source=source)
line_t = p.line(x="x",
                y="ty",
                line_color="firebrick",
                line_width=2,
                source=source)

p.background_fill_color = "lightgrey"

legend = Legend(location="top_right")
legend.items = [
    LegendItem(label=value(f"{expr}"), renderers=[line_f]),
    LegendItem(label=value(f"taylor({expr})"), renderers=[line_t]),
]
p.add_layout(legend)


def update():
    try:
        expr = sy.sympify(text.value, dict(x=xs))
    except Exception as exception:
        errbox.text = str(exception)
    else:
        errbox.text = ""
    x, fy, ty = taylor(expr, xs, slider.value, (-2 * sy.pi, 2 * sy.pi), 200)

    p.title.text = "Taylor (n=%d) expansion comparison for: %s" % (
source = ColumnDataSource(data=data)

# create a new plot with a title y_axis range and plot height
p = figure(x_range=countries,
           y_range=(0, 400000000),
           plot_height=450,
           title="")

# creating bar charts for the top 5 movies with color codes
p.vbar(x=dodge('countries', -0.34, range=p.x_range),
       top=top_movies[0],
       width=0.15,
       source=source,
       color="#c9d9d3",
       legend=value(top_movies[0]))

p.vbar(x=dodge('countries', -0.17, range=p.x_range),
       top=top_movies[1],
       width=0.15,
       source=source,
       color="#718dbf",
       legend=value(top_movies[1]))

p.vbar(x=dodge('countries', 0.0, range=p.x_range),
       top=top_movies[2],
       width=0.15,
       source=source,
       color="#e84d60",
       legend=value(top_movies[2]))
Esempio n. 33
0
for plot, source in zip([plot_r1, plot_r2], [source_r1, source_r2]):
    for name, color in zip(df_r1.columns, Dark2[3]):
        if "Y" in name:
            line_width = 4
            line_alpha = 0.6
        else:
            line_width = 2
            line_alpha = 1.

        plot.line(x='index',
                  y=name,
                  line_width=line_width,
                  line_alpha=line_alpha,
                  source=source,
                  color=color,
                  legend=value(name))

    plot.legend.location = "top_left"
    plot.legend.orientation = "horizontal"
    plot.legend.click_policy = "hide"

trial_type_a_corr = Label(x=159, y=175, x_units='screen', y_units='screen',
                          text='Trial Type A Correlation: {corr}'.format(corr=corr_a),
                          render_mode='css', border_line_color='black', border_line_alpha=1.0,
                          background_fill_color='white', background_fill_alpha=1.0)

trial_type_b_corr = Label(x=385, y=175, x_units='screen', y_units='screen',
                          text='Trial Type B Correlation: {corr}'.format(corr=corr_b),
                          render_mode='css', border_line_color='black', border_line_alpha=1.0,
                          background_fill_color='white', background_fill_alpha=1.0)
Esempio n. 34
0
    def textStamp(self, figure):
        self.source_text_stamp = ColumnDataSource(data.EMPTY)
        self.source_text_stamp.add([], "datasize")
        self.source_text_stamp.add([], "fontsize")
        self.source_text_stamp.add([], "colour")
        #render_text_stamp = self.figure.circle(x="xs",y="ys",legend_label="X", source=source);
        starting_font_size = 30  #in pixels
        starting_colour = "orange"  #in CSS-type spec
        '''glyph = bokeh.models.Text(
                x="xs", 
                y="ys", 
                text=value("🌧"),  
                text_color="colour",
                text_font_size="fontsize")'''
        #glyph.text_font_size = '%spx' % starting_font_size

        #render_text_stamp = self.figure.add_glyph(self.source_text_stamp, glyph)
        render_text_stamp = figure.text_stamp(x="xs",
                                              y="ys",
                                              source=self.source_text_stamp,
                                              text=value("🌧"),
                                              text_color="colour",
                                              text_font_size="fontsize")

        self.source_text_stamp.js_on_change(
            'data',
            bokeh.models.CustomJS(args=dict(
                datasource=render_text_stamp.data_source,
                starting_font_size=starting_font_size,
                figure=figure,
                starting_colour=starting_colour),
                                  code="""
                for(var g = 0; g < datasource.data['fontsize'].length; g++)
                {
                    if(!datasource.data['colour'][g])
                    {
                        datasource.data['colour'][g] = starting_colour;
                    }

                    if(!datasource.data['fontsize'][g])
                    {
                        datasource.data['fontsize'][g] = starting_font_size +'px';
                    }

                    //calculate initial datasize
                    if(!datasource.data['datasize'][g])
                    {
                        var starting_font_proportion = starting_font_size/(figure.inner_height);
                        datasource.data['datasize'][g] = (starting_font_proportion * (figure.y_range.end - figure.y_range.start));
                    }
                }
                """))
        figure.y_range.js_on_change(
            'start',
            bokeh.models.CustomJS(args=dict(
                render_text_stamp=render_text_stamp,
                glyph=render_text_stamp.glyph,
                figure=figure,
                starting_font_size=starting_font_size),
                                  code="""

            for(var g = 0; g < render_text_stamp.data_source.data['fontsize'].length; g++)
            {
                 render_text_stamp.data_source.data['fontsize'][g] = (((render_text_stamp.data_source.data['datasize'][g])/ (figure.y_range.end - figure.y_range.start))*figure.inner_height) + 'px';
            }
            glyph.change.emit();
            """))
        #render_text_stamp = bokeh.models.renderers.GlyphRenderer(data_source=ColumnDataSource(dict(x=x, y=y, text="X")), glyph=bokeh.models.Text(x="xs", y="ys", text="text", angle=0.3, text_color="fuchsia"))
        tool3 = PointDrawTool(renderers=[render_text_stamp], )
        return tool3
Esempio n. 35
0
def result_pic(path_SA, path_S):
    # mod
    nmi_value = collections.defaultdict(list)
    mod_value = collections.defaultdict(list)
    pic_index = []
    for file in os.listdir(path_SA):
        z = file.find("mod.csv")
        x = file.find("nmi.csv")
        if z > -1 or x > -1:
            if z > -1:
                print("z")
                path_mod = path_SA + "/mod.csv"
                reader = csv.reader(open(path_mod))
                for i, line in enumerate(reader):
                    if i != 0:
                        mod_value["SA"].append(line[1])
                        pic_index.append(str(i))
            else:
                path_nmi = path_SA + "/nmi.csv"
                reader = csv.reader(open(path_nmi))
                for i, line in enumerate(reader):
                    if i != 0:
                        nmi_value["SA"].append(line[1])

    # nmi
    for file in os.listdir(path_S):
        z = file.find("mod.csv")
        x = file.find("nmi.csv")
        if z > -1 or x > -1:
            if z > -1:
                path_mod = path_S + "/mod.csv"
                reader = csv.reader(open(path_mod))
                for i, line in enumerate(reader):
                    if i != 0:
                        mod_value["S"].append(line[1])
            else:
                path_nmi = path_S + "/nmi.csv"
                reader = csv.reader(open(path_nmi))
                for i, line in enumerate(reader):
                    if i != 0:
                        nmi_value["S"].append(line[1])

    print(mod_value, len(mod_value))
    print(nmi_value, len(nmi_value))
    df_mod = pd.DataFrame(mod_value, index=pic_index)
    df_nmi = pd.DataFrame(nmi_value, index=pic_index)

    col_mod = ColumnDataSource(df_mod)
    col_nmi = ColumnDataSource(df_nmi)

    p_mod = figure(x_range=pic_index,
                   y_range=(0, 1),
                   plot_height=350,
                   title="mod",
                   tools="")
    p_nmi = figure(x_range=pic_index,
                   y_range=(0, 1),
                   plot_height=350,
                   title="nmi",
                   tools="")

    p_mod.vbar(x=dodge('index', -0.25, range=p_mod.x_range),
               top='SA',
               width=0.2,
               source=col_mod,
               color="#c9d9d3",
               legend=value("SA"))
    p_mod.vbar(x=dodge('index', 0.0, range=p_mod.x_range),
               top='S',
               width=0.2,
               source=col_mod,
               color="#718dbf",
               legend=value("S"))
    p_nmi.vbar(x=dodge('index', -0.25, range=p_nmi.x_range),
               top='SA',
               width=0.2,
               source=col_nmi,
               color="#c9d9d3",
               legend=value("SA"))
    p_nmi.vbar(x=dodge('index', 0.0, range=p_nmi.x_range),
               top='S',
               width=0.2,
               source=col_nmi,
               color="#718dbf",
               legend=value("S"))

    show(p_nmi)
    show(p_mod)
    def _plot_public_data_statistics(self, all_data, version_attr_name,
                                     title_name, label_cb):
        """
        generic method to plot flight hours one data type
        :param all_data: list with all types as string
        :param version_attr_name: attribute name of _VersionData
        :param title_name: name of the data for the title (and hover tool)
        :param label_cb: callback to create the label
        :return: bokeh plot
        """

        # change data structure
        data_hours = {}  # key=data id, value=list of hours for each version
        for d in all_data:
            data_hours[d] = []

        versions = []  # sorted list of all versions
        for ver in sorted(self._version_data,
                          key=functools.cmp_to_key(_Log.compare_version)):
            versions.append(ver)

            # all data points of the requested type for this version
            version_type_data = getattr(self._version_data[ver],
                                        version_attr_name)

            for d in all_data:
                if not d in version_type_data:
                    version_type_data[d] = 0.
                data_hours[d].append(version_type_data[d])

        # cumulative over each version
        for key in all_data:
            data_hours[key] = np.array(data_hours[key])
            data_hours[key + "_cum"] = np.cumsum(data_hours[key])

        # create a 2D numpy array. We could directly pass the dict to the bokeh
        # plot, but then we don't have control over the sorting order
        X = np.zeros((len(all_data), len(versions)))
        i = 0
        all_data_sorted = []
        for key in sorted(
                all_data,
                key=lambda data_key: data_hours[data_key + "_cum"][-1]):
            X[i, :] = data_hours[key + "_cum"]
            all_data_sorted.append(key)
            i += 1
        all_data = all_data_sorted

        colors = viridis(len(all_data))
        # alternative: use patches: http://bokeh.pydata.org/en/latest/docs/gallery/brewer.html
        area = Area(X,
                    title="Flight Hours per " + title_name,
                    tools=TOOLS,
                    active_scroll=ACTIVE_SCROLL_TOOLS,
                    stack=True,
                    xlabel='version (including development states)',
                    ylabel='',
                    color=colors)

        # now set the labels
        for i in range(len(all_data)):
            area.legend[0].items[i].label = props.value(
                label_cb(all_data[i], False))
        area.legend[0].items.reverse()

        # stack the data: we'll need it for the hover tool
        last = np.zeros(len(versions))
        for i in range(len(all_data)):
            last = last + X[i, :]
            data_hours[all_data[i] + '_stacked'] = last
        data_hours['x'] = np.arange(len(versions))

        # hover tool
        source = ColumnDataSource(data=data_hours)
        for d in all_data:
            renderer = area.circle(x='x',
                                   y=d + '_stacked',
                                   source=source,
                                   size=10,
                                   alpha=0,
                                   name=d)
            g1_hover = HoverTool(renderers=[renderer],
                                 tooltips=[
                                     (title_name, label_cb(d, True)),
                                     ('Flight hours (only this version)',
                                      '@' + d + '{0,0.0}'),
                                     ('Flight hours (up to this version)',
                                      '@' + d + '_cum{0,0.0}')
                                 ])
            area.add_tools(g1_hover)

        # TODO: space x-axis entries according to version release date?
        area.xaxis.formatter = FuncTickFormatter(code="""
            var versions = """ + str(versions) + """;
            return versions[Math.floor(tick)]
        """)
        area.xaxis.ticker = FixedTicker(ticks=list(range(len(versions))))
        self._setup_plot(area)
        return area
Esempio n. 37
0
def bar_chart_continent_split():

    # reads df from file
    df = pd.read_csv('bokeh-server/static/university_ranking.csv', index_col=0)

    # splits data-frame into top 800 data-frames per year
    df2016 = df.loc[df['year'] == 2016].head(800)
    df2017 = df.loc[df['year'] == 2017].head(800)
    df2018 = df.loc[df['year'] == 2018].head(800)

    dfs = [df2016, df2017, df2018]

    # continent order that I wanted
    continents = ['Europe', 'America', 'Asia', 'Oceania', 'Africa']

    list = []

    # all years
    years = ['2016', '2017', '2018']

    # all continents put into lists
    continents_2016 = df2016['continent'].tolist()
    continents_2017 = df2017['continent'].tolist()
    continents_2018 = df2018['continent'].tolist()

    # all continents counter and put into dictionaries
    count_2016 = dict(Counter(continents_2016))
    count_2017 = dict(Counter(continents_2017))
    count_2018 = dict(Counter(continents_2018))

    # lists of counts in corrrect order as outlined above
    list2016 = [count_2016[key] for key in continents]
    list2017 = [count_2017[key] for key in continents]
    list2018 = [count_2018[key] for key in continents]

    # dictionary with data for making a figure
    data = {
        'continents': continents,
        '2016': list2016,
        '2017': list2017,
        '2018': list2018
    }

    source = ColumnDataSource(data=data)

    p = figure(x_range=continents,
               y_range=(0, 450),
               plot_height=250,
               plot_width=700,
               title="University count per continent per year",
               tools=['hover', 'save'],
               tooltips='No. of universities: @$name')

    p.vbar(x=dodge('continents', -0.25, range=p.x_range),
           top='2016',
           width=0.2,
           source=source,
           color="#c9d9d3",
           legend=value("2016"),
           name='2016')

    p.vbar(x=dodge('continents', 0.0, range=p.x_range),
           top='2017',
           width=0.2,
           source=source,
           color="#718dbf",
           legend=value("2017"),
           name='2017')

    p.vbar(x=dodge('continents', 0.25, range=p.x_range),
           top='2018',
           width=0.2,
           source=source,
           color="#e84d60",
           legend=value("2018"),
           name='2018')

    p.x_range.range_padding = 0.1
    p.xgrid.grid_line_color = None
    p.legend.location = "top_right"
    p.legend.orientation = "horizontal"

    data_frame = pd.DataFrame.from_dict(data)

    data_frame['mean'] = data_frame.mean(axis=1)
    data_frame['std'] = data_frame.std(axis=1)
    data_frame[['mean', 'std']] = data_frame[['mean', 'std']].astype(int)

    return p, data_frame
Esempio n. 38
0
    else:
        ty = sy.lambdify(xs, tx, modules=['numpy'])(x)

    return x, fy, ty

source = ColumnDataSource(data=dict(x=[], fy=[], ty=[]))

p = figure(x_range=(-7,7), y_range=(-100, 200), plot_width=800, plot_height=400)
line_f = p.line(x="x", y="fy", line_color="navy", line_width=2, source=source)
line_t = p.line(x="x", y="ty", line_color="firebrick", line_width=2, source=source)

p.background_fill_color = "lightgrey"

legend = Legend(location="top_right")
legend.items = [
    LegendItem(label=value("%s" % expr), renderers=[line_f]),
    LegendItem(label=value("taylor(%s)" % expr), renderers=[line_t]),
]
p.add_layout(legend)

def update():
    try:
        expr = sy.sympify(text.value, dict(x=xs))
    except Exception as exception:
        errbox.text = str(exception)
    else:
        errbox.text = ""
    x, fy, ty = taylor(expr, xs, slider.value, (-2*sy.pi, 2*sy.pi), 200)

    p.title.text = "Taylor (n=%d) expansion comparison for: %s" % (slider.value, expr)
    legend.items[0].label = value("%s" % expr)
Esempio n. 39
0
source = ColumnDataSource(data=data)

p = figure(x_range=gpa,
           plot_height=500,
           plot_width=800,
           title='GPA count by year',
           toolbar_location=None,
           tools="")

p.vbar_stack(years,
             x='gpa',
             width=0.9,
             color=colors,
             source=source,
             legend=[value(x) for x in years])

p.y_range.start = 0
p.legend.location = "top_center"
p.legend.orientation = "vertical"

layout_query = layout([
    [wb(btnGroupLetters, width=1000)],
    [wb(btnGroupTitle), wb(btnGroupDept)],
    [wb(title_input),
     wb(paragraph, optionGroup, width=100),
     wb(dept_input)],
    [wb(refresh, width=100)],
    [wb(table)],
])
Esempio n. 40
0
fruits = ['Apples', 'Pears', 'Nectarines', 'Plums', 'Grapes', 'Strawberries']
years = ["2015", "2016", "2017"]
colors = ["#c9d9d3", "#718dbf", "#e84d60"]

data = {'fruits' : fruits,
        '2015'   : [2, 1, 4, 3, 2, 4],
        '2016'   : [5, 3, 4, 2, 4, 6],
        '2017'   : [3, 2, 4, 4, 5, 3]}

source = ColumnDataSource(data=data)

p = figure(x_range=fruits, plot_height=350, title="Fruit Counts by Year",
           toolbar_location=None, tools="")

renderers = p.vbar_stack(years, x='fruits', width=0.9, color=colors, source=source,
                         legend=[value(x) for x in years], name=years)

for r in renderers:
    year = r.name
    hover = HoverTool(tooltips=[
        ("%s total" % year, "@%s" % year),
        ("index", "$index")
    ], renderers=[r])
    p.add_tools(hover)

p.y_range.start = 0
p.x_range.range_padding = 0.1
p.xgrid.grid_line_color = None
p.axis.minor_tick_line_color = None
p.outline_line_color = None
p.legend.location = "top_left"
Esempio n. 41
0
def make_axis(axis, size, factors, dim, flip=False, rotation=0,
              label_size=None, tick_size=None, axis_height=35):
    factors = list(map(dim.pprint_value, factors))
    nchars = np.max([len(f) for f in factors])
    ranges = FactorRange(factors=factors)
    ranges2 = Range1d(start=0, end=1)
    axis_label = dim_axis_label(dim)
    reset = "range.setv({start: 0, end: range.factors.length})"
    ranges.callback = CustomJS(args=dict(range=ranges), code=reset)

    axis_props = {}
    if label_size:
        axis_props['axis_label_text_font_size'] = value(label_size)
    if tick_size:
        axis_props['major_label_text_font_size'] = value(tick_size)

    tick_px = font_size_to_pixels(tick_size)
    if tick_px is None:
        tick_px = 8
    label_px = font_size_to_pixels(label_size)
    if label_px is None:
        label_px = 10

    rotation = np.radians(rotation)
    if axis == 'x':
        align = 'center'
        # Adjust height to compensate for label rotation
        height = int(axis_height + np.abs(np.sin(rotation)) *
                     ((nchars*tick_px)*0.82)) + tick_px + label_px
        opts = dict(x_axis_type='auto', x_axis_label=axis_label,
                    x_range=ranges, y_range=ranges2, plot_height=height,
                    plot_width=size)
    else:
        # Adjust width to compensate for label rotation
        align = 'left' if flip else 'right'
        width = int(axis_height + np.abs(np.cos(rotation)) *
                    ((nchars*tick_px)*0.82)) + tick_px + label_px
        opts = dict(y_axis_label=axis_label, x_range=ranges2,
                    y_range=ranges, plot_width=width, plot_height=size)

    p = Figure(toolbar_location=None, tools=[], **opts)
    p.outline_line_alpha = 0
    p.grid.grid_line_alpha = 0

    if axis == 'x':
        p.yaxis.visible = False
        axis = p.xaxis[0]
        if flip:
            p.above = p.below
            p.below = []
            p.xaxis[:] = p.above
    else:
        p.xaxis.visible = False
        axis = p.yaxis[0]
        if flip:
            p.right = p.left
            p.left = []
            p.yaxis[:] = p.right
    axis.major_label_orientation = rotation
    axis.major_label_text_align = align
    axis.major_label_text_baseline = 'middle'
    axis.update(**axis_props)
    return p
Esempio n. 42
0
def stacked(player):

    playerStats = generateStatsForPlayer(player)
    pitch_breakdown = playerStats['stats']

    years = []
    pitches = ['Fastball', 'Changeup', 'Curve', 'Cutter', 'Splitter', 'Knuckle', 'Slider', 'Sinker', 'Other']

    fastballs = []
    changeups = []
    curves = []
    cutters = []
    splitters = []
    knuckles = []
    sliders = []
    sinkers = []
    others =[]

    for item in pitch_breakdown:
        yr = item['year']
        years.append(yr)
        fastballs.append(float(item['percent_fastball']))
        changeups.append(float(item['percent_changeup']))
        curves.append(float(item['percent_curve']))
        cutters.append(float(item['percent_cutter']))
        splitters.append(float(item['percent_splitter']))
        knuckles.append(float(item['percent_knuckle']))
        sliders.append(float(item['percent_slider']))
        sinkers.append(float(item['percent_sinker']))
        others.append(float(item['percent_other']))

    throws = []
    data = { 'Year': years }

    for perc in fastballs:
        if perc != 0:
            throws.append('Fastball')
            data['Fastball'] = fastballs
            break
    for perc in changeups:
        if perc != 0:
            throws.append('Changeup')
            data['Changeup'] = changeups
            break
    for perc in curves:
        if perc != 0:
            throws.append('Curve')
            data['Curve'] = curves
            break
    for perc in cutters:
        if perc != 0:
            throws.append('Cutter')
            data['Cutter'] = cutters
            break
    for perc in splitters:
        if perc != 0:
            throws.append('Splitter')
            data['Splitter'] = splitters
            break
    for perc in knuckles:
        if perc != 0:
            throws.append('Knuckle')
            data['Knuckle'] = knuckles
            break
    for perc in sliders:
        if perc != 0:
            throws.append('Slider')
            data['Slider'] = sliders
            break
    for perc in sinkers:
        if perc != 0:
            throws.append('Sinker')
            data['Sinker'] = sinkers
            break
    for perc in others:
        if perc != 0:
            throws.append('Other')
            data['Other'] = others
            break

    colors = Category20c[len(throws)]

    # return jsonify(data)
    p = figure(x_range=years, plot_height=350, plot_width=800, title="Pitch Breakdown By Year", toolbar_location=None, tools="")
    p.vbar_stack(throws, x='Year', width=0.9, color=colors, source=data, legend=[value(x) for x in throws])

    p.y_range.start = 0
    p.x_range.range_padding = 0.1
    p.xgrid.grid_line_color = None
    p.axis.minor_tick_line_color = None
    p.outline_line_color = None
    p.legend.location = "center_right"
    p.legend.orientation = "vertical"

    new_legend = p.legend[0]
    p.legend[0].plot = None
    p.add_layout(new_legend, 'right')

    script, div = components(p)

    Flask(__name__).logger.info(script)
    return [script,div]
Esempio n. 43
0
from bokeh.core.properties import value
from bokeh.io import show, output_file
from bokeh.plotting import figure

output_file("bar_stacked.html")

fruits = ['Apples', 'Pears', 'Nectarines', 'Plums', 'Grapes', 'Strawberries']
years = ["2015", "2016", "2017"]
colors = ["#c9d9d3", "#718dbf", "#e84d60"]

data = {'fruits' : fruits,
        '2015'   : [2, 1, 4, 3, 2, 4],
        '2016'   : [5, 3, 4, 2, 4, 6],
        '2017'   : [3, 2, 4, 4, 5, 3]}

p = figure(x_range=fruits, plot_height=250, title="Fruit Counts by Year",
           toolbar_location=None, tools="hover", tooltips="$name @fruits: @$name")

p.vbar_stack(years, x='fruits', width=0.9, color=colors, source=data,
             legend=[value(x) for x in years])

p.y_range.start = 0
p.x_range.range_padding = 0.1
p.xgrid.grid_line_color = None
p.axis.minor_tick_line_color = None
p.outline_line_color = None
p.legend.location = "top_left"
p.legend.orientation = "horizontal"

show(p)
Esempio n. 44
0
def vacantPlot():
    dfvt = pd.read_csv('BokehApp/Data/HousesVacants.csv', delimiter='\t', header=0)
    dfvt = dfvt.iloc[:4]
    dfv = dfvt[['Type', 'Dublin city & suburbs','Rural']]
    dfv['Other cities'] = dfvt.iloc[:, 2:-2].sum(axis=1)
    dfv.set_index('Type', inplace=True)
    dfv.columns = ['Dublin&Suburbs', 'Rural', 'Other cities']
    dfv = dfv[['Dublin&Suburbs', 'Other cities', 'Rural']]
    rowX = dfv.index.values[::]
    xLabel = ['Dublin', 'Other cities', 'Rural']
    lDict = {'For Sale': xLabel, 'Deceased':xLabel, 'Vacant Long Term':xLabel, 'Rental Property':xLabel}
    source = ColumnDataSource(data=dict(x= list(dfv.index.values), y=dfv['Dublin&Suburbs'], y1=dfv['Other cities'], y2=dfv['Rural']))

    p = figure(x_range=FactorRange(*lDict), plot_height=350, plot_width=550, title='Vacant properties in Ireland 2016', x_axis_label=None, y_axis_label=None, tools = 'pan, wheel_zoom, box_zoom, reset')
    hover = HoverTool()
    hover.tooltips=[('Vacant properties', 'Dublin @y / Others @y1 / Rural @y2')]
    p.add_tools(hover)
    
    p.vbar(x=dodge('x', -0.25, range=p.x_range), top='y', width=0.2, source=source, color='#FDE724', legend=value('Dublin&Suburbs'))
    p.vbar(x=dodge('x', 0.0, range=p.x_range), top='y1', width=0.2, source=source, color='#208F8C', legend=value('Other cities'))
    p.vbar(x=dodge('x', 0.25, range=p.x_range), top='y2', width=0.2, source=source, color='#440154', legend=value('Rural'))
    tick_labels = {'1000':'1K','2000':'2K','3000':'3K','4000':'4K','5000':'5K'}
    p.yaxis.major_label_overrides = tick_labels
    p.legend.location= 'top_right'#(370,180)
    p.legend.background_fill_alpha=None
    p.legend.border_line_alpha=0
    p.legend.label_text_font_size = "11px"
    p.y_range.end = dfv.values.max()*1.1+1
    p.legend.click_policy="hide"
    p.title.text_font_size = '15px'
    p.xaxis.major_label_text_font_style = 'bold'
    p.grid.grid_line_alpha = 0.6
    p.grid.grid_line_dash = 'dotted'
    p.grid.grid_line_dash_offset = 5
    p.grid.grid_line_width = 2
    #p.grid.grid_line_color=None
    p.toolbar.autohide = True
    p.outline_line_color=None
    return p
Esempio n. 45
0
))

xdr = DataRange1d()
ydr = DataRange1d()

plot = Plot(x_range=xdr, y_range=ydr, plot_width=800, plot_height=400)
plot.title.text = "Daylight Hours - Warsaw, Poland"
plot.toolbar_location = None

patch1 = Patch(x="dates", y="times", fill_color="skyblue", fill_alpha=0.8)
plot.add_glyph(patch1_source, patch1)

patch2 = Patch(x="dates", y="times", fill_color="orange", fill_alpha=0.8)
plot.add_glyph(patch2_source, patch2)

sunrise_line = Line(x="dates", y="sunrises", line_color="yellow", line_width=2, label=value("sunrise"))
sunrise_line_renderer = plot.add_glyph(source, sunrise_line)

sunset_line = Line(x="dates", y="sunsets", line_color="red", line_width=2, label=value("sunset"))
sunset_line_renderer = plot.add_glyph(source, sunset_line)

text = Text(x="dates", y="times", text="texts", text_align="center")
plot.add_glyph(text_source, text)

xformatter = DatetimeTickFormatter(formats=dict(months=["%b %Y"]))
xaxis = DatetimeAxis(formatter=xformatter)
plot.add_layout(xaxis, 'below')

yaxis = DatetimeAxis()
plot.add_layout(yaxis, 'left')
Esempio n. 46
0
def bokeh_plot_bar(preds,
                   name=None,
                   allele=None,
                   title='',
                   width=None,
                   height=100,
                   palette='Set1',
                   tools=True,
                   x_range=None):
    """Plot bars combining one or more prediction results for a set of
    peptides in a protein/sequence"""

    from bokeh.models import Range1d, HoverTool, ColumnDataSource
    from bokeh.plotting import figure
    from bokeh.transform import dodge
    from bokeh.core.properties import value

    height = 180
    seqlen = 0
    if width == None:
        width = 700
        sizing_mode = 'scale_width'
    for P in preds:
        if P.data is None or len(P.data) == 0:
            continue
        seqlen = get_seq_from_binders(P)

    if x_range == None:
        x_range = Range1d(0, seqlen)
    y_range = Range1d(start=0, end=1)
    if tools == True:
        tools = "xpan, xwheel_zoom, reset, hover"
    else:
        tools = None
    plot = figure(title=title,
                  plot_width=width,
                  sizing_mode=sizing_mode,
                  plot_height=height,
                  y_range=y_range,
                  x_range=x_range,
                  y_axis_label='rank',
                  tools=tools)
    colors = get_bokeh_colors(palette)
    data = {}
    mlist = []
    for pred in preds:
        m = pred.name
        df = pred.data
        if df is None or len(df) == 0:
            continue
        if name != None:
            df = df[df.name == name]
        grps = df.groupby('allele')
        alleles = grps.groups.keys()
        if allele not in alleles:
            continue
        #print (m, alleles, allele)
        df = df[df.allele == allele]
        df = df.sort_values('pos').set_index('pos')
        key = pred.scorekey
        X = df[key]
        X = (X + abs(X.min())) / (X.max() - X.min())
        data[m] = X.values
        data['pos'] = list(X.index)
        #data['peptide'] = df.peptide.values
        mlist.append(m)
    source = ColumnDataSource(data)

    w = round(1.0 / len(mlist), 1) - .1
    i = -w / 2
    for m in mlist:
        #m = pred.name
        c = colors[m]
        plot.vbar(x=dodge('pos', i, range=plot.x_range),
                  top=m,
                  width=w,
                  source=source,
                  color=c,
                  legend=value(m),
                  alpha=.8)
        i += w

    hover = plot.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
        #("allele", "@allele"),
        ("pos", "@pos")
    ])

    plot.min_border = 10
    plot.background_fill_color = "beige"
    plot.background_fill_alpha = 0.5
    plot.toolbar.logo = None
    plot.toolbar_location = "right"
    plot.legend.location = "top_right"
    plot.legend.orientation = "horizontal"
    return plot
Esempio n. 47
0
import numpy as np
import pandas as pd

from bokeh.core.properties import value
from bokeh.plotting import figure, show, output_file
from bokeh.palettes import brewer

output_file('stacked_area.html')

N = 10
df = pd.DataFrame(np.random.randint(10, 100, size=(15, N))).add_prefix('y')

p = figure(x_range=(0, len(df)-1), y_range=(0, 800))
p.grid.minor_grid_line_color = '#eeeeee'

names = ["y%d" % i for i in range(N)]
p.varea_stack(stackers=names, x='index', color=brewer['Spectral'][N], legend=[value(x) for x in names], source=df)

# reverse the legend entries to match the stacked order
p.legend[0].items.reverse()

show(p)
Esempio n. 48
0
]
stageTable = DataTable(source=stageSource, columns=stageColumns, height=250)

stageHistogram = figure(x_range=cancerStage,
                        y_range=(0, 90),
                        plot_height=400,
                        title="Lung Cancer Stage",
                        toolbar_location=None,
                        tools="")

stageHistogram.vbar(x=dodge('Stage', -0.25, range=stageHistogram.x_range),
                    top='Primary',
                    width=0.2,
                    source=stageSource,
                    color="#c9d9d3",
                    legend=value("Primary"))

stageHistogram.vbar(x=dodge('Stage', 0.0, range=stageHistogram.x_range),
                    top='Node',
                    width=0.2,
                    source=stageSource,
                    color="#718dbf",
                    legend=value("Node"))

stageHistogram.vbar(x=dodge('Stage', 0.25, range=stageHistogram.x_range),
                    top='Mets',
                    width=0.2,
                    source=stageSource,
                    color="#e84d60",
                    legend=value("Mets"))
Esempio n. 49
0
def disable_minor_ticks(fig):
    fig.axis.major_label_text_font_size = value('8pt')
    fig.axis.minor_tick_line_color = None
    fig.axis.major_tick_in = 0
Esempio n. 50
0
xformatter = DatetimeTickFormatter(months="%b %d %Y")
from time import mktime
min_time = dt.datetime.min.time()
xticker = FixedTicker(ticks=[
    mktime(dt.datetime.combine(summer_start, min_time).timetuple()) * 1000,
    mktime(dt.datetime.combine(summer_end, min_time).timetuple()) * 1000
])
xaxis = DatetimeAxis(formatter=xformatter, ticker=xticker)
plot.add_layout(xaxis, 'below')

yaxis = DatetimeAxis()
yaxis.formatter.hours = ['%H:%M']
plot.add_layout(yaxis, 'left')

legend = Legend(items=[
    LegendItem(label=value('sunset'), renderers=[sunset_line_renderer]),
    LegendItem(label=value('sunrise'), renderers=[sunrise_line_renderer]),
])
plot.add_layout(legend)

doc = Document()
doc.add_root(plot)

if __name__ == "__main__":
    doc.validate()
    filename = "daylight.html"
    with open(filename, "w") as f:
        f.write(file_html(doc, INLINE, "Daylight Plot"))
    print("Wrote %s" % filename)
    view(filename)
Esempio n. 51
0
           plot_width=1100,
           x_range=FactorRange(*dfSource.index))
# This creates a hover tool to display data when mousing over bars
# The mouse over tool tip will have areas for protected, multiple use, and total
tt = HoverTool(
    tooltips=[("Protected",
               "@Protected{0,0}"), (
                   "Multiple Use",
                   "@{Multiple Use}{0,0}"), ("Total", "@{Total Area}{0,0}")])

p.vbar_stack(dfSource.columns[0:2],
             x='CatCls',
             width=0.8,
             color=colors,
             source=dfSource,
             legend=[value(x) for x in dfSource.columns[0:2]])
# Add the hover tooltip
p.add_tools(tt)
p.title.align = "center"
p.title.text_font_size = '12pt'
p.legend.location = "top_center"
p.legend.orientation = "horizontal"
p.xaxis.major_label_orientation = 1.55
p.xaxis.axis_label_text_font_style = "normal"
p.y_range.start = 0
p.y_range.end = 150000
p.yaxis[0].formatter = NumeralTickFormatter(format="0,0")
p.yaxis.axis_label = "Square Kilometers"
p.yaxis.axis_label_text_font_style = "normal"

show(p)
Esempio n. 52
0
        self.outf.write('%f\t%s\n' % (t,powr))
        self.outf.flush() # use a hard disk, not an SD card...
        print >> sys.stdout,'@',t,'y=',powr
        self.ds.data['x'].append(tdt)
        self.ds.data['y'].append(powr)
        self.ds.trigger('data', self.ds.data, self.ds.data)



# create a plot and style its properties
p = figure(plot_width=800, plot_height=600, x_axis_type="datetime")


p.xaxis.axis_label = "Time"
p.xaxis.axis_label_text_color = "darkred"
p.axis.major_label_text_font_size=value("10pt")
p.xaxis.major_label_orientation = "vertical"
p.yaxis.axis_label = "Power (KW)"
p.lod_threshold = 1000

# add a text renderer to out plot (no data yet)
p.line(x=[], y=[], name="power_line",line_width="2",line_color="blue")
renderer = p.select(dict(name="power_line"))
ds = renderer[0].data_source


    
m = mq(outfname='mqtt_emon.xls',subs=SUBSCRIPTIONS,
           server = SERVER_IP,port=1883,timeout=60,looptimeout=1,ds=ds)

def callstop():
    ("Q1", "jan"), ("Q1", "feb"), ("Q1", "mar"),
    ("Q2", "apr"), ("Q2", "may"), ("Q2", "jun"),
    ("Q3", "jul"), ("Q3", "aug"), ("Q3", "sep"),
    ("Q4", "oct"), ("Q4", "nov"), ("Q4", "dec"),

]

regions = ['east', 'west']

source = ColumnDataSource(data=dict(
    x=factors,
    east=[ 5, 5, 6, 5, 5, 4, 5, 6, 7, 8, 6, 9 ],
    west=[ 5, 7, 9, 4, 5, 4, 7, 7, 7, 6, 6, 7 ],
))

p = figure(x_range=FactorRange(*factors), plot_height=250,
           toolbar_location=None, tools="")

p.vbar_stack(regions, x='x', width=0.9, alpha=0.5, color=["blue", "red"], source=source,
             legend=[value(x) for x in regions])

p.y_range.start = 0
p.y_range.end = 18
p.x_range.range_padding = 0.1
p.xaxis.major_label_orientation = 1
p.xgrid.grid_line_color = None
p.legend.location = "top_center"
p.legend.orientation = "horizontal"

show(p)
Esempio n. 54
0
def nonOccupiers():
    #bokeh_doc = curdoc()
    dfn = pd.read_csv('BokehApp/Data/TT_nonOccupier.csv', delimiter='\t', index_col='Years')
    dfnt = dfn[['Total Transactions', 'Total Non-Occupiers']]
    rowX = '2010', '2011','2012','2013','2014','2015','2016', '2017', '2018'
    sourcent = ColumnDataSource(data=dict( x = rowX, y=dfnt['Total Transactions'], y1=dfnt['Total Non-Occupiers']))
    pn = figure(x_range=rowX, plot_height=350, plot_width=550, title='Properties Transactions in Ireland', y_axis_label=None, x_axis_label=None, tools = 'pan, wheel_zoom, box_zoom, reset')
    pn.vbar(x=dodge('x', 0.0, range=pn.x_range), top='y', width=0.3, source=sourcent, color='#440154', legend=value('Total Transactions'))
    pn.vbar(x=dodge('x', -0.35, range=pn.x_range), top='y1', width=0.3, source=sourcent, color='#FDE724', legend=value('Total Non-Occupiers'))
    
    pn.x_range.range_padding = 0.05
    pn.legend.location = 'top_left'
    hoverpn = HoverTool()
    hoverpn.tooltips=[('Transactions', 'total @y / non-occupiers @y1')]
    pn.add_tools(hoverpn)
    tick_labelspn = {'10000':'10K','20000':'20K','30000':'30K','40000':'40K','50000':'50K', '60000':'60K'}
    pn.yaxis.major_label_overrides = tick_labelspn
    pn.legend.background_fill_alpha=None
    pn.legend.border_line_alpha=0
    pn.legend.label_text_font_size = "11px"
    pn.y_range.end = dfnt.values.max()*1.1+1
    pn.legend.click_policy="hide"
    pn.title.text_font_size = '15px'
    pn.xaxis.major_label_text_font_style = 'bold'
    pn.grid.grid_line_color=None
    pn.toolbar.autohide = True
    #return pn
    #show(pn)def NonOccupiers(): 
    dfn1 = pd.read_csv('BokehApp/Data/TT_nonOccupier.csv', delimiter='\t', index_col='Years')
    dfn3 = dfn1[['Former Owner-Occupier', 'Non-Occupier', 'Non-Household Buyer']]
    rX = '2010', '2011','2012','2013','2014','2015','2016', '2017', '2018'

    srcn3 = ColumnDataSource(data=dict( x = rX,
                                    y=dfn3['Former Owner-Occupier'],
                                    y1=dfn3['Non-Occupier'],
                                    y2=dfn3['Non-Household Buyer']))
    pn3 = figure(x_range=rX, plot_height=350, plot_width=550, title='Properties Transactions in Ireland', y_axis_label=None, x_axis_label=None, tools = 'pan, wheel_zoom, box_zoom, reset')

    pn3.line(x='x', y='y', line_width=2.5, line_color='#440154', source=srcn3, legend=value('Former Owner-Occupier'))
    pn3.line(x='x', y='y1', line_width=2.5, line_color='#FDE724', source=srcn3, legend=value('Non-Occupier'))
    pn3.circle(x='x', y='y', size=5, color='#B2DD2C', source=srcn3, legend=value('Former Owner-Occupier'))
    pn3.circle(x='x', y='y1', size=5, color='#440154', source=srcn3, legend=value('Non-Occupier'))
    pn3.line(x='x', y='y2', line_width=2.5, line_color='#9DD93A', source=srcn3, legend=value('Non-Household Buyer'))
    pn3.circle(x='x', y='y2', size=5, color='#365A8C', source=srcn3, legend=value('Non-Household Buyer'))

            #pne.vbar(x='x', top='y', width=0.4, source=srcne, color='#440154', legend=value('Existing'))
            #pne.vbar(x='x', top='y1', width=0.4, source=srcne, color='#FDE724', legend=value('New'))

    pn3.legend.location = 'top_left'
    hoverpn3 = HoverTool()
    hoverpn3.tooltips=[('Former Owner', '@y'),('Non-Occupier', '@y1'), ('Non-Household', '@y2')]
    pn3.add_tools(hoverpn3)
    tick_labelspn3 = {'5000':'5K','10000':'10K','15000':'15K','20000':'20K','25000':'25K'}
    pn3.yaxis.major_label_overrides = tick_labelspn3
            #pn.xaxis.major_label_overrides = {'2010':'2010', '2011':'2011'}
    #pn3.legend.background_fill_alpha=None
    #pn3.legend.border_line_alpha=0
    pn3.legend.label_text_font_size = "11px"
            #pne.y_range.end = dfnt.values.max()*1.1+1
            #pn.x_range.start = rowX*1.1+1
    pn3.legend.click_policy="hide"
    pn3.title.text_font_size = '15px'
    pn3.xaxis.major_label_text_font_style = 'bold'
    #pn3.xgrid.grid_line_color=None
    pn3.grid.grid_line_alpha = 0.6
    pn3.grid.grid_line_dash = 'dotted'
    pn3.grid.grid_line_dash_offset = 5
    pn3.grid.grid_line_width = 2
    pn3.toolbar.autohide = True
    pn3.outline_line_color=None
    pn3.legend.background_fill_alpha=None
    pn3.legend.border_line_alpha=0
    #return pn3
    #show(pn3)

    dfne = pd.read_csv('BokehApp/Data/HT_NewExisiting.csv', delimiter='\t', index_col='Years')
    rX = '2010', '2011','2012','2013','2014','2015','2016', '2017', '2018'

    srcne = ColumnDataSource(data=dict( x = rX,
                                    y=dfne['Existing'],
                                    y1=dfne['New']))
    pne = figure(x_range=rX, plot_height=350, plot_width=550, title='Properties Transactions in Ireland', y_axis_label=None, x_axis_label=None, tools = 'pan, wheel_zoom, box_zoom, reset')

    pne.line(x='x', y='y', line_width=2.5, line_color='#440154', source=srcne, legend=value('Existing'))
    pne.line(x='x', y='y1', line_width=2.5, line_color='#FDE724', source=srcne, legend=value('New'))
    pne.circle(x='x', y='y', size=5, color='#B2DD2C', source=srcne, legend=value('Existing'))
    pne.circle(x='x', y='y1', size=5, color='#35B778', source=srcne, legend=value('New'))

            #pne.vbar(x='x', top='y', width=0.4, source=srcne, color='#440154', legend=value('Existing'))
            #pne.vbar(x='x', top='y1', width=0.4, source=srcne, color='#FDE724', legend=value('New'))

    pne.legend.location = 'top_left'
    hoverpne = HoverTool()
    hoverpne.tooltips=[('Transactions', 'Exisiting @y / New @y1')]
    pne.add_tools(hoverpne)
    tick_labelspne = {'10000':'10K','20000':'20K','30000':'30K','40000':'40K'}
    pne.yaxis.major_label_overrides = tick_labelspne
            #pn.xaxis.major_label_overrides = {'2010':'2010', '2011':'2011'}
    pne.legend.background_fill_alpha=None
    pne.legend.border_line_alpha=0
    pne.legend.label_text_font_size = "11px"
            #pne.y_range.end = dfnt.values.max()*1.1+1
            #pn.x_range.start = rowX*1.1+1
    pne.legend.click_policy="hide"
    pne.title.text_font_size = '15px'
    pne.xaxis.major_label_text_font_style = 'bold'
    #pne.xgrid.grid_line_color=None
    pne.grid.grid_line_alpha = 0.6
    pne.grid.grid_line_dash = 'dotted'
    pne.grid.grid_line_dash_offset = 5
    pne.grid.grid_line_width = 2
    pne.toolbar.autohide = True
    pne.outline_line_color=None
    #show(pne)

    dfn = pd.read_csv('BokehApp/Data/TT_nonOccupier.csv', delimiter='\t', index_col='Years')
    dfnt = dfn[['Total Transactions', 'Total Non-Occupiers']]

    rowX = '2010', '2011','2012','2013','2014','2015','2016', '2017', '2018'

    sourcent = ColumnDataSource(data=dict( x = rowX,
                                        y=dfnt['Total Transactions'],
                                        y1=dfnt['Total Non-Occupiers']))
    pn = figure(x_range=rowX, plot_height=350, plot_width=550, title='Properties Transactions in Ireland', y_axis_label=None, x_axis_label=None, tools = 'pan, wheel_zoom, box_zoom, reset')
        #pn.x_range=rowX
    pn.vbar(x=dodge('x', 0.0, range=pn.x_range), top='y', width=0.3, source=sourcent, color='#440154', legend=value('Total Transactions'))
    pn.vbar(x=dodge('x', -0.35, range=pn.x_range), top='y1', width=0.3, source=sourcent, color='#FDE724', legend=value('Total Non-Occupiers'))

        #pn.x_range.factors = xstr
        #x_range = FactorRange(factors=['2010', '2011', '2012','2013','2014','2015','2016','2017','2018'])
    pn.x_range.range_padding = 0.05
    pn.legend.location = 'top_left'
    hoverpn = HoverTool()
    hoverpn.tooltips=[('Transactions', 'total @y / non-occupiers @y1')]
    pn.add_tools(hoverpn)
    tick_labelspn = {'10000':'10K','20000':'20K','30000':'30K','40000':'40K','50000':'50K', '60000':'60K'}
    pn.yaxis.major_label_overrides = tick_labelspn
        #pn.xaxis.major_label_overrides = {'2010':'2010', '2011':'2011'}
    pn.legend.background_fill_alpha=None
    pn.legend.border_line_alpha=0
    pn.legend.label_text_font_size = "11px"
    pn.y_range.end = dfnt.values.max()*1.1+1
        #pn.x_range.start = rowX*1.1+1
    pn.legend.click_policy="hide"
    pn.title.text_font_size = '15px'
    pn.xaxis.major_label_text_font_style = 'bold'
    #pn.grid.grid_line_color=None
    pn.grid.grid_line_alpha = 0.6
    pn.grid.grid_line_dash = 'dotted'
    pn.grid.grid_line_dash_offset = 5
    pn.grid.grid_line_width = 2
    pn.toolbar.autohide = True
    pn.outline_line_color=None
    #show(pn)
    t1 = Panel(child=pn, title='Overview')
    t2 = Panel(child=pne, title='Type of sale')
    t3 = Panel(child=pn3, title='Type of buyer')
    tabs = Tabs(tabs=[t1,t2,t3])
    return tabs