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 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 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 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)