def create_circle_legend(circle_var, color_var, legend_min, legend_med, legend_max, x_axis = 'x_axis', y_axis = 'y_axis', plot_height = 200, plot_width = 140): # Get customized df circle_df = create_circle_legend_df(color_var, legend_min, legend_med, legend_max) maxval = circle_df[color_var].max() minval = circle_df[color_var].min() if maxval > abs(minval): minval = maxval * -1 if maxval < abs(minval): maxval = minval * -1 colors = list((RdBu[9])) exp_cmap = LinearColorMapper(palette=colors, low = minval, high = maxval) circle = figure(x_range = FactorRange(), y_range = FactorRange(), plot_width= plot_width, plot_height=plot_height, toolbar_location=None, tools="hover") circle.scatter(x_axis, y_axis, source = circle_df, fill_alpha=1, line_width=0, size="size", fill_color={"field":color_var, "transform":exp_cmap}) circle.x_range.factors = sorted(circle_df[x_axis].unique().tolist()) circle.y_range.factors = circle_df[y_axis].unique().tolist() # plots in reverse order of circle_df (max to min) circle.xaxis.major_label_orientation = math.pi/2 circle.xaxis.axis_label = 'FDR p-value' return circle
def test_axis_type_auto(self): assert(bph._get_axis_class("auto", FactorRange(), 0)) == (CategoricalAxis, {}) assert(bph._get_axis_class("auto", FactorRange(), 1)) == (CategoricalAxis, {}) assert(bph._get_axis_class("auto", DataRange1d(), 0)) == (LinearAxis, {}) assert(bph._get_axis_class("auto", DataRange1d(), 1)) == (LinearAxis, {}) assert(bph._get_axis_class("auto", Range1d(), 0)) == (LinearAxis, {}) assert(bph._get_axis_class("auto", Range1d(), 1)) == (LinearAxis, {}) assert(bph._get_axis_class("auto", Range1d(start=datetime.datetime(2018, 3, 21)), 0)) == (DatetimeAxis, {}) assert(bph._get_axis_class("auto", Range1d(start=datetime.datetime(2018, 3, 21)), 1)) == (DatetimeAxis, {})
def plotCircleHeatMap ( df, circle_var, color_var, x_axis, y_axis, plot_width= 1000, plot_height = 650, font_size = 12, x_axis_lab = "no_label", y_axis_lab = "no_label", show_plot = True, save_png = "plot.png", legend_min = 1e-6, legend_med = .0001, legend_max = 0.01, show_legend = True): # circle_var designed for pvalues. Normalized by taking log 10 of values and multiplying by 5 #added a new column to make the plot size df["size2"] = df[circle_var].apply(lambda x: -1*(np.log(x))) df['size'] = (df["size2"])*3 #find values to set color bar min/ max as maxval = df[color_var].max() minval = df[color_var].min() if maxval > abs(minval): minval = maxval * -1 if maxval < abs(minval): maxval = minval * -1 colors = list((RdBu[9])) exp_cmap = LinearColorMapper(palette=colors, low = minval, high = maxval) p = figure(x_range = FactorRange(), y_range = FactorRange(), plot_width= plot_width, plot_height=plot_height, toolbar_location=None, tools="hover") p.scatter(x_axis,y_axis,source=df, fill_alpha=1, line_width=0, size="size", fill_color={"field":color_var, "transform":exp_cmap}) #p.x_range.factors = sorted(df[x_axis].unique().tolist()) p.x_range.factors = df[x_axis].unique().tolist() p.y_range.factors = sorted(df[y_axis].unique().tolist(), reverse = True) p.xaxis.major_label_orientation = math.pi/2 # font size p.axis.major_label_text_font_size = str(font_size)+"pt" if (x_axis_lab != "no_label" ): p.xaxis.axis_label = x_axis_lab if (y_axis_lab != "no_label" ): p.yaxis.axis_label = y_axis_lab bar = ColorBar(color_mapper=exp_cmap, location=(0,0)) p.add_layout(bar, "right") if show_plot: if show_legend: # Create Circle Legend circle_legend = create_circle_legend(circle_var, color_var, legend_min, legend_med, legend_max) circle_legend.axis.major_label_text_font_size = str(font_size - 1)+"pt" # font size output_notebook() show(row(p, circle_legend)) else: output_notebook() show(p) if save_png != "plot.png": export_png(row(p, circle_legend), filename= save_png) return p
def plotCircleHeatMap(df, circle_var, color_var, x_axis, y_axis, plot_width=1000, plot_height=650, x_axis_lab="no_label", y_axis_lab="no_label"): # circle_var designed for pvalues. Normalized by taking log 10 of values and multiplying by 5 #added a new column to make the plot size df["size"] = (np.log10(df[circle_var])) df["size"] = np.abs(df["size"]) df['size'] = np.where(df["size"] < 0, np.abs(df["size"]), (df["size"])) * 5 maxval = df[color_var].max() minval = df[color_var].min() colors = list((RdBu[9])) exp_cmap = LinearColorMapper(palette=colors, low=minval, high=maxval) p = figure(x_range=FactorRange(), y_range=FactorRange(), plot_width=plot_width, plot_height=plot_height, toolbar_location=None, tools="hover") p.scatter(x_axis, y_axis, source=df, fill_alpha=1, line_width=0, size="size", fill_color={ "field": color_var, "transform": exp_cmap }) p.x_range.factors = sorted(df[x_axis].unique().tolist()) p.y_range.factors = sorted(df[y_axis].unique().tolist(), reverse=True) p.xaxis.major_label_orientation = math.pi / 2 if (x_axis_lab != "no_label"): p.xaxis.axis_label = x_axis_lab if (x_axis_lab != "no_label"): p.yaxis.axis_label = y_axis_lab bar = ColorBar(color_mapper=exp_cmap, location=(0, 0)) p.add_layout(bar, "right") output_notebook() show(p)
def sort_axis(data, key, reverse=False, continous=True): ''' returns list of strings to be used as axis label ticks data - list of dicts with all the data rows key - str(): 'key' to take out the values from each item of list to use as axis range reverse - True/False if to sort in reverse order continous - True/False - for 'number like' values - if only use the values in rows or to create mid-values in range of min/max value ''' values = [value[key] for value in data] values = list(set(values)) if 'date' in key and continous: from itertools import product temp = [[] for item in values[0].split('-')] for i in values: temp[0].append(int(i.split('-')[0])) if len(temp) >= 2: temp[1].extend([1, 12]) if len(temp) >= 3: temp[2].extend([1, 31]) for no, grp in enumerate(temp): temp[no] = ['%02d' % i for i in range(min(grp), max(grp) + 1)] temp = list(product(*temp)) for no, item in enumerate(temp): temp[no] = '-'.join(item) values = temp elif continous: try: temp = [] for item in values: temp.append(int(item)) values = ['%02d' % i for i in range(min(temp), max(temp) + 1)] except: pass values.sort(reverse=reverse) return FactorRange(factors=values)
def create_figure(): dfDemo = dfD[dfD["Pronoun"].isin([genders[i] for i in pronoun.active])] dfPracts = dfDemo[dfDemo["Primary Role"]=="Data Science Industry Practitioner"]["Position in Firm"].value_counts() dfProfs = dfDemo[dfDemo["Primary Role"]=="Data Science Faculty Member/Instructor at Higher Ed Institution"]["Academic position"].value_counts() dfBothAcad = dfDemo[dfDemo["Primary Role"]=="Both Practitioner and Faculty Member/Instructor"]["Academic position"].value_counts() dfBothFirm = dfDemo[dfDemo["Primary Role"]=="Both Practitioner and Faculty Member/Instructor"]["Position in Firm"].value_counts() dfBoth = pd.concat([dfBothAcad,dfBothFirm]) dfBoth = dfBoth.groupby(dfBoth.index).sum().sort_values(ascending=False) dfTotal = pd.DataFrame([dfPracts,dfProfs,dfBothAcad,dfBothFirm], index=["Practitioners","Professors","Both-Academic Position","Both-Industry Position"]) dfTotal = dfTotal.reindex(['Vice-President', 'Senior','Junior', 'Other (please specify)','Adjunct/Part-Time','Assistant Professor', 'Associate Professor', 'Full Professor'], axis=1).rename({"Other (please specify)":"Other"},axis=1) pt = dfTotal.cumsum(axis=1) p = figure(title="Count of Positions of Data Science Professionals", x_axis_label='Primary Role', y_axis_label='Total', x_range = FactorRange(factors=list(pt.index)), plot_height=600, plot_width=900,tools=[]) for column,color in zip(pt.columns,all_palettes['PiYG'][len(pt.columns)]): p.vbar(x=pt.index,bottom=pt[column]-dfTotal[column],top=pt[column],width=.2,color=color, legend = column) p.ygrid.minor_grid_line_color = 'black' p.ygrid.minor_grid_line_alpha = 0.1 p.legend.location = "top_left" p.toolbar.logo = None return p
def test_chart_tools_linear(self, mock_warn): base_args = dict( title="title", xlabel="xlabel", ylabel="ylabel", legend="top_left", xscale="linear", yscale="linear", xgrid=True, ygrid=True, width=800, height=600, ) expected = [ [PanTool, WheelZoomTool, BoxZoomTool, PreviewSaveTool, ResizeTool, ResetTool, HelpTool], [], [ResizeTool, PanTool, BoxZoomTool, ResetTool, LassoSelectTool], ] scenarios = zip( [True, False, "resize,pan,box_zoom,reset,lasso_select"], expected ) self.check_tools_scenario(base_args, scenarios) self.check_tools_scenario(base_args, scenarios, categorical=True) msg_repeat = "LassoSelectTool are being repeated" expected_tools = [ResizeTool, PanTool, BoxZoomTool, ResetTool, LassoSelectTool, LassoSelectTool] mock_warn.reset_mock() # Finally check removing tools base_args['tools'] = "resize,pan,box_zoom,reset,lasso_select,lasso_select" chart = Chart(**base_args) chart.x_range = FactorRange() self.compare_tools(chart.tools, expected_tools) mock_warn.assert_any_call(msg_repeat)
def test_chart_tools_linear(self, mock_warn): base_args = dict(title="title", xlabel="xlabel", ylabel="ylabel", legend="top_left", xscale="linear", yscale="linear", xgrid=True, ygrid=True, width=800, height=600, filename=False, server=False, notebook=False) expected = [ [ PanTool, WheelZoomTool, BoxZoomTool, PreviewSaveTool, ResizeTool, ResetTool ], [], [ResizeTool, PanTool, BoxZoomTool, ResetTool, LassoSelectTool], ] scenarios = zip( [True, False, "resize,pan,box_zoom,reset,lasso_select"], expected) self.check_tools_scenario(base_args, scenarios) # need to change the expected tools because categorical scales # automatically removes pan and zoom tools expected = [ [PreviewSaveTool, ResizeTool, ResetTool], [], [ResizeTool, ResetTool, LassoSelectTool], ] scenarios = zip( [True, False, "resize,pan,box_zoom,reset,lasso_select"], expected) self.check_tools_scenario(base_args, scenarios, categorical=True) msg_repeat = "LassoSelectTool are being repeated" msg_removed = "categorical plots do not support pan and zoom operations.\n" \ "Removing tool(s): pan, box_zoom" expected_tools = [ ResizeTool, ResetTool, LassoSelectTool, LassoSelectTool ] mock_warn.reset_mock() # Finally check repeated tools base_args[ 'tools'] = "resize,pan,box_zoom,reset,lasso_select,lasso_select" chart = Chart(**base_args) chart.x_range = FactorRange() chart.tools = [] chart.create_tools(chart._options.tools) self.compare_tools(chart.tools, expected_tools) mock_warn.assert_any_call(msg_repeat) mock_warn.assert_any_call(msg_removed)
def check_tools_scenario(self, base_args, scenarios, categorical=False): for tools, expected_tools in scenarios: base_args['tools'] = tools chart = Chart(**base_args) if categorical: chart.x_range = FactorRange() chart.tools = [] chart.create_tools(chart._options.tools) self.compare_tools(chart.tools, expected_tools) chart = Chart(**base_args) chart.y_range = FactorRange() chart.tools = [] chart.create_tools(chart._options.tools) self.compare_tools(chart.tools, expected_tools) else: self.compare_tools(chart.tools, expected_tools)
def _get_range(self, dim, start, end): """Create a :class:`Range` for the :class:`Chart`. Args: dim (str): the name of the dimension, which is an attribute of the builder start: the starting value of the range end: the ending value of the range Returns: :class:`Range` """ dim_ref = getattr(self, dim) values = dim_ref.data dtype = dim_ref.dtype sort = self.sort_dim.get(dim) # object data or single value if dtype.name == 'object': factors = values.drop_duplicates() if sort: # TODO (fpliger): this handles pandas API change so users do not experience # the related annoying deprecation warning. This is probably worth # removing when pandas deprecated version (0.16) is "old" enough try: factors.sort_values(inplace=True) except AttributeError: factors.sort(inplace=True) setattr(self, dim + 'scale', 'categorical') return FactorRange(factors=factors.tolist()) elif np.issubdtype(dtype, np.datetime64): setattr(self, dim + 'scale', 'datetime') return Range1d(start=start, end=end) else: if end == 'None' or (end - start) == 0: setattr(self, dim + 'scale', 'categorical') return FactorRange(factors=['None']) else: diff = end - start setattr(self, dim + 'scale', 'linear') return Range1d(start=start - 0.1 * diff, end=end + 0.1 * diff)
def _plot_bokeh(self, current_plot, show_legend=True): from bokeh.models.tools import HoverTool from collections import OrderedDict from bokeh.models.ranges import FactorRange import bokeh.plotting as bkh value_lst = self.matrix.flatten() min_el = min(value_lst) vmax = float(max(value_lst) - min_el) color_lst = [BOKEH_CMAP[int((v - min_el) / vmax * (len(BOKEH_CMAP) - 1))] \ for v in value_lst] source = bkh.ColumnDataSource( data=dict( x=self.labels * self.matrix.shape[0], y=numpy.array([[i] * self.matrix.shape[1] for i in self.labels]).flatten(), color=color_lst, value=value_lst, ) ) # current_plot._below = [] current_plot.x_range = FactorRange(factors=self.labels) current_plot.y_range = FactorRange(factors=self.labels) # current_plot._left = [] # current_plot.extra_y_ranges = {"foo": bkh.FactorRange(factors=self.labels)} # current_plot.add_layout(CategoricalAxis(y_range_name="foo"), place='left') # current_plot.extra_x_ranges = {"foo": bkh.FactorRange(factors=self.labels)} # current_plot.add_layout(CategoricalAxis(x_range_name="foo"), place='top') current_plot.rect('x', 'y', 0.98, 0.98, source=source, color='color', line_color=None) current_plot.grid.grid_line_color = None current_plot.axis.axis_line_color = None current_plot.axis.major_tick_line_color = None hover = current_plot.select(dict(type=HoverTool)) if not hover: hover = HoverTool(plot=current_plot, always_active=True) hover.tooltips = OrderedDict([ ('labels', '@x @y'), ('value', '@value') ]) current_plot.tools.append(hover) return current_plot
def plot_amp_qa(data, name, lower=None, upper=None, amp_keys=None, title=None, plot_height=80, plot_width=700, ymin=None, ymax=None): '''Creates gridplot of 3 camera separated amp plots Args: data: table of per_amp qadata name: metric being plotted (str) Options: lower: list of lower thresholds per camera from get_thresholds() format: [[lower_errB, lowerB], [lower_errR, lowerR], [lower_errZ, lowerZ]] upper: list of upper thresholds per camera from get_thresholds() format : [[upperB, upper_errB], [upperR, upper_errR], [upperZ, upper_errZ]] amp_keys: list of amps that have data title: title for plot, if different than name (str) plot_height, plot_width: height, width of graph in pixels ymin/ymax: lists of y axis ranges for B, R, Z plots, unless data exceeds these Output: Bokeh gridplot object''' if title == None: title = name labels = [(spec, amp) for spec in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] for amp in ['A', 'B', 'C', 'D']] figs = [] for cam in ['B', 'R', 'Z']: if cam == 'B': fig = plot_amp_cam_qa(data, name, cam, labels, title, lower=lower, upper=upper, amp_keys=amp_keys, plot_height=plot_height+25, plot_width=plot_width, ymin=ymin[0], ymax=ymax[0]) if cam == 'R': fig = plot_amp_cam_qa(data, name, cam, labels, title, lower=lower, upper=upper, amp_keys=amp_keys, plot_height=plot_height, plot_width=plot_width, ymin=ymin[1], ymax=ymax[1]) if cam == 'Z': fig = plot_amp_cam_qa(data, name, cam, labels, title, lower=lower, upper=upper, amp_keys=amp_keys, plot_height=plot_height, plot_width=plot_width, ymin=ymin[2], ymax=ymax[2]) if name == "BIAS": fig.yaxis.ticker = AdaptiveTicker(base=10, desired_num_ticks=5, mantissas=np.arange(1, 5.5, 0.5), min_interval=1) fig.yaxis.formatter = NumeralTickFormatter(format='e') else: fig.yaxis.ticker = AdaptiveTicker(base=10, desired_num_ticks=5, mantissas=np.arange(1, 5.5, 0.5), min_interval=1) fig.yaxis.formatter = NumeralTickFormatter(format='a') figs.append(fig) # x-axis labels for spectrograph 0-9 and amplifier A-D axis = bk.figure(x_range=FactorRange(*labels), toolbar_location=None, plot_height=50, plot_width=plot_width, y_axis_location=None) axis.line(x=labels, y=0, line_color=None) axis.grid.grid_line_color=None axis.outline_line_color=None fig = gridplot([[figs[0]], [figs[1]], [figs[2]], [axis]], toolbar_location='right') return fig
def plot_total_time(stats: pd.DataFrame, palette: Palette = Spectral5) -> Figure: """Plots a summary bar graph giving total run time for each configuration and run. Args: stats (pd.DataFrame): Data frame containing the statistics output palette (Palette, optional): Colour palette. Defaults to Spectral5. Returns: figure.Figure: The plotting figure """ if stats.configuration.nunique() == 1: # Group by run only y = stats.run.unique() by = ["run"] elif stats.run.nunique() == 1: # Group by configuration only y = stats.configuration.unique() by = ["configuration"] else: # Group by both y = [(c, r) for c in stats.configuration.unique() for r in stats.run.unique()] by = ["configuration", "run"] df = stats.groupby(by=by).sum() tooltips = [ ("configuration", "@" + "_".join(by)), ("time", "@time"), ] p = figure( y_range=FactorRange(*y), title="Total run time for all instances", tooltips=tooltips, ) p.hbar( y="_".join(by), right="time", height=0.5, fill_color=factor_cmap( "_".join(by), palette=palette, factors=stats.run.unique() if len(by) > 1 else y, start=len(by) - 1, ), line_color=None, source=ColumnDataSource(df), ) p.x_range.start = 0 p.xaxis.axis_label = "Time (s)" p.yaxis.axis_label = "Configuration" return p
def _update_histogram(self, figure, source, hist, edges, name=""): if isinstance(edges[0], str): figure.x_range = FactorRange(factors=edges) else: figure.x_range = DataRange1d() source.data = self._hist_source_dict(hist, edges) if name: figure.title.text = name figure.y_range.start = -0.1 * np.max(hist) figure.y_range.end = 1.1 * np.max(hist)
def make_stacked_barchart(df, x_var, cat_var, y_var, fillna=True, x_labels=None, bar_labels=None, kwargs_figure={}): from bokeh.models import ColumnDataSource from bokeh.plotting import figure from bokeh.core.properties import value from bokeh.models.ranges import FactorRange from bokeh.io import show from bokeh.plotting import figure assert type(x_var) is str, "x-variable should be a string but isn't." assert type( cat_var) is str, "category variable should be a string but isn't." assert type(y_var) is str, "y-variable should be a string but isn't." pt = df.pivot(x_var, cat_var, y_var) if fillna: pt.fillna(0, inplace=True) pt = pt.cumsum(axis=1) bar_vars = pt.columns from bokeh.palettes import brewer assert len(bar_vars) in brewer['Dark2'], "Not enough colors." x = x_labels if x_labels is not None else FactorRange( factors=list(pt.index)) legend = bar_labels if bar_labels is not None else list(bar_vars) colors = brewer['Dark2'][len(bar_vars)] source = ColumnDataSource(data=df) p = figure(x_range=x, **kwargs_figure) bot = 0 for k, var in enumerate(bar_vars): p.vbar(x=pt.index, bottom=bot, top=pt[var], color=colors[k], legend=var, width=0.25) bot = pt[var] return p
def generate_chart(year): data = get_data(year) plot_data = { 'country': data.index.tolist(), 'count': [float(i) for i in data.values.tolist()] } barchart = Bar(plot_data, label='country', values='count', color="red", xgrid=False, ygrid=False, plot_width=800, plot_height=500, tools="pan,wheel_zoom,box_zoom,reset,resize") barchart.title = "Formula SAE Michigan " + year + " Countries" barchart.x_range = FactorRange(factors=data.index.tolist()) barchart._xaxis.axis_label = "Country" barchart._xaxis.axis_line_color = None barchart._xaxis.major_tick_line_color = None barchart._xaxis.minor_tick_line_color = None barchart._yaxis.axis_label = "Number of Teams" barchart._yaxis.axis_line_color = None barchart._yaxis.major_tick_line_color = None barchart._yaxis.minor_tick_line_color = None barchart.outline_line_color = None barchart.toolbar_location = 'right' barchart.logo = None hover = HoverTool(tooltips=[("Country", '@x'), ("# Teams", '@height')]) barchart.add_tools(hover) return barchart
def bar(self, data_frame: pd.DataFrame, category: str = None, value: float = None, text: str = None, color: str = None, title: str = None): source = construct_categorical_data(data_frame, c_col=category, v_col=value, text_col=text) p = self._chart.figure if title is not None: self._chart.set_title(title) p.x_range = FactorRange(factors=data_frame[category].values) p.y_range = Range1d(0, data_frame[value].max() * 1.1) p.yaxis.formatter = self.tick_formater('integer') if data_frame[category].nunique() > 5: p.xaxis.major_label_orientation = math.pi / 2 p.vbar(x='category', top='value', width=0.5, color=self.next_color(), source=source) y_offset = 20 # y_offset = data_frame[value].max() * 0.1 if text is not None: text_glyph = Text(x="category", y="value", y_offset=y_offset, text="text", text_align='center', text_font_size='10pt', text_color="white") p.add_glyph(source, text_glyph) return self
def barplot(x=None, y=None, data=None, stacked=False, width=500, height=500, hue_order=None, p=None, **plot_kw): grouped = data.groupby(x, sort=False) x_values = list(grouped.groups.keys()) metadata = grouped.pipe(filter_groups, approx=True) if p is None: p = figure(x_range=FactorRange(*x_values), width=width, height=height, x_axis_label=x[0], y_axis_label=y) data = dict(x=x_values, y=grouped[y].agg('mean')) data.update({col: metadata[col] for col in metadata.columns}) if len(x) > 1: data['color'] = grouped['color'].nth(0, dropna='all') data[x[1]] = grouped[x[1]].nth(0, dropna='all') p.vbar(x='x', top='y', width=0.9, line_color='black', source=data, **plot_kw) p.xaxis.major_label_orientation = "vertical" return p
def update(json_data): sql_data = json_to_sql(json_data) data = get_dataframe(sql_data) columns = data.columns.tolist() columns.remove('x') x_axis_data = [(x, z) for x in data['x'] for z in columns] to_zip = [data[c].tolist() for c in columns] y_axis_data = sum(zip(*to_zip), ()) source = ColumnDataSource( data=dict(x_axis_data=x_axis_data, y_axis_data=y_axis_data)) p = figure(x_range=FactorRange(*x_axis_data), plot_width=1200, plot_height=600, title="Chart with Zip implementation") p.vbar(x='x_axis_data', top='y_axis_data', width=1, source=source, line_color="white", fill_color=factor_cmap('x_axis_data', palette=viridis(len(columns)), factors=columns, start=1, end=len(columns))) p.y_range.start = 0 p.x_range.range_padding = 0.1 p.xaxis.major_label_orientation = 1 p.xgrid.grid_line_color = None return p
def create_weight_plot(df): """Crea gráfico de importancia de variables sobre calidad del agua Parameters: df (Dataframe): Dataframe con los datos a mostrar en la visualización Returns: DataTable: Gráfico de importancia de variables sobre calidad del agua """ source = ColumnDataSource(df) TOOLTIPS = [ ('Atributo', '@Attribute'), ('Peso', '@Weight'), ] weight_plot = figure(max_width=650, height=400, toolbar_location=None, sizing_mode='stretch_width',y_range=FactorRange(factors=source.data['Attribute']), x_range=(0,1), tooltips=TOOLTIPS) weight_plot.hbar(y='Attribute', left='Weight', right=0, source=source, height=0.6, fill_color=bokeh_utils.BAR_COLORS_PALETTE[0], line_color=bokeh_utils.BAR_COLORS_PALETTE[0]) weight_plot.title.text = 'Peso de indicadores influentes' weight_plot.title.text_color = bokeh_utils.TITLE_FONT_COLOR weight_plot.title.align = 'left' weight_plot.title.text_font_size = '16px' weight_plot.title.offset = -100 weight_plot.min_border_right = 15 weight_plot.xaxis.major_label_text_color = bokeh_utils.LABEL_FONT_COLOR weight_plot.yaxis.major_label_text_color = bokeh_utils.LABEL_FONT_COLOR weight_plot.border_fill_color = bokeh_utils.BACKGROUND_COLOR return weight_plot
columns=['category', 'amount']) source = ColumnDataSource(dict(x=[], y=[])) x_label = "Category" y_label = "Amount" title = "BAR PLOT" import itertools from bokeh.models.ranges import FactorRange import math plot = figure(plot_width=600, plot_height=600, x_axis_label=x_label, y_axis_label=y_label, title=title, x_range=FactorRange(factors=list(dat.category))) source = ColumnDataSource(dict(x=[], y=[], color=[])) plot.vbar(source=source, x='x', top='y', color='color', bottom=0, width=0.3) plot.xaxis.major_label_orientation = math.pi / 2 def authorview(): global plot global db global source tempdf = pd.read_sql('SELECT * FROM sales_by_author', db) colors = colors = itertools.cycle(Spectral6) c = [] for i, x in enumerate(colors): c.append(x) print(i)
def test__check_compatible_scale_and_ranges_incompat_numeric_scale_and_factor_range( ): plot = Plot(x_scale=LinearScale(), x_range=FactorRange()) check = plot._check_compatible_scale_and_ranges() assert check != []
def test_get_set_multi_mismatch(self): obj = bmp._list_attr_splat([LinearAxis(), FactorRange()]) with pytest.raises(AttributeError) as e: obj.formatter.power_limit_low == 10 assert str(e.value).endswith("list items have no %r attribute" % "formatter")
def get_range_instance(): return FactorRange('foo', 'bar')
def test__check_compatible_scale_and_ranges_compat_factor(): plot = Plot(x_scale=CategoricalScale(), x_range=FactorRange()) check = plot._check_compatible_scale_and_ranges() assert check == []
def plot_team_stat(comparison_stat, agg_func): """Creates figures with bars plots of teams stats. :param comparison_stat: str. Statistic to plot. :param agg_func: str. 'mean' or 'sum'. :return: bokeh figures. """ map_agg_func = ('mean', 'sum') data = create_data_source(comparison_stat, map_agg_func[agg_func]) source = ColumnDataSource(data=data) teams = list(source.data['team']) # Plot avg stat per game p_1 = figure(x_range=FactorRange(factors=teams), plot_height=400, plot_width=700) hover = HoverTool(tooltips=[('', '@{Total}')]) hover.point_policy = 'follow_mouse' p_1.add_tools(hover) p_1.vbar(x='team', top='Total', source=source, width=0.4, color=Spectral4[0]) p_1.x_range.range_padding = 0.05 p_1.xaxis.major_label_orientation = 1 p_1.xaxis.major_label_text_font_size = "10pt" p_1.toolbar_location = None # Plot breakdown by match result p_2 = figure(x_range=FactorRange(factors=teams), plot_height=400, plot_width=700, tools='hover', tooltips='@$name', title='Breakdown by Match Result') w = p_2.vbar(x=dodge('team', -0.25, range=p_2.x_range), top='w', width=0.2, source=source, color=Spectral4[1], name='w') d = p_2.vbar(x=dodge('team', 0.0, range=p_2.x_range), top='d', width=0.2, source=source, color=Spectral4[2], name='d') l = p_2.vbar(x=dodge('team', 0.25, range=p_2.x_range), top='l', width=0.2, source=source, color=Spectral4[3], name='l') legend_it = [('Won', [w]), ('Drew', [d]), ('Lost', [l])] legend = Legend(items=legend_it, location=(0, 155)) p_2.add_layout(legend, 'right') p_2.title.text_font_size = '12pt' p_2.x_range.range_padding = 0.05 p_2.xgrid.grid_line_color = None p_2.xaxis.major_label_text_font_size = "10pt" p_2.xaxis.major_label_orientation = 1 p_2.toolbar_location = None return p_1, p_2
def boxplot_series(groups, values, xlim=(None, None), ylim=(None, None), **kwargs): """Create a (e.g. time-) series of boxplots for a variable. :param groups: the grouping variable (the x-axis values). The function will handle also non-numeric, categorical grouping variables (though the sort order is not controllable). :param values: the data for boxplots are drawn (the y-axis values). :param xlim: tuple for plotting limits (start, end). A value None will trigger calculation from the data. :param ylim: tuple for plotting limits (start, end). A value None will trigger calculation from the data. :param kwargs: kwargs for bokeh figure. :returns: a bokeh plot. After creating this plot, you may wish to change the following: * p.xaxis.axis_label = 'Read Length / bases' * p.yaxis.axis_label = 'Number of reads' """ df = pd.DataFrame(dict(group=groups, value=values)) uniq = df.group.unique() # numeric or categorical if not np.issubdtype(uniq.dtype, np.number): x_range = FactorRange(factors=uniq) else: xlim = util.Limiter(util.pad(uniq)).fix(*xlim) x_range = Range1d(start=xlim.min, end=xlim.max, bounds=(xlim.min, xlim.max)) # find the quartiles and IQR for each category groups = df.groupby('group') quantiles = groups.quantile([0.25, 0.5, 0.75]) quantiles.index.names = ['group', 'quantile'] uniq = groups.apply(lambda x: x.name).tolist() q1 = quantiles.xs(0.25, level='quantile') q2 = quantiles.xs(0.50, level='quantile') q3 = quantiles.xs(0.75, level='quantile') iqr = q3 - q1 upper = q3 + 1.5 * iqr lower = q1 - 1.5 * iqr defaults = {"output_backend": "webgl", "height": 300, "width": 600} defaults.update(kwargs) ylim = util.Limiter().accumulate(df['value']).fix(*ylim) y_range = Range1d(start=ylim.min, end=ylim.max, bounds=(ylim.min, ylim.max)) p = figure(**defaults, x_range=x_range, y_range=y_range) # stems p.segment(uniq, upper.value, uniq, q3.value, line_color="black") p.segment(uniq, lower.value, uniq, q1.value, line_color="black") # boxes for low, high in ((q2.value, q3.value), (q1.value, q2.value)): p.vbar(uniq, 0.8, low, high, line_color='black') return p
def test__get_scale_factor_range(): s = bph._get_scale(FactorRange(), "auto") assert isinstance(s, CategoricalScale)
r = kw['edge_renderer'] assert r.glyph.line_color == "purple" assert r.selection_glyph.line_color == "blue" assert r.nonselection_glyph.line_color == "yellow" assert r.hover_glyph.line_color == "red" assert r.muted_glyph.line_color == "orange" assert r.glyph.line_width == 23 assert r.selection_glyph.line_width == 23 assert r.nonselection_glyph.line_width == 23 assert r.hover_glyph.line_width == 23 assert r.muted_glyph.line_width == 23 _RANGES = [Range1d(), DataRange1d(), FactorRange()] class Test__get_axis_class(object): @pytest.mark.parametrize('range', _RANGES) @pytest.mark.unit def test_axis_type_None(self, range): assert (bph._get_axis_class(None, range, 0)) == (None, {}) assert (bph._get_axis_class(None, range, 1)) == (None, {}) @pytest.mark.parametrize('range', _RANGES) @pytest.mark.unit def test_axis_type_linear(self, range): assert (bph._get_axis_class("linear", range, 0)) == (LinearAxis, {}) assert (bph._get_axis_class("linear", range, 1)) == (LinearAxis, {})
def make_graf(p, pav, count, factor): p = figure(x_range=[-5, 5], y_range=FactorRange(factors=factor), height=heigth_count(count), tools="save", toolbar_location="above") p.title.text = "<-Katabolizmas|Anabolizmas->" p.title.align = "center" # p.output_backend = "svg" p.text(x=[-4.7], y=[(count - (count - 3) / 3 - 1)], text=["Rytas"], text_font_size='10pt', text_font_style="bold", angle=1.56) p.text(x=[-4.7], y=[(count - (count - 3) / 3 * 2 - 2)], text=["Pietūs"], text_font_size='10pt', text_font_style="bold", angle=1.56) p.text(x=[-4.7], y=[(count - count)], text=["Vakaras"], text_font_size='10pt', text_font_style="bold", angle=1.56) p.x_range.bounds = 'auto' p.y_range.bounds = 'auto' p.xaxis.axis_label = pav p.yaxis.visible = False p.xaxis.ticker = FixedTicker( ticks=[-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]) p.xaxis.major_label_overrides = { -3.5: "Didelis", -2.5: "Vidutinis", -1.5: "Mažas", -0.5: "Norma", 0.5: "Norma", 1.5: "Mažas", 2.5: "Vidutinis", 3.5: "Didelis" } p.xaxis.major_tick_line_color = None # p.output_backend = "svg" p.add_layout( Span(location=0, dimension='height', line_color='black', line_dash='solid', line_width=4)) p.add_layout( Span(location=1, dimension='height', line_color='green', line_dash='dashed', line_width=4)) p.add_layout( Span(location=-1, dimension='height', line_color='green', line_dash='dashed', line_width=4)) p.add_layout( Span(location=2, dimension='height', line_color='orange', line_dash='dashed', line_width=4)) p.add_layout( Span(location=-2, dimension='height', line_color='orange', line_dash='dashed', line_width=4)) p.add_layout( Span(location=3, dimension='height', line_color='red', line_dash='dashed', line_width=4)) p.add_layout( Span(location=-3, dimension='height', line_color='red', line_dash='dashed', line_width=4)) p.add_layout( Span(location=4, dimension='height', line_color='darkred', line_dash='dashed', line_width=4)) p.add_layout( Span(location=-4, dimension='height', line_color='darkred', line_dash='dashed', line_width=4)) p.add_layout( BoxAnnotation(top=(count - 3) / 3 + 1, fill_alpha=0.1, fill_color='black')) p.add_layout( BoxAnnotation(bottom=(count - 3) / 3 + 1, top=(count - 3) / 3 * 2 + 2, fill_alpha=0.1, fill_color='cyan')) p.add_layout(BoxAnnotation(top=count, fill_alpha=0.1, fill_color='yellow')) return p