def __init__(self, x_range=(0, 0), y_range=None, width=450, height=300, x_label=None, y_label=None, x_axis_type='auto', y_axis_type='auto'): output_notebook(resources=INLINE, hide_banner=True) self.fig = figure(x_range=x_range, y_range=y_range, width=width, height=height, x_axis_type=x_axis_type, y_axis_type=y_axis_type) if x_label is not None: self.fig.xaxis.axis_label = x_label if y_label is not None: self.fig.yaxis.axis_label = y_label self.fig.xaxis.visible = True self.fig.yaxis.visible = True self.fig.xgrid.visible = False self.fig.ygrid.visible = False if x_axis_type == 'log': self.fig.xaxis[0].formatter = FuncTickFormatter( code=modify_exposant) if y_axis_type == 'log': self.fig.yaxis[0].formatter = FuncTickFormatter( code=modify_exposant)
def tweak_figure(fig: Figure) -> Figure: """ Set some common attributes for a figure """ # fig.grid.grid_line_color = None # fig.axis.axis_line_color = None fig.axis.major_tick_line_color = None fig.axis.major_label_text_font_size = "9pt" fig.axis.major_label_standoff = 0 fig.xaxis.major_label_orientation = np.pi / 3 # truncate axis tick values format_js = """ if (tick.toString().length > 15) { if (typeof tick === 'string') { return tick.toString().substring(0, 13) + '...'; } else { return tick.toPrecision(1); } } else { return tick; } """ fig.xaxis.formatter = FuncTickFormatter(code=format_js) fig.yaxis.formatter = FuncTickFormatter(code=format_js) return fig
def __init__(self, source): plot = figure(plot_width=900, plot_height=900, x_minor_ticks=None, y_minor_ticks=None, x_axis_location='above', tools='save') plot.y_range = Range1d(-73.5, 0.5) plot.x_range = Range1d(-0.5, 73.5) plot.xaxis.axis_label = 'Winning Score' plot.yaxis.axis_label = 'Losing Score' plot.xaxis.axis_label_text_font_size = '18pt' plot.yaxis.axis_label_text_font_size = '18pt' plot.xaxis.axis_label_text_font_style = 'bold' plot.yaxis.axis_label_text_font_style = 'bold' plot.yaxis.formatter = FuncTickFormatter(code='return -tick') plot.background_fill_color = '#cccccc' plot.grid.grid_line_color = None plot.xaxis.ticker = range(0, 74, 7) plot.yaxis.ticker = range(0, -74, -7) plot.axis.major_tick_in = 1 plot.axis.major_tick_out = -1 plot.axis.major_label_text_font_size = '8pt' plot.outline_line_width = 1 plot.outline_line_color = 'black' self.plot = plot self.gridlines = self.set_up_gridlines() self.set_up_quad(source)
def graph_bgp(label_dict, redundancy_counts, x_ticks): """ graph bgp the main graphing function used to graph the given dataset we will be graphing this two ways - full and downsampled for computers that cannot handle the full graph, please use the downsampled data set in order to see the graph without hassle """ # define output html file output_file("bgpgraph.html") # define the figure initial parameters p = figure( title="INTERNET'S REDUNDANCY", # title toolbar_location="above", # toolbar location sizing_mode='stretch_both', # sizing parameters of the graph output_backend="webgl", # allows us to utilize webgl to reduce load ) # draw circles with size 1, color navy, and semi transparent for each datapoint p.circle(x_ticks, redundancy_counts, size=1, color="navy", alpha=0.5) # x axis label p.xaxis.axis_label = 'IPv4 Routes' # y axis label p.yaxis.axis_label = 'AVAILABLE REDUNDANT PATHS' # this allows us to replace our x_ticks with real labels - ip routes p.xaxis.formatter = FuncTickFormatter(code=""" var labels = %s; return labels[tick]; """ % label_dict) # displays graph on default browser show(p)
def plot_sleepiness_vs_exercise(): # TODO strenght exercise from .data import cardio_dataframe as CDF c = CDF() c['dt'] = unlocalize(c['start_time']) c = c.set_index('dt').sort_index() c = c[c['error'].isna()] # FIXME error handling # todo for error handling, would be nice to have unused variable detection? s = _sleepy_df() c = c[c.index >= min( s.index)] # clip till the time we started collecting it deltas = [timedelta(hours=h) for h in range(-200, 200)] # we want to find out what predicts sleepiness.. # so sleepiness is y and kcal is x ldf = lag_df(x=c['kcal'], y=s['sleepy'], deltas=deltas) # todo maybe rolling is a somewhat misleading name? f = rolling(x='lag', y='value', df=ldf, avgs=[]).figure f.xaxis.formatter = FuncTickFormatter(code=hhmm_formatter( unit=ldf.index.dtype)) return f
def show_p2(): p2 = figure(title='p3: Sales of 5 best selling products', x_axis_label='date', y_axis_label='daily sales') output_file('p3.html') lx_orig,ly = get_lists() lx = lx_orig colors_list=['blue','yellow','green','red','purple'] legends_list = [] labels = best5.ix[:,0] labels1 = ['ID '+str(labels[n]) for n in best5.index] for i in np.arange(5): legends_list.append(labels1[i]) for (c,l,x,y) in zip(colors_list, legends_list, lx, ly): p2.line(x,y,color=c, legend=l, line_width=3) from bokeh.models import FuncTickFormatter p2.legend.location = 'bottom_right' # Change the xaxis label kk = best5_1.ix[1:-1].keys() kk_noyear = [d[0:-5] for d in kk] # Remove years (e.g. '/2013') kk_js = [str(s) for s in kk_noyear] # Remove u prefix (e.g. u'...') from strings. p2.xaxis[0].formatter = FuncTickFormatter(code=""" var tlabels = %s; return tlabels[tick]; """%repr(kk_js)) show(p2)
def plot_bokeh(topics, eigenvalues): top_words = get_top_words(topics) topic_num = len(topics.keys()) word_num = len(top_words) X, Y, S, C = [], [], [], [] for x in topics: for item in topics[x]: word = item[1] radi = item[0] X.append(x) Y.append(top_words.index(word)) S.append(abs(radi)**2 * 40) C.append(eigenvalues[x]) p = figure(title="Reduce Dimension") p.circle(X, Y, fill_color='blue', fill_alpha=0.2, size=S) p.x_range = Range1d(-1, topic_num) p.xaxis.ticker = FixedTicker(ticks=range(topic_num)) p.xgrid.minor_grid_line_color = 'grey' p.xgrid.minor_grid_line_alpha = 0.2 p.ygrid.minor_grid_line_color = 'grey' p.ygrid.minor_grid_line_alpha = 0.2 p.y_range = Range1d(word_num, -1) data = {} for i in range(word_num): data[i] = str(top_words[i]) p.yaxis.ticker = FixedTicker(ticks=range(word_num)) p.yaxis.formatter = FuncTickFormatter(code=""" var data = %s; return data[tick]; """ % data) return p
def trip_fare_init(self, width=310, height=350, webgl=True): def ticker(): labels = { 0: '0~5', 1: '5~10', 2: '10~25', 3: '25~50', 4: '50~100', 5: '>100' } return labels[tick] self.trip_fare = figure(webgl=webgl, toolbar_location=None, width=width, height=height, title='Fare (US dolloars)') self.trip_fare_source = ColumnDataSource( data=dict(x=range(6), fare=self.data.get_fare())) vbar = self.trip_fare.vbar(width=1, bottom=0, x='x', top='fare', source=self.trip_fare_source, fill_alpha=0.7, line_color="white", color='#ffcc5c') self.trip_fare.y_range.start = 0 self.trip_fare.xaxis.major_tick_line_color = None self.trip_fare.xaxis.minor_tick_line_color = None self.trip_fare.xaxis.formatter = FuncTickFormatter.from_py_func(ticker) self.trip_fare.select(dict(type=GlyphRenderer)) self.trip_fare.add_tools( HoverTool(renderers=[vbar], tooltips=[("Trips", "@fare")]))
def tweak_figure( fig: Figure, ptype: Optional[str] = None, show_yaxis: bool = False, max_lbl_len: int = 15, ) -> None: """ Set some common attributes for a figure """ fig.axis.major_label_text_font_size = "9pt" fig.xaxis.major_label_orientation = pi / 3 fig.title.text_font_size = "10pt" if ptype in ["bar", "pie", "hist", "kde", "qq", "box", "hex", "heatmap"]: fig.grid.grid_line_color = None fig.axis.minor_tick_line_color = None if ptype in ["bar", "hist"] and not show_yaxis: fig.yaxis.major_label_text_font_size = "0pt" fig.yaxis.major_tick_line_color = None if ptype in ["bar", "nested", "stacked", "heatmap", "box"]: fig.xaxis.formatter = FuncTickFormatter(code=""" if (tick.length > %d) return tick.substring(0, %d-2) + '...'; else return tick; """ % (max_lbl_len, max_lbl_len)) if ptype in ["nested", "stacked"]: fig.y_range.start = 0 fig.x_range.range_padding = 0.03 fig.xgrid.grid_line_color = None
def extrapolate_logistic(df, country="US", days_in_future=100, logy=True): dates = df.index y = df.loc[:, country].values x = (dates - np.datetime64(dates[0])).days p0 = np.log([2.3, 46, 2000]) x0, cov = curve_fit(logistic_model, x, y, p0=p0, maxfev=10000) sds = np.sqrt(np.diag(cov)) dts = np.arange(len(dates) + days_in_future) if logy: p = plotting.figure(y_axis_type="log", x_axis_type="datetime") p.yaxis.formatter = FuncTickFormatter(code=code) else: p = plotting.figure(y_axis_type="log", x_axis_type="datetime") plt_dates = [ dates[0] + datetime.timedelta(days=x) for x in range(0, dts[-1]) ] p.line( plt_dates, logistic_model(dts, *x0), color=colors[0], line_width=2.0, line_dash="dashed", ) ln = p.line(dates, logistic_model(x, *x0), color=colors[0], line_width=2) p.circle(x=dates, y=y, color=colors[0]) legend_it = [(country, [ln])] legend = Legend( items=legend_it, location="top_right", orientation="horizontal" ) legend.spacing = 17 legend.click_policy = "hide" p.add_layout(legend, "above") label_opts = dict( x=plt_dates[-1], y=np.min(logistic_model(dts, *x0)), text_align="right", text_font_size="9pt", ) caption = Label( text=f'Created by Tom Barclay on {datetime.datetime.now().strftime("%b %d, %Y")}', **label_opts, ) p.add_layout(caption, "below") script, div = components(p) embedfile = f"_includes/{country.replace(' ', '')}_infections_embed.html" with open(embedfile, "w") as ff: ff.write(div) ff.write(script) return [ f'{(dates[0] + datetime.timedelta(days=np.exp(x0[1]))).strftime("%b %d, %Y")}', np.exp(x0[2]), ]
def initialize(self, doc, plot_lst): plot = figure(tools = utils.default_tools(), y_range = [0, self.nrows], x_range = [self.frequency_range[0], self.frequency_range[-1]], output_backend="webgl") plot.yaxis.formatter = FuncTickFormatter(code = """ return (%s - tick)*%s """ % (self.nrows, self.time_per_sample)) self.waterfall_renderer = [] for i in range(self.nconnections): self.waterfall_renderer.append( WaterfallRenderer(palette = utils.PALETTES[self.palette], time_length = self.nrows, fft_length = self.size, min_value = self.values_range[0], max_value = self.values_range[-1])) plot.renderers.append(self.waterfall_renderer[i]) self.plot = plot plot_lst.append(self) def callback(): self.update( ) doc.add_periodic_callback(callback, self.update_time)
def initialize(self, legend_list=utils.default_labels_f, update_time=100, values_range=(-200, 10), time_per_sample=0.1, number_of_samples=200, palette='Inferno'): self.nrows = number_of_samples self.time_per_sample = time_per_sample self.plot = figure( tools=['save', 'reset'], y_range=[0, self.nrows], x_range=[self.frequency_range[0], self.frequency_range[-1]], output_backend="webgl") self.plot.yaxis.formatter = FuncTickFormatter(code=""" return (%s - tick)*%s """ % (self.nrows, time_per_sample)) self.waterfall_renderer = [] for i in range(self.nconnections): self.waterfall_renderer.append( WaterfallRenderer(palette=utils.PALETTES[palette], time_length=self.nrows, fft_length=self.size, min_value=values_range[0], max_value=values_range[-1])) self.plot.renderers.append(self.waterfall_renderer[i]) self.plot_lst.append(self) if self.name: self.set_title(self.name) self.doc.add_periodic_callback(self.update, update_time)
def systemEvolutionBarPlot(df, yLabel, values): with Timer(key='systemEvolutionBarPlot', verbose=True): p = Bar(df, label='snapshot', values=values, agg='sum', stack='software', legend='bottom_left', bar_width=0.5, xlabel="Snapshots", ylabel=yLabel, responsive=True, height=200,tools='hover') glyph_renderers = p.select(GlyphRenderer) bar_source = [glyph_renderers[i].data_source for i in range(len(glyph_renderers))] hover = p.select(HoverTool) hover.tooltips = [ ('software',' @software'), ('value', '@height'), ] p.xaxis.formatter=FuncTickFormatter.from_py_func(getWeekStringTick) p.axis.minor_tick_line_color = None p.background_fill_color = "#fafafa" p.legend.location = "top_left" p.toolbar.logo = None p.toolbar_location = None legend=p.legend[0].legends p.legend[0].legends=[] l = Legend( location=(0, -30)) l.items=legend p.add_layout(l, 'right') return p
def plotForecast(ForecastTable, counterNumber): dayNames = [] for i in range(ForecastTable.shape[0]): dayNames.append(WeekdayNames[ForecastTable.index[i].weekday()]) output_file("ForecastBarPlot.html") p = figure(plot_width=600, plot_height=400, title="7 Day Bicycle Count Forecast for " + counterNames[counterNumber]) p.vbar(x=[0, 1, 2, 3, 4, 5, 6], width=0.5, bottom=0, top=ForecastTable.iloc[:, counterNumber], color="DeepSkyBlue") label_dict = {} for i, s in enumerate(dayNames): label_dict[i] = s p.xaxis.formatter = FuncTickFormatter(code=""" var labels = %s; return labels[tick]; """ % label_dict) #show(p) return p
def specific_set(self, x_offers, firing_rate, percents_B, y_range=None, title='', size=SIZE): """Figure 4C, 4G, 4K""" fig = ubkh.figure(title=title, plot_width=size, plot_height=size, tools=TOOLS, y_range=(y_range[0] - 0.05 * (y_range[1] - y_range[0]), y_range[1])) self.set_x_ticks(fig, list(range(len(x_offers)))) fig.xaxis.formatter = FuncTickFormatter(code=""" var labels = {}; return labels[tick]; """.format({i: '{}B:{}A'.format(x_B, x_A) for i, (x_A, x_B) in enumerate(x_offers)})) fig.xaxis.major_label_orientation = np.pi / 2 y_min, y_max = y_range K = 0.94 * (y_max - y_min) + y_min xs = [x_offers.index(key) for key in percents_B.keys()] ys = [y * 0.94 * (y_max - y_min) + y_min for y in percents_B.values()] fig.line(x=(min(xs), max(xs)), y=(K, K), color="black", line_dash='dashed') fig.circle(x=xs, y=ys, color="black", size=15) r_A, r_B = firing_rate xs_A = [x_offers.index(key) for key in r_A.keys()] xs_B = [x_offers.index(key) for key in r_B.keys()] fig.diamond(x=xs_A, y=list(r_A.values()), size=15, color=A_color, alpha=0.75) fig.circle( x=xs_B, y=list(r_B.values()), size=10, color=B_color, alpha=0.75) self.save_and_show(fig, title)
def set_hhmm_axis(axis, *, mint: int, maxt: int, period: int = 30) -> None: from bokeh.models import FixedTicker # FIXME infer mint/maxt ticks = list(range(mint, maxt, period)) axis.ticker = FixedTicker(ticks=ticks) from bokeh.models import FuncTickFormatter axis.formatter = FuncTickFormatter(code=hhmm_formatter(unit=int))
def plot_sleepiness_vs_sleep(): from .data import sleep_dataframe as DF sdf = DF() sdf = sdf[sdf['error'].isna()] # todo not sure... maybe sleep start/end would be better? or just median?? sdf = sdf.set_index('date') # sdf.index = unlocalize(sdf.index) s = _sleepy_df() sdf = sdf[sdf.index >= min(s.index)] deltas = [timedelta(hours=h) for h in range(-24 * 5, 24 * 5, 4)] # TODO need something similar to scatter matrix, but instead of scatter, covariance?? # TODO unhardcode ress = [] for col in [ 'bed_time', 'coverage', 'avg_hr', 'hrv_morning', 'hrv_evening' ]: ldf = lag_df(x=sdf[col], y=s['sleepy'], deltas=deltas) # TODO wtf?? so r = rolling(x='lag', y='value', df=ldf, avgs=[]) r.figure.title.text = f'lag plot: sleepiness vs {col}' r.figure.xaxis.formatter = FuncTickFormatter(code=hhmm_formatter( unit=ldf.index.dtype)) ress.append(r) # TODO maybe allow to yield plots? then just assume column layout return column([r.layout for r in ress])
def update(self): output_items = self.process.get_plot_data() if len(output_items[0]) != 0: fc = self.process.get_center_freq() bw = self.process.get_bandwidth() fftsize = self.process.get_size() if self.fc != fc or self.bw != bw or self.size != fftsize: self.size = fftsize self.set_frequency_range(fc, bw, notify_process=False) if not self.is_message: for i in range(self.nconnections): if self.waterfall_renderer[i].latest != list( output_items[i]): self.waterfall_renderer[i].latest = list( output_items[i]) else: self.waterfall_renderer[0].update = \ not self.waterfall_renderer[0].update else: self.time_per_sample = self.process.get_time_per_fft() self.plot.xaxis.formatter = FuncTickFormatter(code=""" return tick*%s """ % self.time_per_sample) for i in range(self.nrows): if self.waterfall_renderer[i].latest != list( output_items[i]): self.waterfall_renderer[0].latest = output_items[i] else: self.waterfall_renderer[0].update = \ not self.waterfall_renderer[0].update return
def apply_axis_formatter(plot, element): plot.handles['xaxis'].formatter = bokeh.models.DatetimeTickFormatter(hourmin = '%H:%M', minutes='%H:%M', minsec='%H:%M:%S', seconds='%H:%M:%S') plot.handles['yaxis'].formatter = FuncTickFormatter(code="""return Math.abs(tick)""") plot.handles['xaxis'].axis_label = "UTC time [min]" plot.handles['yaxis'].axis_label = "Distance [km]"
def tweak_figure(fig: Figure) -> None: """ Set some common attributes for a figure """ fig.grid.grid_line_color = None fig.axis.axis_line_color = None fig.axis.major_tick_line_color = None fig.axis.major_label_text_font_size = "9pt" fig.axis.major_label_standoff = 0 fig.xaxis.major_label_orientation = np.pi / 3 # truncate axis tick values format_js = """ if (tick.length > 15) return tick.substring(0, 13) + '...'; else return tick; """ fig.xaxis.formatter = FuncTickFormatter(code=format_js) fig.yaxis.formatter = FuncTickFormatter(code=format_js)
def _init_figure(self): # plot height will be set later f = figure(tools=Figure._tools, plot_width=self._scheme.plot_width, logo=None, sizing_mode='scale_width', x_axis_type='linear') # TODO: backend webgl (output_backend="webgl") removed due to this bug: # https://github.com/bokeh/bokeh/issues/7568 f.border_fill_color = convert_color(self._scheme.border_fill) f.xaxis.axis_line_color = convert_color(self._scheme.axis_line_color) f.yaxis.axis_line_color = convert_color(self._scheme.axis_line_color) f.xaxis.minor_tick_line_color = convert_color(self._scheme.tick_line_color) f.yaxis.minor_tick_line_color = convert_color(self._scheme.tick_line_color) f.xaxis.major_tick_line_color = convert_color(self._scheme.tick_line_color) f.yaxis.major_tick_line_color = convert_color(self._scheme.tick_line_color) f.xaxis.major_label_text_color = convert_color(self._scheme.axis_label_text_color) f.yaxis.major_label_text_color = convert_color(self._scheme.axis_label_text_color) f.xgrid.grid_line_color = convert_color(self._scheme.grid_line_color) f.ygrid.grid_line_color = convert_color(self._scheme.grid_line_color) f.title.text_color = convert_color(self._scheme.plot_title_text_color) f.left[0].formatter.use_scientific = False f.background_fill_color = convert_color(self._scheme.background_fill) # mechanism for proper date axis without gaps, thanks! # https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/t3HkalO4TGA f.xaxis.formatter = FuncTickFormatter( args=dict( axis=f.xaxis[0], formatter=DatetimeTickFormatter(days=['%d %b', '%a %d'], months=['%m/%Y', "%b %y"]), source=self._cds, ), code=""" axis.formatter.doFormat = function (ticks) { const dates = ticks.map(i => source.data.datetime[i]), valid = t => t !== undefined, labels = formatter.doFormat(dates.filter(valid)); let i = 0; return dates.map(t => valid(t) ? labels[i++] : ''); }; const axisticks = axis.tick_coords.major[0], labels = axis.formatter.doFormat(ticks); return labels[axisticks.indexOf(tick)]; """) ch = CrosshairTool(line_color=self._scheme.crosshair_line_color) f.tools.append(ch) h = HoverTool(tooltips=[('Time', '@datetime{%x %X}')], mode="vline", formatters={'datetime': 'datetime'} ) f.tools.append(h) self._hover = h self.figure = f
def update_plot_after_montage_change(self): self.fig.title.text = self.title goto_sample = int(self.fs * self.loc_sec) page_width_samples = int(self.page_width_secs * self.fs) hw = half_width_epoch_sample = int(page_width_samples / 2) s0 = limit_sample_check(goto_sample - hw, self.signals) s1 = limit_sample_check(goto_sample + hw, self.signals) window_samples = s1 - s0 signal_view = self.signals[:, s0:s1] inmontage_view = np.dot(self.current_montage_instance.V.data, signal_view) self.ch_start = 0 self.ch_stop = inmontage_view.shape[0] numRows = inmontage_view.shape[0] # ??? # print('numRows: ', numRows) data = inmontage_view[self.ch_start:self.ch_stop, :] # note transposed # really just need to reset the labels ticklocs = [] ## xlim(*xlm) # xticks(np.linspace(xlm, 10)) dmin = data.min() dmax = data.max() dr = (dmax - dmin) * 0.7 # Crowd them a bit. y0 = dmin y1 = (numRows - 1) * dr + dmax ## ylim(y0, y1) ticklocs = [ii * dr for ii in range(numRows)] ticklocs.reverse() # inplace bottom = -dr / 0.7 top = (numRows - 1) * dr + dr / 0.7 self.y_range.start = bottom self.y_range.end = top # self.fig.y_range = Range1d(bottom, top) # print("ticklocs:", ticklocs) offsets = np.zeros((numRows, 2), dtype=float) offsets[:, 1] = ticklocs self.ticklocs = ticklocs # self.time = t ylabels = self.current_montage_instance.montage_labels ylabel_dict = dict(zip(ticklocs, ylabels)) # print('ylabel_dict:', ylabel_dict) self.fig.yaxis.ticker = FixedTicker( ticks=ticklocs) # can also short cut to give list directly self.fig.yaxis.formatter = FuncTickFormatter(code=""" var labels = %s; return labels[tick]; """ % ylabel_dict)
def _axis_properties(self, axis, key, plot, dimension, ax_mapping={ 'x': 0, 'y': 1 }): """ Returns a dictionary of axis properties depending on the specified axis. """ axis_props = {} if ((axis == 'x' and self.xaxis in ['bottom-bare', 'top-bare']) or (axis == 'y' and self.yaxis in ['left-bare', 'right-bare'])): axis_props['axis_label'] = '' axis_props['major_label_text_font_size'] = '0pt' axis_props['major_tick_line_color'] = None axis_props['minor_tick_line_color'] = None else: rotation = self.xrotation if axis == 'x' else self.yrotation if rotation: axis_props['major_label_orientation'] = np.radians(rotation) ticker = self.xticks if axis == 'x' else self.yticks if isinstance(ticker, Ticker): axis_props['ticker'] = ticker elif isinstance(ticker, int): axis_props['ticker'] = BasicTicker(desired_num_ticks=ticker) elif isinstance(ticker, (tuple, list)): if all(isinstance(t, tuple) for t in ticker): pass else: axis_props['ticker'] = FixedTicker(ticks=ticker) if FuncTickFormatter is not None and ax_mapping and dimension: formatter = None if dimension.value_format: formatter = dimension.value_format elif dimension.type in dimension.type_formatters: formatter = dimension.type_formatters[dimension.type] if formatter: msg = ('%s dimension formatter could not be ' 'converted to tick formatter. ' % dimension.name) try: formatter = FuncTickFormatter.from_py_func(formatter) except RuntimeError: self.warning(msg + 'Ensure Flexx is installed ' '("conda install -c bokeh flexx" or ' '"pip install flexx")') except Exception as e: error = 'Pyscript raised an error: {0}'.format(e) error = error.replace('%', '%%') self.warning(msg + error) else: axis_props['formatter'] = formatter return axis_props
def _setup_plot(self): plots_width = self._config['plot_width'] plots_height = self.plot_height p = self._p p.plot_width = plots_width p.plot_height = plots_height # -> other attributes are set via theme.yaml # disable x grid lines p.xgrid.grid_line_color = None p.ygrid.grid_line_color = 'navy' p.ygrid.grid_line_alpha = 0.13 p.ygrid.minor_grid_line_color = 'navy' p.ygrid.minor_grid_line_alpha = 0.05 p.toolbar.logo = None # hide the bokeh logo (we give credit at the # bottom of the page) #p.lod_threshold=None # turn off level-of-detail # axis labels: format time if self._use_time_formatter: p.xaxis[0].formatter = FuncTickFormatter( code=''' //func arguments: ticks, x_range // assume us ticks ms = Math.round(tick / 1000) sec = Math.floor(ms / 1000) minutes = Math.floor(sec / 60) hours = Math.floor(minutes / 60) ms = ms % 1000 sec = sec % 60 minutes = minutes % 60 function pad(num, size) { var s = num+""; while (s.length < size) s = "0" + s; return s; } if (hours > 0) { var ret_val = hours + ":" + pad(minutes, 2) + ":" + pad(sec,2) } else { var ret_val = minutes + ":" + pad(sec,2); } if (x_range.end - x_range.start < 4e6) { ret_val = ret_val + "." + pad(ms, 3); } return ret_val; ''', args={'x_range': p.x_range}) # make it possible to hide graphs by clicking on the label p.legend.click_policy = "hide"
def clock_ms_tick_formatter() -> TickFormatter: milliseconds_since_epoch = 0 return FuncTickFormatter( code=""" var d = new Date(initial + tick); return "" + d.getHours() + ":" + ("00" + d.getMinutes()).slice(-2) + ":" + ("00" + d.getSeconds()).slice(-2); """, args={"initial": milliseconds_since_epoch}, )
def test_functickformatter_from_coffeescript_with_args(): coffee_code = "return slider.get('value') + tick" js_code = "\n return slider.get('value') + tick;\n" slider = Slider() formatter = FuncTickFormatter.from_coffeescript(code=coffee_code, args={"slider": slider}) function_wrapper = formatter.code.replace(js_code, "") assert function_wrapper == "var formatter;\n\nformatter = function() {};\n\nreturn formatter()" assert formatter.args == {"slider": slider}
def test_functickformatter_from_py_func(): def convert_to_minutes(seconds): return seconds * 60 formatter = FuncTickFormatter.from_py_func(convert_to_minutes) js_code = pyscript.py2js(convert_to_minutes, 'formatter') function_wrapper = formatter.code.replace(js_code, '') assert function_wrapper == "function (seconds) {return formatter(seconds)};"
def test_functickformatter_from_py_func_no_args(): def convert_to_minutes(): return tick * 60 # noqa formatter = FuncTickFormatter.from_py_func(convert_to_minutes) js_code = flexx.pyscript.py2js(convert_to_minutes, 'formatter') function_wrapper = formatter.code.replace(js_code, '') assert function_wrapper == "return formatter();\n"
def test_functickformatter_from_py_func_no_args(): def convert_to_minutes(): return tick * 60 # noqa formatter = FuncTickFormatter.from_py_func(convert_to_minutes) js_code = flexx.pyscript.py2js(convert_to_minutes, 'formatter') function_wrapper = formatter.code.replace(js_code, '') assert function_wrapper == "formatter();\n"
def callback4(attr, old, new): column4plot = p4_widget.value if int(column4plot[-2:]) > 9: num = column4plot[-2:] else: num = column4plot[-1:] data_4.data = {'x': days, 'y': list(bike_days_tot_perc[num])} p4.line('x', 'y', source=data_4, color='red', line_width=2) p4.xaxis.formatter = FuncTickFormatter(code=""" var labels = %s; return labels[tick]; """ % label_dict)
def callback5(attr, old, new): column5plot = p5_widget.value if int(column5plot[-2:]) > 9: num = column5plot[-2:] else: num = column5plot[-1:] data_5.data = {'x': months, 'y': list(bike_months_tot_perc[num])} p5.line('x', 'y', source=data_5, color='red', line_width=2) p5.xaxis.formatter = FuncTickFormatter(code=""" var labels = %s; return labels[tick]; """ % label_dict_m)
def test_functickformatter_from_coffeescript_with_args(): coffee_code = dedent(""" return slider.get("value") // 2 + tick """) slider = Slider() formatter = FuncTickFormatter.from_coffeescript(code=coffee_code, args={"slider": slider}) assert formatter.code == dedent("""\ return Math.floor(slider.get("value") / 2) + tick; """) assert formatter.args == {"slider": slider}
def test_functickformatter_from_py_func(): def convert_to_minutes(seconds): return seconds * 60 formatter = FuncTickFormatter.from_py_func(convert_to_minutes) js_code = pyscript.py2js(convert_to_minutes, 'formatter') function_wrapper = formatter.code.replace(js_code, '') assert function_wrapper == "function (seconds) {return formatter(seconds)};" assert formatter.lang == "javascript"
def evolutionCharts(df): df['week']= df['snapshot'].apply(getWeekString) df = df[df['end'].notnull()] df=df.sort(['snapshot'], ascending=[1]) df['snapshotId']= range(1, len(df) + 1) source = ColumnDataSource(df) plots={'size':evolSize(source,df)} last=None for q in qa: pt = figure( plot_width=600, plot_height=200 , min_border=10, min_border_left=50 , toolbar_location="above",responsive=True) pt.background_fill_color = "#fafafa" pt.legend.location = "top_left" pt.toolbar.logo = None pt.toolbar_location = None hit_renderers = [] legends=[] for m,v in q['metrics'].items(): l=pt.line(x='snapshotId',y=m.lower(), line_width=2,source=source, color=v['color']) c=pt.circle(x='snapshotId',y=m.lower(), line_width=2,source=source, color=v['color']) # invisible circle used for hovering hit_target =Circle(x='snapshotId',y=m.lower(), size=10,line_color=None, fill_color=None) hit_renderer = pt.add_glyph(source, hit_target) legends.append((v['label']+" ["+m.lower()+"]",[l,c])) pt.add_tools(HoverTool(renderers=[hit_renderer], tooltips={'Metric':v['label'], "Week": "@week", 'Value':"@"+m.lower()})) pt.xaxis[0].ticker.desired_num_ticks = df.shape[0]/2 pt.xaxis.formatter=FuncTickFormatter.from_py_func(getWeekStringTick) pt.axis.minor_tick_line_color = None legend = Legend(location=(0, -30)) legend.items=legends pt.add_layout(legend, 'right') pt.xaxis[0].axis_label = 'Snapshot' pt.yaxis[0].axis_label = 'Average quality' plots[q['dimension']]=pt last=pt return plots
def test_functickformatter_from_coffeescript_no_arg(): coffee_code = """ square = (x) -> x * x return square(tick) """ js_code = "\n var square;\n square = function(x) {\n return x * x;\n };\n return square(tick);\n" formatter = FuncTickFormatter.from_coffeescript(code=coffee_code) function_wrapper = formatter.code.replace(js_code, "") assert function_wrapper == "var formatter;\n\nformatter = function() {};\n\nreturn formatter()" assert formatter.args == {}
def test_functickformatter_from_coffeescript_with_args(): coffee_code = dedent(""" return slider.get("value") // 2 + tick """) slider = Slider() formatter = FuncTickFormatter.from_coffeescript(code=coffee_code, args={"slider": slider}) assert formatter.code == dedent("""\ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); return Math.floor(slider.get("value") / 2) + tick; """) assert formatter.args == {"slider": slider}
def _axis_properties(self, axis, key, plot, dimension, ax_mapping={'x': 0, 'y': 1}): """ Returns a dictionary of axis properties depending on the specified axis. """ axis_props = {} if ((axis == 'x' and self.xaxis in ['bottom-bare', 'top-bare']) or (axis == 'y' and self.yaxis in ['left-bare', 'right-bare'])): axis_props['axis_label'] = '' axis_props['major_label_text_font_size'] = '0pt' axis_props['major_tick_line_color'] = None axis_props['minor_tick_line_color'] = None else: rotation = self.xrotation if axis == 'x' else self.yrotation if rotation: axis_props['major_label_orientation'] = np.radians(rotation) ticker = self.xticks if axis == 'x' else self.yticks if isinstance(ticker, Ticker): axis_props['ticker'] = ticker elif isinstance(ticker, int): axis_props['ticker'] = BasicTicker(desired_num_ticks=ticker) elif isinstance(ticker, (tuple, list)): if all(isinstance(t, tuple) for t in ticker): pass else: axis_props['ticker'] = FixedTicker(ticks=ticker) if FuncTickFormatter is not None and ax_mapping and dimension: formatter = None if dimension.value_format: formatter = dimension.value_format elif dimension.type in dimension.type_formatters: formatter = dimension.type_formatters[dimension.type] if formatter: msg = ('%s dimension formatter could not be ' 'converted to tick formatter. ' % dimension.name) try: formatter = FuncTickFormatter.from_py_func(formatter) except RuntimeError: self.warning(msg+'Ensure Flexx is installed ' '("conda install -c bokeh flexx" or ' '"pip install flexx")') except Exception as e: error = 'Pyscript raised an error: {0}'.format(e) error = error.replace('%', '%%') self.warning(msg+error) else: axis_props['formatter'] = formatter return axis_props
def test_functickformatter_from_py_func_with_args(): slider = Slider() def convert_to_minutes(x=slider): return tick * 60 # noqa formatter = FuncTickFormatter.from_py_func(convert_to_minutes) js_code = flexx.pyscript.py2js(convert_to_minutes, 'formatter') function_wrapper = formatter.code.replace(js_code, '') assert function_wrapper == "formatter(x);\n" assert formatter.args['x'] is slider
def test_functickformatter_from_coffeescript_no_arg(): coffee_code = dedent(""" square = (x) -> x * x return square(tick) """) formatter = FuncTickFormatter.from_coffeescript(code=coffee_code) assert formatter.code == dedent("""\ var square; square = function (x) { return x * x; }; return square(tick); """) assert formatter.args == {}
def test_functickformatter_from_coffeescript_no_arg(): coffee_code = dedent(""" square = (x) -> x * x return square(tick) """) formatter = FuncTickFormatter.from_coffeescript(code=coffee_code) assert formatter.code == dedent("""\ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var square; square = function (x) { return x * x; }; return square(tick); """) assert formatter.args == {}
def test_functickformatter_bad_pyfunc_formats(): def has_positional_arg(x): return None with pytest.raises(ValueError): FuncTickFormatter.from_py_func(has_positional_arg) def has_positional_arg_with_kwargs(y, x=5): return None with pytest.raises(ValueError): FuncTickFormatter.from_py_func(has_positional_arg_with_kwargs) def has_non_Model_keyword_argument(x=10): return None with pytest.raises(ValueError): FuncTickFormatter.from_py_func(has_non_Model_keyword_argument)
df['Gun_Seconds'] = map(lambda i: time_to_seconds(i),df['Gun Tim']) df['Pace'] = map(lambda i: time_to_seconds(i),df['Pace']) #df['Net Tim']= map(lambda i: if (str(i).split(':')),df['Div/Tot']) together = pd.concat(dfs) together['Rank'] = together['Net_Seconds'].rank() gun_color_women ="#ff3399" gun_color_men ='#0000ff' net_color_women ="#9900cc" net_color_men = "#006666" ####PLOT ONE#### DATA DISTRIBUTIONS - GUN TIME plot_one = figure(plot_width=900,plot_height=500) plot_one.xaxis.formatter = FuncTickFormatter.from_py_func(seconds_formatted) #hover_one =HoverTool( # tooltips=[ # ("index", "$index"), # ("(x,y)", "($x, $y)"), # ("desc", "@desc"), # ] # ) plot_one.add_tools(HoverTool()) #WOMEN density = stats.kde.gaussian_kde(females['Gun_Seconds'].dropna()) x = np.arange(0.,max(females['Gun_Seconds'].dropna()), 1) y = [density(y) for y in x]