def test_band(output_file_url, selenium, screenshot):
x_range = Range1d(0, 10)
y_range = Range1d(0, 10)
# Have to specify x/y range as labels aren't included in the plot area solver
plot = Plot(plot_height=HEIGHT,
plot_width=WIDTH,
x_range=x_range,
y_range=y_range,
toolbar_location=None)
source = ColumnDataSource(data=dict(
x1=[1, 3, 5, 7, 9],
lower1=[1, 2, 1, 2, 1],
upper1=[2, 3, 2, 3, 2],
x2=[200, 250, 350, 450, 550],
lower2=[400, 300, 400, 300, 400],
upper2=[500, 400, 500, 400, 500],
))
band1 = Band(base='x1',
lower='lower1',
upper='upper1',
line_width=3,
line_color='red',
line_dash='dashed',
source=source)
band2 = Band(base='x2',
lower='lower2',
upper='upper2',
base_units='screen',
lower_units='screen',
upper_units='screen',
dimension='width',
line_width=3,
fill_color='blue',
line_color='green',
source=source)
plot.add_layout(band1)
plot.add_layout(band2)
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Take screenshot
screenshot.assert_is_valid()
def plot(self, figure):
source = self.asColumnDataSource()
figure.title.text = self.title
for party in self.parties:
color = self.party_to_color[party]
figure.circle('Date', party, source=source, size=4, color=color, alpha=0.1)
figure.line('Date', party + '_mean', source=source, color=color)
band = Band(
base='Date',
lower=party + '_low',
upper=party + '_up',
source=source,
level='underlay',
fill_alpha=0.2,
line_width=1,
fill_color=color)
figure.add_layout(band)
if self.results:
election_result = Span(
location=self.results[party],
dimension='width',
line_color=color,
line_width=2)
figure.add_layout(election_result)
self._plot_next_election(figure)
self._plot_today(figure)
return figure
def plot_data(data, ticker):
p = bk.figure(x_axis_type='datetime')
p.xaxis.axis_label = 'Date'
p.yaxis.axis_label = 'Price'
p.line(data['Date'],
data['Open'],
legend=ticker + ' Open',
line_color="green")
p.line(data['Date'], data['Close'], legend=ticker + ' Close')
p.line(data['Date'],
data['High'],
legend=ticker + ' High',
line_color='red')
p.line(data['Date'],
data['Low'],
legend=ticker + ' Low',
line_color='orange')
source = ColumnDataSource({
'base': data['Date'],
'lower': data['Low'],
'upper': data['High']
})
band = Band(base='base',
lower='lower',
upper='upper',
source=source,
level='underlay',
fill_alpha=1.0,
line_width=1,
line_color='black')
p.add_layout(band)
return p
def init(self, doc):
# Source must only be modified through a stream
self.source = ColumnDataSource(data=self.data)
self.colors[0] = 'cyan'
#self.source = ColumnDataSource(data=self.data[self.scale])
# Enable theming
theme = Theme(
os.path.dirname(os.path.abspath(__file__)) + '/theme.yaml')
doc.theme = theme
self.doc = doc
fig = figure(plot_width=600,
plot_height=400,
tools='xpan,xwheel_zoom, xbox_zoom, reset, save',
title=self.title,
x_axis_label=self.XAXIS,
y_axis_label=self.ylabel)
# Initialize plots
for i, key in enumerate(self.keys):
fig.line(source=self.source,
x=self.x,
y=key,
color=self.colors[i],
line_width=LINE_WIDTH,
legend_label=key)
band = Band(source=self.source,
base=self.x,
lower=key + 'lower',
upper=key + 'upper',
level='underlay',
line_color=self.colors[i],
line_width=1,
line_alpha=0.2,
fill_color=self.colors[i],
fill_alpha=0.2)
fig.add_layout(band)
def switch_scale(attr, old, new):
"""Callback for RadioButtonGroup to switch tick scale
and refresh document
Args:
attr: variable to be changed, in this case 'active'
old: old index of active button
new: new index of active button
"""
self.scale = self.scales[new]
self.source.data = self.data[self.scale]
self.timescales = RadioButtonGroup(
labels=[str(scale) for scale in self.scales],
active=self.scales.index(self.scale))
self.timescales.on_change('active', switch_scale)
self.structure = layout([[self.timescales], [fig]])
self.doc.add_root(self.structure)
self.fig = fig
def test_Band() -> None:
band = Band()
assert band.level == 'annotation'
assert band.lower == field("lower")
assert band.lower_units == 'data'
assert band.upper == field("upper")
assert band.upper_units == 'data'
assert band.base == field("base")
assert band.dimension == 'height'
assert isinstance(band.source, ColumnDataSource)
assert band.x_range_name == 'default'
assert band.y_range_name == 'default'
check_line_properties(band, "", "#cccccc", 1.0, 0.3)
check_fill_properties(band, "", "#fff9ba", 0.4)
check_properties_existence(
band, ANNOTATION + [
"lower",
"lower_units",
"upper",
"upper_units",
"base",
"base_units",
"dimension",
"source",
], LINE, FILL)
def plot_classification(point, ideal_function):
"""
plots the classification function and a point on top. It also displays the tolerance
:param point: a dict with "x" and "y"
:param ideal_function: a classification object
"""
if ideal_function is not None:
classification_function_dataframe = ideal_function.dataframe
point_str = "({},{})".format(point["x"], round(point["y"], 2))
title = "point {} with classification: {}".format(point_str, ideal_function.name)
p = figure(title=title, x_axis_label='x', y_axis_label='y')
# draw the ideal function
p.line(classification_function_dataframe["x"], classification_function_dataframe["y"],
legend_label="Classification function", line_width=2, line_color='black')
# procedure to show the tolerance within the graph
criterion = ideal_function.tolerance
classification_function_dataframe['upper'] = classification_function_dataframe['y'] + criterion
classification_function_dataframe['lower'] = classification_function_dataframe['y'] - criterion
source = ColumnDataSource(classification_function_dataframe.reset_index())
band = Band(base='x', lower='lower', upper='upper', source=source, level='underlay',
fill_alpha=0.3, line_width=1, line_color='green', fill_color="green")
p.add_layout(band)
# draw the point
p.scatter([point["x"]], [round(point["y"], 4)], fill_color="red", legend_label="Test point", size=8)
return p
def update(self):
if self.test_done and not self.analysed:
self.btn.label = 'Test Complete'
np.savetxt('test.txt', np.column_stack((self.x, self.y)))
x = np.array(self.x)
y = np.array(self.y)
results = analyse_data(x, y, 7, 3)
tmeans, fmeans, e_fmeans, msg, _critical_load, load_asymptote, predicted_force = results
self.results_div.text = msg
fill_src = ColumnDataSource(dict(x=tmeans, upper=predicted_force,
lower=load_asymptote*np.ones_like(tmeans)))
self.fig.add_layout(
Band(base='x', lower='lower', upper='upper', source=fill_src, fill_alpha=0.7)
)
self.fig.circle(tmeans, fmeans, color='red', size=5, line_alpha=0)
esource = ColumnDataSource(dict(x=tmeans, upper=fmeans+e_fmeans, lower=fmeans-e_fmeans))
self.fig.add_layout(
Whisker(source=esource, base='x', upper='upper', lower='lower', level='overlay')
)
self.analysed = True
else:
if self.tindeq is not None:
self.btn.label = 'Start Test'
self.state.update(self)
self.source.stream({'x': self.xnew, 'y': self.ynew})
nlaps = self.duration // 10
self.laps.text = f"Rep {1 + nlaps - self.reps}/{nlaps}"
self.reset()
def plot(env: str, var: str = 'duration', n_steps:List = None, ncols:int = 3, win:int = 20, standalone:bool = False):
"""
env: which enviroment to plot for
var: which variable to plot against the episodes
n_steps: list of n steps to plot for
ncols: numbe rof columns in the output
win: size of the smoothing avg window
standalone: to plto also standalone
"""
df = load_csv(env)
# df = pd.read_csv('data/CartPole-v0.csv', dialect='unix')
cnf = {True: {'legend': 'Semi-gradient', 'color': '#66C2A5'},
False: {'legend': 'Full-gradient', 'color': '#FC8D62'}}
varnames = {'G': 'Return',
'duration': 'Length of episode'}
if n_steps is None:
n_steps = sorted(df.n_step.unique())
figs = []
for n_step in n_steps:
step_df = df[df.n_step == n_step]
fig = figure(title=f'{varnames.get(var, var)} using {n_step}-step TD', active_scroll='wheel_zoom')
for semi in (True, False):
# _df = step_df[df.semi_gradient == semi]
# fig.circle(_df.episode, _df[var], legend=cnf[semi]['legend'], line_color=cnf[semi]['color'])
mean_df = step_df[df.semi_gradient == semi].groupby(['episode']).agg({var: ['mean', 'std', 'min', 'max']})
# Smooth the curves
mean_df = mean_df.rolling(win, min_periods=1).mean()
mean_df = mean_df.fillna(0)
# Plot the mean line
fig.line(mean_df.index, mean_df[var]['mean'], legend=cnf[semi]['legend'], line_color=cnf[semi]['color'], line_width=2)
# Plot the std band
mean_df['upper'] = mean_df[var]['mean'] + mean_df[var]['std'] / 2
mean_df['lower'] = mean_df[var]['mean'] - mean_df[var]['std'] / 2
# mean_df['upper'] = mean_df[var]['max']
# mean_df['lower'] = mean_df[var]['min']
source = ColumnDataSource(mean_df)
band = Band(base='episode', lower='lower_', upper='upper_', source=source, level='underlay',
fill_alpha=.1, line_width=0, fill_color=cnf[semi]['color'])
fig.add_layout(band)
figs.append(fig)
grid = gridplot(figs, ncols=ncols, sizing_mode='stretch_both', toolbar_location='below')
html_components = '\n'.join(components(grid))
path = os.path.join(os.getcwd(), 'docs/_includes', f'{env}_{var}.html')
print(f'Save plot to {path}')
with open(path, 'w') as fp:
fp.write(html_components)
if standalone:
html_standalone = file_html(grid, CDN, f"{env}_{var}")
path = os.path.join(os.getcwd(), 'docs/_includes', f'{env}_{var}_standalone.html')
with open(path, 'w') as fp:
fp.write(html_standalone)
def update(self, data_dict):
for plot, fig in zip(self.plots, self.figures):
try:
try:
key, idx = fig.title.text.split('-')
data = data_dict[key][int(idx)]
except ValueError:
data = data_dict[fig.title.text]
except KeyError:
if self.i == 0:
pass
else:
continue
new_data = dict()
if self.i == 0:
if fig.title.text == 'samples':
fig.xaxis.axis_label = 'phi'
fig.yaxis.axis_label = 'phi_dot'
new_data['x'], new_data['y'], *_ = [data[0], data[1]]
elif fig.title.text == 'model_ranges':
new_data = {'lower': [1.0], 'upper': [1.0], 'x': [self.i], 'y': [1.0]}
plot.data_source.data.update(new_data)
self.band = Band(base='x', lower='lower', upper='upper', source=plot.data_source, level='underlay',
fill_alpha=1.0, line_width=1, line_color='black')
fig.add_layout(self.band)
fig.xaxis.axis_label = 'iteration'
else:
fig.xaxis.axis_label = 'iteration'
new_data['x'] = [self.i]
new_data['y'] = [data]
else:
if fig.title.text == 'samples':
new_data['x'] = plot.data_source.data['x'] + data[0]
new_data['y'] = plot.data_source.data['y'] + data[1]
elif fig.title.text == 'model_ranges':
new_data['x'] = plot.data_source.data['x'] + [self.i]
new_data['y'] = plot.data_source.data['y'] + [data['y']]
new_data['lower'] = plot.data_source.data['lower'] + [data['lower']]
new_data['upper'] = plot.data_source.data['upper'] + [data['upper']]
fig.y_range = Range1d(np.min(plot.data_source.data['lower']), 2)
else:
new_data['x'] = plot.data_source.data['x'] + [self.i]
new_data['y'] = plot.data_source.data['y'] + [data]
plot.data_source.data.update(new_data)
self.i += 1
push_notebook(handle=self.plot_handle)
def test_Whisker_and_Band_accept_negative_values() -> None:
whisker = Whisker(base=-1., lower=-1.5, upper=-0.5)
assert whisker.base == -1.
assert whisker.lower == -1.5
assert whisker.upper == -0.5
band = Band(base=-1., lower=-1.5, upper=-0.5)
assert band.base == -1.
assert band.lower == -1.5
assert band.upper == -0.5
def create_plot(source, x, y, depth, sat_position, title):
depth_is_positive = depth.startswith("+")
depth_coordinate = depth[1]
plot = figure(
plot_height=400,
plot_width=400,
title=title,
match_aspect=True,
aspect_scale=1,
tools="",
x_range=[-constants.PLOTS_RANGE, constants.PLOTS_RANGE],
y_range=[-constants.PLOTS_RANGE, constants.PLOTS_RANGE],
background_fill_color=colors["background"],
border_fill_color=colors["elements-background"],
outline_line_alpha=0,
)
plot.title.text_color = colors["text-dimmed"]
plot.grid.visible = False
plot.axis.visible = False
plot.line(
x,
y,
source=source,
line_width=3,
line_dash="dashed",
line_color=colors["orbit"],
)
plot.circle(
x,
y,
source=source,
view=generate_view(source, depth_coordinate, depth_is_positive),
size=5,
color=colors["orbit"],
)
plot.circle(
x,
y,
source=sat_position,
color=colors["satellite"],
size=10,
)
plot.add_layout(
Band(
base="x",
lower="lower",
upper="upper",
source=earth,
level="underlay",
fill_alpha=0.5,
line_width=1,
line_color=colors["earth"],
fill_color=colors["earth"],
)
)
return plot
def add_band(f, x, ylo, yhi, source, color, alpha=0.3, y_range_name='default'):
band = Band(base=x,
lower=ylo,
upper=yhi,
source=ColumnDataSource(source),
fill_color=color,
fill_alpha=alpha,
line_width=1,
line_color=color,
y_range_name=y_range_name)
f.add_layout(band)
def add_band(self, x_column, source, max_values_column, min_values_column):
# add a 'confidence interval' or band to the figure
max_min_interval = Band(base=x_column,
lower=max_values_column,
upper=min_values_column,
source=ColumnDataSource(source),
level='underlay',
fill_alpha=1.0,
line_width=1,
line_color='black')
self.p.add_layout(max_min_interval)
def SFH_plot(DB, SDB, gid):
rshift = DB.query('id == {}'.format(gid)).zgrism.values[0]
t50 = DB.query('id == {}'.format(gid)).t_50.values[0]
t50_err = DB.query('id == {}'.format(gid)).t_50_hdr.values[0]
t50_l = t50_err[0]
t50_h = t50_err[1]
x = np.linspace(t50_l, t50_h, 100)
top = interp1d(SDB.LBT,SDB['{}_84'.format(gid)])(x)
bottom = interp1d(SDB.LBT,SDB['{}_16'.format(gid)])(x)
df = pd.DataFrame({'x':x, 'top':top, 'bottom':bottom})
source = ColumnDataSource(df)
LBT = SDB.LBT
SFH = SDB['{}'.format(gid)]
LBT = LBT[SFH**2 > 0]
SFH = SFH[SFH**2 > 0]
zs = [z_at_value(cosmo.lookback_time,(U*u.Gyr + cosmo.lookback_time(rshift)),
zmax=1E6) for U in LBT]
src_sfh = ColumnDataSource(data = {'LBT':LBT,'SFH':SFH, 'z':zs })
sfh = figure(plot_width = 900, plot_height = 350, x_axis_label ='Lookback Time (Gyr)',
y_axis_label = 'SFR (M/yr)')
for i in range(90):
sfh.line(SDB.LBT.values, SDB['{}_x_{}'.format(gid, i)].values, color = '#532436', alpha=.075)
r1 = sfh.line(source = src_sfh, x = 'LBT', y='SFH', color = '#C1253C', line_width = 2)
sfh.line(SDB.LBT,SDB['{}_16'.format(gid)], color ='black', line_width = 2)
sfh.line(SDB.LBT,SDB['{}_84'.format(gid)], color ='black', line_width = 2)
sfh.line([t50, t50], [interp1d(SDB.LBT,SDB['{}_16'.format(gid)])(t50),
interp1d(SDB.LBT,SDB['{}_84'.format(gid)])(t50)],line_width=2.4, color = 'black')
sfh.line([t50, t50], [interp1d(SDB.LBT,SDB['{}_16'.format(gid)])(t50),
interp1d(SDB.LBT,SDB['{}_84'.format(gid)])(t50)],line_width=2, color = '#ED2D39')
band = Band(base='x', lower='top', upper='bottom', source=source, level='underlay',
fill_color = '#4E7577', fill_alpha=0.7, line_width=1, line_color='black')
sfh.add_layout(band)
sfh.add_tools(HoverTool(tooltips = [('Lookback time', '@LBT'),
('SFH', '@SFH'), ('z', '@z')], renderers = [r1]))
sfh.xaxis.axis_label_text_font_size = "20pt"
sfh.yaxis.axis_label_text_font_size = "20pt"
sfh.xaxis.major_label_text_font_size = "15pt"
sfh.yaxis.major_label_text_font_size = "15pt"
return sfh
def plot_pr_curve(pr_curve, auprc, model_name=None, file_name=None):
if model_name is None:
model_name = ""
else:
model_name += ": "
p = figure(
plot_width=600,
plot_height=400,
title=f"{model_name}Precision - Recall Curve",
x_axis_label="Recall",
y_axis_label="Precision",
)
source = dict(zip(["recall", "precision", "thr"], pr_curve))
source["lower_band"] = np.repeat(0.0, source["recall"].shape[0])
source = ColumnDataSource(source)
_ = p.line(
x="recall",
y="precision",
color="coral",
line_width=1.0,
legend_label=f"AUPRC: {auprc:.2%}",
source=source,
)
band = Band(
base="recall",
lower="lower_band",
upper="precision",
level="underlay",
fill_color="coral",
fill_alpha=0.2,
source=source,
)
p.add_layout(band)
p.xgrid.grid_line_color = None
p.xaxis.formatter = NumeralTickFormatter(format="0%")
p.yaxis.formatter = NumeralTickFormatter(format="0%")
p.legend.label_text_font_size = "8pt"
p.legend.location = "top_right"
p.title.align = "center"
p.title.text_font_size = "12pt"
show(p)
if file_name is not None:
p.output_backend = "svg"
_ = export_svgs(p, filename=file_name)
def add_band(x, y, minimum, maximum, plot, alpha, color='lightsteelblue'):
dftemp = pd.DataFrame(data=dict(x=x, y=y[0])).sort_values(by="x")
dftemp['upper'] = minimum
dftemp['lower'] = maximum
source = ColumnDataSource(dftemp.reset_index())
band = Band(base='x',
lower='lower',
upper='upper',
source=source,
level='underlay',
fill_alpha=alpha,
line_width=0.3,
line_color='black',
fill_color=color,
line_dash='dashed')
plot.add_layout(band)
def create_stock_plot(ti, d1, d2):
#getting stock data from ticker input
data = q.get_table(
'WIKI/PRICES',
paginate=True,
ticker=ti,
date={
'gte': d2,
'lte': d1
},
qopts={"columns": ["ticker", "date", "close", "low", "high"]})
#creating dictionary database to plot
df = pd.DataFrame(data=dict(
x=data.date, y=data.close, low=data.low, high=data.high)).sort_values(
by="x")
source = ColumnDataSource(df.reset_index())
t1 = "Closing Cost with High/Low Reach Band for Stock: %s" % (ti)
t2 = "From %s to %s" % (d2, d1)
#creating figure
p = figure(title=t1,
plot_width=700,
plot_height=500,
x_axis_type="datetime")
p.y_range = Range1d(data.low[data.low.idxmin()] - 2,
data.high[data.high.idxmax()] + 2)
p.xaxis.axis_label = 'Days'
p.yaxis.axis_label = 'Value in USD'
p.line('x', 'y', color='firebrick', source=source, line_width=2)
band = Band(base='x',
lower='low',
upper='high',
level='underlay',
source=source,
fill_alpha=0.5,
line_width=1,
line_color='black',
fill_color='grey')
p.add_layout(band)
p.add_layout(Title(text=t2, align="center"), "below")
return p
def init(self, doc):
#Source must only be modified through a stream
self.source = ColumnDataSource(data=self.data)
#Enable theming
theme = Theme('forge/blade/core/market/theme.yaml')
doc.theme = theme
self.doc = doc
fig = figure(
plot_width=600,
plot_height=400,
tools='pan,xwheel_zoom,box_zoom,save,reset',
title='Neural MMO: Market Data',
x_axis_label=self.x,
y_axis_label=self.ylabel)
#Initialize plots
for i, key in enumerate(self.keys):
fig.line(
source=self.source,
x=self.x,
y=key,
color=self.colors[i],
line_width=LINE_WIDTH,
legend_label=key)
band = Band(
source=self.source,
base=self.x,
lower=key+'lower',
upper=key+'upper',
level='underlay',
line_color=self.colors[i],
line_width=1,
line_alpha=0.2,
fill_color=self.colors[i],
fill_alpha=0.2)
fig.add_layout(band)
#Set root
self.doc.add_root(fig)
self.fig = fig
def make_control_chart(dictionary, id):
source = AjaxDataSource(data_url=request.url_root + 'control-chart/' + id +
"/",
polling_interval=1000,
mode='replace')
source.data = dictionary
keys = [
key for key in dictionary
if not (key.endswith("_lower") or (key.endswith("_upper")))
]
figures = []
for key in keys:
if key == "time_stamp": continue
plot = figure(plot_height=300,
sizing_mode='scale_width',
x_axis_type="datetime")
band = Band(
base="time_stamp",
lower=key + '_lower',
upper=key + '_upper',
source=source,
level='underlay',
fill_alpha=0.4,
line_width=1,
fill_color='#55FF88',
line_color='red',
line_dash='dashed',
)
plot.add_layout(band)
plot.line('time_stamp', key, source=source, line_width=4)
plot.circle('time_stamp',
key,
source=source,
line_width=4,
color="red")
figures.append(plot)
script, div = components(column(figures))
return script, div
def st_plot_wind_pressure(self):
"""
Plot wind pressure along the sign face.
The value may change for 45 degrees and a large aspect ratio.
"""
#Set up plot
plot = Plot()
#Graph of Drag Factors along sign
x = np.linspace(0, self.sign_w, num=50)
if self.wind.loadcase is Cases.FAT:
y = [
0.5 * 1.2 * self.wind.V_sit_beta.value**2 * self.C_dyn / 1000 *
self.C_fig for ix in x
]
else:
y = [
0.5 * 1.2 * self.wind.V_sit_beta.value**2 *
self.C_dyn * self.K_p / 1000 * self.C_pn_func(
self.sign_w, self.sign_h, self.wind.Wind_mult.height, ix)
for ix in x
]
source = ColumnDataSource(dict(x=x, y=y))
drag_factor = Line(x='x', y='y', line_color="#f46d43", line_width=3)
plot.add_glyph(source, drag_factor)
#Fille area under line
fill_under = Band(base='x',
upper='y',
source=source,
level='underlay',
fill_color='#55FF88')
plot.add_layout(fill_under)
#Plot setup
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
plot.xaxis.axis_label = "Distance along sign (m)"
plot.yaxis.axis_label = "Wind Pressure (kPa)"
plot.y_range = Range1d(0, max(y) * 1.3)
return plot
def draw_prediction_band(region, conf_level, **kwargs):
plot_params = {'line_alpha': 0, 'fill_alpha': 0.4}
plot_params.update(kwargs)
L, x0, k, L_std, x0_std, k_std = params_CDS.data[region]
xs = np.arange(lines_CDS.data['date'].size)
offset = get_offset_from_start_date(region)
bands_CDS.data[f'{region}_lower'], bands_CDS.data[
f'{region}_upper'] = (logistic_function(
xs, L - L_std * z_star(conf_level), x0 + offset, k),
logistic_function(
xs, L + L_std * z_star(conf_level),
x0 + offset, k))
bands[region] = Band(base='date',
lower=f'{region}_lower',
upper=f'{region}_upper',
source=bands_CDS,
level='underlay',
**plot_params)
plot.add_layout(bands[region])
def plot_hr_profile(df_ts, x='s', y='BPM'):
p = figure(
width=450,
height=325,
title=f'Workout heart rate profile',
x_axis_label='Time (seconds)',
y_axis_label='BPM',
toolbar_location="above",
tools='box_zoom,undo,redo,reset',
tooltips=[
('Time', '@Time'),
('BPM', '@BPM'),
]
)
cds = ColumnDataSource(df_ts)
p.line(x, y, source=cds, color="black", alpha=0)
band = Band(base='s', upper=y, source=cds, level='underlay',
fill_alpha=0.90, fill_color='#ab383a') #e73360
p.add_layout(band)
return p, cds
def plot_cs_prof(alg, instr, filename):
def update_triangle(source):
return CustomJS(args=dict(source=source, xr=p.x_range),
code="""
var data = source.data;
var x = data["size"]
var range = data["range"]
var cond = range[0] / (xr.end - xr.start)
if (Math.abs(cond - 1) > 0.001)
for (var i = 0; i < x.length; i++) {
x[i] = x[i] * cond;
range[i] = xr.end - xr.start
}
source.change.emit();
""")
timeframe = instr.timeframe
close_df = pd.DataFrame(columns=[
'time', 'close_price', 'open_price_oncl', 'close_side', 'last_indic',
'profit'
])
open_df = pd.DataFrame(columns=[
'time', 'open_price', 'close_price_onop', 'open_side', 'first_indic',
'profit'
])
for pos in alg.positions:
pos_trades = pos.trades
for j in range(len(pos_trades)):
if pos.closed:
if j < len(pos_trades) - 1:
close_df = close_df.append(
pd.DataFrame([[
pos_trades[j].close_time,
pos_trades[j].close_price,
pos_trades[j].open_price, pos_trades[j].side, 0, 0
]],
columns=[
'time', 'close_price',
'open_price_oncl', 'close_side',
'last_indic', 'profit'
]))
elif pos_trades[j].close_time > 0:
close_df = close_df.append(
pd.DataFrame([[
pos_trades[j].close_time,
pos_trades[j].close_price,
pos_trades[j].open_price, pos_trades[j].side, 1,
pos.profit
]],
columns=[
'time', 'close_price',
'open_price_oncl', 'close_side',
'last_indic', 'profit'
]))
if j > 0:
open_df = open_df.append(
pd.DataFrame([[
pos_trades[j].open_time, pos_trades[j].open_price,
pos_trades[j].close_price, pos_trades[j].side, 0,
pos.profit
]],
columns=[
'time', 'open_price', 'close_price_onop',
'open_side', 'first_indic', 'profit'
]))
else:
open_df = open_df.append(pd.DataFrame([[
pos_trades[j].open_time, pos_trades[j].open_price,
pos_trades[j].close_price, pos_trades[j].side, 1,
pos.profit
]],
columns=[
'time', 'open_price',
'close_price_onop',
'open_side',
'first_indic',
'profit'
]),
ignore_index=True)
df = pd.DataFrame(instr.candles)
opendf_len = len(open_df)
closedf_len = len(close_df)
df['size'] = 12.0
close_df['size'] = 12.0
open_df['size'] = 12.0
df["date"] = pd.to_datetime(df["time"].astype(str),
format='%Y%m%d%H%M%S%f')
timedelta = df['date'][len(df) -
1] - df['date'][len(df) -
1].floor(str(timeframe) + 'T')
df = df.drop(['time'], axis=1)
close_df["date"] = pd.to_datetime(close_df["time"].astype(str),
format='%Y%m%d%H%M%S%f')
close_df = close_df.drop(['time'], axis=1)
open_df["date"] = pd.to_datetime(open_df["time"].astype(str),
format='%Y%m%d%H%M%S%f')
open_df = open_df.drop(['time'], axis=1)
df = df.sort_values(by=['date'])
close_df = close_df.sort_values(by=['date'])
open_df = open_df.sort_values(by=['date'])
df = df.reset_index()
df['index'] = df.index
close_df = close_df.reset_index()
open_df = open_df.reset_index()
df['index'] = df['index'].astype(np.float64)
close_df['index'] = df['index'].astype(np.float64)
open_df['index'] = df['index'].astype(np.float64)
close_df = reindex_by_df(close_df, df, timeframe)
open_df = reindex_by_df(open_df, df, timeframe)
w = (0.5)
output_file(filename, title="Graphs")
TOOLS = "pan,wheel_zoom,reset,save"
inc = df['close'] > df['open']
dec = ~inc
ind_close = close_df["last_indic"] == 1
ind_close_subseq = close_df["last_indic"] == 0
ind_close_pos = close_df['close_side'] == -1
ind_open_subseq = open_df["first_indic"] == 0
ind_open = open_df["first_indic"] == 1
ind_open_pos = open_df['open_side'] == -1
max_range = (df['high'] - df['low']).max()
range_constant = 31 if len(df) - 31 > 0 else len(df)
min_low_range = df['low'][:range_constant].min()
max_high_range = df['high'][:range_constant].max()
p = figure(title="Candlestick chart with timeframe = " + str(timeframe) +
" munutes",
x_axis_type="linear",
tools=TOOLS,
plot_width=1000,
toolbar_location="left",
x_range=(-1.5, 30),
y_range=(min_low_range - max_range / 2,
max_high_range + max_range / 2))
df['range'] = p.x_range.end - p.x_range.start
close_df['range'] = p.x_range.end - p.x_range.start
open_df['range'] = p.x_range.end - p.x_range.start
p.segment(df['index'], df['high'], df['index'], df['low'], color="black")
min_diff = np.fabs(df['close'] - df['open'])
min_diff = min_diff[min_diff > 0].min()
prec = "0"
for i in range(0, 16):
if min_diff * 10**i >= 1:
prec = prec * i
break
df['close_eq'] = df['close'] + min_diff
df.loc[df['close'] + min_diff > df['high'],
'close_eq'] = df['close'] - min_diff
ind_eq = df['close'] == df['open']
df['index'] = df.index
mysource1 = ColumnDataSource(df[inc])
mysource2 = ColumnDataSource(df[dec])
mysource3 = ColumnDataSource(df[ind_eq])
bars_1 = p.vbar(source=mysource1,
x="index",
width=w,
bottom="open",
top="close",
fill_color="honeydew",
line_color="black",
line_width=1)
bars_2 = p.vbar(source=mysource2,
x="index",
width=w,
bottom="close",
top="open",
fill_color="deepskyblue",
line_color="black",
line_width=1)
bars_3 = p.vbar(source=mysource3,
x="index",
width=w,
bottom="close_eq",
top="open",
fill_color="white",
line_color="black",
line_width=1,
fill_alpha=0.0)
hover = HoverTool(renderers=[bars_1, bars_2, bars_3],
tooltips=[('high', '@high{0.' + str(prec) + '}'),
('low', '@low{0.' + str(prec) + '}'),
('open', '@open{0.' + str(prec) + '}'),
('close', '@close{0.' + str(prec) + '}'),
('volume', '@vol{0.0}'),
('date', "@date{%Y-%m-%d %H:%M:%S}")],
formatters={"date": "datetime"})
p.add_tools(hover)
p.xaxis.major_label_overrides = {
i: date.strftime('%Y-%m-%d %H:%M:%S')
for i, date in enumerate(df["date"])
}
if (opendf_len > 0):
open_df['time'] = open_df['date'].dt.floor(str(timeframe) +
'T') + timedelta
source1 = ColumnDataSource(open_df[ind_open
& (open_df['open_side'] == 1)])
source2 = ColumnDataSource(open_df[ind_open
& (open_df['open_side'] == -1)])
source5 = ColumnDataSource(open_df[ind_open_subseq
& (open_df['open_side'] == 1)])
source6 = ColumnDataSource(open_df[ind_open_subseq
& (open_df['open_side'] == -1)])
tr_1 = p.triangle(x="index",
y="open_price",
size="size",
fill_alpha=0.7,
source=source1,
fill_color="green")
inv_tr_1 = p.inverted_triangle(x="index",
y="open_price",
size="size",
fill_alpha=0.7,
source=source2,
fill_color="green")
tr_3 = p.triangle(x="index",
y="open_price",
size="size",
fill_alpha=0.7,
source=source5,
fill_color="purple")
inv_tr_3 = p.inverted_triangle(x="index",
y="open_price",
size="size",
fill_alpha=0.7,
source=source6,
fill_color="purple")
p.x_range.js_on_change('start', update_triangle(source1))
p.x_range.js_on_change('start', update_triangle(source2))
p.x_range.js_on_change('start', update_triangle(source5))
p.x_range.js_on_change('start', update_triangle(source6))
hover1 = HoverTool(renderers=[tr_1, inv_tr_1, tr_3, inv_tr_3],
tooltips=[
('open_price',
'@open_price{0.' + str(prec) + '}'),
('close_price_onop',
'@close_price_onop{0.' + str(prec) + '}'),
('date', "@date{%Y-%m-%d %H:%M:%S}")
],
formatters={"date": "datetime"})
p.add_tools(hover1)
if (closedf_len > 0):
close_df['time'] = close_df['date'].dt.floor(str(timeframe) +
'T') + timedelta
source3 = ColumnDataSource(close_df[ind_close
& (close_df['close_side'] == 1)])
source4 = ColumnDataSource(close_df[ind_close
& (close_df['close_side'] == -1)])
source7 = ColumnDataSource(close_df[ind_close_subseq
& (close_df['close_side'] == 1)])
source8 = ColumnDataSource(close_df[ind_close_subseq
& (close_df['close_side'] == -1)])
tr_2 = p.inverted_triangle(x="index",
y="close_price",
size="size",
fill_alpha=0.7,
source=source3,
fill_color="yellow")
inv_tr_2 = p.triangle(x="index",
y="close_price",
size="size",
fill_alpha=0.7,
source=source4,
fill_color="yellow")
tr_4 = p.inverted_triangle(x="index",
y="close_price",
size="size",
fill_alpha=0.7,
source=source7,
fill_color="brown")
inv_tr_4 = p.triangle(x="index",
y="close_price",
size="size",
fill_alpha=0.7,
source=source8,
fill_color="brown")
p.x_range.js_on_change('start', update_triangle(source3))
p.x_range.js_on_change('start', update_triangle(source4))
p.x_range.js_on_change('start', update_triangle(source7))
p.x_range.js_on_change('start', update_triangle(source8))
hover2 = HoverTool(renderers=[tr_2, inv_tr_2, tr_4, inv_tr_4],
tooltips=[('close_price',
'@close_price{0.' + str(prec) + '}'),
('open_price_oncl',
'@open_price_oncl{0.' + str(prec) + '}'),
('date', "@date{%Y-%m-%d %H:%M:%S}")],
formatters={"date": "datetime"})
p.add_tools(hover2)
p.yaxis.axis_label = 'Price'
p.xaxis.major_label_orientation = 3.14 / 4
p.grid.grid_line_alpha = 0.5
point_attributes = ['x', 'y', 'sx', 'sy']
wheel_attributes = point_attributes + ['delta']
close_df = close_df[close_df['last_indic'] == 1]
close_df.loc[np.isnan(close_df['profit']), 'profit'] = 0.0
prof = close_df['profit'].iloc[-1]
if (open_df['date'].iloc[-1] > close_df['date'].iloc[-1]):
prof = open_df['profit'].iloc[-1]
first_el = df.iloc[0]
first_el = first_el.to_frame().T
first_el['profit'] = 0.0
last_el = df.iloc[-1]
last_el = last_el.to_frame().T
last_el['profit'] = prof
last_el['date'] = last_el['date'] + dt.timedelta(minutes=timeframe)
close_df = close_df.append(first_el, sort=True)
close_df = close_df.append(last_el, sort=True)
close_df = close_df.sort_values(by=['date'])
close_df = close_df.reset_index()
close_df['cumsum'] = close_df['profit'].cumsum(skipna=True)
close_df['pos'] = 0.0
close_df['pos'] = close_df.loc[close_df['cumsum'] > 0, 'cumsum']
close_df.loc[np.isnan(close_df['pos']), 'pos'] = 0
close_df['neg'] = 0.0
close_df['neg'] = close_df.loc[close_df['cumsum'] < 0, 'cumsum']
close_df.loc[np.isnan(close_df['neg']), 'neg'] = 0.0
close_df['zeros'] = 0.0
plot_prof = figure(
title="Profit plot",
x_axis_type="datetime",
tools=TOOLS,
plot_width=1000,
toolbar_location="left",
x_range=(df["date"].min(), close_df["date"].max()),
y_range=(close_df['cumsum'].min() -
(close_df['cumsum'].max() - close_df['cumsum'].min()) * 0.1,
close_df['cumsum'].max() +
(close_df['cumsum'].max() - close_df['cumsum'].min()) * 0.1))
date_mid = pd.DataFrame()
close_df['date'] = (pd.DatetimeIndex(close_df['date']).astype(np.int64))
curloc = np.sign(
close_df['cumsum'].shift().fillna(0) * close_df['cumsum']) < 0
date_mid['date'] = close_df['date'].shift(
)[curloc] + close_df['cumsum'].shift()[curloc] * (
close_df['date'][curloc] - close_df['date'].shift())[curloc] / (
close_df['cumsum'].shift()[curloc] - close_df['cumsum'])[curloc]
date_mid = date_mid[np.isfinite(date_mid['date'])]
date_mid['date'] = pd.to_datetime(date_mid['date'])
close_df['date'] = pd.to_datetime(close_df['date'])
date_mid['cumsum'] = 0.0
date_mid['pos'] = 0.0
date_mid['neg'] = 0.0
date_mid['zeros'] = 0.0
close_df = close_df.drop(['level_0', 'index'], axis=1)
close_d_no_mids = close_df
close_df = pd.concat([close_df, date_mid], sort=True)
close_df = close_df.sort_values(by=['date'])
close_df = close_df.reset_index()
close_d_no_mids = close_d_no_mids.sort_values(by=['date'])
close_d_no_mids = close_d_no_mids.reset_index()
close_d_no_mids = close_d_no_mids.drop(['index'], axis=1)
close_df = close_df.drop(['index'], axis=1)
source_no_mids = ColumnDataSource(close_d_no_mids)
source = ColumnDataSource(close_df)
band = Band(base='date',
lower='zeros',
upper='pos',
source=source,
fill_alpha=0.75,
fill_color="green")
plot_prof.add_layout(band)
plot_prof.yaxis.axis_label = 'Profit'
band = Band(base='date',
lower='zeros',
upper='neg',
source=source,
fill_alpha=0.75,
fill_color="red")
plot_prof.add_layout(band)
profit_line = plot_prof.line(x='date',
y='cumsum',
source=source_no_mids,
line_width=2)
hover3 = HoverTool(renderers=[profit_line],
tooltips=[('date', '@date{%Y-%m-%d %H:%M:%S}'),
('profit', '@cumsum{0.' + str(prec) + '}')],
formatters={"date": "datetime"})
plot_prof.add_tools(hover3)
candlestick_y_axis = p.select(dict(type=Axis, layout="left"))[0]
candlestick_y_axis.formatter.use_scientific = False
prof_y_axis = plot_prof.select(dict(type=Axis, layout="left"))[0]
prof_y_axis.formatter.use_scientific = False
save(column(p, plot_prof), filename)
def forestplot(self, credible_interval, quartiles, linewidth, markersize,
ax, rope):
"""Draw forestplot for each plotter.
Parameters
----------
credible_interval : float
How wide each line should be
quartiles : bool
Whether to mark quartiles
linewidth : float
Width of forestplot line
markersize : float
Size of marker in center of forestplot line
ax : Axes
Axes to draw on
"""
if rope is None or isinstance(rope, dict):
pass
elif len(rope) == 2:
cds = ColumnDataSource({
"x":
rope,
"lower": [-2 * self.y_max(), -2 * self.y_max()],
"upper": [self.y_max() * 2, self.y_max() * 2],
})
band = Band(
base="x",
lower="lower",
upper="upper",
fill_color=[
color for _, color in zip(
range(4),
cycle(plt.rcParams["axes.prop_cycle"].by_key()
["color"]))
][2],
line_alpha=0.5,
source=cds,
)
ax.renderers.append(band)
else:
raise ValueError("Argument `rope` must be None, a dictionary like"
'{"var_name": {"rope": (lo, hi)}}, or an '
"iterable of length 2")
# Quantiles to be calculated
endpoint = 100 * (1 - credible_interval) / 2
if quartiles:
qlist = [endpoint, 25, 50, 75, 100 - endpoint]
else:
qlist = [endpoint, 50, 100 - endpoint]
for plotter in self.plotters.values():
for y, rope_var, values, color in plotter.treeplot(
qlist, credible_interval):
if isinstance(rope, dict):
self.display_multiple_ropes(rope, ax, y, linewidth,
rope_var)
mid = len(values) // 2
param_iter = zip(
np.linspace(2 * linewidth, linewidth, mid,
endpoint=True)[-1::-1], range(mid))
for width, j in param_iter:
ax.line([values[j], values[-(j + 1)]], [y, y],
line_width=width,
line_color=color)
ax.circle(
x=values[mid],
y=y,
size=markersize * 0.75,
fill_color=color,
)
_title = Title()
_title.text = "{:.1%} Credible Interval".format(credible_interval)
ax.title = _title
return ax
def _bokeh_component_plot(self,
component: str,
plot_options: dict,
data_color: str = "darkblue",
core_axis=None):
""" Define a plot for an individual component. """
times, obs, err = (self.__dict__[component].times,
self.__dict__[component].observations,
self.__dict__[component].errors)
source = ColumnDataSource(
dict(times=times,
obs=obs,
err=err,
lower=obs - err,
upper=obs + err))
if not core_axis:
p = figure(title=component,
x_range=[times[0], times[-1]],
**plot_options)
else:
p = figure(title=component,
x_range=core_axis.x_range,
**plot_options)
p.background_fill_color = "lightgrey"
p.yaxis.axis_label = f"{component} (mm)"
p.xaxis.axis_label = "Time stamp (UTC)"
p.min_border_bottom = 0
p.min_border_top = 0
p_scatter = p.scatter(x="times",
y="obs",
source=source,
line_color=None,
color=data_color)
p_band = Band(base="times",
lower="lower",
upper="upper",
source=source,
level="underlay",
fill_alpha=1.0,
line_width=1,
line_color=data_color)
p.add_layout(p_band)
datetick_formatter = DatetimeTickFormatter(
days=["%Y/%m/%d"],
months=["%Y/%m/%d"],
hours=["%Y/%m/%dT%H:%M:%S"],
minutes=["%Y/%m/%dT%H:%M:%S"],
seconds=["%H:%M:%S"],
hourmin=["%Y/%m/%dT%H:%M:%S"],
minsec=["%H:%M:%S"])
p.xaxis.formatter = datetick_formatter
# Add picker
picks = ColumnDataSource({"x": [], "y": [], 'color': []})
renderer = p.scatter(x='x',
y='y',
source=picks,
color='color',
size=10)
renderer_up = p.ray(x='x',
y='y',
source=picks,
color='color',
angle=90,
angle_units="deg",
length=0)
renderer_down = p.ray(x='x',
y='y',
source=picks,
color='color',
angle=270,
angle_units="deg",
length=0)
draw_tool = PointDrawTool(
renderers=[renderer, renderer_up, renderer_down],
empty_value="red",
num_objects=2)
p.add_tools(draw_tool)
p.toolbar.active_tap = draw_tool
tabledatetimeformatter = DateFormatter(format="%Y/%m/%d")
columns = [
TableColumn(field="x",
title="Date",
formatter=tabledatetimeformatter),
TableColumn(field="y",
title="Offset (mm)",
formatter=NumberFormatter(format="0.00"))
]
table = DataTable(source=picks,
columns=columns,
editable=True,
width=300)
return p, table
y_range=y_range,
toolbar_location=None)
source = ColumnDataSource(data=dict(
x1=[1, 3, 5, 7, 9],
lower1=[1, 2, 1, 2, 1],
upper1=[2, 3, 2, 3, 2],
x2=[200, 250, 350, 450, 550],
lower2=[400, 300, 400, 300, 400],
upper2=[500, 400, 500, 400, 500],
))
band1 = Band(base='x1',
lower='lower1',
upper='upper1',
line_width=3,
line_color='red',
line_dash='dashed',
source=source)
band2 = Band(base='x2',
lower='lower2',
upper='upper2',
base_units='screen',
lower_units='screen',
upper_units='screen',
dimension='width',
line_width=3,
fill_color='blue',
line_color='green',
source=source)
def bokeh_scatter(data, fig_dir, factor_name, threshold=0.05):
plot_data = dict(
x=data.index.tolist(),
pval_adj=data['p.adjusted'].tolist(),
neg_log10_pval_adj=data['neg_log_padj'].tolist(),
R2=data['R2'].tolist(),
upper=[data['neg_log_padj'].max() * 1.2] * len(data),
lower=[-np.log10(threshold)] * len(data),
n1=data['n1'].tolist(),
n2=data['n2'].tolist(),
)
plots = []
factors = pd.MultiIndex.get_level_values(data.index, 1).unique()
palette = Category10[10] + Dark2[8] + Accent[8]
index_cmap = factor_cmap('x',
palette=palette,
factors=sorted(factors),
start=1,
end=2)
tooltips = [('R2', '@R2'), ('adjusted p-value', '@pval_adj'),
('#samples in {} 1'.format(factor_name), '@n1'),
('#samples in {} 2'.format(factor_name), '@n2')]
titles = {
'neg_log10_pval_adj': 'Permanova test: -log10[adjusted p-value]',
'R2': 'Permanova test: R2 score'
}
for metric, title in titles.items():
p = figure(title=title,
x_range=FactorRange(*plot_data['x']),
tooltips=tooltips)
p.vbar(x='x',
top=metric,
width=0.9,
source=plot_data,
line_color="white",
fill_color=index_cmap)
if metric == 'neg_log10_pval_adj':
p.line(
list(range(len(data) + len(factors))),
[-np.log10(threshold)] * (len(data) + len(factors)),
line_color='grey',
line_dash='dashed',
line_width=1,
line_alpha=0.5,
legend_label="{:.0%} significance threshold".format(threshold))
band = Band(base='x',
lower='lower',
upper='upper',
level='underlay',
source=ColumnDataSource(plot_data),
line_dash='dashed',
fill_alpha=0.5,
line_width=1,
line_color='black')
p.add_layout(band)
p.legend.background_fill_alpha = 0.0
p.xaxis.major_label_orientation = "vertical"
p.xaxis.axis_label_text_font_size = "10pt"
plots.append(p)
grid = gridplot(plots, ncols=1, plot_width=1500, plot_height=500)
output_file(f"{fig_dir}/permanova_results_{factor_name}.html")
save(grid)
def add_border(self, plot, projection="ortho", pts=1000):
if projection == "ortho":
xe = np.linspace(-1, 1, pts)
ye = np.sqrt(1 - xe**2)
res = self.npix_o
else:
xe = np.linspace(-2, 2, pts)
ye = 0.5 * np.sqrt(4 - xe**2)
res = self.npix_m
d = 1 - 2 * np.sqrt(2) / res
# Fill above
source = ColumnDataSource(
data=dict(x=d * xe, lower=d * ye, upper=np.ones_like(xe)))
band = Band(
base="x",
lower="lower",
upper="upper",
level="overlay",
fill_alpha=1,
fill_color="white",
line_width=0,
source=source,
)
plot.add_layout(band)
# Fill below
source = ColumnDataSource(
data=dict(x=d * xe, lower=-np.ones_like(xe), upper=-d * ye))
band = Band(
base="x",
lower="lower",
upper="upper",
level="overlay",
fill_alpha=1,
fill_color="white",
line_width=0,
source=source,
)
plot.add_layout(band)
# Fill right
if projection == "ortho":
source = ColumnDataSource(data=dict(
x=[1 + 1.1 * (d - 1), 1.1],
lower=[-1.0, -1.0],
upper=[1.0, 1.0],
))
else:
source = ColumnDataSource(data=dict(
x=[2 * (1 + 1.1 * (d - 1)), 2.1],
lower=[-1.0, -1.0],
upper=[1.0, 1.0],
))
band = Band(
base="x",
lower="lower",
upper="upper",
level="overlay",
fill_alpha=1.0,
fill_color="white",
line_width=0,
source=source,
)
plot.add_layout(band)
# Fill left
if projection == "ortho":
source = ColumnDataSource(data=dict(
x=[-1.1, -(1 + 1.1 * (d - 1))],
lower=[-1.0, -1.0],
upper=[1.0, 1.0],
))
else:
source = ColumnDataSource(data=dict(
x=[-2.1, -2 * (1 + 1.1 * (d - 1))],
lower=[-1.0, -1.0],
upper=[1.0, 1.0],
))
band = Band(
base="x",
lower="lower",
upper="upper",
level="overlay",
fill_alpha=1.0,
fill_color="white",
line_width=0,
source=source,
)
plot.add_layout(band)
# Plot contour
plot.line(d * xe, d * ye, line_width=2, color="black", alpha=1)
plot.line(d * xe, -d * ye, line_width=2, color="black", alpha=1)
p_sx = figure(plot_width=600, plot_height=450,
tools='pan,wheel_zoom, box_zoom, box_select, crosshair, undo,redo,save,reset,help',
tooltips=TOOLTIPS,
title="Significanse Curve", x_axis_type='datetime',
background_fill_color = "#282C44",
background_fill_alpha = 1) #p = <class 'bokeh.plotting.figure.Figure'>
p_sx.yaxis.minor_tick_in = 5
renderer_line = p_sx.line( x='start_datetime_dt', y='sx_value', source=source_sx,
line_width=2, color='#08F7FE',
line_alpha=0.7,
selection_alpha=1,
nonselection_alpha=1,
)
band = Band(base='start_datetime_dt', lower=0, upper='sx_value', source=source_sx, level='underlay',
fill_color='#08F7FE', fill_alpha=0.1, line_width=0, line_color='black')
p_sx.add_layout(band)
#*******************************************************************
renderer_circle = p_sx.circle(x='start_datetime_dt', y='sx_value',
source=source_sx, size = 7,
fill_color='#08F7FE', fill_alpha=0.3,
line_color='#08F7FE', line_width=2)
selected_circle = Circle(fill_alpha = 1, fill_color='#FE53BB')
nonselected_circle = Circle(fill_alpha=0.2, fill_color='#08F7FE', line_color="blue")
renderer_circle.selection_glyph = selected_circle
renderer_circle.nonselection_glyph = nonselected_circle
select_overlay = p_sx.select_one(BoxSelectTool).overlay
select_overlay.fill_color = "firebrick"
select_overlay.line_color = None
# ***********************************************:
tools='',
background_fill_color="#fafafa",
toolbar_location=None,
y_axis_location="right",
margin=(5, 5, 5, 5))
iqr_p.line(x='date',
y='med',
color='#53b497',
legend_label='Median correl.',
line_width=2,
source=band_source)
band = Band(base='date',
lower='q1',
upper='q3',
source=band_source,
level='underlay',
fill_color='#53b497',
fill_alpha=0.2,
line_width=1,
line_color='#53b497',
line_alpha=0.4)
iqr_p.add_layout(band)
iqr_p.xaxis.visible = False
iqr_p.legend.location = "top_left"
iqr_p.legend.border_line_width = 0
iqr_p.legend.border_line_color = None
iqr_p.legend.background_fill_color = None
iqr_p.legend.background_fill_alpha = 0.0
iqr_p.yaxis.minor_tick_line_color = None
iqr_p.grid.grid_line_alpha = 0.3
iqr_p.legend.label_text_font_size = '8pt'
