def test_patches_hover_still_works_when_a_seleciton_is_preselcted(output_file_url, selenium):
# This tests an edge case interaction when Patches (specifically) is used
# with a tool that requires hit testing e.g. HitTool AND a selection is
# pre-made on the data source driving it.
plot = Plot(
x_range=Range1d(0, 100),
y_range=Range1d(0, 100),
min_border=0
)
source = ColumnDataSource(dict(
xs=[[0, 50, 50, 0], [50, 100, 100, 50]],
ys=[[0, 0, 100, 100], [0, 0, 100, 100]],
color=['pink', 'blue']
))
source.selected = {
'0d': {'glyph': None, 'indices': []},
'1d': {'indices': [1]},
'2d': {}
}
plot.add_glyph(source, Patches(xs='xs', ys='ys', fill_color='color'))
plot.add_tools(HoverTool())
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Hover plot and test no error
canvas = selenium.find_element_by_tag_name('canvas')
actions = ActionChains(selenium)
actions.move_to_element_with_offset(canvas, 100, 100)
actions.perform()
# If this assertion fails then there were likely errors on hover
assert has_no_console_errors(selenium)
def draw_heat_map(df, file_name, minimum_feature_contribution):
# this is the colormap from the original plot
colors = [
"#75968f", "#a5bab7", "#c9d9d3", "#e2e2e2", "#dfccce",
"#ddb7b1", "#cc7878", "#933b41", "#550b1d"
]
# Set up the data for plotting. We will need to have values for every
# pair of year/month names. Map the rate to a color.
interval = []
date = []
color = []
value = []
for d in df['Date']:
for i in df.columns[COLUMNS_TO_SKIP:]:
interval.append(i)
date.append(d)
percentage = float(df[df['Date'] == d][i])
value.append(percentage)
color_value = colors[int(percentage / len(colors))]
color.append(color_value)
source = ColumnDataSource(
#data=dict(month=month, year=year, color=color, rate=rate)
data=dict(interval=interval, date=date, color=color, value=value)
)
feature_name = file_name[:-4]
#chart_file_name = feature_name + '_hm.html'
file_name_wo_extn = file_name[:-4]
chart_file_name = os.path.join(os.path.sep, os.getcwd(), OUTPUT_DIR_NAME, file_name_wo_extn + '_hm.html')
#output_file(chart_file_name)
output_file(chart_file_name)
TOOLS = "resize,hover,save,pan,box_zoom,wheel_zoom"
title = feature_name.upper() + ' distribution from ' + str(df['Date'][0]) + ' to ' + str(df['Date'][len(df) - 1])
p = figure(title=title,
x_range= list(df['Date']), y_range=list(df.columns[COLUMNS_TO_SKIP:]),
x_axis_location="above", plot_width=1300, plot_height=500,
toolbar_location="left", tools=TOOLS)
p.rect("date", "interval", 1, 1, source=source,
color="color", line_color=None)
p.grid.grid_line_color = None
p.axis.axis_line_color = None
p.axis.major_tick_line_color = None
p.axis.major_label_text_font_size = "5pt"
p.axis.major_label_standoff = 0
p.xaxis.major_label_orientation = np.pi/3
hover = p.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([
('date', '@date @interval'),
('percentage', '@value'),
])
save(p) # save the plt
def test_the_default_titles_settings_and_ensure_outside_any_axes(output_file_url, selenium, screenshot):
# Testing title rendering of background and border is covered in the
# label test. The title added to plot as the primary title
# should always be outside axes and other side renderers.
source = ColumnDataSource(data=dict(x=[1, 2], y=[1, 2]))
def make_plot(location, title_align, two_axes=True):
plot = Plot(
plot_width=400, plot_height=200,
x_range=Range1d(0, 2), y_range=Range1d(0, 2),
toolbar_location=None,
title="Title %s - %s" % (location, title_align),
title_location=location,
)
plot.title.title_align = title_align
plot.add_glyph(source, Circle(x='x', y='y', radius=0.4))
plot.add_layout(LinearAxis(), location)
if two_axes:
plot.add_layout(LinearAxis(), location)
return plot
layout = Column(
make_plot('above', 'left', two_axes=False), # This is a workaround top doesn't like two axes
make_plot('right', 'right'),
make_plot('below', 'center'),
make_plot('left', 'left')
)
# Save the plot and start the test
save(layout)
selenium.get(output_file_url)
# Take screenshot
assert screenshot.is_valid()
def _create_grid_plot_of_trends(df, X, col_list, filename):
width = 600
height = 400
color_palette = [ 'Black', 'Red', 'Purple', 'Green', 'Brown', 'Yellow', 'Cyan', 'Blue', 'Orange', 'Pink']
i = 0
#2 columns, so number of rows is total /2
row_index = 0
row_list = []
row = []
for col in col_list[1:]: #skip the date column
# create a new plot
s1 = figure(x_axis_type = 'datetime', width=width, plot_height=height, title=col + ' trend')
#seasonal decompae to extract seasonal trends
decomposition = seasonal_decompose(np.array(df[col]), model='additive', freq=15)
s1.line(X, decomposition.trend, color=color_palette[i % len(color_palette)], alpha=0.5, line_width=2)
row.append(s1)
if len(row) == 2:
row_copy = copy.deepcopy(row)
row_list.append(row_copy)
row = []
i = 0
i += 1
# put all the plots in a grid layout
p = gridplot(row_list)
save(vplot(p), filename=filename, title='trends')
def test_color_bar_placement_and_render(output_file_url, selenium, screenshot):
plot = Plot(height=HEIGHT, width=WIDTH,
x_range=Range1d(0,10), y_range=Range1d(0,10),
toolbar_location=None)
bar_vertical_right_panel = create_vertical_color_bar_with_log_cmap()
bar_vertical_right_panel.location = (0, 0)
bar_vertical_in_frame = create_vertical_color_bar_with_log_cmap()
bar_vertical_in_frame.location = "top_right"
bar_vertical_in_frame.title = "Dummy Title"
bar_vertical_in_frame.title_standoff = 7
bar_horizontal_below_panel = create_horizontal_color_bar_with_linear_cmap()
bar_horizontal_below_panel.location = (0, 0)
bar_horizontal_in_frame = create_horizontal_color_bar_with_linear_cmap()
bar_horizontal_in_frame.location = "bottom_left"
bar_horizontal_in_frame.title = "Dummy Title"
plot.add_layout(bar_vertical_right_panel, 'right')
plot.add_layout(bar_vertical_in_frame)
plot.add_layout(bar_horizontal_below_panel, 'below')
plot.add_layout(bar_horizontal_in_frame)
# 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 _draw_multiple_line_plot(filename, title, X, y, colors, legend, line_dash, line_width, x_axis_type, x_axis_label, y_axis_label, y_start=0, y_end=10, width=800, height=400):
#output_file(filename, title=title)
p1 = figure(x_axis_type = x_axis_type, plot_width=width, plot_height=height, y_range=(y_start, y_end))
for i in range(len(y)):
p1.line(X[i], y[i], color=colors[i], legend=legend[i], line_dash=line_dash[i], line_width=line_width[i])
#p1.multi_line(X, y, color=colors, legend=legend, line_dash=line_dash, line_width=line_width)
# p1.multi_line(xs=X,
# ys=y,
# line_color=colors,
# line_width=5)
p1.title = title
#p1.grid.grid_line_color='Black'
#p.ygrid[0].grid_line_alpha=0.5
p1.legend.orientation = "bottom_left"
p1.grid.grid_line_alpha=0.75
p1.xaxis.axis_label = x_axis_label
p1.yaxis.axis_label = y_axis_label
p1.ygrid.band_fill_color="olive"
p1.ygrid.band_fill_alpha = 0.25
p1.ygrid.minor_grid_line_color = 'navy'
p1.ygrid.minor_grid_line_alpha = 0.1
save(vplot(p1), filename=filename, title=title)
def test_arrow(output_file_url, selenium, screenshot):
# Have to specify x/y range as labels aren't included in the plot area solver
plot = figure(height=HEIGHT, width=WIDTH, x_range=(0,10), y_range=(0,10), tools='', toolbar_location="above")
arrow1 = Arrow(x_start=1, y_start=3, x_end=6, y_end=8,
line_color='green', line_alpha=0.7,
line_dash='8 4', line_width=5, end=OpenHead()
)
arrow1.end.line_width=8
arrow2 = Arrow(x_start=2, y_start=2, x_end=7, y_end=7,
start=NormalHead(), end=VeeHead()
)
arrow2.start.fill_color = 'indigo'
arrow2.end.fill_color = 'orange'
arrow2.end.size = 50
plot.add_layout(arrow1)
plot.add_layout(arrow2)
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Take screenshot
assert screenshot.is_valid()
def test_label(output_file_url, selenium, screenshot):
# 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=Range1d(0, 10), y_range=Range1d(0, 10),
toolbar_location=None)
label1 = Label(x=1, y=6, x_offset=25, y_offset=25,
text="Demo Label",
text_font_size='38pt', text_color='red', text_alpha=0.9,
text_baseline='bottom', text_align='left',
background_fill_color='green', background_fill_alpha=0.2,
angle=15, angle_units='deg',
render_mode='canvas')
label2 = Label(x=3, y=5.5, text="(I'm Canvas)", text_font_size='20pt',
border_line_color='black', border_line_width=2, border_line_dash='8 4',
render_mode='canvas')
label3 = Label(x=1, y=2, x_offset=25, y_offset=25,
text="Demo Label",
text_font_size='38pt', text_color='red', text_alpha=0.9,
text_baseline='bottom', text_align='left',
background_fill_color='green', background_fill_alpha=0.2,
angle=0.261, angle_units='rad',
render_mode='css')
label4 = Label(x=3, y=1.0, text="(I'm CSS)", text_font_size='20pt',
border_line_color='black', border_line_width=2, border_line_dash='8 4',
render_mode='css')
label_above = Label(
x=0, y=0, text="Label in above panel", x_units='screen', y_units='screen',
text_font_size='38pt', text_color='firebrick', text_alpha=0.9,
)
label_left = Label(
x=0, y=0, text="Label in left panel",
x_units='screen', y_units='screen', angle=90, angle_units='deg',
text_font_size='18pt', text_color='firebrick', text_alpha=0.9,
background_fill_color='aliceblue', text_baseline='top',
)
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
plot.add_layout(label1)
plot.add_layout(label2)
plot.add_layout(label3)
plot.add_layout(label4)
plot.add_layout(label_above, 'above')
plot.add_layout(label_left, 'left')
# 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 test_lasso_select(output_file_url, selenium):
plot = generate_plot()
#limit to one callback on click release
plot.add_tools(LassoSelectTool(select_every_mousemove=False))
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Drag a lasso selection area around middle point
canvas = selenium.find_element_by_tag_name('canvas')
actions = ActionChains(selenium)
actions.move_to_element_with_offset(canvas, PLOT_DIM * 0.25, PLOT_DIM * 0.25)
actions.click_and_hold()
actions.move_by_offset(0, PLOT_DIM * 0.5)
actions.move_by_offset(PLOT_DIM * 0.5, 0)
actions.move_by_offset(0, PLOT_DIM * -0.5)
actions.release()
actions.perform()
# Get the alert from box select and assert that the middle item is selected
alert = selenium.switch_to_alert()
assert alert.text == 'middle'
def draw_stacked_chart(df, file_name, minimum_feature_contribution):
logger.info('drawing stacked chart for ' + file_name)
col_list, remaining_features, remaining_features_values = va_utils.get_significant_features(df, minimum_feature_contribution)
X = list(df['Date'])
data = OrderedDict()
for col in col_list:
data[col] = df[col]
#finally add the remaining features as a combined single column
data['everything-else'] = remaining_features_values
feature_name = file_name[:-4]
#chart_file_name = feature_name + '.html'
#output_file(chart_file_name)
file_name_wo_extn = file_name[:-4]
chart_file_name = os.path.join(os.path.sep, os.getcwd(), OUTPUT_DIR_NAME, file_name_wo_extn + '_stacked_chart.html')
output_file(chart_file_name)
title = feature_name.upper() + ' distribution from ' + str(df['Date'][0]) + ' to ' + str(df['Date'][len(df) - 1])
bar = Bar(data, X, title= title, stacked=True, legend='bottom_left', tools='hover,pan,wheel_zoom,box_zoom,reset,resize', width=1300, height=500)
# glyph_renderers = bar.select(dict(type=GlyphRenderer))
# bar_source = glyph_renderers[0].data_source
# hover = bar.select(dict(type=HoverTool))
# hover.tooltips = [
# ('name',' @cat'),
# ('number', '$y'),
# ]
save(bar)
logger.info('saved the chart in ' + chart_file_name)
def save(self, title='Training Results'):
if len(self.figures) > 0:
if os.path.isfile(self.plot_path):
os.remove(self.plot_path)
output_file(self.plot_path, title=title)
plot = column(*self.figures)
save(plot)
self.clear()
self.results.to_csv(self.path, index=False, index_label=False)
def __init__(self, model, driver, output_file_url, has_no_console_errors):
self._driver = driver
self._model = model
self._has_no_console_errors = has_no_console_errors
save(self._model)
self._driver.get(output_file_url)
self.init_results()
def test_y_range_does_not_pan_above_y_max(output_file_url, selenium):
y_range_max = 4
plot = make_pan_plot_with_callback(yr=Range1d(0, 3, bounds=(None, y_range_max)))
save(plot)
selenium.get(output_file_url)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=50, pan_y=150)
new_range_end = float(selenium.execute_script("""alert(window.get_y_range_end())"""))
selenium.switch_to_alert().dismiss() # This is not necessary but assists debugging
assert round(new_range_end) == y_range_max
def test_reversed_x_range_does_not_pan_left_of_x_max(output_file_url, selenium):
x_range_max = 4
plot = make_pan_plot_with_callback(xr=Range1d(3, 0, bounds=(None, x_range_max)))
save(plot)
selenium.get(output_file_url)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=200, pan_y=0)
new_range_end = float(selenium.execute_script("""alert(window.get_x_range_start())"""))
selenium.switch_to_alert().dismiss() # This is not necessary but assists debugging
assert round(new_range_end) == x_range_max
def test_reversed_y_range_does_not_pan_below_y_max(output_file_url, selenium):
y_range_max = 4
plot = make_pan_plot_with_callback(yr=Range1d(3, 0, bounds=(None, y_range_max)))
save(plot)
selenium.get(output_file_url)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=50, pan_y=-150)
new_range_end = float(selenium.execute_script("""alert(window.get_y_range_start())"""))
selenium.switch_to_alert().dismiss()
assert round(new_range_end) == y_range_max
def test_x_range_does_not_pan_left_of_x_min(output_file_url, selenium):
x_range_min = -1
plot = make_pan_plot_with_callback(xr=Range1d(0, 3, bounds=(x_range_min, None)))
save(plot)
selenium.get(output_file_url)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=200, pan_y=0)
new_range_start = float(selenium.execute_script("""alert(window.get_x_range_start())"""))
selenium.switch_to_alert().dismiss()
assert round(new_range_start) == x_range_min
def test_reversed_y_range_does_not_pan_below_y_max(output_file_url, selenium):
y_range_max = 4
plot = make_plot(yr=Range1d(3, 0, bounds=(None, y_range_max)))
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=50, pan_y=-150)
new_range_end = float(selenium.execute_script("""alert(Bokeh.index['plot-id'].model.y_range.max)"""))
selenium.switch_to_alert().dismiss()
assert round(new_range_end) == y_range_max
def output_charts(self,name,period, bot,top,fast_k,fast_d):
candlestick = self.candlestick(name)
rsi = self.rsi(candlestick,period,bot,top)
stoch_rsi = self.stoch_rsi(candlestick,period,fast_k,fast_d)
macd = self.macd(candlestick)
self.plot_results(candlestick,rsi,stoch_rsi,macd)
l=layout([[candlestick], [rsi],[stoch_rsi],[macd]])
output_file("charts/"+name.replace("/","")+".html",title="Crypto chart for "+name)
#show(l)
save(l)
def test_x_range_does_not_pan_left_of_x_min(output_file_url, selenium):
x_range_min = -1
plot = make_plot(xr=Range1d(0, 3, bounds=(x_range_min, None)))
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=150, pan_y=0)
new_range_start = float(selenium.execute_script("""alert(Bokeh.index['plot-id'].model.x_range.start)"""))
selenium.switch_to_alert().dismiss()
assert round(new_range_start) == x_range_min
def test_x_range_does_not_pan_right_of_x_max(output_file_url, selenium):
x_range_max = 4
plot = make_plot(xr=Range1d(0, 3, bounds=(None, x_range_max)))
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=-150, pan_y=0)
new_range_end = float(selenium.execute_script("""alert(Bokeh.index['plot-id'].model.x_range.end)"""))
selenium.switch_to_alert().dismiss() # This is not necessary but assists debugging
assert round(new_range_end) == x_range_max
def test_selection_tool_make_selection(output_file_url, selenium):
plot = make_plot()
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
perform_box_selection(selenium, (50, 200), (450, 400))
code = "return Bokeh.index['plot-id'].model.select_one('rect-glyph').data_source.selected['1d'].indices"
selected = selenium.execute_script(code)
assert selected == [0, 1]
def test_y_range_does_not_pan_below_y_min(output_file_url, selenium):
y_range_min = -1
plot = make_pan_plot_with_callback(yr=Range1d(0, 3, bounds=(y_range_min, None)))
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=50, pan_y=-150)
new_range_start = float(selenium.execute_script("""alert(window.get_y_range_start())"""))
selenium.switch_to_alert().dismiss() # This is not necessary but assists debugging
assert round(new_range_start) == y_range_min
def test_wheel_zoom_is_deselected_by_default(output_file_url, selenium):
# Make plot and add a taptool callback that generates an alert
plot = make_plot()
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
# Tap the plot and test for alert
scroll_button = get_non_stale_scroll_button(selenium)
scroll_classes = scroll_button.get_attribute('class')
assert 'active' not in scroll_classes
def test_selection_tool_selection_ending_outside_frame_makes_selection(output_file_url, selenium):
plot = make_plot()
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# make selection ending outside of frame
perform_box_selection(selenium, (50, 50), (1000, 1000))
code = "return Bokeh.index['plot-id'].model.select_one('rect-glyph').data_source.selected['1d'].indices"
selected = selenium.execute_script(code)
assert selected == [0,1,2]
def test_responsive_chart_starts_at_correct_size(output_file_url, selenium):
hist = Histogram(df['mpg'], title="MPG Distribution", responsive=True)
save(hist)
selenium.set_window_size(width=1000, height=600)
selenium.get(output_file_url)
canvas = selenium.find_element_by_tag_name('canvas')
wait_for_canvas_resize(canvas, selenium)
# Canvas width should be just under 1000
assert canvas.size['width'] > 900
assert canvas.size['width'] < 1000
def test_reversed_y_range_does_not_pan_above_y_min(output_file_url, selenium):
y_range_min = -1
plot = make_pan_plot_with_callback(yr=Range1d(3, 0, bounds=(y_range_min, None)))
save(plot)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=50, pan_y=150)
new_range_start = float(selenium.execute_script("""alert(window.get_y_range_end())"""))
selenium.switch_to_alert().dismiss()
assert round(new_range_start) == y_range_min
def test_wheel_zoom_can_be_selected(output_file_url, selenium):
# Make plot and add a taptool callback that generates an alert
plot = make_plot()
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
# Tap the plot and test for alert
scroll_button = get_non_stale_scroll_button(selenium)
scroll_button.click()
scroll_classes = scroll_button.get_attribute("class")
assert "active" in scroll_classes
def test_responsive_plot_starts_at_correct_size(output_file_url, selenium):
plot = figure(responsive=True, title="Test Me")
plot.scatter([1, 2, 3], [3, 2, 3])
save(plot)
selenium.set_window_size(width=1000, height=600)
selenium.get(output_file_url)
canvas = selenium.find_element_by_tag_name('canvas')
wait_for_canvas_resize(canvas, selenium)
# Canvas width should be just under 1000
assert canvas.size['width'] > 900
assert canvas.size['width'] < 1000
def test_range_with_callback_triggers_alert(output_file_url, selenium):
# Simple test to ensure range callbacks are working
# Rest of tests in this file depend on range callback.
plot = make_pan_plot_with_callback()
initial_start = plot.x_range.start
save(plot)
selenium.get(output_file_url)
# Pan plot and test for new range value
pan_plot(selenium, pan_x=100, pan_y=100)
new_range_start = float(selenium.execute_script("""alert(window.get_x_range_start())"""))
selenium.switch_to_alert().dismiss()
assert new_range_start < initial_start
def test_scale_width_maintains_a_minimum_height(output_file_url, selenium):
# The aspect ratio is landscape but should not allow a height less than 100
plot = make_sizing_mode_plot(1200, 600, sizing_mode='scale_width')
save(plot)
# Open the browser with the plot and resize the window small
selenium.set_window_size(width=100, height=600)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
canvas = selenium.find_element_by_tag_name('canvas')
wait_for_canvas_resize(canvas, selenium)
# Plot should have been shrunk somewhat
assert canvas.size['height'] < 600
assert canvas.size['height'] >= 100
{% for root in roots %}
{{ embed(root) }}
{% endfor %}
</div>
{{ plot_script }}
</body>
</html>
""")
axes = [
"a",
"b",
"l",
"r",
"al",
"ar",
"bl",
"br",
"alr",
"blr",
"lab",
"rab",
"ab",
"lr",
"ablr",
"",
]
figures = list(map(make_figure, axes))
save(figures, template=template)
color_bar = ColorBar(color_mapper=color_mapper,
ticker=LogTicker(),
border_line_color=None,
location=(0, 0),
label_standoff=12)
#p.add_layout(color_bar, 'left')
p.grid.grid_line_color = 'red'
p.patches('x',
'y',
source=source,
fill_color={
'field': 'rate',
'transform': color_mapper
},
fill_alpha=0.7,
line_color="black",
line_width=0.5)
hover = p.select_one(HoverTool)
hover.point_policy = "follow_mouse"
hover.tooltips = [
("Provinsi", "@name"),
#("Harga(Rp/100 Kg)", "@rate"),
("(Long, Lat)", "($x, $y)"),
]
print(save(p, filename='good' + '.html'))
def plot_spike_psth(spike_times, stim_data, channel_name,
unsorted_save_folder):
################################ get the TRIAL TIMES ###################################
#########################################################################################
trials = range(len(stim_data))
stim_orientation, idx, inv = np.unique(stim_data.orientations,
return_index=True,
return_inverse=True)
stim_dict = dict()
for ori in stim_orientation:
stim_dict[str(ori)] = stim_data.orientations[
stim_data.orientations ==
ori].index.values ### put indices of stim_data that correspond to this orientation, from inv
#### ^ stim_dict gives indices of stim_data for given orientations.
trial_range = 1.0 # 0.5
#trial_time_vector = np.linspace(-trial_range,trial_range,300) ## 300=trial length, in LFP sample (LFP fs=300 samples/sec)
###### Gather spike data from behavior trials:
spikes = []
for i in trials:
print 'i = ', i
trial_time = stim_data.times[i]
print 'trial_time = ', trial_time
temp_idx = (spike_times < trial_time + trial_range) & (
spike_times > trial_time - trial_range)
#print 'temp_idx = ', temp_idx
temp_trial = spike_times[temp_idx] - trial_time
spikes.append(temp_trial)
stim_data['spikes'] = spikes
stim_data.to_csv(unsorted_save_folder + '/stim_data_spikes.csv')
print 'STIM_DATA = ', stim_data
tuning_dict = dict()
for ori in stim_dict:
print stim_data.spikes[stim_dict[ori]]
raster = figure(width=1000,
height=400,
y_axis_label='Trial Number',
title='Raster')
all_spike_times = []
num_trials = len(stim_data.spikes[stim_dict[ori]]) # len(trials)
trials_by_ori = range(num_trials)
bin_time = 0.025 # 25 ms bins
num_bins = np.int(trial_range * 2 / bin_time)
time_vec = np.linspace(-trial_range, trial_range, num_bins)
tuning_time = 0.1 # sec. window in which to look for response modulation, before and after stim onset.
alltrials_modulation = []
for trial in trials_by_ori:
trial_time = stim_data.spikes[
stim_dict[ori][trial]] ## spike times on this trial
num_spikes_ontrial = len(trial_time)
print 'trial %d has %d spikes' % (trial, num_spikes_ontrial)
all_spike_times.append(trial_time)
####### MAKE RASTER
raster.segment(x0=trial_time,
y0=np.repeat(trial, num_spikes_ontrial),
x1=trial_time,
y1=np.repeat(trial + 1, num_spikes_ontrial),
color="black",
line_width=0.5)
#### get histogram for each trial:
temp_hist, edges = np.histogram(trial_time,
bins=num_bins,
range=[-trial_range, trial_range])
spikes_after_stim = temp_hist[(edges < tuning_time) & (edges >= 0)]
spikes_before_stim = temp_hist[(edges < 0)
& (edges > -tuning_time)]
print 'spikes_after_stim = ', spikes_after_stim
print 'spikes_before_stim = ', spikes_before_stim
trial_modulation = np.sum(spikes_after_stim) - np.sum(
spikes_before_stim
) ## total spikes in 100ms after - total spikes in 100ms before stim.
alltrials_modulation.append(
trial_modulation /
tuning_time) ## divide by 0.1 to get #spikes/second
if trial == 0:
raw_hist = temp_hist
else:
raw_hist = np.vstack([raw_hist, temp_hist])
np.savez(unsorted_save_folder + '/raw_histogram_%s.npz' % str(ori),
raw_hist=raw_hist)
print 'length of all_spike_times = ', len(all_spike_times)
print 'shape of overall histo = ', raw_hist.shape
histo_fig = figure(width=1000,
plot_height=500,
y_axis_label='Firing Rate (Hz)',
x_axis_label='Time (sec)',
x_range=raster.x_range)
all_spike_times = np.concatenate(
all_spike_times).ravel() ## make one long vector of spike times.
#hist, edges = np.histogram(all_spike_times, bins=num_bins)
hist = np.mean(raw_hist, axis=0)
hist_std = np.std(raw_hist, axis=0)
print 'shape of averaged hist = ', hist.shape
bin_width = np.diff(edges)[0] # in seconds.
print 'hist, edges: ', hist, edges
print 'bin_width = ', bin_width
print 'num_trials = ', num_trials
print 'shape of hist, edges = ', hist.shape, edges.shape
histo_fig.quad(
top=hist / bin_width,
bottom=0,
left=edges[:-1],
right=edges[1:], ## hist/bin_width = firing rate in Hz
fill_color="#036564",
line_color="#036564") #033649
#histo_fig.line(edges[:-1]+bin_width/2, hist/bin_width)
### get the number of spikes in the 100ms before and after stim presentation:
tuning_dict[ori] = (
np.mean(alltrials_modulation), stats.sem(alltrials_modulation)
) ## (np.mean(hist[20:24])/np.mean(hist[16:20]))/bin_width/num_trials
print 'tuning dict = ', tuning_dict
print 'np.mean(alltrials_modulation) = ', np.mean(alltrials_modulation)
print 'np.std(alltrials_modulation) = ', np.std(alltrials_modulation)
#################################### instead of histogram, plot mean+std of numbers of spikes on each trial (binned).
firingrate_line = figure(width=1000,
plot_height=500,
y_axis_label='Firing Rate (Hz)',
x_axis_label='Time (sec)',
x_range=raster.x_range)
hist_smooth = ndimage.filters.gaussian_filter1d(hist / bin_width,
sigma=0.5)
firingrate_line.line(edges[:-1] + bin_width / 2, hist_smooth)
std_x = (edges[:-1] + bin_width / 2).tolist()
std_y1 = (-hist_std + hist / bin_width).tolist()
std_y2 = (hist_std + hist / bin_width).tolist()
print 'std_x = ', std_x
print 'std_y1 ', std_y1
print 'std_y2 = ', std_y2
std_x.extend(np.flipud(std_x).tolist())
std_y1.extend(np.flipud(std_y2).tolist())
print 'std_plot_x = ', std_x
print 'std_plot_y = ', std_y1
firingrate_line.patch(std_x, std_y1, color="#99d8c9")
#firingrate_line.patch(edges[:-1]+bin_width/2,hist_std+hist/bin_width)
#firingrate_line.patch(edges[:-1]+bin_width/2,hist/bin_width+hist_std)
all_spike_times = None
#histo_fig.line(win_x,[w/win_size/len(stim_dict[ori]) for w in windowd_spike_vec],color='magenta')
output_file(unsorted_save_folder + '/spike_histogram_' + str(ori) +
'.html')
grid = gridplot([[raster], [histo_fig],
[firingrate_line]]) #,[firingrate_line]
save(grid)
#stim_name = 'orientation_' + ori
#output_file(save_folder + '/psth_'+str(stim_name)+'.html')
#save(raster)
#fig.savefig((unsorted_save_folder + str(channel_name) + '.pdf'))
## plot tuning curve:
tuning_fig = figure(width=1000,
plot_height=500,
y_axis_label='Spikes/Sec After - Before Stim',
x_axis_label='Orientations (deg)')
#### plot means:
tuning_fig.scatter(tuning_dict.keys(),
[means[0] for means in tuning_dict.values()])
#### plot stds:
## get x and y coordinates for the lines:
err_xs = []
err_ys = []
for x, y, yerr in zip(tuning_dict.keys(),
[means[0] for means in tuning_dict.values()],
[stds[1] for stds in tuning_dict.values()]):
err_xs.append((x, x))
err_ys.append((y - yerr, y + yerr))
tuning_fig.multi_line(err_xs, err_ys)
output_file(unsorted_save_folder + '/tuning.html')
save(tuning_fig)
def status_rect(data,direction,kp_fc,name='traffic map',origin_column='origin_ststus',
predict_column='predict_status',datetime_column='datetime',time_unit=5):
#the input dataframe must contain a 'datetime' type column for y axis
#if no prediction, predict=False
#check the categories of colormapper and hover tooltips
lane= origin_column.split('_')[0]
data['date'] = data[datetime_column].dt.date.astype(str)
kplist = list(sorted(set(data['kp'])))
ws={}
fkp={}
kpac=0
for ind, kp in enumerate(kplist):
if ind ==0:
ws[kp]=kp+((kplist[ind+1]-kp)/2)
elif kp == kplist[-1]:
ws[kp]=((kp-kplist[ind-1])/2)*2
else:
ws[kp]=((kp-kplist[ind-1])/2)+((kplist[ind+1]-kp)/2)
fkp[kp]=kpac+(ws[kp]/2)
kpac+=ws[kp]
data['width']=data.kp.replace(ws)
data['f_kp']=data.kp.replace(fkp)
source = ColumnDataSource(data)
toolbar = 'hover,save,pan,box_zoom,reset,wheel_zoom'
#the base-plot setting
p= figure(title=name,
x_range= Range1d(end = max(kplist)+ws[max(kplist)],start =0),
y_range=Range1d(start = max(data[datetime_column]),end =min(data[datetime_column])),
y_axis_type='datetime', plot_height = (len(data[datetime_column].unique())*3)+100,
x_axis_location='above',tools=toolbar,
plot_width = 20*len(kplist))
p.xaxis.axis_label= 'KP(km)'
p.yaxis.axis_label= 'Time'
p.yaxis.formatter = DatetimeTickFormatter(minutes=['%Y-%m-%d %H:%M'], days=['%Y-%m-%d %H:%M'],hours =['%Y-%m-%d %H:%M'],
months=['%Y-%m-%d %H:%M'],years=['%Y-%m-%d %H:%M'])
p.ygrid[0].ticker.desired_num_ticks = int(len(data[datetime_column].unique())/12)
p.toolbar.logo = None
p.xaxis.major_label_orientation = 45
p.xaxis.ticker = kplist
#set axis for facility
p.extra_x_ranges={'facility':Range1d(end = max(kplist)+ws[max(kplist)],start =0)}
p.add_layout(LinearAxis(x_range_name='facility',axis_label='facility',
ticker=list(kp_fc.keys()),major_label_orientation = 45,
formatter=FuncTickFormatter(code="""var kpfc_dict = %s;return kpfc_dict[tick];""" %kp_fc)),
'below')
hover = p.select_one(HoverTool)
#draw rectangles for original status
mapper = CategoricalColorMapper(palette=['#cc7878','#c9d9d3','#550b1d','#933b41'],
factors=['congestion','free_flow','traffic_jam','conditional'])
p.rect('f_kp',datetime_column,
width='width',height=1000*60*time_unit,source=source,
fill_color={'field':origin_column,'transform':mapper},fill_alpha = 0.3,
line_color=None,legend=origin_column)
if predict_column!=None:
#draw rectangles for predict status
mapper2 = CategoricalColorMapper(palette=['#c9d9d3','yellow'],
factors=['p_free_flow','p_traffic_jam'])
p.rect('f_kp','dtime',
width='width',height=1000*60*time_unit,source=source,
fill_color={'field':predict_column,'transform':mapper2},fill_alpha = 0.2,
line_color=None,legend=predict_column)
hover.tooltips = [('kp','@kp'),("date","@date"),("time","@time"),('lane',lane),('speed',"@{}_speed".format(lane)),
('car_vol','@{}_carvol'.format(lane)),('occ','@{}_occ'.format(lane)),
('status','@{}'.format(origin_column)),('p_status','@{}'.format(predict_column))]
else:
hover.tooltips = [('kp','@kp'),("date","@date"),("time","@time"),('lane',lane),('speed',"@{}_speed".format(lane)),
('car_vol','@{}_carvol'.format(lane)),('occ','@{}_occ'.format(lane)),
('status','@{}'.format(origin_column))]
output_file('/data/projects/Highway/NEXCO_2017/2_visualization/traffic_per_kp_map/{}.html'.format(name))
#show(p)
save(p)
case = label_alleles(case, allelic_case, ch_ss_num=5)
for case in cases.values():
plot_dict = plot_PTE_case(case, plot_dict, w=1050, h=500)
# sort the plots. SCL first, channel + repeat after, followed by their
# size standards.
plot_keys = sorted([key for key in plot_dict.keys() if 'SCL' not in key])
scl_keys = sorted([key for key in plot_dict.keys() if 'SCL' in key])
plot_keys = [*scl_keys, *plot_keys]
plots = column([plot_dict[ch] for ch in plot_keys], sizing_mode='fixed')
case_html = case.name + '.html'
output_file(case_html)
show(plots)
save(plots)
print('Saved {}'.format(case_html))
""" Next steps
1. Correctly label regions and peaks on the allelic ladder.
2. Use allelic ladder to annotate sample peaks.
a. May need to deal with stutter vs. true allelic peak
3. Get area under each peak.
a. Given a list of peaks, get their bases.
b. Include stutter in area calculation or not? Won't matter so long as we are consistent. Easier to exclude stutter.
"""
alleles = {
'channel_1': {
'D8S1179': {
[
selectors_map + map_range_widgets + [radioGroup_level_select] +
[button_continental_us_only]
#+[Spacer(background='black',height=2)]
+ [Div(text="<center><i> Time History Animation </i></center>")]
#+[Spacer(background='black',height=2)]
+ [[spinner_minStepTime, radioGroup_play_controls],
date_range_slider],
p_map
],
[selectors_graph + [data_notes], p_graph],
footer
])
lout.margin = (4, 20, 4, 20) # top, right, bottom, left
lout.sizing_mode = 'scale_width'
save(lout, template=template_ext_js(['jquary', 'pako']))
# view(output_filename+'.html')
# view('http://localhost:7800/'+localhost_path+this_filename+'.html')
elif sys.argv[1] == 'mobile':
print('Making mobile output version')
lout_mobile = layout([
heading, [selectors_map] + map_range_widgets,
[radioGroup_level_select, button_continental_us_only], p_map,
[spinner_minStepTime, radioGroup_play_controls, date_range_slider],
p_graph, [[[selectors_graph]], data_notes], footer
])
lout_mobile.margin = (4, 20, 4, 20) # top, right, bottom, left
lout_mobile.sizing_mode = 'scale_width'
save(lout_mobile,
filename=output_filename + '_mobile.html',
def test_scale_both_resizes_width_and_height_with_fixed_aspect_ratio(
output_file_url, selenium):
# Test that a Bokeh plot embedded in a desktop-ish setting (e.g.
# a Phosphor widget) behaves well w.r.t. resizing.
# We want the aspect ratio of the initial plot to be maintained, but we
# can't measure it perfectly so we test against bounds.
aspect_ratio = 2
plot_width = 400 * aspect_ratio
plot_height = 400
lower_bound = aspect_ratio * 0.95
upper_bound = aspect_ratio * 1.05
plot = make_sizing_mode_plot(plot_width,
plot_height,
sizing_mode='scale_both')
save(plot)
# Open the browser with the plot and resize the window to get an initial measure
selenium.set_window_size(width=1200, height=600)
selenium.get(output_file_url)
assert has_no_console_errors(selenium)
canvas = selenium.find_element_by_tag_name('canvas')
# Check initial size
wait_for_canvas_resize(canvas, selenium)
#
height1 = canvas.size['height']
width1 = canvas.size['width']
aspect_ratio1 = width1 / height1
assert aspect_ratio1 > lower_bound
assert aspect_ratio1 < upper_bound
# Now resize to a smaller width and check again
selenium.set_window_size(width=800, height=600)
wait_for_canvas_resize(canvas, selenium)
#
height2 = canvas.size['height']
width2 = canvas.size['width']
aspect_ratio2 = width2 / height2
assert aspect_ratio2 > lower_bound
assert aspect_ratio2 < upper_bound
assert width2 < width1 - 20
assert height2 < height1 - 20
# Now resize back and check again
selenium.set_window_size(width=1200, height=600)
wait_for_canvas_resize(canvas, selenium)
#
height3 = canvas.size['height']
width3 = canvas.size['width']
assert width3 == width1
assert height3 == height1
# Now resize to a smaller height and check again
selenium.set_window_size(width=1200, height=400)
wait_for_canvas_resize(canvas, selenium)
#
height4 = canvas.size['height']
width4 = canvas.size['width']
aspect_ratio4 = width4 / height4
assert aspect_ratio4 > lower_bound
assert aspect_ratio4 < upper_bound
assert width4 < width1
assert height4 < height1
# Now resize back and check again
selenium.set_window_size(width=1200, height=600)
wait_for_canvas_resize(canvas, selenium)
#
height5 = canvas.size['height']
width5 = canvas.size['width']
assert width5 == width1
assert height5 == height1
def make_char():
states = []
predictions = []
with open('predictions.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
for state in row:
if state == '' or state == 'predicted_cases':
continue
state = state.replace('state_', "")
states.append(state)
line_count += 1
else:
predictions.append(row[-1])
line_count += 1
state_resources = []
beds_total = []
beds_aval = []
ven_total = []
ven_aval = []
with open('PPE_Datasheet.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count > 1:
state_resources.append(row[0])
beds_total.append(row[1])
beds_aval.append(row[2])
ven_total.append(row[3])
ven_aval.append(row[4])
else:
line_count += 1
resources = [
'Total Beds', 'Available Beds', 'Total Ventilators',
'Available Ventilators'
]
data_r = {
'states': state_resources,
'Total Beds': beds_total,
'Available Beds': beds_aval,
'Total Ventilators': ven_total,
'Available Ventilators': ven_aval
}
# this creates [ ("Apples", "2015"), ("Apples", "2016"), ("Apples", "2017"), ("Pears", "2015), ... ]
x_r = [(s, r) for s in state_resources for r in resources]
counts = sum(
zip(data_r['Total Beds'], data_r['Available Beds'],
data_r['Total Ventilators'], data_r['Available Ventilators']),
()) # like an hstack
source = ColumnDataSource(
data=dict(states=states, predictions=predictions, all=predictions))
source_rr = ColumnDataSource(
data=dict(x_r=x_r, counts=counts, all_counts=counts))
p_rr = figure(x_range=FactorRange(*x_r),
plot_height=500,
plot_width=1200,
title="State Resources - June 10th",
toolbar_location=None,
tools="")
p_rr.vbar(x='x_r', top='counts', width=0.9, source=source_rr)
p_rr.y_range.start = 0
p_rr.x_range.range_padding = 0.1
p_rr.xaxis.major_label_orientation = 1
p_rr.xgrid.grid_line_color = None
p_rr.add_tools(HoverTool(tooltips=[('Number of Resources', '@counts')]))
p = figure(x_range=source.data['states'],
plot_height=500,
plot_width=1200,
title='Predictions by State - June 10th',
toolbar_location=None,
tools="")
p.vbar(x='states', top='predictions', width=0.5, source=source)
p.xaxis.major_label_orientation = math.pi / 2
p.yaxis[0].formatter = NumeralTickFormatter(format='0')
p.add_tools(
HoverTool(
tooltips=[('State',
'@states'), ('Predicted Number of Cases',
'@predictions')]))
callback = CustomJS(args=dict(source=source, source_rr=source_rr),
code="""
var data = source.data;
var selection = cb_obj.value
var states = data['states']
var predictions = data['predictions']
var all = data['all']
for (var i = 0; i < states.length; i++) {
if (selection == 'All States'){
predictions[i] = all[i]
}
else if (selection != states[i]) {
predictions[i] = 0
}
else {
predictions[i] = all[i]
}
}
var data_rr = source_rr.data;
var states_rr = data_rr['x_r']
var resources_rr = data_rr['counts']
var resources_rr_all = data_rr['all_counts']
var start = -1
for (var i = 0; i < states_rr.length; i++) {
if (selection == 'All States'){
resources_rr[i] = resources_rr_all[i]
}
else if(selection == states_rr[i][0]){
if(start == -1){
start = i
}
}
}
for (var i = 0; i < states_rr.length; i++){
if (start != -1){
if (i >= start && i < (start + 4)){
resources_rr[i] = resources_rr_all[i]
}
else {
resources_rr[i] = 0
}
}
else{
resources_rr[i] = resources_rr_all[i]
}
}
source_rr.change.emit();
source.change.emit();
""")
menu = Select(options=['All States'] + source.data['states'],
value='All States',
title='Select State')
menu.js_on_change('value', callback)
output_file('Templates/bar_chart.html')
#output_file('bar_chart.html')
title = Div(
text=
"""<h1>Prediction of Covid-19 Cases and Availability of Resources</h1>""",
width=1200,
height=50)
div1 = Div(text="""<h3>Overview</h3>
In 2020, the coronavirus became a global pandemic, affecting millions of people around the world. As a result, many hospitals have been collecting data as new patients come in to aid research into its spread and overall trajectory. Our model takes in data from various datasets and resources and compiles it to make a prediction about the number of cases in each state for a given day, depending on outbreak data from previous days. Furthermore, visualization of hospital data for each state such as number of beds and ventilators for selected states will allow us to better predict when shortages of personal protective equipment (PPE) and resources in hospitals may occur.
<h3> Additional Resources</h3>
<a href = "https://www.cdc.gov/coronavirus/2019-ncov/covid-data/covidview/index.html" target="_blank"> CDC Website</a> with information about treatment and symptoms <br>
<a href = "https://covid19.healthdata.org/united-states-of-america" target="_blank"> University of Washington Model</a> with prediction on Covid-19 Cases<br>
<a href = "https://docs.google.com/spreadsheets/d/1ir6MK_WFQwnuboa5sKVWtliHktkKOWDw3rUH7aiYTXU/edit?usp=sharing" target="_blank"> Google Sheets</a> with more information on state resources<br>
""",
width=300,
height=100)
side = column(menu, div1)
layout = gridplot([title, None, p, side, p_rr, None], ncols=2)
curdoc().add_root(layout)
save(layout,
filename='Templates/bar_chart.html',
title='Covid-19 Outbreak Prediction')
#save(layout, filename = 'bar_chart.html', title = 'Covid-19 Outbreak Prediction')
#make_char()
def save(self, filename: str) -> None:
"""
save function
"""
save(self.to_render, filename=filename, resources=CDN, title="Report")
plot.add_layout(
Arrow(start=TeeHead(line_width=1),
x_start=6,
y_start=5,
x_end=8,
y_end=6,
line_width=10))
plot.add_layout(
Arrow(start=VeeHead(line_width=1, fill_color="white"),
x_start=6,
y_start=4,
x_end=8,
y_end=5,
line_width=10))
plot.add_layout(
Arrow(start=NormalHead(line_width=1, fill_color="white"),
x_start=6,
y_start=3,
x_end=8,
y_end=4,
line_width=10))
plot.add_layout(
Arrow(start=OpenHead(line_width=1),
x_start=6,
y_start=2,
x_end=8,
y_end=3,
line_width=10))
save(plot)
template = """
{% block preamble %}
<style>
body { background-color: lightblue; }
</style>
{% endblock %}
"""
plot = Plot(plot_width=600,
plot_height=600,
x_range=Range1d(0, 10),
y_range=Range1d(0, 10),
toolbar_location=None)
# This is the no-fill that we're testing
plot.background_fill_color = None
plot.border_fill_color = None
plot.add_glyph(Circle(x=3, y=3, size=50, fill_color='#ffffff'))
plot.add_glyph(Circle(x=6, y=6, size=50, fill_color='#ffffff'))
yaxis = LinearAxis(major_label_text_color='#ffffff',
major_label_text_font_size="30pt")
plot.add_layout(yaxis, 'left')
xaxis = LinearAxis(major_label_text_color='#ffffff',
major_label_text_font_size="30pt")
plot.add_layout(xaxis, 'below')
save(plot, template=template)
def plot_bars(df, perc, outfile, total):
"""
input: dataframe with ranks and number of concordantly classified contigs,
name for an output file, total number of contigs (as input for analysis),
number of contigs classified by both/all methods, and whether or not
to create a plot of percentages
output: bar graph as html file (saved as 'outfile' -> see input)
"""
output_file(outfile)
def find_suitable_y(n):
"""
Find a proper upper limit for the y-axis, based on the maximum value to plot.
"""
if n > 20000:
return (
n
) #just use the maximum value in case the numbers get really big
elif n > 10000:
return (20000)
elif n > 5000:
return (10000)
elif n > 2000:
return (5000)
elif n > 1000:
return (2000)
elif n > 500:
return (1000)
elif n > 200:
return (500)
elif n > 100:
return (200)
else:
return (100) #100 will probably do as lower limit
nr_source = ColumnDataSource(
data=dict(ranks=df["Rank"],
classified_contigs=df["classified_contigs"],
consistently_classified=df["consistently_classified"],
inconsistently_classified=df["inconsistently_classified"],
consistently_unclassified=df["consistently_unclassified"],
only_jovian=df["only_jovian"],
only_cat=df["only_cat"]))
title = "Classified contigs comparison (Jovian-CAT)"
ymax = find_suitable_y(total)
colors = ["#0000A6", "#63FFAC", "#B79762", "#004D43", "#FFDBE5"]
parts = [
"consistently_classified", "inconsistently_classified", "only_jovian",
"only_cat", "consistently_unclassified"
]
nr_fig = figure(x_range=df["Rank"],
plot_height=600,
plot_width=1000,
title=title,
toolbar_location=None,
tools="hover, pan",
tooltips="@ranks $name: @$name")
nr_fig.vbar_stack(parts,
x='ranks',
width=0.9,
color=colors,
source=nr_source,
legend=[value(x) for x in parts])
nr_fig.xgrid.grid_line_color = None
nr_fig.legend.orientation = "horizontal"
nr_fig.legend.location = "top_center"
nr_panel = Panel(child=nr_fig, title="Absolute numbers of contigs")
perc_source = ColumnDataSource(
data=dict(ranks=perc["Rank"],
classified_contigs=perc["classified_contigs"],
consistently_classified=perc["consistently_classified"],
inconsistently_classified=perc["inconsistently_classified"],
consistently_unclassified=perc["consistently_unclassified"],
only_jovian=perc["only_jovian"],
only_cat=perc["only_cat"]))
perc_fig = figure(x_range=perc["Rank"],
plot_height=600,
plot_width=1000,
title=title,
toolbar_location=None,
tools="hover, pan",
tooltips="@ranks $name: @$name %")
perc_fig.vbar_stack(parts,
x='ranks',
width=0.9,
color=colors,
source=perc_source,
legend=[value(x) for x in parts])
perc_fig.xgrid.grid_line_color = None
perc_fig.legend.orientation = "horizontal"
perc_fig.legend.location = "top_center"
perc_panel = Panel(child=perc_fig, title="Percentages of contigs")
tabs = Tabs(tabs=[nr_panel, perc_panel])
save(tabs)
return (None)
def player_plots(df, base_path, gw_cnt):
players = df["full_name_id"].values.tolist()
players3 = df["full_name_code"].values.tolist()
players4 = df["full_name_id"].values.tolist()
tools = "hover"
tooltips = """<table style="padding: 5px; color: #888;">
<tr style="line-height: 0.8; font-size: 17px; font-weight: bold; padding:10; margin: 0">
<td colspan=3" style="padding:5px;">@name</td>
</tr>
<tr style="line-height: 0.8; font-size: 12px; padding:5px !important; margin: 5px;">
<td style="font-weight: bold; padding:5px;">Gameweek</td>
<td style="padding:5px;">@x</td>
</tr>
<tr style="line-height: 0.8; font-size: 12px; padding:5px !important; margin: 5px;">
<td style="font-weight: bold; padding:5px;">Price</td>
<td style="padding:5px;">@y_value £</td>
</tr>
<tr style="line-height: 0.8; font-size: 12px; padding:5px !important; margin: 5px;">
<td style="font-weight: bold; padding:5px;">Points</td>
<td style="padding:5px;">@y_pts</td>
</tr>
<tr style="line-height: 0.8; font-size: 12px; padding:5px !important; margin: 5px;">
<td style="font-weight: bold; padding:5px;">Minutes</td>
<td style="padding:5px;">@y_mins</td>
</tr>
<tr style="line-height: 0.8; font-size: 12px; padding:5px !important; margin: 5px;">
<td style="font-weight: bold; padding:5px;">ICT</td>
<td style="padding:5px;">@y_ict</td>
</tr>
</table>
"""
for i in range(0, len(players)):
player3 = players3[i]
player4 = players4[i]
# get plots data
val = functions.get_player_data(base_path=base_path+"scraper/", player=player4)
source = ColumnDataSource(
data=dict(name=([player3[:player3.index('_')]] * len(val['gw'])),
x=val['gw'],
y_value=val['value'] / 10,
y_pts=val['total_points'],
y_mins=val['minutes'],
y_ict=val['ict_index']))
# plots
p_price = figure(y_axis_label='£', tools=tools, x_range=(1, gw_cnt))
p_price.line('x', 'y_value', source=source, line_width=2)
p_price.hover.tooltips = tooltips
p_pts = figure(y_axis_label='Points', tools=tools, x_range=(1, gw_cnt))
p_pts.line('x', 'y_pts', source=source, line_width=2)
p_pts.hover.tooltips = tooltips
p_mins = figure(y_axis_label='Minutes', tools=tools, x_range=(1, gw_cnt), y_range=(0, 100))
p_mins.line('x', 'y_mins', source=source, line_width=2)
p_mins.hover.tooltips = tooltips
p_ict = figure(x_axis_label='GW', y_axis_label='ICT', tools=tools, x_range=(1, gw_cnt))
p_ict.line('x', 'y_ict', source=source, line_width=2)
p_ict.hover.tooltips = tooltips
p = gridplot([p_price, p_pts, p_mins, p_ict],
ncols=1,
plot_width=300,
plot_height=120,
toolbox=None,
toolbar_options={'logo': None})
fig = row(p)
md_file = base_path + 'web/static/assets/bokeh/player_stats/' + player3 + '.html'
print("Generating " + md_file + "...")
output_file(md_file)
save(fig)
x = [ (cat, year) for cat in categories for year in years ]
counts = sum(zip(data[years[0]], data[years[1]], data[years[2]]), ()) # like an hstack
source = ColumnDataSource(data=dict(x=x, counts=counts))
p = figure(x_range=FactorRange(*x), plot_height=250, title=None, toolbar_location=None, tools="")
p.vbar(x='x', top='counts', width=0.9, source=source, line_color="white",
# use the palette to colormap based on the the x[1:2] values
fill_color=factor_cmap('x', palette=Colorblind[3], factors=years, start=1, end=2))
p.y_range.start = 0
p.x_range.range_padding = 0.1
p.xaxis.major_label_orientation = 1
p.xgrid.grid_line_color = None
file_name="MSD_Growth"
output_file(file_name+".html")
save(p)
p.toolbar.logo = None
p.toolbar_location = None
p.background_fill_color = None
p.border_fill_color = None
export_png(p,filename=file_name+".png")
p.output_backend="svg"
export_svgs(p,filename=file_name+".svg")
{% block contents %}
<div class="grid">
{% for root in roots %}
{{ embed(root) }}
{% endfor %}
</div>
{% endblock %}
"""
axes = [
"a",
"b",
"l",
"r",
"al",
"ar",
"bl",
"br",
"alr",
"blr",
"lab",
"rab",
"ab",
"lr",
"ablr",
"",
]
figures = list(map(make_figure, axes))
save(figures, template=template, title="CSS grid with an extended template")
def make_chart(client, numDays):
x = list(range(1, numDays+1))
x.reverse()
# info placeholder getting the mfp data
info = {}
today = date.today()
calorieList = {}
goals = client.get_date(today).goals
for day in x:
# it really is this easy
# for a month need to be smarter
# start at the earliest day
dayToEval = today - timedelta(days=day)
info[day] = client.get_date(dayToEval.year, dayToEval.month, dayToEval.day)
print(info[day])
# just check the calories to make sure information is present
data['days'].append(day)
if 'calories' in info[day].totals:
data['macros']['carbs'].append(info[day].totals['carbohydrates'])
data['macros']['protein'].append(info[day].totals['protein'])
data['macros']['fat'].append(info[day].totals['fat'])
else:
# error case handling to keep the x and y sizes equal
data['carbs'].append(math.nan)
data['protein'].append(math.nan)
data['fat'].append(math.nan)
# look for calories per item
for meal in info[day].meals:
for food in meal.entries:
calorieList[food.name] = food.totals['calories']
# sort the foods by calories
sortedCalList = [(k, calorieList[k]) for k in sorted(calorieList, key=calorieList.get, reverse=True)]
for i in range(1, 15):
print(sortedCalList[i])
# set up the bokeh plot, stacked bar graph for now
#source = ColumnDataSource(data=data)
p = figure(title='Macros Per Day')
p.border_fill_color = "whitesmoke"
p.min_border_left = 80
p.min_border_top = 40
p.min_border_bottom = 80
# just add all the lines, no multi line bull
for macro, color in zip(data['macros'], colors):
p.line(data['days'], data['macros'][macro], line_width=4, color=color, alpha=0.8, legend=macro)
#p.multi_line([data['days'], data['days'], data['days']], [data['carbs'], data['protein'], data['fat']],
# line_color=colors, line_width=4)
carbGoal = Span(location=goals['carbohydrates'], dimension='width', line_color=colors[0], line_dash='dashed', line_width=3)
proteinGoal = Span(location=goals['protein'], dimension='width', line_color=colors[1], line_dash='dashed', line_width=3)
fatGoal = Span(location=goals['fat'], dimension='width', line_color=colors[2], line_dash='dashed', line_width=3)
p.add_layout(carbGoal)
p.add_layout(proteinGoal)
p.add_layout(fatGoal)
p.legend.location = "top_left"
p.legend.click_policy = "hide"
output_file("calories.html")
save(p)
def create_table(status_dict):
"""Create interactive ``bokeh`` table containing the logfile status
results.
Parameters
----------
status_dict : dict
Nested dictionary with status results from all logfiles
"""
# Rearrange the nested dictionary into a non-nested dict for the table
filenames = []
dates = []
missings = []
results = []
for key in status_dict:
filenames.append(status_dict[key]['logname'])
dates.append(datetime.fromtimestamp(status_dict[key]['latest_time']))
missings.append(str(status_dict[key]['missing_file']))
results.append(status_dict[key]['status'])
# div to color the boxes in the status column
success_template = """
<div style="background:<%=
(function colorfromstr(){
if(value == "success"){
return("green")}
else{return("red")}
}()) %>;
color: white">
<%= value %></div>
"""
# div to color the boxes in the column for possibly late logfiles
missing_template = """
<div style="background:<%=
(function colorfrombool(){
if(value == "True"){
return("orange")}
else{return("green")}
}()) %>;
color: white">
<%= value %></div>
"""
success_formatter = HTMLTemplateFormatter(template=success_template)
missing_formatter = HTMLTemplateFormatter(template=missing_template)
data = dict(name=list(status_dict.keys()),
filename=filenames,
date=dates,
missing=missings,
result=results)
source = ColumnDataSource(data)
datefmt = DateFormatter(format="RFC-2822")
columns = [
TableColumn(field="name", title="Monitor Name", width=200),
TableColumn(field="filename", title="Most Recent File", width=350),
TableColumn(field="date",
title="Most Recent Time",
width=200,
formatter=datefmt),
TableColumn(field="missing",
title="Possible Missing File",
width=200,
formatter=missing_formatter),
TableColumn(field="result",
title="Status",
width=100,
formatter=success_formatter),
]
data_table = DataTable(source=source,
columns=columns,
width=800,
height=280,
index_position=None)
# Get output directory for saving the table files
output_dir = SETTINGS['outputs']
output_filename = 'cron_status_table'
# verify/create output sub-directory
output_dir = os.path.join(output_dir, 'monitor_cron_jobs')
ensure_dir_exists(output_dir)
# Save full html
html_outfile = os.path.join(output_dir, '{}.html'.format(output_filename))
output_file(html_outfile)
save(data_table)
try:
set_permissions(html_outfile)
except PermissionError:
logging.warning(
'Unable to set permissions for {}'.format(html_outfile))
logging.info('Saved Bokeh full HTML file: {}'.format(html_outfile))
elements['name_lower'] = elements['name'].str.lower()
source = ColumnDataSource(elements)
html_font_template = '<font color="<%= CPK %>"><%= value %></font>'
html_image_template = """
<a href="http://images-of-elements.com/<%= value %>.php" target="_blank">
<img src="http://images-of-elements.com/<%= value %>.jpg" style="width:40px;height:40px;border:0">
</a>
"""
columns = [
TableColumn(field='atomic number',
title='Atomic Number',
formatter=NumberFormatter(text_align="right")),
TableColumn(field='symbol',
title='Symbol',
formatter=StringFormatter(text_align="center")),
TableColumn(field='name',
title='Name',
formatter=HTMLTemplateFormatter(template=html_font_template)),
TableColumn(field='name_lower',
title='Image',
formatter=HTMLTemplateFormatter(template=html_image_template))
]
data_table = DataTable(source=source,
columns=columns,
editable=False,
row_height=45)
save(data_table)
def generate_cluster_report(report: ClusterReport, output: Path):
page = create_page(report)
ensure_directory(output.parent)
logging.info(f"Generating monitoring report into {output}")
save(page, output, title="Cluster monitor", resources=CDN)
from __future__ import absolute_import from bokeh.io import save from bokeh.models.widgets import MultiSelect, Panel, Tabs select = MultiSelect(options=["First option", "Second option"]) panel = Panel(title="A tab", child=select) tabs = Tabs(tabs=[panel], width=300) save(tabs)
def test_missing_filename(self):
io._state.file = None
with self.assertRaises(RuntimeError):
io.save("obj", None, "resources", "title")
ottawaIntl = pd.read_csv(path+"/Data/50430-2016_base_10_GDD.csv", header=None)
calgaryIntl = pd.read_csv(path+"/Data/49568-2016_base_10_GDD.csv", header=None)
gddOttawa =ottawaIntl.iloc[:][1].tolist()
gddCalgary =calgaryIntl.iloc[:][1].tolist()
gddHalifax =halifaxIntl.iloc[:][1].tolist()
days = list(range(0,len(calgaryIntl)))
halifaxIntlPlot = figure(plot_width=800, plot_height=450, title="GDD for Halifax for the year 2016", tools='hover, pan, box_zoom')
halifaxIntlPlot.grid.grid_line_alpha=0.3
halifaxIntlPlot.xaxis.axis_label = "Days"
halifaxIntlPlot.yaxis.axis_label = "GDD"
halifaxIntlPlot.line(days, gddHalifax, color='#000080')
ottawaIntlPlot = figure(plot_width=800, plot_height=450, title="GDD for Ottawa for the year 2016", tools='hover, pan, box_zoom')
ottawaIntlPlot.grid.grid_line_alpha=0.3
ottawaIntlPlot.xaxis.axis_label = "Days"
ottawaIntlPlot.yaxis.axis_label = "GDD"
ottawaIntlPlot.line(days, gddOttawa, color='red')
calgaryIntlPlot = figure(plot_width=800, plot_height=450, title="GDD for Calgary for the year 2016", tools='hover, pan, box_zoom')
calgaryIntlPlot.grid.grid_line_alpha=0.3
calgaryIntlPlot.xaxis.axis_label = "Days"
calgaryIntlPlot.yaxis.axis_label = "GDD"
calgaryIntlPlot.line(days, gddCalgary, color='Green')
output_file('docs/bokehplot.html')
save(column(halifaxIntlPlot, ottawaIntlPlot, calgaryIntlPlot))
def jwst_inventory(instruments=JWST_INSTRUMENT_NAMES,
dataproducts=['image', 'spectrum', 'cube'],
caom=False, plot=False):
"""Gather a full inventory of all JWST data in each instrument
service by instrument/dtype
Parameters
----------
instruments: sequence
The list of instruments to count
dataproducts: sequence
The types of dataproducts to count
caom: bool
Query CAOM service
plot: bool
Return a pie chart of the data
Returns
-------
astropy.table.table.Table
The table of record counts for each instrument and mode
"""
logging.info('Searching database...')
# Iterate through instruments
inventory, keywords = [], {}
for instrument in instruments:
ins = [instrument]
for dp in dataproducts:
count = instrument_inventory(instrument, dataproduct=dp, caom=caom)
ins.append(count)
# Get the total
ins.append(sum(ins[-3:]))
# Add it to the list
inventory.append(ins)
# Add the keywords to the dict
keywords[instrument] = instrument_keywords(instrument, caom=caom)
logging.info('Completed database search for {} instruments and {} data products.'.
format(instruments, dataproducts))
# Make the table
all_cols = ['instrument'] + dataproducts + ['total']
table = pd.DataFrame(inventory, columns=all_cols)
# Plot it
if plot:
# Determine plot location and names
output_dir = get_config()['outputs']
if caom:
output_filename = 'database_monitor_caom'
else:
output_filename = 'database_monitor_jwst'
# Make the plot
plt = bar_chart(table, 'instrument', dataproducts,
title="JWST Inventory")
# Save the plot as full html
html_filename = output_filename + '.html'
outfile = os.path.join(output_dir, 'monitor_mast', html_filename)
output_file(outfile)
save(plt)
set_permissions(outfile)
logging.info('Saved Bokeh plots as HTML file: {}'.format(html_filename))
# Save the plot as components
plt.sizing_mode = 'stretch_both'
script, div = components(plt)
div_outfile = os.path.join(output_dir, 'monitor_mast', output_filename + "_component.html")
with open(div_outfile, 'w') as f:
f.write(div)
f.close()
set_permissions(div_outfile)
script_outfile = os.path.join(output_dir, 'monitor_mast', output_filename + "_component.js")
with open(script_outfile, 'w') as f:
f.write(script)
f.close()
set_permissions(script_outfile)
logging.info('Saved Bokeh components files: {}_component.html and {}_component.js'.format(
output_filename, output_filename))
# Melt the table
table = pd.melt(table, id_vars=['instrument'],
value_vars=dataproducts,
value_name='files', var_name='dataproduct')
return table, keywords
def plot(data, x_axis, y_axis, group_by):
cats = list("abcdef")
yy = np.random.randn(2000)
g = np.random.choice(cats, 2000)
for i, l in enumerate(cats):
yy[g == l] += i // 2
df = pd.DataFrame(dict(score=yy, group=g))
# find the quartiles and IQR for each category
groups = df.groupby('group')
q1 = groups.quantile(q=0.25)
q2 = groups.quantile(q=0.5)
q3 = groups.quantile(q=0.75)
iqr = q3 - q1
upper = q3 + 1.5 * iqr
lower = q1 - 1.5 * iqr
# find the outliers for each category
def outliers(group):
cat = group.name
return group[(group.score > upper.loc[cat]['score']) |
(group.score < lower.loc[cat]['score'])]['score']
out = groups.apply(outliers).dropna()
# prepare outlier data for plotting, we need coordinates for every outlier.
if not out.empty:
outx = []
outy = []
for cat in cats:
# only add outliers if they exist
if not out.loc[cat].empty:
for value in out[cat]:
outx.append(cat)
outy.append(value)
p = plotting.figure(tools="save",
background_fill_color="#EFE8E2",
title="",
x_range=cats)
# if no outliers, shrink lengths of stems to be no longer than the minimums or maximums
qmin = groups.quantile(q=0.00)
qmax = groups.quantile(q=1.00)
upper.score = [
min([x, y]) for (x, y) in zip(list(qmax.loc[:, 'score']), upper.score)
]
lower.score = [
max([x, y]) for (x, y) in zip(list(qmin.loc[:, 'score']), lower.score)
]
# stems
p.segment(cats, upper.score, cats, q3.score, line_color="black")
p.segment(cats, lower.score, cats, q1.score, line_color="black")
# boxes
p.vbar(cats,
0.7,
q2.score,
q3.score,
fill_color="#E08E79",
line_color="black")
p.vbar(cats,
0.7,
q1.score,
q2.score,
fill_color="#3B8686",
line_color="black")
# whiskers (almost-0 height rects simpler than segments)
p.rect(cats, lower.score, 0.2, 0.01, line_color="black")
p.rect(cats, upper.score, 0.2, 0.01, line_color="black")
# outliers
if not out.empty:
p.circle(outx, outy, size=6, color="#F38630", fill_alpha=0.6)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = "white"
p.grid.grid_line_width = 2
p.xaxis.major_label_text_font_size = "12pt"
name = '{}_{}_{}_{}'.format(filename, __name__, x_axis, y_axis)
name = name.replace(':', '')
plotting.output_file(join_path('static', name + '.html'),
title=name,
mode='cdn',
root_dir=None)
save(p)
js, div = components(p, wrap_script=False, wrap_plot_info=True)
return {'div': div, 'js': js}
def save_static(data: pd.DataFrame, filename: str, title: str):
data['y'] = np.log10(data.y.values)
diff = data.y.max() - data.y.min()
scale = abs(data.y.min())
data['y'] += scale
data['y'] /= diff
#kui p väärtus on
# p = 0.5
#siis graafikul peab see olema
# print((np.log10(-np.log10(p))+scale)/diff)
hover = HoverTool(
tooltips=[("value",
"@text"), ("count_first",
"@count_first"), ("count_second",
"@count_second")])
plot = figure(
tools=[hover,
WheelZoomTool(),
BoxZoomTool(),
PanTool(),
ResetTool()],
webgl=True,
plot_width=800,
plot_height=700,
)
source = ColumnDataSource(data)
scatter = plot.scatter(source=source,
line_width=0,
line_alpha=0,
size=10,
x="x",
y="y",
alpha=0.5)
loc = ((np.log10(-np.log10(0.5)) + scale) / diff)
p_line = Span(location=loc,
dimension='width',
line_color='red',
line_width=3)
plot.renderers.append(p_line)
p_value_text = bokeh.models.Paragraph()
p_value = TextInput(title='p value',
value='0.5',
callback=CustomJS(args=dict(source=source,
line=p_line,
p_text=p_value_text),
code='''
val = parseFloat(cb_obj.value);
if (val < 0|| val > 1){{
alert('p must be between 0 and 1')
}}
line.location = (Math.log10(-Math.log10(val)) + {scale})/{diff};
p_text.text = "p =" + (val).toString()
p_text.trigger('change')
line.trigger('change')
'''.format(scale=float(scale), diff=float(diff))))
left = Span(location=-0.5, dimension='height', line_color='maroon')
plot.renderers.append(left)
right = Span(location=0.5, dimension='height', line_color='maroon')
plot.renderers.append(right)
left_limit = Slider(title='left_limit',
value=-0.5,
start=-1,
end=0,
step=0.001,
orientation='horizontal',
callback=CustomJS(args=dict(source=source, line=left),
code='''
line.location = cb_obj.value;
line.trigger('change')
'''))
right_limit = Slider(title='right_limit',
value=0.5,
start=0,
end=1,
step=0.001,
orientation='horizontal',
callback=CustomJS(args=dict(source=source,
line=right),
code='''
line.location = cb_obj.value;
line.trigger('change')
'''))
###################################################
## Data table ##############################
###################################################
aux_source = bokeh.models.ColumnDataSource(column_names=['index', 'text'])
table = bokeh.models.DataTable(
source=aux_source,
columns=[bokeh.models.TableColumn(field='text', title='text')],
fit_columns=True,
width=300)
###################################################
## Buttons ##############################
###################################################
button_width = 40
buttons = [
bokeh.models.Button(label='1', width=button_width),
bokeh.models.Button(label='2', width=button_width),
bokeh.models.Button(label='3', width=button_width),
bokeh.models.Button(label='4', width=button_width),
bokeh.models.Button(label='5', width=button_width),
bokeh.models.Button(label='6', width=button_width)
]
def make_button_callback(label):
if label in '123':
v_pred = 'source.data.y[i] > (Math.log10(-Math.log10(parseFloat(p_value.value))) + {scale})/{diff}'.format(
scale=float(scale), diff=float(diff))
elif label in '456':
v_pred = 'source.data.y[i] <= (Math.log10(-Math.log10(parseFloat(p_value.value))) + {scale})/{diff}'.format(
scale=float(scale), diff=float(diff))
if label in '14':
h_pred = 'source.data.x[i] <= left_limit.value'
elif label in '25':
h_pred = 'source.data.x[i] > left_limit.value && source.data.x[i] < right_limit.value'
elif label in '36':
h_pred = 'source.data.x[i] >= right_limit.value'
condition = '({h_pred} && {v_pred})'.format(h_pred=h_pred,
v_pred=v_pred)
return CustomJS(args=dict(source=source,
left_limit=left_limit,
right_limit=right_limit,
p_value=p_value,
table=table),
code='''
table.source.data.index = []
table.source.data.text = []
for (var i = 0; i < source.data.x.length; i++){{
if {condition}{{
table.source.data.index.push(source.data.index[i])
table.source.data.text.push(source.data.text[i])
}}
}}
table.trigger('change')
'''.format(condition=condition))
for button in buttons:
button.callback = make_button_callback(button.label)
# plot.renderers.extend(
# [
# Span(location=-math.log10(0.05), dimension='width', line_color='blue'),
# Span(location=-math.log10(0.05 / len(source.data['index'])), dimension='width',
# line_color='darkblue')
# ]
# )
## Siin on y-koordinaatide jooned
# labels = np.arange(10, 100, 10) / 100
# labels = np.append([0.001, 0.01, 0.05], labels)
# coords = -np.log10(labels)
# y_ticker = bokeh.models.tickers.FixedTicker(ticks=coords)
plot.ygrid[0].ticker = bokeh.models.tickers.FixedTicker(ticks=[])
plot.yaxis[0].formatter = bokeh.models.formatters.PrintfTickFormatter()
plot.yaxis[0].formatter.format = ''
plot.set(x_range=Range1d(-1.1, 1.1), y_range=Range1d(-0.05, 1.05))
sliders = VBox(p_value_text, p_value, left_limit, right_limit)
save_filename = bokeh.models.TextInput(value='filename')
save_button = bokeh.models.Button(label='Save')
save_button.callback = CustomJS(args=dict(
table=table,
filename=save_filename,
),
code='''
if (table.source.data.text == undefined){
alert('No elements selected! Press 1-6');
}
var text = table.source.data.text.join('\\n');
var name = filename.value
if (name === ''){
alert('Filename is empty!')
}
console.log(name)
var a = document.createElement("a");
document.body.appendChild(a);
a.style = "display: none";
func = function (data, fileName) {
console.log('doing')
blob = new Blob([data], {type: "text/plain"}),
url = window.URL.createObjectURL(blob);
a.href = url;
a.download = fileName;
a.click();
window.URL.revokeObjectURL(url);
}
func(text, name)
console.log('done')
''')
input_box = widgetbox(save_filename, save_button)
app = row(
column(plot),
column(row(sliders),
row(*buttons[:3]),
row(*buttons[3:]),
row(input_box),
row(table),
responsive=False))
curdoc().add_root(app)
save(curdoc(),
filename=filename,
title=title,
resources=bokeh.resources.INLINE)
def accelplotter(j):
#print('Generating spectrogram for earthquake ' + str(quakecounter) + '/' + str(len(quakelist)) + ':')
#print(' ' + str(round(j[2])) + 'M ' + j[0])
quaketime = j[3]
quaketime = datetime.utcfromtimestamp(quaketime)
quaketime = quaketime.strftime("%Y-%m-%d %H:%M:%S UTC")
windowstart = (j[5]) - 60 #start spectrogram 1min before arrival
windowend = windowstart + 240 #end spectrogram after 4min
if windowstart < starttime_s:
windowstart = starttime_s #if window starts before data, cut window to data
if windowend > endtime_s:
windowend = endtime_s #if window ends before data, cut window to data
windowindices = []
for kindex, k in enumerate(time_s): #find indices of times in window for
if k <= windowstart:
continue
if k >= windowend:
continue
#print(windowend)
windowindices.append(kindex)
window_accelx = accelx[
windowindices] #cut down arrays to times in the window
window_accely = accely[windowindices]
window_accelz = accelz[windowindices]
window_time_s = []
for row in windowindices:
window_time_s.append(time_s[row])
def interpolateaccel(axis):
f = interpolate.interp1d(window_time_s, axis,
kind='cubic') #make interpolation function
timelength = int((windowend - windowstart) * 1000) #max(window_time_s)
timenew = np.linspace(window_time_s[0], window_time_s[-1],
timelength) #generate even time values
accelaxisnew = f(timenew) #actually use interpolation function
return accelaxisnew
accelxnew = interpolateaccel(window_accelx)
accelynew = interpolateaccel(window_accely)
accelznew = interpolateaccel(window_accelz)
timenew = np.linspace(-60000, 180000, 240000)
windowname = j[0] #set name of window to location of quake
windowname = windowname.replace(
" ", "") #strip whitespace to make a valid filename
#windowname = windowname + '_' + j[3] + '_'
windowfilename = str(round(
j[2])) + 'M_' + windowname + '.html' #generate filename
def accelplot(colortheme):
if colortheme == 'default':
colortheme = ['white', 'steelblue', 'steelblue', 'steelblue']
if colortheme == 'tcolor':
colortheme = ['dimgray', 'lightskyblue', 'pink', 'white']
#set output file name
output_file(
str(round(j[2])) + 'M_' + windowname + '_acceleration.html')
#create three plots
pwidth = 1800
pheight = 250
pxaccel = figure(plot_width=pwidth,
plot_height=pheight,
title='x axis acceleration',
background_fill_color=colortheme[0],
toolbar_location=None,
tooltips=[("x", "$x"), ("y", "$y")])
pxaccel.line(timenew,
accelxnew,
legend='x',
line_width=1,
line_color=colortheme[1])
pxaccel.x_range = Range1d(-6000, 180000)
pyaccel = figure(plot_width=pwidth,
plot_height=pheight,
title='y axis acceleration',
background_fill_color=colortheme[0],
toolbar_location=None,
tooltips=[("x", "$x"), ("y", "$y")])
pyaccel.line(timenew,
accelynew,
legend='y',
line_width=1,
line_color=colortheme[2])
pyaccel.x_range = Range1d(-6000, 180000)
pzaccel = figure(plot_width=pwidth,
plot_height=pheight,
title='z axis acceleration',
background_fill_color=colortheme[0],
toolbar_location=None,
tooltips=[("x", "$x"), ("y", "$y")])
pzaccel.line(timenew,
accelznew,
legend='z',
line_width=1,
line_color=colortheme[3])
pzaccel.x_range = Range1d(-6000, 180000)
#show(grid)
return pxaccel, pyaccel, pzaccel
accelgrid = accelplot('default')
#pxaccel,pyaccel,pzaccel = accelgrid
pxaccel = accelgrid[0]
pyaccel = accelgrid[1]
pzaccel = accelgrid[2]
#pxaccel = pxaccel[0]
#return pxaccel
def fftaccel3(axis, axisname):
sampling_rate = 1000 # Hz
#N = windowend - windowstart # array size
N = 240000
#accelxshort = accelxnew[(start_time*sampling_rate):(end_time*sampling_rate)]
# Nyquist Sampling Criteria (for interpolated data)
T = 1 / sampling_rate
xfft = np.linspace(0.0, 1.0 / (2.0 * T), int(N / 2))
# FFT algorithm
yr = fft(axis) # "raw" FFT with both + and - frequencies
yfft = 2 / N * np.abs(yr[0:np.int(N / 2)]) # positive freqs only
p1 = figure(
tooltips=[("x", "$x"), ("y", "$y")],
y_axis_type='log',
plot_width=500,
plot_height=500,
toolbar_location="left",
title=axisname + ' axis fast fourier transform',
)
p1.x_range = Range1d(0, 200)
p1.line(
xfft,
yfft,
)
#show(p1)
f, t2, Sxx = signal.spectrogram(axis, fs=1000, nperseg=1000)
p = figure(title=axisname + ' axis spectrogram',
tooltips=[("time", "$t2"), ("freq.", "$f"),
("value", "@Sxx")],
plot_width=1800,
plot_height=250,
toolbar_location='left')
p.x_range.range_padding = p.y_range.range_padding = 0
#original palette: spectral11
p.image(image=[np.log(Sxx)],
x=0,
y=0,
dw=10,
dh=10,
palette="Plasma256")
#mapper = linear_cmap(field_name=Sxx,low=min(Sxx),high=max(Sxx))
#color_bar = ColorBar(color_mapper=mapper['transform'],width=8,location=(0,0))
#p.add_layout(color_bar,'right')
output_file(
str(round(j[2])) + 'M_' + windowname + axisname + '_fft.html')
#show(grid)
return p1, p
fftx = fftaccel3(accelxnew, 'x')
ffty = fftaccel3(accelynew, 'y')
fftz = fftaccel3(accelznew, 'z')
fftxtop = fftx[0]
fftxspec = fftx[1]
fftytop = ffty[0]
fftyspec = ffty[1]
fftztop = fftz[0]
fftzspec = fftz[1]
gridx = gridplot([pxaccel, fftxspec], ncols=1)
smallgridx = gridplot([fftxtop, gridx], ncols=2)
gridy = gridplot([pyaccel, fftyspec], ncols=1)
smallgridy = gridplot([fftytop, gridy], ncols=2)
gridz = gridplot([pzaccel, fftzspec], ncols=1)
smallgridz = gridplot([fftztop, gridz], ncols=2)
biggrid = gridplot([smallgridx, smallgridy, smallgridz], ncols=1)
output_file(windowfilename)
save(biggrid)
def createMap():
#pd.options.display.float_format = '{:,.0f}'.format
shapefile = '/Users/Aditya/Desktop/project/geoData/ne_110m_admin_0_countries.shp'
datafile = '/Users/Aditya/Desktop/project/output.csv'
#Read shapefile using Geopandas
gdf = gpd.read_file(shapefile)[['ADMIN', 'ADM0_A3', 'geometry']]
#Rename columns.
gdf.columns = ['country', 'country_code', 'geometry']
#Drop row corresponding to 'Antarctica'
#gdf.at[43, 'country'] = "French Guiana"
#drop antartica, takes too much space
gdf = gdf.drop(gdf.index[159])
#Read csv file using pandas
df = pd.read_csv(datafile,
names=[
'Country', 'Deaths', 'Deaths /1M pop', 'New Deaths',
'Tests', 'Confirmed Cases',
'Confirmed Case/Fatality Rate',
'Confirmed Cases/1M pop', 'EstimatedCases',
'Seasonal Flu Deaths1(CDC/WHO 2017)'
],
skiprows=2)
merged = gdf.merge(df, left_on='country', right_on='Country', how='left')
merged['Deaths /1M pop'].fillna("No Data", inplace=True)
merged.round({'Deaths /1M pop': 2})
#print(merged.head(merged['Deaths /1M pop']))
#Read data to json.
merged_json = json.loads(merged.to_json())
#Convert to String like object.
json_data = json.dumps(merged_json)
#Input GeoJSON source that contains features for plotting.
geosource = GeoJSONDataSource(geojson=json_data)
#Define a sequential multi-hue color palette.
palette = brewer['YlOrRd'][7]
#Reverse color order so that dark blue is highest obesity.
palette = palette[::-1]
#Instantiate LinearColorMapper that linearly maps numbers in a range, into a sequence of colors.
color_mapper = LinearColorMapper(palette=palette,
low=0,
high=350,
nan_color='#d9d9d9')
#Define custom tick labels for color bar.
tick_labels = {
'0': '0',
'50': '50',
'100': '100',
'150': '150',
'200': '200',
'250': '250',
'300': '300',
'350': '>350'
}
#Add hover tool
TOOLTIPS = """
<div>
<div>
<span style="font-size: 14px; color: black;"> Country: @country </span>
</div>
<div>
<span style="font-size: 14px; color: black;"> Deaths /1M: @{Deaths /1M pop}{0.00 a} </span>
</div>
</div>
"""
hover = HoverTool(tooltips=TOOLTIPS)
#Create color bar.
color_bar = ColorBar(color_mapper=color_mapper,
label_standoff=9,
width=20,
height=555,
border_line_color=None,
location=(0, -10),
orientation='vertical',
major_label_overrides=tick_labels,
background_fill_color="#1e1e2f",
major_label_text_color="white")
#Create figure object.
p = figure(title='Deaths per Million',
plot_height=610,
plot_width=1100,
toolbar_location=None,
tools=[hover])
p.title.text_color = "white"
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
p.background_fill_color = "#3690c0"
p.border_fill_color = "#1e1e2f"
p.axis.visible = False
today = date.today()
d2 = today.strftime("%B %d, %Y")
title = "Data is from https://www.realclearpolitics.com/coronavirus. Last updated %s" % d2
p.add_layout(Title(text=title, align="left", text_color="white"), "below")
#Add patch renderer to figure.
p.patches('xs',
'ys',
source=geosource,
fill_color={
'field': 'Deaths /1M pop',
'transform': color_mapper
},
line_color='black',
line_width=0.25,
fill_alpha=1)
#Specify figure layout.
p.add_layout(color_bar, 'right')
script, div = components(p)
#Display figure.
save(p)
return p
def plot_raw_traces(traces, time, stim_name, ch, save_folder):
print 'shape traces[:,0] = ', traces[:, 0].shape
print 'time shape = ', time.shape
#################### BOKEH FIGURE #########################
fig = plt.figure(figsize=(20, 10))
num_trials = traces.shape[1]
gs = gridspec.GridSpec(num_trials, 1,
width_ratios=[1, 1]) ## a subplot for every trial
ax = range(num_trials)
all_spike_times = []
raster = figure(width=1000,
height=400,
y_axis_label='Trial Number',
title='Raster + Histogram Channel %d, Orientation %d' %
(ch + 1, stim_name))
spike_vec = np.zeros([len(time), 1])
time_vec = np.linspace(0, len(time), len(time))
for trial in range(num_trials):
print 'trial # ', trial
peaks, times, ifr_vec = run_spike_detect(traces[:, trial])
all_spike_times.append(times)
spike_vec[times] += 1
trial_time = [t / 30e3 - 0.5 for t in times]
#ax = plt.subplot(gs[trial])
#sns.tsplot(downsample(traces[:,trial],10),time=time,value='Voltage (uV)',color='black',linewidth=0.1)
ax[trial] = figure(width=1000, plot_height=500)
#s1 = figure(width=1000, plot_height=500, title='Spikes')
ax[trial].line(time, traces[:,
trial]) ## (time is already downsampled)
ax[trial].circle(
trial_time, peaks, color='red'
) ## convert to seconds and subtract 0.5 b/c plotting data on time from -0.5 to +0.5 seconds
#ax.set_ylim([-1000,1000])
#ax.set(y_range=Range1d(-1000, 1000))
#axes.append[ax]
raster.segment(x0=trial_time,
y0=np.repeat(trial, len(times)),
x1=trial_time,
y1=np.repeat(trial + 1, len(times)),
color="black",
line_width=0.5)
p = gridplot([[s1] for s1 in ax]) #gridplot([[s1] for s1 in axes])
#fig.savefig(save_folder + '/raw_psth_'+str(stim_name)+'.pdf')
output_file(save_folder + '/raw_psth_' + str(stim_name) + '.html')
# show the results
save(p)
############## SPIKE HISTOGRAM FIGURE ############################
histo_fig = figure(width=1000,
plot_height=500,
y_axis_label='Firing Rate (Hz)',
x_axis_label='Time (sec)',
x_range=raster.x_range)
print 'len all_spike_times = ', len(all_spike_times)
num_bins = 50
hist, edges = np.histogram(flatten(all_spike_times), bins=num_bins)
bin_width = np.diff(edges)[0] / fs # in seconds.
edges = edges / fs - 0.5 ## plot x-axis in seconds.
histo_fig.quad(
top=hist / bin_width / num_trials,
bottom=0,
left=edges[:-1],
right=edges[1:], ## hist/bin_width = firing rate in Hz
fill_color="#036564",
line_color="#033649")
#time
# pass this to the sliding window - get sum of spikes in each 100ms window.
win_size = 2**8
win_step = 2**2
win_x, windowd_spike_vec = windowed_histogram(spike_vec, time_vec,
win_size, win_step)
histo_fig.line([t / fs - 0.5 for t in win_x],
[w / win_size * fs / num_trials for w in windowd_spike_vec],
color='magenta')
output_file(save_folder + '/spike_histogram_' + str(stim_name) + '.html')
grid = gridplot([[raster], [histo_fig]])
save(grid)
def test_label(output_file_url, selenium, screenshot):
# 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=Range1d(0, 10),
y_range=Range1d(0, 10),
toolbar_location=None)
label1 = Label(x=1,
y=6,
x_offset=25,
y_offset=25,
text=["Demo Label"],
text_font_size='38pt',
text_color='red',
text_alpha=0.9,
text_baseline='bottom',
text_align='left',
background_fill_color='green',
background_fill_alpha=0.2,
angle=15,
angle_units='deg',
render_mode='canvas')
label2 = Label(x=3,
y=5.5,
text=["(I'm Canvas)"],
text_font_size='20pt',
border_line_color='black',
border_line_width=2,
border_line_dash='8 4',
render_mode='canvas')
label3 = Label(x=1,
y=2,
x_offset=25,
y_offset=25,
text=["Demo Label"],
text_font_size='38pt',
text_color='red',
text_alpha=0.9,
text_baseline='bottom',
text_align='left',
background_fill_color='green',
background_fill_alpha=0.2,
angle=0.261,
angle_units='rad',
render_mode='css')
label4 = Label(x=3,
y=1.0,
text=["(I'm CSS)"],
text_font_size='20pt',
border_line_color='black',
border_line_width=2,
border_line_dash='8 4',
render_mode='css')
label_above = Label(
x=0,
y=0,
text=["Label in above panel"],
x_units='screen',
y_units='screen',
text_font_size='38pt',
text_color='firebrick',
text_alpha=0.9,
)
label_left = Label(
x=0,
y=0,
text=["Label in left panel"],
x_units='screen',
y_units='screen',
angle=90,
angle_units='deg',
text_font_size='18pt',
text_color='firebrick',
text_alpha=0.9,
background_fill_color='aliceblue',
text_baseline='top',
)
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
plot.add_layout(label1)
plot.add_layout(label2)
plot.add_layout(label3)
plot.add_layout(label4)
plot.add_layout(label_above, 'above')
plot.add_layout(label_left, 'left')
# Save the plot and start the test
save(plot)
selenium.get(output_file_url)
# Take screenshot
assert screenshot.is_valid()
def tplot(name,
var_label = None,
auto_color=True,
interactive=False,
combine_axes=True,
nb=False,
save_file=None,
gui=False,
qt=True,
pyqtgraph=False):
"""
This is the function used to display the tplot variables stored in memory.
The default output is to show the plots stacked on top of one another inside a GUI window.
The GUI window has the option to export the plots in either PNG or HTML formats.
.. note::
This plotting routine uses the python Bokeh library, which creates plots using HTML and Javascript.
Bokeh is technically still in beta, so future patches to Bokeh may require updates to this function.
Parameters:
name : str / list
List of tplot variables that will be plotted
var_label : str, optional
The name of the tplot variable you would like as
a second x axis.
auto_color : bool, optional
Automatically color the plot lines.
interactive : bool, optional
If True, a secondary interactive plot will be generated next to spectrogram plots.
Mousing over the spectrogram will display a slice of data from that time on the
interactive chart.
combine_axis : bool, optional
If True, the axes are combined so that they all display the same x range. This also enables
scrolling/zooming/panning on one plot to affect all of the other plots simultaneously.
nb : bool, optional
If True, the plot will be displayed inside of a current Jupyter notebook session.
save_file : str, optional
A full file name and path.
If this option is set, the plot will be automatically saved to the file name provided in an HTML format.
The plots can then be opened and viewed on any browser without any requirements.
gui : bool, optional
If True, then this function will output the 2 HTML components of the generated plots as string variables.
This is useful if you are embedded the plots in your own GUI. For more information, see
http://bokeh.pydata.org/en/latest/docs/user_guide/embed.html
qt : bool, optional
If True, then this function will display the plot inside of the Qt window. From this window, you
can choose to export the plots as either an HTML file, or as a PNG.
Returns:
None
Examples:
>>> #Plot a single line
>>> import pytplot
>>> x_data = [2,3,4,5,6]
>>> y_data = [1,2,3,4,5]
>>> pytplot.store_data("Variable1", data={'x':x_data, 'y':y_data})
>>> pytplot.tplot("Variable1")
>>> #Display two plots
>>> x_data = [1,2,3,4,5]
>>> y_data = [[1,5],[2,4],[3,3],[4,2],[5,1]]
>>> pytplot.store_data("Variable2", data={'x':x_data, 'y':y_data})
>>> pytplot.tplot(["Variable1", "Variable2"])
>>> #Display 2 plots, using Variable1 as another x axis
>>> x_data = [1,2,3]
>>> y_data = [ [1,2,3] , [4,5,6], [7,8,9] ]
>>> v_data = [1,2,3]
>>> pytplot.store_data("Variable3", data={'x':x_data, 'y':y_data, 'v':v_data})
>>> pytplot.options("Variable3", 'spec', 1)
>>> pytplot.tplot(["Variable2", "Variable3"], var_label='Variable1')
>>> #Plot all 3 tplot variables, sending the output to an HTML file
>>> pytplot.tplot(["Variable1", "Variable2", "Variable3"], save_file='C:/temp/pytplot_example.html')
>>> #Plot all 3 tplot variables, sending the HTML output to a pair of strings
>>> div, component = pytplot.tplot(["Variable1", "Variable2", "Variable3"], gui=True)
"""
#Check a bunch of things
if(not isinstance(name, list)):
name=[name]
num_plots = 1
else:
num_plots = len(name)
for i in range(num_plots):
if isinstance(name[i], int):
name[i] = list(pytplot.data_quants.keys())[name[i]]
if name[i] not in pytplot.data_quants.keys():
print(str(i) + " is currently not in pytplot")
return
if isinstance(var_label, int):
var_label = list(pytplot.data_quants.keys())[var_label]
if pyqtgraph:
layout = QtPlotter.generate_stack(name, var_label=var_label, auto_color=auto_color, combine_axes=combine_axes, mouse_moved_event=pytplot.hover_time.change_hover_time)
pytplot.pytplotWindow.newlayout(layout)
pytplot.pytplotWindow.resize(pytplot.tplot_opt_glob['window_size'][0], pytplot.tplot_opt_glob['window_size'][1])
pytplot.pytplotWindow.show()
pytplot.pytplotWindow.activateWindow()
if not (hasattr(sys, 'ps1')) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
return
else:
layout = HTMLPlotter.generate_stack(name, var_label=var_label, auto_color=auto_color, combine_axes=combine_axes, interactive=interactive)
#Output types
if gui:
script, div = components(layout)
return script, div
elif nb:
output_notebook()
show(layout)
return
elif save_file != None:
output_file(save_file, mode='inline')
save(layout)
return
elif qt:
dir_path = os.path.dirname(os.path.realpath(__file__))
output_file(os.path.join(dir_path, "temp.html"), mode='inline')
save(layout)
new_layout = WebView()
pytplot.pytplotWindow.resize(pytplot.tplot_opt_glob['window_size'][0]+100,pytplot.tplot_opt_glob['window_size'][1]+100)
new_layout.resize(pytplot.tplot_opt_glob['window_size'][0],pytplot.tplot_opt_glob['window_size'][1])
dir_path = os.path.dirname(os.path.realpath(__file__))
new_layout.setUrl(QtCore.QUrl.fromLocalFile(os.path.join(dir_path, "temp.html")))
pytplot.pytplotWindow.newlayout(new_layout)
pytplot.pytplotWindow.show()
pytplot.pytplotWindow.activateWindow()
if not (hasattr(sys, 'ps1')) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
return
else:
dir_path = os.path.dirname(os.path.realpath(__file__))
output_file(os.path.join(dir_path, "temp.html"), mode='inline')
show(layout)
return
