def test():
p = figure(x_range=(-20, 20), y_range=(-20, 20), toolbar_location=None, webgl=False, plot_width=750, plot_height=750)
p.border_fill_color = '#eeeeee'
p.background_fill_color = 'white'
p.outline_line_color = None
p.grid.grid_line_color = None
session = push_session(curdoc())
curdoc().add_root(p)
session.show()
car = Car([1.0, 2.0], angle_to_vector(math.pi/2), wheels_angle=0.4, speed=1.0, width=1.0, length=2.0, fig=p, nrays=36)
border = geom.Figure([[-10.0, -10.0], [-10.0, 10.0], [10.0, 10.0], [10.0, -10.0]],
close=True, fig=p)
obstacle = geom.Figure([[-5.0, 0.0], [0.0, 0.0], [0.0, -5.0], [-5.0, -5.0]],
close=True, fig=p)
#obstacle = geom.Figure(close=True, fig=p)
#print border.points
#obstacle.set_points([[-5.0, 0.0], [0.0, 0.0], [0.0, -5.0], [-5.0, -5.0]])
env = geom.CompoundFigure([border, obstacle])
env.draw()
for i in xrange(10000):
car.turn_wheels(random.random() - 0.5)
car.save_pos()
car.move(0.1)
if car.path().intersect(env) != None:
car.restore_pos()
car.speed = -car.speed
car.draw(env)
time.sleep(0.01)
def test_model_in_empty_document_context_manager_is_used(self):
m = mock.MagicMock(name='_ModelInEmptyDocument')
plot1 = figure()
curdoc().add_root(plot1)
with mock.patch('bokeh.embed._ModelInEmptyDocument', m):
embed.notebook_div(plot1)
m.assert_called_once_with(plot1)
def main(options, args):
logger = log.get_logger("ginga", options=options)
# create a new plot with default tools, using figure
fig = figure(x_range=[0,600], y_range=[0,600], plot_width=600, plot_height=600,
toolbar_location=None)
viewer = ib.CanvasView(logger)
viewer.set_figure(fig)
def load_file(path):
image = AstroImage(logger)
image.load_file(path)
viewer.set_image(image)
def load_file_cb(attr_name, old_val, new_val):
#print(attr_name, old_val, new_val)
load_file(new_val)
# add a entry widget and configure with the call back
dstdir = options.indir
path_w = TextInput(value=dstdir, title="File:")
path_w.on_change('value', load_file_cb)
if len(args) > 0:
load_file(args[0])
# put the path widget and viewer in a layout and add to the document
curdoc().add_root(vplot(fig, path_w))
def input_change(self, obj, attrname, old, new):
if obj == self.ticker4_2_select:
self.ticker4_2 = new
if obj == self.ticker4_1_select:
self.ticker4_1 = new
if obj == self.ticker4_select:
self.ticker4 = new
if obj == self.ticker3_2_select:
self.ticker3_2 = new
if obj == self.ticker3_1_select:
self.ticker3_1 = new
if obj == self.ticker3_select:
self.ticker3 = new
if obj == self.ticker2p_select:
self.ticker2p = new
if obj == self.ticker2_select:
self.ticker2 = new
if obj == self.ticker1p_select:
self.ticker1p = new
if obj == self.ticker1_select:
self.ticker1 = new
if obj == self.button_select:
self.button = new
if 'run' in self.button:
self.make_source()
self.make_plots()
self.set_children()
curdoc().add(self)
def change_symbol(self, obj,attrname, old, new):
self.selected_symbol = new
Dashboard.recreate_all(self)
if symbols_filtered:
self.source_stocks_rank.data = symbols_filtered
curdoc().add(self)
def render_plot():
build_plot()
session = push_session(curdoc())
curdoc().add_periodic_callback(callback, 60000)
session.show() # open the document in a browser
session.loop_until_closed() # run forever
return ""
def set_plot(self):
# print ("set_plot")
"""Makes and sets the plot based on the current configuration of app."""
self.update_xy_ranges(source=self.df)
plot = self.make_plot()
self.plot = plot
curdoc()._add_all()
def exec_filter_symbol(self, obj,attrname, old, new):
Dashboard.recreate_all(self)
dat = Dashboard._pre_filtered_ranks[new]
self.source_stocks_rank.data = dat
self.symbol_filter.value = new
curdoc().add(self)
def notebook_plot(x_key, y_key, **kwargs):
r"""Live plot log entries in the current notebook.
Parameters
----------
x_key : str
The key in the serialized JSON object that contains the x-axis
value.
y_key : str
See `x_key`.
\*\*kwargs
Connection parameters passed to the `connect` function.
"""
subscriber, sequence, x, y = connect(x_key, y_key, **kwargs)
session = push_session(curdoc())
output_notebook()
fig = figure()
plot = fig.line(x, y)
show(fig)
def notebook_update():
update(x_key, y_key, sequence, subscriber, plot)
push_notebook()
curdoc().add_periodic_callback(notebook_update, 50)
session.loop_until_closed()
def brand_change(self, obj, attrname, old, new):
bdf = self.brand_df
if self.selectr.value is None or self.selectr.value == 'Most Popular Brands':
return
self.update_selected_on_source(self.selectr.value)
self.set_children()
curdoc().add(self)
def render_table(sym):
df = get_data(sym)
text_input = TextInput(value=sym.upper(), title="Label:")
mids = (df['open'] + df['close'])/2
spans = abs(df['open'] - df['close'])
inc = df['close'] > df['open']
dec = df['close'] < df['open']
w = 12*60*60*1000 # half day in ms
TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
global p
p = figure(x_axis_type="datetime", tools=TOOLS, plot_width=750, plot_height=300, toolbar_location="left")
p.title = sym.upper() + " Candlestick"
p.xaxis.major_label_orientation = pi/4
p.grid.grid_line_alpha=0.3
p.segment(df.date, df.high, df.date, df.low, color="black")
p.rect(df.date[inc], mids[inc], w, spans[inc], fill_color="#D5E1DD", line_color="black")
p.rect(df.date[dec], mids[dec], w, spans[dec], fill_color="#F2583E", line_color="black")
session = push_session(curdoc())
curdoc().add_periodic_callback(update, 1000)
session.show() # open the document in a browser
session.loop_until_closed() # run forever
output_file("candlestick.html", title="candlestick.py example")
def on_slider_change(self, obj, attrname, old, new):
if obj == self.min_excitation:
self.min_excitation.value = new
if self.min_excitation.value > self.max_excitation.value:
self.min_excitation.value = old
if obj == self.max_excitation:
self.max_excitation.value = new
if self.max_excitation.value < self.min_excitation.value:
self.max_excitation.value = old
if obj == self.min_emission:
self.min_emission.value = new
if self.min_emission.value > self.max_emission.value:
self.min_emission.value = old
if obj == self.max_emission:
self.max_emission.value = new
if self.max_emission.value < self.min_emission.value:
self.max_emission.value = old
self.set_sliders()
self.make_source()
self.set_children()
curdoc().add(self)
def inst_date_change(self, obj, attrname, old, new):
logging.debug('Date change!')
self.inst_date = new
self.make_source()
self.make_plots()
self.set_children()
curdoc().add(self)
def star_change(self, obj, attrname, old, new):
logging.debug('Star change!')
self.star = new
self.make_inst_date_input()
self.make_source()
self.make_plots()
self.set_children()
curdoc().add(self)
def par_change(self, obj, attrname, old, new):
# Update plots
self.mainplot, highest = self.plot_Trun()
name, T = highest.sort('ccf_max', ascending=False)[['name', 'T']].values[0]
self.ccf_plot = self.plot_ccf(name, T)
self.set_children()
curdoc().add(self)
def button_group_click(new):
global play
if new == 0: # play
play = True
curdoc().add_periodic_callback(update, interval)
else:
play = False
curdoc().remove_periodic_callback(update)
def Trun_change(self, obj, attrname, old, new):
idx = int(new['1d']['indices'][0])
T = self.current_source.data['T'][idx]
name = self.current_source.data['name'][idx]
logging.debug('T = {}\nName = {}\n'.format(T, name))
self.ccf_plot = self.plot_ccf(name, T)
self.set_children()
curdoc().add(self)
def input_change(self, obj, attrname, old, new):
if obj == self.ticker2_select:
self.ticker2 = new
if obj == self.ticker1_select:
self.ticker1 = new
self.make_source()
self.make_plots()
self.set_children()
curdoc().add(self)
def reschedule_redraw(self, time_sec):
doc = curdoc()
try:
doc.remove_timeout_callback(self._defer_timer)
except Exception:
pass
msec = int(time_sec * 1000.0)
self._defer_timer = curdoc().add_timeout_callback(self.timer_cb,
msec)
def toggle_handler(active):
if active:
toggle.label = 'Stop'
checkbox_group.disabled = True
#t3.data_source.data["text"] = ['Running']
curdoc().add_periodic_callback(update, periodic_callback_time_ms)
else:
toggle.label = 'Start'
checkbox_group.disabled = False
#t3.data_source.data["text"] = ['Stopped']
curdoc().remove_periodic_callback(update)
def selection_change(self, obj, attrname, old, new):
#self.make_brand_plot
#self.set_children()
#curdoc().add(self)
bdf = self.brand_df
min_idx, max_idx = shoes_func.min_max_range(ranges, bdf['price'])
self.configure_brand_source(min_idx, max_idx)
self.make_brand_source()
self.make_brand_plot(min_idx, max_idx)
self.set_children()
curdoc().add(self)
def wrapper(*args, **kwargs):
docname = prefix + str(uuid.uuid4())
output_server(docname, url=url)
curdoc().autoadd(False)
app = func(*args, **kwargs)
curdoc()._plotcontext.children = [app]
curdoc().add_all()
changed = push()
logger.debug("stored: %s", str(changed))
app.docname = docname
return app
def toggle_handler(active):
#t3.data_source.data["text"] = ['State = {}'.format(toggle.active)]
if active:
toggle.label = 'Stop'
#toggle.type = 'danger'
t3.data_source.data["text"] = ['Running']
curdoc().add_periodic_callback(update, periodic_callback_time_ms)
else:
toggle.label = 'Start'
#toggle.type = 'success'
t3.data_source.data["text"] = ['Stopped']
curdoc().remove_periodic_callback(update)
def input_change(self, obj, attrname, old, new):
self.make_source()
self.make_county_source()
print "source len: ", len(self.source.data['state'])
print "county len: ", len(self.county_source.data['names'])
if self.selectr.value is None or self.selectr.value == 'Choose A State':
pass
else:
self.plot.title = self.selectr.value
self.populate_glyphs()
self.set_children()
curdoc().add(self)
def input_change(self, obj, attrname, old, new):
"""Executes whenever the input form changes.
It is responsible for updating the plot, or anything else you want.
Args:
obj : the object that changed
attrname : the attr that changed
old : old value of attr
new : new value of attr
"""
self.update_data()
self.make_plot()
curdoc().add(self)
def onscreen_message(self, text, delay=None):
doc = curdoc()
try:
doc.remove_timeout_callback(self._msg_timer)
except Exception:
pass
if text is not None:
self.set_onscreen_message(text)
msec = int(delay * 1000.0)
if delay:
self._msg_timer = curdoc().add_timeout_callback(
self.onscreen_message_off, msec)
def bokeh_local(self):
p = figure()
x, y = read_log()
# print x, y
self.r = p.line(x, y, color='navy', line_width=3)
session = push_session(curdoc())
session.show()
def main():
session = push_session(curdoc(), session_id='labeler')
document = session.document
print document
do_step(document)
session.show()
session.loop_until_closed()
def test_replot_remove(self):
self.assertIsNotNone(self.bokeh_server, "Server failed to start, cannot tests")
ar_downsample._loadAR()
output_server("Census")
source = ServerDataSource(data_url="fn://bivariate", owner_username="******")
plot = square('A', 'B', source=source)
ar_downsample.replot(plot, remove_original=False)
self.assertTrue(plot in curdoc().context.children, "Not retained")
ar_downsample.replot(plot, remove_original=True)
self.assertTrue(plot not in curdoc().context.children, "Not removed")
try:
ar_downsample.replot(plot, remove_original=True)
except:
self.assertTrue(False, "Error reploting plot not in curdoc")
def check_change(self, obj, attrname, old, new):
#Turn on/off the counties/hotel data
print "what the heck ", obj, attrname, old, new
if 0 in new:
self._show_counties = True
else:
self._show_counties = False
if 1 in new:
self._show_hotels = True
else:
self._show_hotels = False
self.populate_glyphs()
self.set_children()
curdoc().add(self)
from bokeh.io import output_file, show
from bokeh.layouts import widgetbox
from bokeh.models.widgets import Dropdown
from bokeh.plotting import curdoc, vplot
menu = [("Quaterly", "Quarterly"), ("Half Yearly", "Half Yearly"), None,
("Yearly", "Yearly")]
dropdown = Dropdown(label="Time Period", button_type="warning", menu=menu)
def function_to_call(attr, old, new):
print dropdown.value
dropdown.on_change('value', function_to_call)
curdoc().add_root(dropdown)
def __init__(self,
bokeh_doc_name,
monitor_channels=None,
open_browser=False,
server_url='http://localhost:5006/',
colors=colors):
"""
Initialize a Bokeh plot!
Parameters
----------
bokeh_doc_name : str
The name of the Bokeh document. Use a different name for each
experiment if you are storing your plots.
monitor_channels : list(MonitorsChannel or Monitor)
The monitor channels and monitors that you want to plot. The
monitors within a :class:`MonitorsChannel` will be plotted together in a single
figure.
open_browser : bool, optional
Whether to try and open the plotting server in a browser window.
Defaults to ``True``. Should probably be set to ``False`` when
running experiments non-locally (e.g. on a cluster or through SSH).
server_url : str, optional
Url of the bokeh server. Ex: when starting the bokeh server with
``bokeh serve --ip 0.0.0.0`` at ``alice``, server_url should be
``http://alice:5006``. When not specified the default configured
to ``http://localhost:5006/``.
colors : list(str)
The list of string hex codes for colors to cycle through when creating new lines on the same figure.
"""
# Make sure Bokeh is available
if BOKEH_AVAILABLE:
monitor_channels = raise_to_list(monitor_channels)
if monitor_channels is None:
monitor_channels = []
self.channels = monitor_channels
self.colors = colors
self.bokeh_doc_name = bokeh_doc_name
self.server_url = server_url
session = push_session(curdoc(),
session_id=self.bokeh_doc_name,
url=self.server_url)
# Create figures for each group of channels
self.data_sources = {}
self.figures = []
self.figure_indices = {}
self.line_color_idx = 0
for i, channel in enumerate(self.channels):
idx = i
assert isinstance(channel, MonitorsChannel) or isinstance(channel, Monitor), \
"Need channels to be type MonitorsChannel or Monitor. Found %s" % str(type(channel))
# create the figure for this channel
fig = figure(title='{} #{}'.format(bokeh_doc_name,
channel.name),
x_axis_label='epochs',
y_axis_label='value',
logo=None,
toolbar_location='right')
# keep track of the line colors so we can rotate them around in the same manner across figures
self.line_color_idx = 0
# for each monitor in this channel, create the line (and train/valid/test variants if applicable)
# If this is a MonitorsChannel of multiple Monitors to plot
if isinstance(channel, MonitorsChannel):
for monitor in channel.monitors:
if monitor.train_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, monitor.name, TRAIN_MARKER])
self._create_line(fig, name)
if monitor.valid_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, monitor.name, VALID_MARKER])
self._create_line(fig, name)
if monitor.test_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, monitor.name, TEST_MARKER])
self._create_line(fig, name)
# otherwise it is a single Monitor
else:
if channel.train_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, TRAIN_MARKER])
self._create_line(fig, name)
if channel.valid_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, VALID_MARKER])
self._create_line(fig, name)
if channel.test_flag:
name = COLLAPSE_SEPARATOR.join(
[channel.name, TEST_MARKER])
self._create_line(fig, name)
if open_browser:
session.show()
if (cb_obj.active.includes(12)){jline.visible = true;}
// 1 index box is bline
if (cb_obj.active.includes(13)){kline.visible = true;}
if (cb_obj.active.includes(14)){kkline.visible = true;}
// 1 index box is bline
""",
args={
'aline': aline,
'bline': bline,
'cline': cline,
'ccline': ccline,
'dline': dline,
'ddline': ddline,
'eline': eline,
'fline': fline,
'gline': gline,
'ggline': ggline,
'hline': hline,
'iline': iline,
'jline': jline,
'kline': kline,
'kkline': kkline
})
checkboxes.js_on_click(callback)
layout = row(p1, checkboxes)
# output_file('BV2_DUT_sensors_134_sections.html')
# show(column(p1, p2, checkboxes))
curdoc().add_root(layout)
curdoc().title = "BV2"
show(layout)
elif Gender == 'All':
df = df
if Race != 'All':
df = df[df['RaceID'] == Race]
elif Race == 'All':
df = df
df = df[df['Split'] == split]
time = []
for value in df['Duration']:
if "-1 day" in value:
value = "00:00:00"
time.append(get_sec(value))
avg = sum(time) / len(time)
avges.append(avg)
newdf = pd.DataFrame({'splits': Splits, 'AvgDuration': avges})
newdf['AvgDuration'] = pd.to_datetime(newdf["AvgDuration"],
unit='s').dt.time
print(newdf)
plot.data_source.data['x'] = newdf.splits
plot.data_source.data['y'] = newdf.AvgDuration
Racetypes = Initialdf["RaceID"].unique().tolist()
Genders = ['All', 'M', 'F']
RaceSelect = Select(title="Select Race:", options=Racetypes)
GenderSelect = Select(title="Select Name:", options=Genders)
GenderSelect.on_change('value', update)
RaceSelect.on_change('value', update)
controls = column(GenderSelect, RaceSelect)
curdoc().add_root(row(p, controls))
from bokeh.models.tools import HoverTool, CrosshairTool, CustomAction
from bokeh.plotting import figure, curdoc
from bokeh.models.widgets import CheckboxGroup, RadioGroup, DataTable, TableColumn, Panel, Tabs
from bokeh.themes import Theme, built_in_themes
#
from itsdangerous import TimestampSigner
# from itsdangerous import BadSignature, SignatureExpired
import sys
sys.path.append("fontawesome")
from fontawesome.fontawesome_icon import FontAwesomeIcon
from nc_transform import get_plottable_variables, get_nc_data, get_tsp_data_dict
curdoc_element = curdoc()
args = curdoc_element.session_context.request.arguments
if not Path(os.environ['TSPLOT_DOWNLOAD']).exists():
Path(os.environ['TSPLOT_DOWNLOAD']).mkdir(parents=True, exist_ok=True)
def get_variables(resource_url):
plottable_variables = get_plottable_variables(resource_url)
return plottable_variables
class metadict(dict):
pass
date = DatePicker(value=str(D_MAX), min_date=str(D_MIN), max_date=str(D_MAX))
date.on_change("value", update_date)
reload_str = f"Dataset last loaded <i>{datetime.now().strftime('%Y-%m-%d %H:%M')}</i>"
last_refresh = Div(text=reload_str)
reload_btn = Button(label="Reload Counter", button_type="primary")
reload_btn.on_click(reload_counter)
_iframe = Div(text=IFRAME)
INFO_TEXT = f"""Dataset file: <pre>{DATASET}</pre>"""
# <br>Remote file: <pre>{REMOTE_DATASET}</pre>
# <br>Hashes: <pre>{HASH}<br>{REMOTE_HASH}</pre>
# <br>If the hashes do not match the dataset has been updated on GitHub"""
dataset_info = Div(text=INFO_TEXT)
extras = row(column(_iframe), column(dataset_info), column(reload_btn))
drops = row(gyms, date, last_refresh)
plots = row(plot_line(), plot_heat())
plot2 = row(plot_week_line())
tabs = Tabs(tabs=[
Panel(child=column(drops, plots, plot2), title="Historic Data"),
Panel(child=extras, title="Extras"),
])
l = row(tabs)
curdoc().add_root(l)
curdoc().title = "Depot Climbing Gym Dashboard"
curdoc().add_periodic_callback(update, 300000) # 5 minute update
def update(attr, old, new):
button.update(button_type='warning', label='Loading, please wait')
def calculate():
global home_to_plot, state_dict
data_selector = data_type_selector.labels[
data_type_selector.active]
if data_selector == 'Net Load':
data_to_plot = 'grid'
plot1.yaxis.axis_label = 'Net Load [kWh]'
if data_selector == 'Load + Battery(Charging)':
data_to_plot = 'Load_+_Battery(Charging)'
plot1.yaxis.axis_label = 'Load [kWh]'
if data_selector == "Electric Vehicle Consumption":
data_to_plot = 'car1'
plot1.yaxis.axis_label = 'Consumption [kWh]'
if data_selector == "PV Generation + Battery(Discharge)":
data_to_plot = 'PV_+_Battery(Discharge)'
plot1.yaxis.axis_label = 'Generation [kWh]'
trainDays_to_plot = int(trainDays_input.value)
new_home_to_plot = state_dict[community_selector.active]
#new_home_to_plot = int(home_id_selector.value) ###
plot1.title.text = f'{data_selector} forecasting of {new_home_to_plot} for date {date_slider.value}'
if new_home_to_plot != home_to_plot:
startDate = filterData[
filterData['state'] ==
new_home_to_plot]['time'].iloc[0].date() ##change
endDate = filterData[filterData['state'] ==
new_home_to_plot]['time'].iloc[-1].date()
middle = startDate + (endDate - startDate) / 1.5
date_slider.start = startDate
date_slider.end = endDate
date_slider.value = middle
date_to_plot = str(middle)
print(startDate, endDate, middle)
#daterange_raw = list(date_slider.value_as_datetime)
#daterange_to_plot = [daterange_raw[0].strftime("%Y-%m-%d"), daterange_raw[1].strftime("%Y-%m-%d")]
date_to_plot = date_slider.value
new_src1, new_mape1 = arima(date=date_to_plot,
state=new_home_to_plot,
data=data_to_plot,
trainDays=trainDays_to_plot)
src1.data.update(new_src1.data)
plot1.legend.title = f'Abs Error = {round(new_mape1,3)}%'
button.update(button_type='success', label='Done')
home_to_plot = new_home_to_plot
curdoc().add_next_tick_callback(calculate)
# flag = 0
# break
# else:
# flag = 1
# if flag == 1:
# stopState[node.index] = 1
# elif flag == 0:
# stopState[node.index] = 0
# if count > len(currentState)*100:
# infiniteFlag = True
# break
new_data = dict()
new_data['x'] = [i for i in range(len(currentState))]
new_data['y'] = currentState
ds.data = new_data
#for i in graphList:
# print(i.index, i.weight , i.adjVec, i.adjNum, i.weightPerNumPlusOne)
#print(currentState)
# for i,choose in enumerate(currentState):
# if choose == 1:
# MWIS.append(i)
# totalWeight += graphList[i].weight
# print(MWIS)
# print(totalWeight)
curdoc().add_periodic_callback(compute, 500)
curdoc().add_root(p)
def showGui(self):
output_file(os.path.join("webpages","multiSignalSplicer.html"))
logger.logData(source="Master splicer",priority="INFO",msgType="Show",msgData=())
show(self.gui)
curdoc().add_root(self.gui)
x_axis_label='Petal_width',
y_axis_label='Petal_length',
height=500,
width=500)
p1.circle(x="petal_length",
y="sepal_length",
color="color",
fill_alpha=0.5,
size=5,
source=source)
p2.circle(x="petal_width",
y="petal_length",
color="color",
fill_alpha=0.5,
size=5,
source=source)
button.on_click(click)
layout = row(column(select, button, div), column(p1), column(p2))
# # use curdoc to add your widgets to the document
curdoc().add_root(layout)
curdoc().title = "DVA_ex_3"
# # use on of the commands below to start your application
# # bokeh serve --show dva_ex3_skeleton_HS20.py
# # python -m bokeh serve --show dva_ex3_skeleton_HS20.py
# # bokeh serve --dev --show dva_ex3_skeleton_HS20.py
# # python -m bokeh serve --dev --show dva_ex3_skeleton_HS20.py
def click():
div.text = f'{"The final cost is : calculating..."}'
curdoc().add_next_tick_callback(start_clustering)
source=surrogate_source,
legend=label.lower())
p.yaxis.axis_label = 'Probability (%)'
plots.append([p])
p.add_tools(HoverTool(tooltips=[(label, "@" + label) for label in D.events]))
p.xaxis.axis_label = 'Time (sec.)'
p.legend.__setattr__('padding', 5)
p.legend.__setattr__('spacing', 0)
p.legend.__setattr__('label_height', 0)
p.legend.__setattr__('glyph_height', 10)
p.legend.__setattr__('background_fill_alpha', 0.5)
p.legend.__setattr__('label_text_alpha', 0.5)
x_range.follow = "end"
x_range.follow_interval = follow_interval
x_range.range_padding = 0
curdoc().add_root(
column(header,
gridplot(plots, toolbar_location="left", sizing_mode='scale_width'),
row(surrogate_button,
example_slider,
filename_field,
select_file_button,
sizing_mode='scale_width'),
sizing_mode='scale_width'))
controls = [example_slider]
for control in controls:
control.on_change('value', lambda attr, old, new: update(new))
curdoc().title = filename
source1.data = temp1.data
source2.data = temp2.data
# change title
p1.title.text = sector_name +' electricity consumption for state: '+ state_name
p2.title.text = sector_name +' electricity consumption for Region: '+ region
def callback_state(attr,old,new):
global state_name, sector_name, region
state_name = new
temp1, temp2, region = get_source(sector_name,state_name)
# change data
source1.data = temp1.data
source2.data = temp2.data
# change title
p1.title.text = sector_name +' electricity consumption for state: '+ state_name
p2.title.text = sector_name +' electricity consumption for Region: '+ region
# make drop down menu
select_sector = Select(title='Sector:', value=[*sector_dict][0], options=[*sector_dict])
select_sector.on_change('value', callback_sector)
select_state = Select(title='State:', value=[*state_dict][0], options=[*state_dict])
select_state.on_change('value', callback_state)
layout = column(widgetbox(select_sector,select_state),p1,p2)
# put the button and plot in a layout and add to the document
curdoc().add_root(layout)
new_figure.xaxis.axis_label = figure_data['xlabel']
new_figure.yaxis.axis_label = figure_data['ylabel']
# adding charts to figure
for chart in figure_data['charts']:
# adding both markers and line for chart
marker = getattr(new_figure, chart['marker'])
scatter = marker(x=[0], y=[0], color=chart['color'], size=10, legend=chart['legend'])
line = new_figure.line(x=[0], y=[0], color=chart['color'], line_width=1, legend=chart['legend'])
# adding data source for markers and line
data_sources[state][chart['key']] = scatter.data_source = line.data_source
figures.append(new_figure)
requests_key = config['requests_key']
url = config['url']
session = push_session(curdoc())
def update():
try:
resp = requests.get(url)
except requests.RequestException:
return
resp_data = resp.json()
data = resp_data['stats'][-1] # Getting "Total" data from locust
if resp_data['state'] in config['states']:
for key, data_source in six.iteritems(data_sources[resp_data['state']]):
# adding data from locust to data_source of our graphs
data_source.data['x'].append(data[requests_key])
data_source.data['y'].append(data[key])
# trigger data source changes
top=result['Amount'],
color="#3498DB")
def update_VBarPlot(attr, old, new):
year = Amountselect.value
temp = result.copy()
temp = temp[temp['Year'] == year]
print(temp)
VBar1.data_source.data['x'] = temp['RaceType']
VBar1.data_source.data['top'] = temp['Amount']
types = Finishdf["RaceType"].unique().tolist()
Finishselect = Select(options=types)
Finishselect.on_change('value', updateFinish)
Avgdf.Year = Avgdf.Year.astype(str)
years = Avgdf.Year.unique().tolist()
Avgselect = Select(options=years)
Avgselect.on_change('value', UpdateAvgPlot)
Amountselect = Select(options=years)
Amountselect.on_change('value', update_VBarPlot)
Avgcontrols = column(Avgselect)
Amountcontrols = column(Amountselect)
FinishControls = column(Finishselect)
l = layout([
[Finishp, FinishControls],
[AvgPlot, Avgcontrols, AmountPlot, Amountcontrols],
])
curdoc().add_root(l)
# selected_source = sorted(data_urls)[select.active]
# data = pd.read_csv(data_urls[selected_source])
data = pd.read_csv(data_urls[select.value])
# Convert EPSG code
p1 = Proj(init='epsg:4326') # this is the EPSG code of the original
p2 = Proj(init='epsg:3857') # this is the EPSG code of the tiles
transformed_coords = [
transform(p1, p2, x1, y1) for x1, y1 in zip(data['X'], data['Y'])
]
data['X'], data['Y'] = (zip(*transformed_coords))
# Convert to coordinates
new_data = {'X': data['X'], 'Y': data['Y']}
src.data = new_data
# menu = [(k, k) for k in data_urls.keys()]
# select = RadioGroup(active=0,
# labels=sorted(data_urls.keys()))
# select.on_change('active', update)
menu = sorted(data_urls.keys())
select = Select(title='Dataset', value=menu[3], options=menu)
select.on_change('value', update_data)
r1 = row(select, make_plot())
curdoc().add_root(r1)
curdoc().title = "Boston Geo Data Explorer"
from bokeh.embed import file_html from bokeh.plotting import curdoc from bokeh.models.widgets import Button, Toggle, CheckboxGroup from bokeh.models import Column def show_pcur(): show(p_cur) def show_p14(): show(p_14) def show_p28(): show(p_28) button1 = Button(label = "current prediction") button1.on_click(show_pcur) button2 = Button(label = "14 days prediction") button2.on_click(show_p14) button3 = Button(label="28 days prediction") button3.on_click(show_p28) a = curdoc() output_notebook() show(Column(button1,button2,button3)) !bokeh serve --show
stacked_chart_positive_data = wrangle_pos_data_for_stacked_chart(user_inputs)
stacked_chart_negative_data = wrangle_neg_data_for_stacked_chart(user_inputs)
stacked_chart_positive_source = ColumnDataSource(
data=stacked_chart_positive_data)
stacked_chart_negative_source = ColumnDataSource(
data=stacked_chart_negative_data)
stacked_chart = create_stacked_chart(
stacked_chart_positive_data,
stacked_chart_negative_data,
stacked_chart_positive_source,
stacked_chart_negative_source,
)
pie_chart_data = wrangle_data_for_pie_chart(user_inputs)
pie_chart_source = ColumnDataSource(data=pie_chart_data)
pie_chart = create_pie_chart(pie_chart_source)
# layout of charts
bar_chart.margin = (0, 0, 15, 0)
stacked_chart.margin = (0, 0, 15, 0)
charts = column(
bar_chart,
stacked_chart,
pie_chart,
sizing_mode="stretch_width",
margin=(0, 15, 0, 15),
)
# doc.theme = Theme(filename="main/static/main/ghg_bokeh_theme.yaml")
curdoc().add_root(layout([[inputs, charts]], css_classes=["center"]))
#
# Widgets
#
# data filters
filter_answered = checkbox_categorical_filter(src_ans, src_ans_orig)
filter_nanswered = checkbox_categorical_filter(src_nans, src_nans_orig)
# checkbox object
checkbox_group = CheckboxGroup(labels=LABELS_kmeans, active=[i for i in range(len(LABELS_kmeans))])
# event handlers
checkbox_group.js_on_change('active', filter_answered)
checkbox_group.js_on_change('active', filter_nanswered)
# output_file("color_scatter.html", title="color_scatter.py example")
# layout specificationns
lay = layout(
children = [
[p_answered, p_nanswered],
[checkbox_group],
]
)
tab = Panel(child=lay, title = 'Clusters')
tabs = Tabs(tabs=[tab])
curdoc().add_root(tabs)
# show(tabs) # open a browser or notebook depending on configuration
#DF TO DICT FOR GRAPHS
graph1_dict = df1.to_dict('list')
#print('graph1_dict ', graph1_dict)
graph1_source.data = graph1_dict
graph1.title.text = graph1_title
graph1.add_tools(
HoverTool(tooltips=[("Time", "@Time{%d-%m-%Y %H:%M}"),
(graph1_title, "@Metric{0,000.000}")],
formatters={'Time': 'datetime'}))
graph2_dict = df2.to_dict('list')
#print('graph1_dict ', graph1_dict)
graph2_source.data = graph2_dict
graph2.title.text = graph2_title
graph2.add_tools(
HoverTool(tooltips=[("Time", "@Time{%d-%m-%Y %H:%M}"),
(graph2_title, "@Metric{0,000.000}")],
formatters={'Time': 'datetime'}))
dropdown_coll1.on_change('value', refresh_graphs)
dropdown_coll2.on_change('value', refresh_graphs)
dropdown_days.on_change('value', refresh_graphs)
dropdown_hours.on_change('value', refresh_graphs)
dropdown_mins.on_change('value', refresh_graphs)
curdoc().add_root(
layout([dropdown_days, dropdown_hours, dropdown_mins], dropdown_coll1,
graph1, dropdown_coll2, graph2))
distortion_slider.value)
pBox.children[0] = p
submit_button.on_click(submit_button_cb)
variation_selector.on_change('active', selector_cb)
save_button.on_click(save_button_cb)
#slider.on_change('value', cb)
# hack to throttle slider callback (https://stackoverflow.com/questions/38375961/throttling-in-bokeh-application/38379136#38379136)
distortion_slider.callback_policy = 'mouseup' #call only on mouseup
#slider.callback_throttle = 50 #call max every x ms
source = ColumnDataSource(data=dict(value=[]))
source.on_change('data', slider_cb)
distortion_slider.callback = CustomJS(args=dict(source=source),
code="""
source.data = { value: [cb_obj.value] }
""")
# ## some CSS to center layout
# header = Div(text="""
# <style>
# body { width: 1150px; margin: 0 auto; }
# </style>
# """)
# curdoc().add_root(header)
curdoc().add_root(layout)
curdoc().add_root(source)
lic2bus[bus.Plaka].append(bus)
new_data = {
"lon": [[lon2wmlon(bus.Boylam) for bus in buses]
for buses in lic2bus.values()],
"lat": [[lat2wmlat(bus.Enlem) for bus in buses]
for buses in lic2bus.values()],
"license":
list(lic2bus.keys()),
"time": [buses[-1].Saat for buses in lic2bus.values()],
}
bus_line_renderer.data_source.data = new_data
print(
"Hi!",
new_data["lon"][:3],
new_data["lat"][:3],
new_data["license"][:3],
new_data["time"][:3],
)
new_data["lon"] = [vals[-1] for vals in new_data["lon"]]
new_data["lat"] = [vals[-1] for vals in new_data["lat"]]
bus_circle_renderer.data_source.data = new_data
update()
curdoc().add_root(p)
curdoc().add_root(explanation)
curdoc().add_periodic_callback(callback=update, period_milliseconds=60000)
colorcycler = cycle(colors)
legend_items = []
for lib in subset:
next_color = next(colorcycler)
line = f.line(x=subset[lib].index, y=subset[lib], line_color=next_color)
legend_items.append((lib, [line]))
legend = Legend(items=legend_items, location=(0, -60))
f.add_layout(legend, 'right')
return f
def app_layout(self):
controls = widgetbox([self.experiments_combo], width=200)
self._layout = row(self.make_plot(self.experiment_name), controls)
return self._layout
def update_experiment(self, attr, old, new):
if self._layout is not None:
self._layout.children[0] = self.make_plot()
if __name__ == '__main__':
plot = main()
if plot is not None:
curdoc().add_root(plot.static_layout())
#export_png(curdoc(), 'genesdetected.png')
save(curdoc(), 'coverage_mean.html')
elif __name__.startswith('bk_script'):
plot = main()
if plot is not None:
curdoc().add_root(plot.app_layout())
p4 = gridplot([[splom, dum_fig]], toolbar_location=None)
# [END] tab 4 - splom plot --------------------------------------------------------------------------------------------
# // TOOL GUI ===========================================================================================================================================================
# Spinner GUI
spinner = Spinner(title="Size", low=0, high=4, step=0.1, value=1, width=300)
# spinner.js_link('value', points.glyph, 'radius')
# Dropdown menu GUI
glyphs = [
"Blood Categorie", "Blood Bas Analysis", "Enzym & Minerals & Proteine",
"Other Tests"
]
select = Select(title="Select plot:", value="", options=[""] + glyphs)
curdoc().add_root(Row(select, name='root'))
def callback(attr, old, new):
layouts = curdoc().get_model_by_name('root').children
for glyph in glyphs:
plot = curdoc().get_model_by_name(glyph)
if plot:
layouts.remove(plot)
if new:
p = figure(name=new)
#exec(new + ' = p.' + new + '("x", "y", source = source)')
layouts.append(p)
select.on_change('value', callback)
opts['color_index'] = color.value if color.value != 'None' else None
if size.value != 'None':
opts['size_index'] = size.value
opts['scaling_factor'] = (1. / df[size.value].max()) * 200
points = hv.Points(df, kdims=kdims, label=label).opts(plot=opts,
style=style)
return renderer.get_plot(points).state
def update(attr, old, new):
layout.children[1] = create_figure()
x = Select(title='X-Axis', value='mpg', options=quantileable)
x.on_change('value', update)
y = Select(title='Y-Axis', value='hp', options=quantileable)
y.on_change('value', update)
size = Select(title='Size', value='None', options=['None'] + quantileable)
size.on_change('value', update)
color = Select(title='Color', value='None', options=['None'] + quantileable)
color.on_change('value', update)
controls = widgetbox([x, y, color, size], width=200)
layout = row(controls, create_figure())
curdoc().add_root(layout)
curdoc().title = "Crossfilter"
# pick a date
date_picker_i = DatePicker(value=date.today(),max_date=date.today(), title='Choose inital date:', width=150, disabled=False)
mydate_i=date_picker_i.value
date_picker_f = DatePicker(value=date.today(),max_date=date.today(), title='Choose final date:' , width=150, disabled=False)
mydate_f=date_picker_f.value
date_picker_i.on_change('value',initial_date)
date_picker_f.on_change('value',final_date)
hist_button = Button(label="Show History", button_type="default", width=310)
hist_button.on_click(get_history)
pre_head = PreText(text="N.B.: Readout every 10 seconds. Be patient!",width=500, height=50)
pre_head2 = PreText(text="",width=400, height=25)
pre_temp_top = PreText(text="",width=400, height=20)
pre_temp_mid = PreText(text="",width=400, height=20)
pre_temp_bot = PreText(text="",width=400, height=20)
h_space = PreText(text="",width=50, height=1)
v_space = PreText(text="",width=1, height=50)
# curdoc().add_root(column(pre_head,row(div,column(pre_head2,pre_temp_top,pre_temp_mid,pre_temp_bot),column(plot['temperature'],plot['humidity'],plot['pressure']),)))
curdoc().add_root(column(row(h_space,pre_head),row(h_space,live_hours_input, h_space, h_space, date_picker_i, date_picker_f), row(h_space,live_checkbox,h_space, h_space, hist_button),v_space,row(h_space,plot['temperature'],h_space,plot['humidity'],h_space,plot['pressure']), v_space,row(h_space,div)))
readdata()
main()
# time.sleep ( 10 )
periodic_callback_id = curdoc().add_periodic_callback(update, 10000)
else:
pass
from cobras_ts.visualquerier import VisualQuerier
from cobras_ts.cobras_kshape import COBRAS_kShape
import random
import numpy as np
import pandas as pd
import sys
def communicate_query_result(query_result):
global querier
querier.query_result = query_result
querier.query_answered = True
curdoc().title = "COBRAS-TS"
loading = Div(text="""<h3>Loading...<h3>""", width=100, height=100)
def mustlink_callback():
global query_answered
global querier
global layout
global button_ml
global button_cl
button_ml.disabled = True
button_cl.disabled = True
layout.children[1].children[1].children[1] = loading
def main():
ui = UI(_callback, UISpecs())
# show(ui.layout)
curdoc().add_root(ui.layout)
def demo_callback(*args, **kwargs):
"""
This script takes a screenshot of quicktime. It assumes
1. the window is in the upper left at (0, 0) of the main screen
2. that it's taking a screenshot of an iPhone camera in iOS 12
How to launch quicktime to record screen:
* File > New Movie Recording
* Click on red button and select "source: iPhone"
"""
os.system(
"""osascript -e 'tell application "Keyboard Maestro Engine" to do script "3CF8CFB6-5A27-47FF-8DFF-F6CBA7FCE841"'"""
)
print("\n" + "picture taken" + "\n")
with open("webcam.png", "rb") as f:
callback(f)
# put the button and plot in a layout and add to the document
demo = Button(label="Take picture", button_type="success")
demo.on_click(demo_callback)
if True:
button = upload
else:
button = demo
curdoc().add_root(column(button, p))
# # 'wellio': main_dir + "/docs/js/bundle.js",
# # 'my_gist': "make_a_plot.js",
# # 'my_test2': "./static/js/test_bokeh.js"
# },
# # css_file=main_dir + "../docs/css/main.css"
# )
# def load_callback(event, value):
# print('load this {}'.format(value))
code = '''
plot_log(\"current_log\", source.value)
target.text = \"done\"
'''
markdown = pn.pane.Markdown("<b>Markdown display</b>", width=400)
file_load_selector = pn.widgets.FileInput(accept='.LAS,.json,.las',
name='File Input')
# file_load_selector.link(file_load_selector, callbacks={'value': load_callback})
file_load_selector.jslink(target=markdown, code={'value': code})
# file_load_selector.jscallback(value=code, args={'value': file_load_selector.value})
print('creating column')
main_column = pn.Column(width=900)
test_html = pn.panel('<h1> Hi select a log file! </h1>')
main_column.append(test_html)
main_column.append(file_load_selector)
main_column.append(pn.panel("<script> plot_log(\"current_log\") </script>"))
main_column.append(markdown)
print('trying to add to doc')
main_column.servable()
doc = curdoc()
