def show_server(server, notebook_url, server_id):
"""
Displays a bokeh server inline in the notebook.
Parameters
----------
server: bokeh.server.server.Server
Bokeh server instance which is already running
notebook_url: str
The URL of the running Jupyter notebook server
server_id: str
Unique ID to identify the server with
"""
from bokeh.embed import server_document
from IPython.display import publish_display_data
if callable(notebook_url):
url = notebook_url(server.port)
else:
url = _server_url(notebook_url, server.port)
script = server_document(url, resources=None)
publish_display_data({
HTML_MIME: script,
EXEC_MIME: ""
},
metadata={EXEC_MIME: {
"server_id": server_id
}})
def load_hvjs(cls, logo=False, bokeh_logo=False, mpl_logo=False, plotly_logo=False,
JS=True, message='HoloViewsJS successfully loaded.'):
"""
Displays javascript and CSS to initialize HoloViews widgets.
"""
import jinja2
# Evaluate load_notebook.html template with widgetjs code
if JS:
widgetjs, widgetcss = Renderer.html_assets(extras=False, backends=[], script=True)
else:
widgetjs, widgetcss = '', ''
# Add classic notebook MIME renderer
widgetjs += nb_mime_js
templateLoader = jinja2.FileSystemLoader(os.path.dirname(os.path.abspath(__file__)))
jinjaEnv = jinja2.Environment(loader=templateLoader)
template = jinjaEnv.get_template('load_notebook.html')
html = template.render({'widgetcss': widgetcss,
'logo': logo,
'bokeh_logo': bokeh_logo,
'mpl_logo': mpl_logo,
'plotly_logo': plotly_logo,
'message': message})
publish_display_data(data={'text/html': html})
# Vanilla JS mime type is only consumed by classic notebook
# Custom mime type is only consumed by JupyterLab
if JS:
mimebundle = {
MIME_TYPES['js'] : widgetjs,
MIME_TYPES['jlab-hv-load'] : widgetjs
}
publish_display_data(data=mimebundle)
def show_app(app, state, notebook_url):
'''
'''
logging.basicConfig()
from tornado.ioloop import IOLoop
from ..server.server import Server
loop = IOLoop.current()
server = Server({"/": app}, io_loop=loop, port=0, allow_websocket_origin=[notebook_url])
server_id = uuid4().hex
curstate().uuid_to_server[server_id] = server
server.start()
url = 'http://%s:%d%s' % (notebook_url.split(':')[0], server.port, "/")
from ..embed import server_document
script = server_document(url)
publish_display_data({
HTML_MIME_TYPE: script,
EXEC_MIME_TYPE: ""
}, metadata={
EXEC_MIME_TYPE: {"server_id": server_id}
})
def set(self, dim, n_part):
self.d_n = dim * n_part
publish_display_data(
{SIMZERO_SET_MIME_TYPE: {
'dim': dim,
'n_part': n_part
}})
def _ipython_display_(self):
"""Display the visualization in the Jupyter notebook."""
id = uuid.uuid4()
publish_display_data({'text/html': self._generate_html(id)},
metadata={'jupyter-vega': '#{0}'.format(id)})
publish_display_data({'application/javascript': self._generate_js(id)},
metadata={'jupyter-vega': '#{0}'.format(id)})
def show_doc(obj, state, notebook_handle):
'''
'''
if obj not in state.document.roots:
state.document.add_root(obj)
from ..embed.notebook import notebook_content
comms_target = make_id() if notebook_handle else None
(script, div, cell_doc) = notebook_content(obj, comms_target)
publish_display_data({HTML_MIME_TYPE: div})
publish_display_data({
JS_MIME_TYPE: script,
EXEC_MIME_TYPE: ""
},
metadata={EXEC_MIME_TYPE: {
"id": obj.id
}})
# Comms handling relies on the fact that the cell_doc returned by
# notebook copy has models with the same IDs as the original curdoc
# they were copied from
if comms_target:
handle = CommsHandle(get_comms(comms_target), cell_doc)
state.document.on_change_dispatch_to(handle)
state.last_comms_handle = handle
return handle
def display(obj, raw=False, **kwargs):
"""
Renders any HoloViews object to HTML and displays it
using the IPython display function. If raw is enabled
the raw HTML is returned instead of displaying it directly.
"""
if isinstance(obj, GridSpace):
with option_state(obj):
output = grid_display(obj)
elif isinstance(obj, (CompositeOverlay, ViewableElement)):
with option_state(obj):
output = element_display(obj)
elif isinstance(obj, (Layout, NdLayout, AdjointLayout)):
with option_state(obj):
output = layout_display(obj)
elif isinstance(obj, (HoloMap, DynamicMap)):
with option_state(obj):
output = map_display(obj)
else:
output = {'text/plain': repr(obj)}
if raw:
return output
elif isinstance(output, tuple):
data, metadata = output
else:
data, metadata = output, {}
publish_display_data(data, metadata)
def notebook_show(obj, doc, target):
"""
Displays bokeh output inside a notebook and returns a CommsHandle.
"""
publish_display_data({'text/html': notebook_div(obj, target)})
handle = _CommsHandle(get_comms(target), doc, doc.to_json())
return handle
def display_immediately(self, plain_text, rich_output):
"""
Show output immediately.
This method is similar to the rich output :meth:`displayhook`,
except that it can be invoked at any time.
INPUT:
Same as :meth:`displayhook`.
OUTPUT:
This method does not return anything.
EXAMPLES::
sage: from sage.repl.rich_output.output_basic import OutputPlainText
sage: plain_text = OutputPlainText.example()
sage: from sage.repl.rich_output.backend_ipython import BackendIPythonNotebook
sage: backend = BackendIPythonNotebook()
sage: _ = backend.display_immediately(plain_text, plain_text)
Example plain text output
"""
formatted, metadata = self.displayhook(plain_text, rich_output)
if not formatted:
return
publish_display_data(data=formatted, metadata=metadata)
def _add_or_remove_tags(tags_to_add=(), tags_to_remove=()):
"""Adds or removes tags from the frontend."""
# Clear tags when this cell is done.
output_tags = _get_or_create_tags()
tags_to_add = tuple(tags_to_add)
tags_to_remove = tuple(tags_to_remove)
output_tags.update(tags_to_add)
output_tags.difference_update(tags_to_remove)
sys.stdout.flush()
sys.stderr.flush()
metadata = {
'outputarea': {
'nodisplay': True,
'add_tags': tags_to_add,
'remove_tags': tags_to_remove
}
}
if ipython.in_ipython():
if IPython.version_info[0] > 2:
display.publish_display_data({}, metadata=metadata)
else:
display.publish_display_data('display', {}, metadata=metadata)
return output_tags
def load_hvjs(cls, logo=False, bokeh_logo=False, mpl_logo=False, plotly_logo=False,
JS=True, message='HoloViewsJS successfully loaded.'):
"""
Displays javascript and CSS to initialize HoloViews widgets.
"""
import jinja2
# Evaluate load_notebook.html template with widgetjs code
if JS:
widgetjs, widgetcss = Renderer.html_assets(extras=False, backends=[], script=True)
else:
widgetjs, widgetcss = '', ''
# Add classic notebook MIME renderer
widgetjs += nb_mime_js
templateLoader = jinja2.FileSystemLoader(os.path.dirname(os.path.abspath(__file__)))
jinjaEnv = jinja2.Environment(loader=templateLoader)
template = jinjaEnv.get_template('load_notebook.html')
html = template.render({'widgetcss': widgetcss,
'logo': logo,
'bokeh_logo': bokeh_logo,
'mpl_logo': mpl_logo,
'plotly_logo': plotly_logo,
'message': message})
publish_display_data(data={'text/html': html})
# Vanilla JS mime type is only consumed by classic notebook
# Custom mime type is only consumed by JupyterLab
if JS:
mimebundle = {
MIME_TYPES['js'] : widgetjs,
MIME_TYPES['jlab-hv-load'] : widgetjs
}
publish_display_data(data=mimebundle)
def display_immediately(self, plain_text, rich_output):
"""
Show output immediately.
This method is similar to the rich output :meth:`displayhook`,
except that it can be invoked at any time.
INPUT:
Same as :meth:`displayhook`.
OUTPUT:
This method does not return anything.
EXAMPLES::
sage: from sage.repl.rich_output.output_basic import OutputPlainText
sage: plain_text = OutputPlainText.example()
sage: from sage.repl.rich_output.backend_ipython import BackendIPythonNotebook
sage: backend = BackendIPythonNotebook()
sage: _ = backend.display_immediately(plain_text, plain_text)
Example plain text output
"""
formatted, metadata = self.displayhook(plain_text, rich_output)
if not formatted:
return
publish_display_data(data=formatted, metadata=metadata)
def show_app(app, state, notebook_url):
'''
'''
logging.basicConfig()
from tornado.ioloop import IOLoop
from ..server.server import Server
loop = IOLoop.current()
server = Server({"/": app},
io_loop=loop,
port=0,
allow_websocket_origin=[notebook_url])
server_id = uuid4().hex
curstate().uuid_to_server[server_id] = server
server.start()
url = 'http://%s:%d%s' % (notebook_url.split(':')[0], server.port, "/")
from ..embed import server_document
script = server_document(url)
publish_display_data({
HTML_MIME_TYPE: script,
EXEC_MIME_TYPE: ""
},
metadata={EXEC_MIME_TYPE: {
"server_id": server_id
}})
def show_embed(panel, max_states=1000, max_opts=3, json=False,
save_path='./', load_path=None):
"""
Renders a static version of a panel in a notebook by evaluating
the set of states defined by the widgets in the model. Note
this will only work well for simple apps with a relatively
small state space.
Arguments
---------
max_states: int
The maximum number of states to embed
max_opts: int
The maximum number of states for a single widget
json: boolean (default=True)
Whether to export the data to json files
save_path: str (default='./')
The path to save json files to
load_path: str (default=None)
The path or URL the json files will be loaded from.
"""
from IPython.display import publish_display_data
from ..config import config
doc = Document()
comm = Comm()
with config.set(embed=True):
model = panel.get_root(doc, comm)
embed_state(panel, model, doc, max_states, max_opts,
json, save_path, load_path)
publish_display_data(*render_model(model))
def load_notebook(inline=True, load_timeout=5000):
from IPython.display import publish_display_data
resources = INLINE if inline else CDN
prev_resources = settings.resources(default="server")
user_resources = settings.resources._user_value is not _Unset
resources = Resources.from_bokeh(resources)
try:
bundle = bundle_resources(resources)
bundle = Bundle.from_bokeh(bundle)
configs, requirements, exports, skip_imports = require_components()
ipywidget = 'ipywidgets_bokeh' in sys.modules
bokeh_js = _autoload_js(bundle, configs, requirements, exports,
skip_imports, ipywidget, load_timeout)
finally:
if user_resources:
settings.resources = prev_resources
else:
settings.resources.unset_value()
publish_display_data({
'application/javascript': bokeh_js,
LOAD_MIME: bokeh_js,
})
bokeh.io.notebook.curstate().output_notebook()
# Publish comm manager
JS = '\n'.join([PYVIZ_PROXY, _JupyterCommManager.js_manager, nb_mime_js])
publish_display_data(data={LOAD_MIME: JS, 'application/javascript': JS})
def publish_display_data(data: Dict[str, Any], metadata: Dict[Any, Any] | None = None,
source: str | None = None, *, transient: Dict[str, Any] | None = None, **kwargs: Any) -> None:
'''
'''
# This import MUST be deferred or it will introduce a hard dependency on IPython
from IPython.display import publish_display_data
publish_display_data(data, metadata, source, transient=transient, **kwargs)
def show(captured_io, to_html_func):
output = captured_io.stdout + captured_io.stderr
display.publish_display_data('', {
'text/plain': output,
'text/html': to_html_func(output)
}, {})
for o in captured_io.outputs:
o.display()
def load_nb(cls, inline=True):
"""
Loads the plotly notebook resources.
"""
from IPython.display import publish_display_data
cls._loaded = True
init_notebook_mode(connected=not inline)
publish_display_data(data={MIME_TYPES['jlab-hv-load']: get_plotlyjs()})
def display(self):
from IPython.display import publish_display_data
publish_display_data(
data=self.data,
metadata=self.metadata,
transient=self.transient,
update=self.update,
)
def load_nb(cls, inline=True):
"""
Loads the plotly notebook resources.
"""
from IPython.display import publish_display_data
cls._loaded = True
init_notebook_mode(connected=not inline)
publish_display_data(data={MIME_TYPES['jlab-hv-load']:
get_plotlyjs()})
def display_info_string(**kwargs):
_template = """
{{widgetcss}}
<table><tr><td>
{% if logo %}
<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAAlw
SFlzAAAJOgAACToB8GSSSgAAAetpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6
bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDUuNC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8x
OTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAg
eG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgICAgICAgICB4bWxuczp0aWZmPSJodHRwOi8vbnMu
YWRvYmUuY29tL3RpZmYvMS4wLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+bWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo
dHRwOi8vbWF0cGxvdGxpYi5vcmcvPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgICAgIDx0aWZmOk9yaWVudGF0aW9uPjE8L3RpZmY6
T3JpZW50YXRpb24+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgqNQaNYAAAGiUlE
QVRIDY1We4xU1Rn/3XPuYx47u8w+hnU38hTcuoUEt/6D2y4RB0ME1BoEd9taJaKh9CFiN7YGp7appUAMNmktMZFoJTYVLVQ0smsy
26CN0SU1QgsuFAaW3WVmx33N677O6XfuyoIxTXqSO/fec+75fd93vt/3/UbDV0aKSZmCpkFMLz3T9utuu2N+o98aDSMBKVAo89z5
y+zEz3ZafcCOfvWdlGCalqKn1Bf71CygTd+mf1esSOnpdMpTb+vWpTZuWVfe3jLPa5tzHYNm0T5N0gpdkkHaDBeGBU6d1/t/fyS8
+/CbqdfUvmsx1PuMgc2bNxv79u1zgd31r+7JH1jbIZKxWRXAcYUQ8IWvBfBXNjEuJWPgMA02NR7C3/pYT9fjdZ3A9tGrWF8YSJHn
qcDz3y7q2T967PZv+gnYJdd1mEZ+62zGDQV/dQgKhmLzDNOXCEWM3j6eTT5Y3w78dOBKJLR1PQf+4ivPj76UPZnssBN+wbM9Aet/
AV81Mf1EEULXYfOobvX2WWQk0aoioXwwSmirOlioY0mu8BIouzYl7P8GV3vpqCCEZvlFz769w08oLDWvyKIyL1asSm28d6WfzA97
ztvvV1kexUMsmhlkULEkuGYmFYC6AvfUrITnwUKl5K79lkjeSSRRTCTbQPd95e1WzMbZSya74XoXAxctCllCnbECMOjZNGRwvzIX
nD85wbkMmKK+U045Dtdi8Qp+SAxU2GTg2bYlC9224pgvmSb54vkVTBQYyhUt2KjAMyMmPjwRQW5Mh2WKwJhlBh6jVGagFM84wZnQ
4bpC0Rt4pk1PbSt0NDcxDA5xryosDHWgtbM0DGZDWLSoiDMDYeQnGVrmOThxLozB0RAaahzkJzjKNqcIQBymJFMkOlN8Dqjpg0XY
Tx5xO/QbmmUrqIjGJznq47TqTaClKYfjp+PInLMwnOdYvtQBZ2XcunQY+VwIo4U4muoFEjVEFE6lQyEUKzHYfgQG9ylCyngU+Cxj
tOqxCDGHcCsOMCs6iQul5ZiStdATYxjMZXDLTUVwLY8Jey4uOh2IxjwsrP8UXJYxUrkZrghBahzV5iXU6gNkq0Z1EzIsUBUSCV2n
EOHo0LVxHCpuxabJJdhi5PFnvw5vLXwXIfNZvD/+JNo/X40NegE54sUaazl+UL8XD1x+FB9Ijjt4EQfdGN6J/x131LwIV9ap/AYs
0x1fz1ZKFbh6A7qKy/By9Dg6G36Ep91vUJJ15Cqr0Z67E8/HzmBrw1OwxWyM+3Mo6BAuSB17oyfx0Oyl2DN0Hqs/70Cx6hBCvESF
UY1ShWXZZEE7OTAYxZzaPH4TuoiusZvRnunFy2NbiHYuBp2vB66srX4vMEjpRKPxKXmnoQ4+Mn4DPiv8CYcrs3GfNUXJLtM+alSO
hrMj/KT+wBNW3+E/2liywNO3iSflbaFva/+stGDTxE0E9Sjaox8HBhxpEamzMGSEaFKg+mjEddzDh1MxTDq3YV1kGBsjfwW3S9Cq
anjmko+ndlb1UR3s6K8JlfphNWq9Ew/7c61T2BB/EbcaNkb8GBaE0tANH7/M34PLdhJDzjIcL9xPbdTG6zyM72Y+wXPHmvB489No
fm0b5HnbQ9Rgp/7DSSd29AeVvPeNyK6JcYl/yQVi5dBjuGvoV/gaJe47s45QUxrDmcYX0MBsdF7egvXZ7+O0vZA4X8QmOQWjlSK7
RDz5wIM30gp9UbWcGjXxhzdDu1SiNSpx6kcQB57rPnr/3dlkZarWLnlRq5oPET1dOCIOk4wALib9eeS5iygfhkd09H0DWphB/+gs
+PcOAS+ssrFmmXXgVfR0de9cpbAJfH3Q1jofW9DZk56dDcVsq9YcsoUMEd1qyLoT3BX1YiyHMJuk97hyjqIoE91t+NcTLeN0ZrfM
oXatZbu6G0h4VG+ibqq0IJVK6cAjo6serG3vSUezCMct0yQeSOFJSUImqb2qbknUpDqlZxE0QZ+ZUpSlZx79h4Nda6zef9dlk121
JDjbR5XggPRZlRnS6bRQRtLpn4++cuie/Yvn2svmNxuLw9WCcYIl4fEoTEGiSTUqJdfgU+8ROqf1iMkLzS389YtNPXc/PH8l8ONB
JZkHD+4JtD04HmVEDWWErmBhzV2/2LB1bemJG6krzv2S6NOHUgtEP0Oif5pE/3fHoruP7N8RiP61GArzSwbUhJJQpXJKiKbfr/3b
IhKq76sKPUdF9NW/LSqfSn6vjv8C45H/6FSgvZQAAAAASUVORK5CYII='
style='height:25px; border-radius:12px; display:inline-block; float:left; vertical-align:middle'></img>
{% endif %}
</td><td>
{% if message %}
<span style='font-size:12px'>{{ message }}</span>
{% endif %}
</td></tr></table>
</div>
"""
clear_output()
logo = kwargs.get('logo', True)
message = kwargs.get('message', 'info ')
template = Template(_template)
html = template.render({
'logo': logo,
'message': message.strip().replace('\n', '<br/>')
})
publish_display_data(data={'text/html': html})
def _ipython_display_(self):
"""
Render Scenes using crystaltoolkit-extension for Jupyter Lab.
This function ensures that objects are also printed in string format
as previously.
"""
from IPython.display import publish_display_data
publish_display_data(self._repr_mimebundle_())
def _ipython_display_(self):
"""Display the visualization in the Jupyter notebook."""
if self.InitNeeded:
html = self._generate_html(self.ID)
#print "generated html:", html
publish_display_data({'text/html': html}, metadata={})
js = self._generate_js(self.ID)
#print "generated javascript:", js
publish_display_data({'application/javascript': js}, metadata={})
self.InitNeeded = False
def load_nb(cls, inline=True):
"""
Loads the plotly notebook resources.
"""
from IPython.display import display, HTML, publish_display_data
if not cls._loaded:
display(HTML(PLOTLY_WARNING))
cls._loaded = True
init_notebook_mode(connected=not inline)
publish_display_data(data={MIME_TYPES['jlab-hv-load']: get_plotlyjs()})
def _show_jupyter_doc_with_state(obj, state, notebook_handle):
comms_target = make_id() if notebook_handle else None
(script, div) = notebook_content(obj, comms_target)
publish_display_data({HTML_MIME_TYPE: div})
publish_display_data({JS_MIME_TYPE: script, EXEC_MIME_TYPE: ""}, metadata={EXEC_MIME_TYPE: {"id": obj._id}})
if comms_target:
handle = _CommsHandle(get_comms(comms_target), state.document,
state.document.to_json())
state.last_comms_handle = handle
return handle
def _ipython_display_(self):
"""Display the visualization in the Jupyter notebook."""
id = uuid.uuid4()
publish_display_data(
{'text/html': self._generate_html(id)},
metadata={'jupyter-vega': '#{0}'.format(id)}
)
publish_display_data(
{'application/javascript': self._generate_js(id)},
metadata={'jupyter-vega': '#{0}'.format(id)}
)
def _ipython_display_(self):
js = ("""
(function (el) {
require(['candela'], function (candela) {
var comp = candela.components['%s'];
var vis = new comp(el.get(0), %s);
vis.render();
});
})(element);
""" % (self.name, json.dumps(self.options, cls=DataFrameEncoder)))
publish_display_data({'application/javascript': js})
def js_publish(id_, inst):
"""Generate Vega JS
Args:
id_: a unique ID to tag the element
inst: a Vega instance
"""
publish_display_data(
# pylint: disable=protected-access
{'application/javascript': inst._generate_js(id_)},
metadata={'jupyter-vega': '#{0}'.format(id_)}
)
def notebook_show(obj, doc, target):
"""
Displays bokeh output inside a notebook and returns a CommsHandle.
"""
bokeh_script, bokeh_div, _ = bokeh.embed.notebook.notebook_content(obj, target)
bokeh_output = """
{bokeh_div}
<script type="application/javascript">{bokeh_script}</script>
""".format(bokeh_div=bokeh_div, bokeh_script=bokeh_script)
publish_display_data({'text/html': encode_utf8(bokeh_output)})
return bokeh.io.notebook.CommsHandle(bokeh.io.notebook.get_comms(target), doc)
def load_notebook(inline=True):
from IPython.display import publish_display_data
# Create a message for the logo (if shown)
LOAD_MIME_TYPE = bokeh.io.notebook.LOAD_MIME_TYPE
bokeh.io.notebook.LOAD_MIME_TYPE = LOAD_MIME
bk_load_notebook(hide_banner=True, resources=INLINE if inline else CDN)
bokeh.io.notebook.LOAD_MIME_TYPE = LOAD_MIME_TYPE
bokeh.io.notebook.curstate().output_notebook()
# Publish comm manager
JS = '\n'.join([PYVIZ_PROXY, JupyterCommManager.js_manager, nb_mime_js])
publish_display_data(data={LOAD_MIME: JS, 'application/javascript': JS})
def on_iopub(self, msg):
if msg["msg_type"] == "error":
publish_display_data(
{
"text/plain":
"{} - {}\n{}".format(
msg["content"]["ename"], msg["content"]["evalue"],
"\n".join(msg["content"]["traceback"]))
},
metadata={"echo": True})
elif msg["msg_type"] == "stream":
publish_display_data({"text/plain": msg["content"]["text"]},
metadata={"echo": True})
elif msg["msg_type"] == "display_data":
publish_display_data(msg["content"]["data"],
metadata={"echo": True})
elif msg["msg_type"] == "execute_result":
publish_display_data(msg["content"]["data"],
metadata={"echo": True})
elif msg["msg_type"] in [
"execute_input", "execution_state", "status"
]:
pass
else:
pprint(msg)
def load_notebook(resources=None,
verbose=False,
hide_banner=False,
load_timeout=5000,
notebook_type='jupyter'):
''' Prepare the IPython notebook for displaying Bokeh plots.
Args:
resources (Resource, optional) :
how and where to load BokehJS from (default: CDN)
verbose (bool, optional) :
whether to report detailed settings (default: False)
hide_banner (bool, optional):
whether to hide the Bokeh banner (default: False)
load_timeout (int, optional) :
Timeout in milliseconds when plots assume load timed out (default: 5000)
notebook_type (string):
notebook_type (default: jupyter)
.. warning::
Clearing the output cell containing the published BokehJS
resources HTML code may cause Bokeh CSS styling to be removed.
Returns:
None
'''
nb_html, nb_js = _load_notebook_html(resources, verbose, hide_banner,
load_timeout)
lab_html, lab_js = _load_notebook_html(resources,
verbose,
hide_banner,
load_timeout,
register_mimetype=False)
if notebook_type == 'jupyter':
publish_display_data({
'text/html': nb_html + _wrap_in_script_tag(nb_js),
LOAD_MIME_TYPE: {
"script": lab_js,
"div": lab_html
}
})
else:
_publish_zeppelin_data(lab_html, lab_js)
def show_server(panel, notebook_url, port):
"""
Displays a bokeh server inline in the notebook.
Arguments
---------
panel: Viewable
Panel Viewable object to launch a server for
notebook_url: str
The URL of the running Jupyter notebook server
port: int (optional, default=0)
Allows specifying a specific port
server_id: str
Unique ID to identify the server with
Returns
-------
server: bokeh.server.Server
"""
from IPython.display import publish_display_data
if callable(notebook_url):
origin = notebook_url(None)
else:
origin = _origin_url(notebook_url)
server_id = uuid.uuid4().hex
server = get_server(panel,
port,
origin,
start=True,
show=False,
server_id=server_id)
if callable(notebook_url):
url = notebook_url(server.port)
else:
url = _server_url(notebook_url, server.port)
script = server_document(url, resources=None)
publish_display_data({
HTML_MIME: script,
EXEC_MIME: ""
},
metadata={EXEC_MIME: {
"server_id": server_id
}})
return server
def table(df):
"""Format a small :class:`~pandas.DataFrame` as an `org-mode table<https://orgmode.org/manual/Tables.html>`_.
:param df: input DataFrame
:type df: :class:`~pandas.DataFrame`
:returns: org-mode table as IPython display string with 'text/org' MIME type
"""
def index(idx):
if isinstance(idx, MultiIndex):
x = list(idx)
return [x[0]
] + [[' ' if x[i][j] == z else z for j, z in enumerate(y)]
for i, y in enumerate(x[1:])]
else:
return [[i] for i in idx]
idx = index(df.index)
cols = index(df.columns)
M = df.as_matrix()
s = '|\n|'.join('|'.join(' ' for _ in range(len(idx[0]))) + '|' + \
'|'.join(str(c[i]) for c in cols) for i in range(len(cols[0]))) + \
'|\n|' + '|'.join('-' for _ in range(len(idx[0]) + len(M[0]))) + '|\n|' + \
'|\n|'.join('|'.join(str(i) for j in z for i in j) for z in zip(idx, M))
return publish_display_data({'text/org': '|' + s + '|'})
def publish_display_data(*args, **kw):
'''
'''
# This import MUST be deferred or it will introduce a hard dependency on IPython
from IPython.display import publish_display_data
return publish_display_data(*args, **kw)
def publish_display_data(*args, **kw):
'''
'''
# This import MUST be deferred or it will introduce a hard dependency on IPython
from IPython.display import publish_display_data
return publish_display_data(*args, **kw)
def load_hvjs(cls, logo=False, bokeh_logo=False, mpl_logo=False, plotly_logo=False,
JS=True, message='HoloViewsJS successfully loaded.'):
"""
Displays javascript and CSS to initialize HoloViews widgets.
"""
import jinja2
templateLoader = jinja2.FileSystemLoader(os.path.dirname(os.path.abspath(__file__)))
jinjaEnv = jinja2.Environment(loader=templateLoader)
template = jinjaEnv.get_template('load_notebook.html')
html = template.render({'logo': logo,
'bokeh_logo': bokeh_logo,
'mpl_logo': mpl_logo,
'plotly_logo': plotly_logo,
'message': message})
publish_display_data(data={'text/html': html})
def _ipython_display_(self):
serialized = self.to_json()
js = ("""
var render = function () {
%s
var c = %s;
require(['candela'], function (candela) {
var comp = candela.components[c.name];
var vis = new comp(element.get(0), c.options);
vis.render();
});
};
render();
""" % (_require_config, serialized))
publish_display_data({
'application/javascript': js,
MIME_TYPE: json.loads(serialized)
})
def show_doc(obj, state, notebook_handle):
'''
'''
from ..embed import notebook_content
comms_target = make_id() if notebook_handle else None
(script, div, cell_doc) = notebook_content(obj, comms_target)
publish_display_data({HTML_MIME_TYPE: div})
publish_display_data({JS_MIME_TYPE: script, EXEC_MIME_TYPE: ""}, metadata={EXEC_MIME_TYPE: {"id": obj._id}})
# Comms handling relies on the fact that the cell_doc returned by
# notebook copy has models with the same IDs as the original curdoc
# they were copied from
if comms_target:
handle = CommsHandle(get_comms(comms_target), cell_doc)
state.document.on_change_dispatch_to(handle)
state.last_comms_handle = handle
return handle
def show_app(app, state, notebook_url, port=0):
''' Embed a Bokeh serer application in a Jupyter Notebook output cell.
Args:
app (Application) :
state (State) :
notebook_url (str) :
port (int) : the port the embedded server will listen on. By default
the port is 0, which results in the server listening on a random dynamic port.
Returns:
None
'''
logging.basicConfig()
from tornado.ioloop import IOLoop
from ..server.server import Server
loop = IOLoop.current()
origin = _origin_url(notebook_url)
server = Server({"/": app}, io_loop=loop, port=port, allow_websocket_origin=[origin])
server_id = uuid4().hex
curstate().uuid_to_server[server_id] = server
server.start()
url = _server_url(notebook_url, server.port)
from ..embed import server_document
script = server_document(url)
publish_display_data({
HTML_MIME_TYPE: script,
EXEC_MIME_TYPE: ""
}, metadata={
EXEC_MIME_TYPE: {"server_id": server_id}
})
def init():
init_js = _require_config + """
require(['candela'], function (candela) {
var components = [];
for (var comp in candela.components) {
if (candela.components.hasOwnProperty(comp)) {
components.push(comp);
}
}
var kernel = IPython.notebook.kernel;
kernel.execute('import pycandela as __pycandela');
kernel.execute('__pycandela._component_list = ' +
JSON.stringify(components));
}, function (error) {
element.append('<pre>' + error + '</pre>');
});
"""
publish_display_data({
'application/javascript': init_js,
MIME_TYPE: None
})
def html_publish_map(data):
"""Run IPython's 'publish_display_data' for each spec.
Args:
data: list of (id, spec) pairings
"""
pipe(
data,
map(lambda x: x[0]),
list,
lambda x: publish_display_data(
{'text/html': render_html(x)},
metadata={'jupyter-vega': '#{0}'.format(x[0])})
)
def on_iopub(self, msg):
if msg["msg_type"] == "error":
publish_display_data({"text/plain": "{} - {}\n{}".format(msg["content"]["ename"],
msg["content"]["evalue"],
"\n".join(msg["content"]["traceback"]))},
metadata={"echo": True})
elif msg["msg_type"] == "stream":
publish_display_data({"text/plain": msg["content"]["text"]}, metadata={"echo": True})
elif msg["msg_type"] == "display_data":
publish_display_data(msg["content"]["data"], metadata={"echo": True})
elif msg["msg_type"] == "execute_result":
publish_display_data(msg["content"]["data"], metadata={"echo": True})
elif msg["msg_type"] in ["execute_input", "execution_state", "status"]:
pass
else:
pprint(msg)
def publish_to_display(obj):
output, _ = DisplayFormatter().format(obj)
publish_display_data(output)
def load_notebook(resources=None, verbose=False, hide_banner=False, load_timeout=5000):
''' Prepare the IPython notebook for displaying Bokeh plots.
Args:
resources (Resource, optional) :
how and where to load BokehJS from (default: CDN)
verbose (bool, optional) :
whether to report detailed settings (default: False)
hide_banner (bool, optional):
whether to hide the Bokeh banner (default: False)
load_timeout (int, optional) :
Timeout in milliseconds when plots assume load timed out (default: 5000)
.. warning::
Clearing the output cell containing the published BokehJS
resources HTML code may cause Bokeh CSS styling to be removed.
Returns:
None
'''
global _NOTEBOOK_LOADED
from .. import __version__
from ..core.templates import NOTEBOOK_LOAD
from ..util.serialization import make_id
from ..resources import CDN
from ..util.compiler import bundle_all_models
if resources is None:
resources = CDN
if not hide_banner:
if resources.mode == 'inline':
js_info = 'inline'
css_info = 'inline'
else:
js_info = resources.js_files[0] if len(resources.js_files) == 1 else resources.js_files
css_info = resources.css_files[0] if len(resources.css_files) == 1 else resources.css_files
warnings = ["Warning: " + msg['text'] for msg in resources.messages if msg['type'] == 'warn']
if _NOTEBOOK_LOADED and verbose:
warnings.append('Warning: BokehJS previously loaded')
element_id = make_id()
html = NOTEBOOK_LOAD.render(
element_id = element_id,
verbose = verbose,
js_info = js_info,
css_info = css_info,
bokeh_version = __version__,
warnings = warnings,
)
else:
element_id = None
_NOTEBOOK_LOADED = resources
custom_models_js = bundle_all_models() or ""
nb_js = _loading_js(resources, element_id, custom_models_js, load_timeout, register_mime=True)
jl_js = _loading_js(resources, element_id, custom_models_js, load_timeout, register_mime=False)
if not hide_banner:
publish_display_data({'text/html': html})
publish_display_data({
JS_MIME_TYPE : nb_js,
LOAD_MIME_TYPE : jl_js
})
def show_app(app, state, notebook_url, port=0, **kw):
''' Embed a Bokeh server application in a Jupyter Notebook output cell.
Args:
app (Application or callable) :
A Bokeh Application to embed inline in a Jupyter notebook.
state (State) :
** Unused **
notebook_url (str or callable) :
The URL of the notebook server that is running the embedded app.
If ``notebook_url`` is a string, the value string is parsed to
construct the origin and full server URLs.
If notebook_url is a callable, it must accept one parameter,
which will be the server port, or None. If passed a port,
the callable must generate the server URL, otherwise if passed
None, it must generate the origin URL for the server.
port (int) :
A port for the embedded server will listen on.
By default the port is 0, which results in the server listening
on a random dynamic port.
Any additional keyword arguments are passed to :class:`~bokeh.server.Server` (added in version 1.1)
Returns:
None
'''
logging.basicConfig()
from tornado.ioloop import IOLoop
from ..server.server import Server
loop = IOLoop.current()
if callable(notebook_url):
origin = notebook_url(None)
else:
origin = _origin_url(notebook_url)
server = Server({"/": app}, io_loop=loop, port=port, allow_websocket_origin=[origin], **kw)
server_id = uuid4().hex
curstate().uuid_to_server[server_id] = server
server.start()
if callable(notebook_url):
url = notebook_url(server.port)
else:
url = _server_url(notebook_url, server.port)
logging.debug("Server URL is %s" % url)
logging.debug("Origin URL is %s" % origin)
from ..embed import server_document
script = server_document(url, resources=None)
publish_display_data({
HTML_MIME_TYPE: script,
EXEC_MIME_TYPE: ""
}, metadata={
EXEC_MIME_TYPE: {"server_id": server_id}
})
def display(self):
from IPython.display import publish_display_data
publish_display_data(data=self.data, metadata=self.metadata)
def display(self):
from IPython.display import publish_display_data
publish_display_data(data=self.data, metadata=self.metadata,
transient=self.transient, update=self.update)
def show(captured_io, to_html_func):
output = captured_io.stdout + captured_io.stderr
display.publish_display_data('', {'text/plain': output,
'text/html': to_html_func(output)}, {})
for o in captured_io.outputs:
o.display()
def display(self):
from IPython.display import publish_display_data
publish_display_data(self.source, self.data, self.metadata)
