def __init__(self, document_name, server_url=None, clear_document=True):
super(PlottingExtension, self).__init__()
self.document_name = document_name
self.server_url = DEFAULT_SRV_URL if server_url is None else server_url
self.session = Session(root_url=self.server_url)
self.document = Document()
self._setup_document(clear_document)
def test_publish_fails_for_invalid_auth(self):
sess = Session(client=app.test_client())
sess.register('testuser', 'testpassword')
sess.use_doc('test_cow')
sess2 = Session(client=app.test_client())
sess2.register('testuser2', 'testpassword')
sess2.docid = sess.docid
self.assertRaises(Exception, sess2.publish)
def __init__(self):
from bokeh.document import Document
from bokeh.session import Session
from bokeh.models import ColumnDataSource
from bokeh.sampledata.population import load_population
self.document = Document()
self.session = Session()
self.session.use_doc('population')
self.session.load_document(self.document)
self.df = load_population()
self.source_pyramid = ColumnDataSource(data=dict())
def init_plot(crawl_name):
session = Session()
document = Document()
session.use_doc(crawl_name)
session.load_document(document)
if document.context.children:
plot = document.context.children[0]
else:
output_server(crawl_name)
# TODO: Remove these when Bokeh is upgraded
# placeholders or Bokeh can't inject properly
current = np.datetime64(datetime.now())
xdr = Range1d(current, current + 1)
ydr = ["urls"]
# styling suggested by Bryan
plot = figure(title="Crawler Monitor",
tools="hover",
x_axis_type="datetime",
y_axis_location="right",
x_range=xdr,
y_range=ydr,
width=1200,
height=600)
plot.toolbar_location = None
plot.xgrid.grid_line_color = None
document.add(plot)
session.store_document(document)
script = autoload_server(plot, session)
#TODO: Looks like a Bokeh bug, probably not repeatable with current code
script = script.replace("'modelid': u'", "'modelid': '")
return script
def __init__(self,
document_name,
server_url=None,
start_server=False,
clear_document=True,
**kwargs):
self.document_name = document_name
self.server_url = (config.bokeh_server
if server_url is None else server_url)
self.start_server = start_server
self.sub = self._start_server_process() if self.start_server else None
self.session = Session(root_url=self.server_url)
self.document = Document()
self._setup_document(clear_document)
super(PlottingExtension, self).__init__(**kwargs)
def test_heatmap_recipe(self):
ar_downsample._loadAR()
reset_output()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot = figure(plot_width=600, plot_height=400, title="Test Title")
plot.square('A', 'B', source=source)
plot2 = ar_downsample.heatmap(plot,
palette="Reds9",
reserve_val=0,
points=True,
client_color=True,
title="Test Title 2")
source2 = self._find_source(plot2)
self.assertEquals("Test Title 2", plot2.title)
self.assertEquals(type(source2), ServerDataSource)
transform = source2.transform
self.assertEquals(type(transform['info']), ar_downsample.Const)
self.assertEquals(type(transform['agg']), ar_downsample.Count)
self.assertEquals(type(transform['shader']), ar_downsample.Seq)
self.assertEquals(transform['shader'].out, "image")
def test_source(self):
ar_downsample._loadAR()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot = figure()
plot.square('A', 'B', source=source)
agg = ar_downsample.CountCategories()
info = ar_downsample.Const(val=1)
shader = ar_downsample.InterpolateColor()
new_source = ar_downsample.source(plot,
agg=agg,
info=info,
shader=shader)
self.assertIsNotNone(new_source.transform)
trans = new_source.transform
self.assertEquals(trans['resample'], 'abstract rendering')
self.assertEquals(trans['agg'], agg)
self.assertEquals(trans['info'], info)
self.assertEquals(trans['shader'], shader)
self.assertEquals(trans['glyphspec'],
plot.select({'type': GlyphRenderer})[0].glyph)
self.assertEquals(trans['points'], False)
def test_replot_result_type(self):
ar_downsample._loadAR()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot = figure()
plot.square('A', 'B', source=source)
expected = {
"image": "Image",
"image_rgb": "ImageRGBA",
"multi_line": "MultiLine"
}
shaders = dict()
for name in dir(ar_downsample):
item = getattr(ar_downsample, name)
if isinstance(item, ar_downsample.Shader):
shaders[item] = item.out
for shader_class in shaders:
shader = shader_class()
rslt = ar_downsample.replot(plot, shader=shader)
self.assertEquals(
expected[shader.out],
self._glyphspec(rslt)['type'],
"Error with {0}. Expected {1}, recieved {2}".format(
str(shader_class), expected[shader.out],
self._glyphspec(rslt)))
def __init__(self, **kw):
super(RadialGraph, self).__init__(**kw)
self._node_source = ColumnDataSource(dict(id=[], time=[],
relevance=[]))
self._edge_source = ColumnDataSource(dict(parent=[], child=[]))
self._session = Session()
self._doc = Document()
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('data_tables_server')
self.session.load_document(self.document)
self.manufacturer_filter = None
self.model_filter = None
self.transmission_filter = None
self.drive_filter = None
self.class_filter = None
self.source = ColumnDataSource()
self.update_data()
self.document.add(self.create())
self.session.store_document(self.document)
def test_publish(self):
sess = Session(client=app.test_client())
sess.register('testuser', 'testpassword')
sess.use_doc('test_cow')
sess.publish()
doc = Doc.load(bokeh_app.servermodel_storage, sess.docid)
assert doc.title == 'test_cow'
assert doc.published == True
def init_plot(crawl_name):
session = Session()
document = Document()
session.use_doc(crawl_name)
session.load_document(document)
if document.context.children:
plot = document.context.children[0]
else:
output_server(crawl_name)
# TODO: Remove these when Bokeh is upgraded
# placeholders or Bokeh can't inject properly
current = np.datetime64(datetime.now())
xdr = Range1d(current, current + 1)
ydr = ["urls"]
# styling suggested by Bryan
plot = figure(title="Crawler Monitor", tools="hover",
x_axis_type="datetime", y_axis_location="right", x_range=xdr, y_range=ydr,
width=1200, height=600)
plot.toolbar_location = None
plot.xgrid.grid_line_color = None
document.add(plot)
session.store_document(document)
script = autoload_server(plot, session)
#TODO: Looks like a Bokeh bug, probably not repeatable with current code
script = script.replace("'modelid': u'", "'modelid': '")
return script
def test_register_configuration(self):
#create a dummy config file
config = tempfile.mkdtemp()
#create server
server = Session(name="foo",
client=app.test_client(),
configdir=config,
load_from_config=True)
assert server.userapikey == "nokey"
#register a user
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
server2 = Session(name="foo",
client=app.test_client(),
configdir=config,
load_from_config=True)
assert server2.userapikey == server.userapikey
assert server2.root_url == server.root_url
def test_register(self):
#create a dummy config file
config = tempfile.mkdtemp()
#create server
server = Session(name="foo", root_url="http://localhost:5006/",
configdir=config
)
assert server.userapikey == "nokey"
#register a user
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
#create a second server configuration
#make sure it loads the proper api key
server2 = Session(name="foo",
configdir=config
)
assert server2.userapikey == server.userapikey
assert server2.root_url == server.root_url
def test_register(self):
#create a dummy config file
config = tempfile.mkdtemp()
#create server
server = Session(name="foo", root_url="http://localhost:5006/",
configdir=config
)
assert server.userapikey == "nokey"
#register a user
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
#create a second server configuration
#make sure it loads the proper api key
server2 = Session(name="foo",
configdir=config
)
assert server2.userapikey == server.userapikey
assert server2.root_url == server.root_url
def wrapper(*args, **kwargs):
document = Document()
session = Session(name=url, root_url=url)
session.use_doc(document.docid)
session.load_document(document)
session.publish()
document.autoadd = False
document.autostore = False
obj = func(*args, **kwargs)
obj._docid = session.docid
obj._root_url = session.root_url
document.add(obj)
session.store_document(document)
return obj
def __init__(self, path, url):
self.document = Document()
self.session = Session(name=url, root_url=url)
#self.session = Session('load_from_config=False')
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest(path)
self.domain = Domain(path)
#handson = Handson()
#self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def test_login2(self):
#create a server config, register a user
config1 = tempfile.mkdtemp()
server = Session(name="foo",
client=app.test_client(),
configdir=config1,
load_from_config=True)
assert server.userapikey == "nokey"
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
config2 = tempfile.mkdtemp()
server2 = Session(name="foo",
client=app.test_client(),
configdir=config2,
load_from_config=True)
assert server2.userapikey == "nokey"
server2.login("testuser", "fluffy")
#make sure the userapikeys match
assert server2.userapikey == server.userapikey
def __init__(self, document_name, server_url=None, start_server=False,
clear_document=True, **kwargs):
self.document_name = document_name
self.server_url = (config.bokeh_server if server_url is None
else server_url)
self.start_server = start_server
self.sub = self._start_server_process() if self.start_server else None
self.session = Session(root_url=self.server_url)
self.document = Document()
self._setup_document(clear_document)
super(PlottingExtension, self).__init__(**kwargs)
def __init__(self):
from bokeh.objects import ColumnDataSource
from bokeh.document import Document
from bokeh.session import Session
from bokeh.sampledata.population import load_population
self.document = Document()
self.session = Session()
self.session.use_doc('population_reveal')
self.session.load_document(self.document)
self.df = load_population()
self.source_pyramid = ColumnDataSource(data=dict())
def test_login1(self):
username = "******"
password = "******"
user.new_user(bokeh_app.servermodel_storage, username, password)
sess = Session(client=app.test_client())
#have not logged in yet, so userinfo should return http error
self.assertRaises(Exception, lambda: sess.userinfo)
#try logging in with wrong password, should be 403
self.assertRaises(Exception, sess.login, 'testuser2', 'wrong password')
#actually login
sess.login('testuser2', 'fluffy')
assert sess.userinfo['username'] == 'testuser2'
def __init__(self, crawl_name, num_urls=DEFAULT_NUM_URLS):
"""
Create a NutchUrlTrails instance for visualizing a running Nutch crawl in real-time using Bokeh
:param name: The name of the crawl (as identified by the queue)
:param num_urls: The number of URLs to display in the visualization
:return: A NutchUrLTrails instance
"""
self.crawl_name = crawl_name
self.num_urls = num_urls
self.open_urls = {}
self.closed_urls = {}
self.old_segments = None
self.old_circles = None
self.session = Session()
self.session.use_doc(self.crawl_name)
self.document = Document()
con = Connection()
exchange = Exchange(EXCHANGE_NAME, 'direct', durable=False)
queue = Queue(crawl_name, exchange=exchange, routing_key=crawl_name)
self.queue = con.SimpleQueue(name=queue)
def wrapper(*args, **kwargs):
reset_output()
docname = prefix + str(uuid.uuid4())
session = Session(name=url, root_url=url)
session.use_doc(docname)
session.load_document(curdoc())
session.publish()
curdoc().autoadd = False
curdoc().autostore = False
obj = func(*args, **kwargs)
tag = embed.autoload_server(obj, session, public=True)
obj._tag = tag
curdoc().add(obj)
changed = session.store_document(curdoc())
logger.debug("stored: %s", str(changed))
return obj
def __init__(self):
from bokeh.models import ColumnDataSource
from bokeh.document import Document
from bokeh.session import Session
from bokeh.sampledata.population import load_population
self.document = Document()
self.session = Session()
self.session.use_doc('population_reveal')
self.session.load_document(self.document)
self.df = load_population()
self.source_pyramid = ColumnDataSource(data=dict())
# just render at the initialization
self._render()
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('data_tables_server')
self.session.load_document(self.document)
self.manufacturer_filter = None
self.model_filter = None
self.transmission_filter = None
self.drive_filter = None
self.class_filter = None
self.source = ColumnDataSource()
self.update_data()
self.document.add(self.create())
self.session.store_document(self.document)
def test_login(self):
#create a server config, register a user
config1 = tempfile.mkdtemp()
server = Session(name="foo", root_url="http://localhost:5006/",
configdir=config1
)
assert server.userapikey == "nokey"
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
#create a separate server config, login a user
config2 = tempfile.mkdtemp()
server2 = Session(name="foo", root_url="http://localhost:5006/",
configdir=config2
)
assert server2.userapikey == "nokey"
server2.login("testuser", "fluffy")
#make sure the userapikeys match
assert server2.userapikey == server.userapikey
def __init__(self, path, url):
self.document = Document()
self.session = Session(name=url, root_url=url)
#self.session = Session('load_from_config=False')
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest(path)
self.domain = Domain(path)
#handson = Handson()
#self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def test_replot_remove(self):
ar_downsample._loadAR()
reset_output()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot = figure()
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 test_replot_property_transfer(self):
ar_downsample._loadAR()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot_width = 612
plot_height = 408
plot_title = "Test title"
plot = figure(plot_width=plot_width,
plot_height=plot_height,
title=plot_title)
plot.square('A', 'B', source=source)
ar_plot = ar_downsample.replot(plot)
self.assertEquals(ar_plot.plot_width, plot_width,
"Plot width not transfered")
self.assertEquals(ar_plot.plot_height, plot_height,
"Plot height not transfered")
self.assertEquals(ar_plot.title, plot_title,
"Plot title not transfered")
plot_width = 612
plot_height = 408
plot_title = "Test title"
ar_plot = ar_downsample.replot(plot,
title=plot_title,
plot_width=plot_width,
plot_height=plot_height)
self.assertEquals(ar_plot.plot_width, plot_width,
"Plot width override failed")
self.assertEquals(ar_plot.plot_height, plot_height,
"Plot height override failed")
self.assertEquals(ar_plot.title, plot_title,
"Plot title override failed")
def __init__(self,
port = BK_SERVER_PORT,
doc_name = DOC_NAME,
colors = COLORS,
show = False,
):
"""
Initialize Bokeh session and document.
"""
self.document = Document()
self.port = port
self.show = show
self.doc_name = doc_name
name="http://localhost:{}/".format(port)
root_url="http://localhost:{}/".format(port)
# Initialize Session
self.session = Session(load_from_config=False,
name=name,
root_url=root_url)
try:
self.session.use_doc(doc_name)
except requests.ConnectionError as e:
print("\nPlease start bokeh-sever on the command line to launch this dashboard.")
exit(1)
self.session.load_document(self.document)
# Configuration
self.colors = itertools.cycle(COLORS)
# Initialize data sources, construct and store dashboard
self.init_sources()
self.document.add(self.construct())
def __init__(self, crawl_name, num_urls=DEFAULT_NUM_URLS):
"""
Create a NutchUrlTrails instance for visualizing a running Nutch crawl in real-time using Bokeh
:param name: The name of the crawl (as identified by the queue)
:param num_urls: The number of URLs to display in the visualization
:return: A NutchUrLTrails instance
"""
self.crawl_name = crawl_name
self.num_urls = num_urls
self.open_urls = {}
self.closed_urls = {}
self.old_segments = None
self.old_circles = None
self.session = Session()
self.session.use_doc(self.crawl_name)
self.document = Document()
con = Connection()
exchange = Exchange(EXCHANGE_NAME, 'direct', durable=False)
queue = Queue(crawl_name, exchange=exchange, routing_key=crawl_name)
self.queue = con.SimpleQueue(name=queue)
def test_contour_recipe(self):
ar_downsample._loadAR()
reset_output()
sess = Session(client=app.test_client())
output_server('Census', session=sess)
source = ServerDataSource(expr={
'op': 'Field',
'args': [':leaf', 'bivariate']
})
plot = figure(plot_width=600, plot_height=400, title="Test Title")
plot.square('A', 'B', source=source)
plot2 = ar_downsample.contours(plot, title="Contour")
source2 = self._find_source(plot2)
self.assertEquals("Contour", plot2.title)
self.assertEquals(type(source2), ServerDataSource)
transform = source2.transform
self.assertEquals(type(transform['info']), ar_downsample.Const)
self.assertEquals(type(transform['agg']), ar_downsample.Count)
self.assertEquals(type(transform['shader']), ar_downsample.Seq)
self.assertEquals(transform['shader'].out, "multi_line")
def wrapper(*args, **kwargs):
docname = prefix + str(uuid.uuid4())
session = Session(name=url, root_url=url)
session.use_doc(docname)
session.load_document(curdoc())
curdoc().autoadd(False)
curdoc().autostore(False)
obj = func(*args, **kwargs)
tag = embed.autoload_server(obj, session)
obj.tag = tag
curdoc().add(obj)
changed = session.store_document(curdoc())
logger.debug("stored: %s", str(changed))
return obj
def test_login(self):
#create a server config, register a user
config1 = tempfile.mkdtemp()
server = Session(name="foo", root_url="http://localhost:5006/",
configdir=config1
)
assert server.userapikey == "nokey"
server.register("testuser", "fluffy")
assert server.userapikey and server.userapikey != "nokey"
#create a separate server config, login a user
config2 = tempfile.mkdtemp()
server2 = Session(name="foo", root_url="http://localhost:5006/",
configdir=config2
)
assert server2.userapikey == "nokey"
server2.login("testuser", "fluffy")
#make sure the userapikeys match
assert server2.userapikey == server.userapikey
class PlottingExtension(Callback):
"""Base class for extensions doing Bokeh plotting.
Parameters
----------
document_name : str
The name of the Bokeh document. Use a different name for each
experiment if you are storing your plots.
##start_server : Removed, as it has a number of flaws inkl. zombi bokeh-server processes!
server_url : str, optional
Url of the bokeh-server. Ex: when starting the bokeh-server with
``bokeh-server --ip 0.0.0.0`` at ``alice``, server_url should be
``http://alice:5006``. Defaults to http://localhost:5006.
clear_document : bool, optional
Whether or not to clear the contents of the server-side document
upon creation. If `False`, previously existing plots within the
document will be kept. Defaults to `True`.
"""
def __init__(self, document_name, server_url=None, clear_document=True):
super(PlottingExtension, self).__init__()
self.document_name = document_name
self.server_url = DEFAULT_SRV_URL if server_url is None else server_url
self.session = Session(root_url=self.server_url)
self.document = Document()
self._setup_document(clear_document)
def _setup_document(self, clear_document=False):
self.session.use_doc(self.document_name)
self.session.load_document(self.document)
if clear_document:
self.document.clear()
self._document_setup_done = True
def __getstate__(self):
state = self.__dict__.copy()
state.pop('_sub', None)
state.pop('session', None)
state.pop('_push_thread', None)
return state
def __setstate__(self, state):
self.__dict__.update(state)
self.session = Session(root_url=self.server_url)
self._document_setup_done = False
def on_callback(self, logs={}):
if not self._document_setup_done:
self._setup_document()
@property
def push_thread(self):
if not hasattr(self, '_push_thread'):
self._push_thread = PushThread(self.session, self.document)
self._push_thread.start()
return self._push_thread
def store_data(self, obj):
self.push_thread.put(obj, PushThread.PUT)
def push_document(self, after_training=False):
self.push_thread.put(after_training, PushThread.PUSH)
def __setstate__(self, state):
self.__dict__.update(state)
if self.start_server:
self._start_server_process()
self.session = Session(root_url=self.server_url)
self._document_setup_done = False
class DataTables(object):
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('data_tables_server')
self.session.load_document(self.document)
self.manufacturer_filter = None
self.model_filter = None
self.transmission_filter = None
self.drive_filter = None
self.class_filter = None
self.source = ColumnDataSource()
self.update_data()
self.document.add(self.create())
self.session.store_document(self.document)
def create(self):
manufacturers = sorted(mpg["manufacturer"].unique())
models = sorted(mpg["model"].unique())
transmissions = sorted(mpg["trans"].unique())
drives = sorted(mpg["drv"].unique())
classes = sorted(mpg["class"].unique())
manufacturer_select = Select(title="Manufacturer:", value="All", options=["All"] + manufacturers)
manufacturer_select.on_change('value', self.on_manufacturer_change)
model_select = Select(title="Model:", value="All", options=["All"] + models)
model_select.on_change('value', self.on_model_change)
transmission_select = Select(title="Transmission:", value="All", options=["All"] + transmissions)
transmission_select.on_change('value', self.on_transmission_change)
drive_select = Select(title="Drive:", value="All", options=["All"] + drives)
drive_select.on_change('value', self.on_drive_change)
class_select = Select(title="Class:", value="All", options=["All"] + classes)
class_select.on_change('value', self.on_class_change)
columns = [
TableColumn(field="manufacturer", header="Manufacturer", type="autocomplete", source=manufacturers),
TableColumn(field="model", header="Model", type="autocomplete", source=models),
TableColumn(field="displ", header="Displacement", type="numeric", format="0.00"),
TableColumn(field="year", header="Year", type="numeric"),
TableColumn(field="cyl", header="Cylinders", type="numeric"),
TableColumn(field="trans", header="Transmission", type="dropdown", strict=True, source=transmissions),
TableColumn(field="drv", header="Drive", type="autocomplete", strict=True, source=drives),
TableColumn(field="class", header="Class", type="autocomplete", strict=True, source=classes),
TableColumn(field="cty", header="City MPG", type="numeric"),
TableColumn(field="hwy", header="Highway MPG", type="numeric"),
]
handson_table = HandsonTable(source=self.source, columns=columns, sorting=True)
xdr = DataRange1d(sources=[self.source.columns("index")])
#xdr = FactorRange(factors=manufacturers)
ydr = DataRange1d(sources=[self.source.columns("cty"), self.source.columns("hwy")])
plot = Plot(title=None, data_sources=[self.source], x_range=xdr, y_range=ydr, plot_width=800, plot_height=300)
xaxis = LinearAxis(plot=plot)
plot.below.append(xaxis)
yaxis = LinearAxis(plot=plot)
ygrid = Grid(plot=plot, dimension=1, ticker=yaxis.ticker)
plot.left.append(yaxis)
cty = Glyph(data_source=self.source, glyph=Circle(x="index", y="cty", fill_color="green"))
hwy = Glyph(data_source=self.source, glyph=Circle(x="index", y="hwy", fill_color="red"))
select_tool = BoxSelectTool(renderers=[cty, hwy], select_y=False)
plot.tools.append(select_tool)
overlay = BoxSelectionOverlay(tool=select_tool)
plot.renderers.extend([cty, hwy, ygrid, overlay])
controls = VBox(children=[manufacturer_select, model_select, transmission_select, drive_select, class_select], width=200)
top_panel = HBox(children=[controls, plot])
layout = VBox(children=[top_panel, handson_table])
return layout
def on_manufacturer_change(self, obj, attr, _, value):
self.manufacturer_filter = None if value == "All" else value
self.update_data()
def on_model_change(self, obj, attr, _, value):
self.model_filter = None if value == "All" else value
self.update_data()
def on_transmission_change(self, obj, attr, _, value):
self.transmission_filter = None if value == "All" else value
self.update_data()
def on_drive_change(self, obj, attr, _, value):
self.drive_filter = None if value == "All" else value
self.update_data()
def on_class_change(self, obj, attr, _, value):
self.class_filter = None if value == "All" else value
self.update_data()
def update_data(self):
df = mpg
if self.manufacturer_filter:
df = df[df["manufacturer"] == self.manufacturer_filter]
if self.model_filter:
df = df[df["model"] == self.model_filter]
if self.transmission_filter:
df = df[df["trans"] == self.transmission_filter]
if self.drive_filter:
df = df[df["drv"] == self.drive_filter]
if self.class_filter:
df = df[df["class"] == self.class_filter]
self.source.data = ColumnDataSource.from_df(df)
self.session.store_document(self.document)
def run(self, poll_interval=0.5):
link = self.session.object_link(self.document.context)
print("Please visit %s to see the plots (press ctrl-C to exit)" % link)
try:
while True:
self.session.load_document(self.document)
time.sleep(poll_interval)
except KeyboardInterrupt:
print()
except ConnectionError:
print("Connection to bokeh-server was terminated")
from __future__ import print_function
import time
import numpy as np
import sympy as sy
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.glyphs import Line
from bokeh.objects import Plot, DataRange1d, LinearAxis, ColumnDataSource, Grid, Legend
from bokeh.session import Session
from bokeh.widgets import Slider, TextInput, HBox, VBox, Dialog
document = Document()
session = Session()
session.use_doc('taylor_server')
session.load_document(document)
xs = sy.Symbol('x')
expr = sy.exp(-xs)*sy.sin(xs)
order = 1
def taylor(fx, xs, order, x_range=(0, 1), n=200):
x0, x1 = x_range
x = np.linspace(float(x0), float(x1), n)
fy = sy.lambdify(xs, fx, modules=['numpy'])(x)
tx = fx.series(xs, n=order).removeO()
if tx.is_Number:
def login(password, username='******'):
session = Session()
session.login(username, password)
from __future__ import print_function
import sys
import requests
from datetime import date
from bokeh.widgetobjects import HBox, VBox, TableColumn, HandsonTable, ObjectExplorer
from bokeh.objects import Plot, ColumnDataSource, DataRange1d, Glyph, LinearAxis, DatetimeAxis, Grid, HoverTool
from bokeh.glyphs import Line, Circle
from bokeh.document import Document
from bokeh.session import Session
document = Document()
session = Session()
session.use_doc('widgets_server')
session.load_document(document)
def make_plot():
source = ColumnDataSource(dict(
dates = [ date(2014, 3, i) for i in [1, 2, 3, 4, 5] ],
downloads = [100, 27, 54, 64, 75],
))
xdr = DataRange1d(sources=[source.columns("dates")])
ydr = DataRange1d(sources=[source.columns("downloads")])
plot = Plot(title="Product downloads", data_sources=[source], x_range=xdr, y_range=ydr, plot_width=400, plot_height=400)
line = Line(x="dates", y="downloads", line_color="blue")
line_glyph = Glyph(data_source=source, xdata_range=xdr, ydata_range=ydr, glyph=line)
plot.renderers.append(line_glyph)
circle = Circle(x="dates", y="downloads", fill_color="red")
circle_glyph = Glyph(data_source=source, xdata_range=xdr, ydata_range=ydr, glyph=circle)
plot.renderers.append(circle_glyph)
import requests
from requests.exceptions import ConnectionError
import pandas as pd
from bokeh.objects import (Plot, ColumnDataSource, DataRange1d, FactorRange,
LinearAxis, CategoricalAxis, Grid, Glyph, Legend, SingleIntervalTicker, HoverTool)
from bokeh.widgetobjects import Select, HBox, VBox
from bokeh.glyphs import Line, Quad
from bokeh.document import Document
from bokeh.session import Session
from bokeh.sampledata.population import load_population
document = Document()
session = Session()
session.use_doc('population_server')
session.load_document(document)
df = load_population()
revision = 2012
year = 2010
location = "World"
years = list(map(str, sorted(df.Year.unique())))
locations = sorted(df.Location.unique())
source_pyramid = ColumnDataSource(data=dict())
def pyramid():
def test_register_twice_should_fail(self):
sess = Session(client=app.test_client())
sess.register('testuser1', 'testpassword1')
self.assertRaises(RuntimeError, sess.register, 'testuser1',
'testpassword1')
class DashBoard(object):
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def render(self):
self.create_layout()
self.document.add(self.layout)
self.update_data()
def create_layout(self):
#button = Button(label="Randomize data", type="success")
#button.on_click(update_data)
#top_panel = HBox(children=[button, self.harvest.plot, self.harvest.rate_plot])
top_panel = HBox(children=[self.harvest.plot, self.harvest.rate_plot])
domains = VBox(children=[self.domain.sort_relevant_plot, self.domain.sort_crawled_plot, self.domain.sort_frontier_plot], width=200)
#middle_panel = HBox(children=[domains, handson.plot])
middle_panel = HBox(children=[domains])
layout = VBox(children=[top_panel, middle_panel, self.termite.plot])
self.layout = layout
return layout
def update_data(self):
self.harvest.source = self.harvest.update_source()
self.domain.sort_relevant_source, self.domain.sort_crawled_source, self.domain.sort_frontier_source = self.domain.update_source()
self.termite.data, self.termite.source = self.termite.update_source()
#self.session.store_objects(ds)
self.session.store_document(self.document)
def run(self, poll_interval=0.5):
#link = self.session.object_link(self.document.context)
#print("Please visit %s to see the plots (press ctrl-C to exit)" % link)
try:
while True:
self.update_data()
self.session.load_document(self.document)
time.sleep(poll_interval)
except KeyboardInterrupt:
print()
except ConnectionError:
print("Connection to bokeh-server was terminated")
from __future__ import print_function
import numpy as np
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.glyphs import *
from bokeh.objects import (
Plot, Range1d, LinearAxis, Grid, ColumnDataSource, PanTool, WheelZoomTool
)
from bokeh.session import Session
document = Document()
session = Session()
session.use_doc('prim_server')
session.load_document(document)
x = np.arange(1,6)
y = np.arange(5, 0, -1)
source = ColumnDataSource(data=dict(x=x,y=y))
xdr = Range1d(start=0, end=10)
ydr = Range1d(start=0, end=10)
def make_plot(name, glyph):
plot = Plot(x_range=xdr, y_range=ydr, min_border=80)
plot.add_glyph(source, glyph)
xaxis = LinearAxis()
from __future__ import print_function
import numpy as np
from bokeh.models import ColumnDataSource, DataRange1d, Plot, Circle, VBox, HBox, Button, TapTool
from bokeh.document import Document
from bokeh.session import Session
from bokeh.browserlib import view
document = Document()
session = Session()
session.use_doc("linked_tap_server")
session.load_document(document)
N = 9
x = np.linspace(-2, 2, N)
y = x ** 2
source1 = ColumnDataSource(dict(x=x, y=y, size=[20] * N))
xdr1 = DataRange1d()
ydr1 = DataRange1d()
plot1 = Plot(title="Plot1", x_range=xdr1, y_range=ydr1, plot_width=400, plot_height=400)
plot1.tools.append(TapTool(plot=plot1))
plot1.add_glyph(source1, Circle(x="x", y="y", size="size", fill_color="red"))
source2 = ColumnDataSource(dict(x=x, y=y, color=["blue"] * N))
xdr2 = DataRange1d()
ydr2 = DataRange1d()
plot2 = Plot(title="Plot2", x_range=xdr2, y_range=ydr2, plot_width=400, plot_height=400)
plot2.tools.append(TapTool(plot=plot2))
from __future__ import print_function
import numpy as np
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.glyphs import *
from bokeh.objects import (
Plot, Range1d, LinearAxis, Grid, ColumnDataSource, PanTool, WheelZoomTool
)
from bokeh.session import Session
document = Document()
session = Session()
session.use_doc('prim_server')
session.load_document(document)
x = np.arange(1,6)
y = np.arange(5, 0, -1)
source = ColumnDataSource(data=dict(x=x,y=y))
xdr = Range1d(start=0, end=10)
ydr = Range1d(start=0, end=10)
def make_plot(name, glyph):
plot = Plot(x_range=xdr, y_range=ydr, min_border=80)
plot.add_glyph(source, glyph)
xaxis = LinearAxis()
cds_bad_aug_plot = networkx_osm_ops.set_nodes_source_empty()
source_target_plot = networkx_osm_ops.set_nodes_source_empty()
source_sourcenodes_plot = networkx_osm_ops.set_nodes_source_empty()
source_crit_plot = networkx_osm_ops.set_nodes_source_empty()
source_missing_plot = networkx_osm_ops.set_nodes_source_empty()
source_histo_cum_plot = networkx_osm_ops.set_nodes_source_empty()
source_histo_bin_plot = networkx_osm_ops.set_nodes_source_empty()
source_subgraph_plot = networkx_osm_ops.set_nodes_source_empty()
source_hull_node_plot = networkx_osm_ops.set_nodes_source_empty()
source_hull_patch_plot = networkx_osm_ops.set_nodes_source_empty()
#############
#############
# CREATE DOCUMENT
document = Document()
session = Session(load_from_config=False)
session.use_doc('Load OSM')
session.load_document(document)
#############
###############################################################################
def define_files():
'''Define files from root, min_road_type, gmap_background, and indir'''
global root, indir, outroot, outdir, gdelt_infile, osmfile, queryfile, \
html_raw, html_ref, html_gdelt, html_aug, \
min_road_type, gmap_background
# output files
# outroot
outroot = 'osm_' + root.strip() + '_' + min_road_type.lower()
def __setstate__(self, state):
self.__dict__.update(state)
self.session = Session(root_url=self.server_url)
self._document_setup_done = False
from __future__ import print_function
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.session import Session
from bokeh.models.widgets import (
VBox, Icon,
Button, Toggle, Dropdown,
CheckboxGroup, RadioGroup,
CheckboxButtonGroup, RadioButtonGroup,
)
document = Document()
session = Session()
session.use_doc('buttons_server')
session.load_document(document)
def button_handler():
print("button_handler: click")
session.store_document(document)
def toggle_handler(active):
print("toggle_handler: %s" % active)
session.store_document(document)
def dropdown_handler(action):
print("dropdown_handler: %s" % action)
session.store_document(document)
def split_handler(action):
print("split_handler: %s" % action)
def test_register(self):
sess = Session(client=app.test_client())
sess.register('testuser1', 'testpassword1')
sess.userinfo['username'] == 'testuser1'
from requests.exceptions import ConnectionError
import pandas as pd
from bokeh.models import (Plot, ColumnDataSource, DataRange1d, FactorRange,
LinearAxis, CategoricalAxis, Grid, Glyph)
from bokeh.models.widgets import (DateRangeSlider, HBox, VBox, Paragraph,
Select, VBoxModelForm)
from bokeh.glyphs import Rect
from bokeh.document import Document
from bokeh.session import Session
import employment_data_reader as emp
from employment_utils import get_country_for_byte, get_jobtype_for_byte
document = Document()
session = Session()
session.use_doc('employment_server')
session.load_document(document)
days_of_week = {0: "Monday", 1: "Tuesday", 2: "Wednesday", 3: "Thursday",
4: "Friday", 5: "Saturday", 6: "Sunday"}
bounds_start = datetime.date(2012, 11, 1)
bounds_end = datetime.date(2013, 12, 30)
start = datetime.date(2013, 5, 26)
end = datetime.date(2013, 7, 5)
source_country = ColumnDataSource(data=dict())
source_dow = ColumnDataSource(data=dict())
source_jobtype = ColumnDataSource(data=dict())
source_par = Paragraph()
country_choices = ["Dominican Republic___________________",
"Colombia_____________________________",
class PlottingExtension(SimpleExtension):
"""Base class for extensions doing Bokeh plotting.
Parameters
----------
document_name : str
The name of the Bokeh document. Use a different name for each
experiment if you are storing your plots.
start_server : bool, optional
Whether to try and start the Bokeh plotting server. Defaults to
``False``. The server started is not persistent i.e. after shutting
it down you will lose your plots. If you want to store your plots,
start the server manually using the ``bokeh-server`` command. Also
see the warning above.
server_url : str, optional
Url of the bokeh-server. Ex: when starting the bokeh-server with
``bokeh-server --ip 0.0.0.0`` at ``alice``, server_url should be
``http://alice:5006``. When not specified the default configured
by ``bokeh_server`` in ``.blocksrc`` will be used. Defaults to
``http://localhost:5006/``.
clear_document : bool, optional
Whether or not to clear the contents of the server-side document
upon creation. If `False`, previously existing plots within the
document will be kept. Defaults to `True`.
"""
def __init__(self, document_name, server_url=None, start_server=False,
clear_document=True, **kwargs):
self.document_name = document_name
self.server_url = (config.bokeh_server if server_url is None
else server_url)
self.start_server = start_server
self.sub = self._start_server_process() if self.start_server else None
self.session = Session(root_url=self.server_url)
self.document = Document()
self._setup_document(clear_document)
super(PlottingExtension, self).__init__(**kwargs)
def _start_server_process(self):
def preexec_fn():
"""Prevents the server from dying on training interrupt."""
signal.signal(signal.SIGINT, signal.SIG_IGN)
# Only memory works with subprocess, need to wait for it to start
logger.info('Starting plotting server on localhost:5006')
self.sub = Popen('bokeh-server --ip 0.0.0.0 '
'--backend memory'.split(),
stdout=PIPE, stderr=PIPE, preexec_fn=preexec_fn)
time.sleep(2)
logger.info('Plotting server PID: {}'.format(self.sub.pid))
def _setup_document(self, clear_document=False):
self.session.use_doc(self.document_name)
self.session.load_document(self.document)
if clear_document:
self.document.clear()
self._document_setup_done = True
def __getstate__(self):
state = self.__dict__.copy()
state['sub'] = None
state.pop('session', None)
state.pop('_push_thread', None)
return state
def __setstate__(self, state):
self.__dict__.update(state)
if self.start_server:
self._start_server_process()
self.session = Session(root_url=self.server_url)
self._document_setup_done = False
def do(self, which_callback, *args):
if not self._document_setup_done:
self._setup_document()
@property
def push_thread(self):
if not hasattr(self, '_push_thread'):
self._push_thread = PushThread(self.session, self.document)
self._push_thread.start()
return self._push_thread
def store(self, obj):
self.push_thread.put(obj, PushThread.PUT)
def push(self, which_callback):
self.push_thread.put(which_callback, PushThread.PUSH)
def setUp(self):
self.sess = Session(load_from_config=False)
self.sess.docid = 'docid10'
self.sess.apikey = 'apikey123'
self.sess.root_url = "http://foo"
class DataTables(object):
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('data_tables_server')
self.session.load_document(self.document)
self.manufacturer_filter = None
self.model_filter = None
self.transmission_filter = None
self.drive_filter = None
self.class_filter = None
self.source = ColumnDataSource()
self.update_data()
self.document.add(self.create())
self.session.store_document(self.document)
def create(self):
manufacturers = sorted(mpg["manufacturer"].unique())
models = sorted(mpg["model"].unique())
transmissions = sorted(mpg["trans"].unique())
drives = sorted(mpg["drv"].unique())
classes = sorted(mpg["class"].unique())
manufacturer_select = Select(title="Manufacturer:", value="All", options=["All"] + manufacturers)
manufacturer_select.on_change('value', self.on_manufacturer_change)
model_select = Select(title="Model:", value="All", options=["All"] + models)
model_select.on_change('value', self.on_model_change)
transmission_select = Select(title="Transmission:", value="All", options=["All"] + transmissions)
transmission_select.on_change('value', self.on_transmission_change)
drive_select = Select(title="Drive:", value="All", options=["All"] + drives)
drive_select.on_change('value', self.on_drive_change)
class_select = Select(title="Class:", value="All", options=["All"] + classes)
class_select.on_change('value', self.on_class_change)
columns = [
TableColumn(field="manufacturer", title="Manufacturer", editor=SelectEditor(options=manufacturers), formatter=StringFormatter(font_style="bold")),
TableColumn(field="model", title="Model", editor=StringEditor(completions=models)),
TableColumn(field="displ", title="Displacement", editor=NumberEditor(step=0.1), formatter=NumberFormatter(format="0.0")),
TableColumn(field="year", title="Year", editor=IntEditor()),
TableColumn(field="cyl", title="Cylinders", editor=IntEditor()),
TableColumn(field="trans", title="Transmission", editor=SelectEditor(options=transmissions)),
TableColumn(field="drv", title="Drive", editor=SelectEditor(options=drives)),
TableColumn(field="class", title="Class", editor=SelectEditor(options=classes)),
TableColumn(field="cty", title="City MPG", editor=IntEditor()),
TableColumn(field="hwy", title="Highway MPG", editor=IntEditor()),
]
data_table = DataTable(source=self.source, columns=columns, editable=True)
xdr = DataRange1d()
ydr = DataRange1d()
plot = Plot(title=None, x_range=xdr, y_range=ydr, plot_width=800, plot_height=300)
xaxis = LinearAxis(plot=plot)
plot.below.append(xaxis)
yaxis = LinearAxis(plot=plot)
ygrid = Grid(plot=plot, dimension=1, ticker=yaxis.ticker)
plot.left.append(yaxis)
cty_glyph = Circle(x="index", y="cty", fill_color="#396285", size=8, fill_alpha=0.5, line_alpha=0.5)
hwy_glyph = Circle(x="index", y="hwy", fill_color="#CE603D", size=8, fill_alpha=0.5, line_alpha=0.5)
cty = GlyphRenderer(data_source=self.source, glyph=cty_glyph)
hwy = GlyphRenderer(data_source=self.source, glyph=hwy_glyph)
tooltips = [
("Manufacturer", "@manufacturer"),
("Model", "@model"),
("Displacement", "@displ"),
("Year", "@year"),
("Cylinders", "@cyl"),
("Transmission", "@trans"),
("Drive", "@drv"),
("Class", "@class"),
]
cty_hover_tool = HoverTool(plot=plot, renderers=[cty], tooltips=tooltips + [("City MPG", "@cty")])
hwy_hover_tool = HoverTool(plot=plot, renderers=[hwy], tooltips=tooltips + [("Highway MPG", "@hwy")])
select_tool = BoxSelectTool(plot=plot, renderers=[cty, hwy], dimensions=['width'])
plot.tools.extend([cty_hover_tool, hwy_hover_tool, select_tool])
plot.renderers.extend([cty, hwy, ygrid])
controls = VBox(children=[manufacturer_select, model_select, transmission_select, drive_select, class_select], width=200)
top_panel = HBox(children=[controls, plot])
layout = VBox(children=[top_panel, data_table])
return layout
def on_manufacturer_change(self, obj, attr, _, value):
self.manufacturer_filter = None if value == "All" else value
self.update_data()
def on_model_change(self, obj, attr, _, value):
self.model_filter = None if value == "All" else value
self.update_data()
def on_transmission_change(self, obj, attr, _, value):
self.transmission_filter = None if value == "All" else value
self.update_data()
def on_drive_change(self, obj, attr, _, value):
self.drive_filter = None if value == "All" else value
self.update_data()
def on_class_change(self, obj, attr, _, value):
self.class_filter = None if value == "All" else value
self.update_data()
def update_data(self):
df = mpg
if self.manufacturer_filter:
df = df[df["manufacturer"] == self.manufacturer_filter]
if self.model_filter:
df = df[df["model"] == self.model_filter]
if self.transmission_filter:
df = df[df["trans"] == self.transmission_filter]
if self.drive_filter:
df = df[df["drv"] == self.drive_filter]
if self.class_filter:
df = df[df["class"] == self.class_filter]
self.source.data = ColumnDataSource.from_df(df)
self.session.store_document(self.document)
def run(self, do_view=False, poll_interval=0.5):
link = self.session.object_link(self.document.context)
print("Please visit %s to see the plots" % link)
if do_view: view(link)
print("\npress ctrl-C to exit")
self.session.poll_document(self.document)
class Population(object):
year = 2010
location = "World"
def __init__(self):
from bokeh.objects import ColumnDataSource
from bokeh.document import Document
from bokeh.session import Session
from bokeh.sampledata.population import load_population
self.document = Document()
self.session = Session()
self.session.use_doc('population_reveal')
self.session.load_document(self.document)
self.df = load_population()
self.source_pyramid = ColumnDataSource(data=dict())
def render(self):
self.pyramid_plot()
self.create_layout()
self.document.add(self.layout)
self.update_pyramid()
def pyramid_plot(self):
from bokeh.objects import (Plot, DataRange1d, LinearAxis, Grid, Glyph,
Legend, SingleIntervalTicker)
from bokeh.glyphs import Quad
xdr = DataRange1d(sources=[self.source_pyramid.columns("male"),
self.source_pyramid.columns("female")])
ydr = DataRange1d(sources=[self.source_pyramid.columns("groups")])
self.plot = Plot(title="Widgets", x_range=xdr, y_range=ydr, plot_width=600, plot_height=600)
xaxis = LinearAxis(plot=self.plot)
self.plot.below.append(xaxis)
yaxis = LinearAxis(plot=self.plot, ticker=SingleIntervalTicker(interval=5))
self.plot.left.append(yaxis)
xgrid = Grid(plot=self.plot, dimension=0, ticker=xaxis.ticker)
ygrid = Grid(plot=self.plot, dimension=1, ticker=yaxis.ticker)
male_quad = Quad(left="male", right=0, bottom="groups", top="shifted", fill_color="blue")
male_quad_glyph = Glyph(data_source=self.source_pyramid,
xdata_range=xdr, ydata_range=ydr, glyph=male_quad)
self.plot.renderers.append(male_quad_glyph)
female_quad = Quad(left=0, right="female", bottom="groups", top="shifted",
fill_color="violet")
female_quad_glyph = Glyph(data_source=self.source_pyramid,
xdata_range=xdr, ydata_range=ydr, glyph=female_quad)
self.plot.renderers.append(female_quad_glyph)
legend = Legend(plot=self.plot, legends=dict(Male=[male_quad_glyph],
Female=[female_quad_glyph]))
self.plot.renderers.append(legend)
def on_year_change(self, obj, attr, old, new):
self.year = int(new)
self.update_pyramid()
def on_location_change(self, obj, attr, old, new):
self.location = new
self.update_pyramid()
def create_layout(self):
from bokeh.widgetobjects import Select, HBox, VBox
years = list(map(str, sorted(self.df.Year.unique())))
locations = sorted(self.df.Location.unique())
year_select = Select(title="Year:", value="2010", options=years)
location_select = Select(title="Location:", value="World", options=locations)
year_select.on_change('value', self.on_year_change)
location_select.on_change('value', self.on_location_change)
controls = HBox(children=[year_select, location_select])
self.layout = VBox(children=[controls, self.plot])
def update_pyramid(self):
pyramid = self.df[(self.df.Location == self.location) & (self.df.Year == self.year)]
male = pyramid[pyramid.Sex == "Male"]
female = pyramid[pyramid.Sex == "Female"]
total = male.Value.sum() + female.Value.sum()
male_percent = -male.Value / total
female_percent = female.Value / total
groups = male.AgeGrpStart.tolist()
shifted = groups[1:] + [groups[-1] + 5]
self.source_pyramid.data = dict(
groups=groups,
shifted=shifted,
male=male_percent,
female=female_percent,
)
self.session.store_document(self.document)
from requests.exceptions import ConnectionError
import pandas as pd
from bokeh.objects import (Plot, ColumnDataSource, DataRange1d, FactorRange,
LinearAxis, CategoricalAxis, Grid, Glyph)
from bokeh.widgetobjects import (DateRangeSlider, HBox, VBox, Paragraph,
Select, VBoxModelForm)
from bokeh.glyphs import Rect
from bokeh.document import Document
from bokeh.session import Session
import employment_data_reader as emp
from employment_utils import get_country_for_byte, get_jobtype_for_byte
document = Document()
session = Session()
session.use_doc('employment_server')
session.load_document(document)
days_of_week = {
0: "Monday",
1: "Tuesday",
2: "Wednesday",
3: "Thursday",
4: "Friday",
5: "Saturday",
6: "Sunday"
}
bounds_start = datetime.date(2012, 11, 1)
bounds_end = datetime.date(2013, 12, 30)
start = datetime.date(2013, 5, 26)
import time
from numpy import pi, sin, cos, linspace
from bokeh.browserlib import view
from bokeh.document import Document
from bokeh.glyphs import Line
from bokeh.objects import (
Plot, DataRange1d, LinearAxis,
ColumnDataSource, Glyph, PanTool, WheelZoomTool
)
from bokeh.session import Session
document = Document()
session = Session()
session.use_doc('line_animate')
session.load_document(document)
x = linspace(-2*pi, 2*pi, 1000)
x_static = linspace(-2*pi, 2*pi, 1000)
y = sin(x)
z = cos(x)
source = ColumnDataSource(data=dict(x=x, y=y, z=z, x_static=x_static))
xdr = DataRange1d(sources=[source.columns("x")])
xdr_static = DataRange1d(sources=[source.columns("x_static")])
ydr = DataRange1d(sources=[source.columns("y")])
plot = Plot(x_range=xdr_static, y_range=ydr, min_border=50)
