From 881ceeaa08398f171c5c2ff1173b20203cc9c641 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Sun, 15 Nov 2015 21:41:13 -0500 Subject: [PATCH 01/23] initial pdf work --- nbpresent/__init__.py | 10 ++++++++-- nbpresent/exporter.py | 12 ++++++++++++ src/es6/mode/notebook.es6 | 14 ++++++++++---- 3 files changed, 30 insertions(+), 6 deletions(-) diff --git a/nbpresent/__init__.py b/nbpresent/__init__.py index 7eec550..33779b2 100644 --- a/nbpresent/__init__.py +++ b/nbpresent/__init__.py @@ -4,5 +4,11 @@ def load_jupyter_server_extension(nbapp): from nbconvert.exporters.export import exporter_map - from .exporter import PresentExporter - exporter_map["nbpresent"] = PresentExporter + from .exporter import ( + PresentExporter, + PDFPresentExporter, + ) + exporter_map.update( + nbpresent=PresentExporter, + nbpresent_pdf=PDFPresentExporter + ) diff --git a/nbpresent/exporter.py b/nbpresent/exporter.py index 355c221..4adda1d 100644 --- a/nbpresent/exporter.py +++ b/nbpresent/exporter.py @@ -36,3 +36,15 @@ def from_notebook_node(self, nb, resources=None, **kw): resources=resources, **kw ) + + +class PDFPresentExporter(PresentExporter): + def from_notebook_node(self, *args, **kwargs): + super(PDFPresentExporter, self).__init__(*args, **kwargs) + + def from_notebook_node(self, nb, resources=None, **kw): + return super(PDFPresentExporter, self).from_notebook_node( + nb, + resources=resources, + **kw + ) diff --git a/src/es6/mode/notebook.es6 b/src/es6/mode/notebook.es6 index dc0e01d..2ef2024 100644 --- a/src/es6/mode/notebook.es6 +++ b/src/es6/mode/notebook.es6 @@ -114,11 +114,17 @@ export default class NotebookMode extends Mode { dlMenu.insert("li", ":nth-child(4)") .append("a") - .text("Presentation (.nbpresent.html)") - .on("click", this.nbconvert); + .text("Presentation (.zip)") + .on("click", () => this.nbconvert("nbpresent")); + + dlMenu.insert("li", ":nth-child(5)") + .append("a") + .text("Presentation (.pdf)") + .on("click", () => this.nbconvert("nbpresent_pdf")); + } - nbconvert(){ - Jupyter.menubar._nbconvert("nbpresent", true); + nbconvert(key){ + Jupyter.menubar._nbconvert(key, true); } } From 1e49f0585d6c5a129af8a8c64baf41a5b2d8d9d5 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Tue, 17 Nov 2015 00:01:51 -0500 Subject: [PATCH 02/23] multipage pdf generation --- bin/rasterize.js | 48 ---------- nbpresent/exporters/__init__.py | 7 ++ nbpresent/exporters/base.py | 4 + nbpresent/{exporter.py => exporters/html.py} | 18 +--- nbpresent/exporters/pdf.py | 59 ++++++++++++ nbpresent/exporters/pdf_capture.py | 92 +++++++++++++++++++ nbpresent/{present.py => present/__main__.py} | 8 +- nbpresent/present/pdf.py | 20 ++++ src/es6/mode/base.es6 | 3 +- src/js/index.js | 8 +- 10 files changed, 197 insertions(+), 70 deletions(-) delete mode 100644 bin/rasterize.js create mode 100644 nbpresent/exporters/__init__.py create mode 100644 nbpresent/exporters/base.py rename nbpresent/{exporter.py => exporters/html.py} (69%) create mode 100644 nbpresent/exporters/pdf.py create mode 100644 nbpresent/exporters/pdf_capture.py rename nbpresent/{present.py => present/__main__.py} (74%) create mode 100644 nbpresent/present/pdf.py diff --git a/bin/rasterize.js b/bin/rasterize.js deleted file mode 100644 index b0e0f67..0000000 --- a/bin/rasterize.js +++ /dev/null @@ -1,48 +0,0 @@ -var page = require('webpage').create(), - system = require('system'), - address, output, size; - -if (system.args.length < 3 || system.args.length > 5) { - console.log('Usage: rasterize.js URL filename [paperwidth*paperheight|paperformat] [zoom]'); - console.log(' paper (pdf output) examples: "5in*7.5in", "10cm*20cm", "A4", "Letter"'); - console.log(' image (png/jpg output) examples: "1920px" entire page, window width 1920px'); - console.log(' "800px*600px" window, clipped to 800x600'); - phantom.exit(1); -} else { - address = system.args[1]; - output = system.args[2]; - page.viewportSize = { width: 600, height: 600 }; - if (system.args.length > 3 && system.args[2].substr(-4) === ".pdf") { - size = system.args[3].split('*'); - page.paperSize = size.length === 2 ? { width: size[0], height: size[1], margin: '0px' } - : { format: system.args[3], orientation: 'portrait', margin: '1cm' }; - } else if (system.args.length > 3 && system.args[3].substr(-2) === "px") { - size = system.args[3].split('*'); - if (size.length === 2) { - pageWidth = parseInt(size[0], 10); - pageHeight = parseInt(size[1], 10); - page.viewportSize = { width: pageWidth, height: pageHeight }; - page.clipRect = { top: 0, left: 0, width: pageWidth, height: pageHeight }; - } else { - console.log("size:", system.args[3]); - pageWidth = parseInt(system.args[3], 10); - pageHeight = parseInt(pageWidth * 3/4, 10); // it's as good an assumption as any - console.log ("pageHeight:",pageHeight); - page.viewportSize = { width: pageWidth, height: pageHeight }; - } - } - if (system.args.length > 4) { - page.zoomFactor = system.args[4]; - } - page.open(address, function (status) { - if (status !== 'success') { - console.log('Unable to load the address!'); - phantom.exit(1); - } else { - window.setTimeout(function () { - page.render(output); - phantom.exit(); - }, 200); - } - }); -} diff --git a/nbpresent/exporters/__init__.py b/nbpresent/exporters/__init__.py new file mode 100644 index 0000000..a648ab2 --- /dev/null +++ b/nbpresent/exporters/__init__.py @@ -0,0 +1,7 @@ +# flake8: noqa +from .base import ( + ASSETS, + APP_ROOT +) +from .html import PresentExporter +from .pdf import PDFPresentExporter diff --git a/nbpresent/exporters/base.py b/nbpresent/exporters/base.py new file mode 100644 index 0000000..3291cd4 --- /dev/null +++ b/nbpresent/exporters/base.py @@ -0,0 +1,4 @@ +import os + +APP_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +ASSETS = os.path.join(APP_ROOT, "static", "nbpresent") diff --git a/nbpresent/exporter.py b/nbpresent/exporters/html.py similarity index 69% rename from nbpresent/exporter.py rename to nbpresent/exporters/html.py index 4adda1d..4182adc 100644 --- a/nbpresent/exporter.py +++ b/nbpresent/exporters/html.py @@ -4,8 +4,10 @@ from nbconvert.exporters.html import HTMLExporter -APP_ROOT = os.path.abspath(os.path.dirname(__file__)) -ASSETS = os.path.join(APP_ROOT, "static", "nbpresent") +from .base import ( + APP_ROOT, + ASSETS +) class PresentExporter(HTMLExporter): @@ -36,15 +38,3 @@ def from_notebook_node(self, nb, resources=None, **kw): resources=resources, **kw ) - - -class PDFPresentExporter(PresentExporter): - def from_notebook_node(self, *args, **kwargs): - super(PDFPresentExporter, self).__init__(*args, **kwargs) - - def from_notebook_node(self, nb, resources=None, **kw): - return super(PDFPresentExporter, self).from_notebook_node( - nb, - resources=resources, - **kw - ) diff --git a/nbpresent/exporters/pdf.py b/nbpresent/exporters/pdf.py new file mode 100644 index 0000000..6559743 --- /dev/null +++ b/nbpresent/exporters/pdf.py @@ -0,0 +1,59 @@ +import os +from glob import glob +import shutil + + +try: + from PySide.QtGui import QApplication, QImage, QPainter, QPrinter +except ImportError as err: + from PyQt4.QtGui import QApplication, QImage, QPainter, QPrinter +from ghost import Ghost + + +import tornado.ioloop +import tornado.web + + +from ipython_genutils.tempdir import TemporaryWorkingDirectory + +from .html import PresentExporter +from .pdf_capture import pdf_capture + + +class PDFPresentExporter(PresentExporter): + def __init__(self, *args, **kwargs): + super(PDFPresentExporter, self).__init__(*args, **kwargs) + + + def from_notebook_node(self, nb, resources=None, **kw): + output, resources = super(PDFPresentExporter, self).from_notebook_node( + nb, resources=resources, **kw + ) + + with TemporaryWorkingDirectory() as td: + for path, res in resources.get("outputs", {}).items(): + shutil.copyfile(path, os.path.join(td, os.path.basename(path))) + + index_html = os.path.join(td, "index.html") + + with open(index_html, "w+") as f: + f.write(output) + + pdf_capture(nb, td) + self.log.info("Building PDF") + + pdf_file = 'notebook.pdf' + if not os.path.isfile(pdf_file): + raise IOError("PDF creating failed") + self.log.info('PDF successfully created') + with open(pdf_file, 'rb') as f: + pdf_data = f.read() + + # convert output extension to pdf + # the writer above required it to be tex + resources['output_extension'] = '.pdf' + # clear figure outputs, extracted by latex export, + # so we don't claim to be a multi-file export. + resources.pop('outputs', None) + + return pdf_data, resources diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py new file mode 100644 index 0000000..b37756a --- /dev/null +++ b/nbpresent/exporters/pdf_capture.py @@ -0,0 +1,92 @@ +from concurrent import futures +from glob import glob +import os + +try: + from PySide.QtGui import QApplication, QImage, QPainter, QPrinter +except ImportError as err: + from PyQt4.QtGui import QApplication, QImage, QPainter, QPrinter + +from ghost import Ghost + + +import tornado.web +from tornado.httpserver import HTTPServer + +from tornado.ioloop import IOLoop +from tornado.concurrent import run_on_executor + +from PyPDF2 import ( + PdfFileReader, + PdfFileMerger, +) + + +class CaptureServer(HTTPServer): + executor = futures.ThreadPoolExecutor(max_workers=1) + + def __init__(self, *args, **kwargs): + super(CaptureServer, self).__init__(*args, **kwargs) + + @run_on_executor + def capture(self): + # DO SOME MAGIC + ghost = Ghost() + session = ghost.start() + session.open("http://localhost:9999/index.html") + + merger = PdfFileMerger() + + # try: + # session.wait_for_selector("#nbpresent_present_btn") + # except Exception as err: + # print(err) + + + for i, slide in enumerate(self.notebook.metadata.nbpresent.slides): + filename = "notebook-{0:04d}.pdf".format(i) + print(filename) + screenshot(self.notebook, session, filename) + merger.append(PdfFileReader(filename, "rb")) + + out = merger.write("notebook.pdf") + + # while nbpresent.mayAdvance() + # screenshot(self.notebook, session) + IOLoop.instance().stop() + + +def screenshot(nb, session, dest="notebook.pdf"): + printer = QPrinter(QPrinter.HighResolution) + printer.setResolution(600) + printer.setOutputFileName(dest) + printer.setPaperSize(QPrinter.A3) + printer.setOrientation(QPrinter.Landscape) + printer.setOutputFormat(QPrinter.PdfFormat) + + painter = QPainter(printer) + painter.scale(10, 10) + + session.main_frame.render(painter) + + painter.end() + + +def pdf_capture(nb, static_path): + settings = { + "static_path": static_path + } + + app = tornado.web.Application([ + (r"/(.*)", tornado.web.StaticFileHandler, { + "path": settings['static_path'] + }), + ], **settings) + + server = CaptureServer(app) + server.notebook = nb + + ioloop = IOLoop.instance() + ioloop.add_callback(server.capture) + server.listen(9999) + ioloop.start() diff --git a/nbpresent/present.py b/nbpresent/present/__main__.py similarity index 74% rename from nbpresent/present.py rename to nbpresent/present/__main__.py index cf0707c..40ae999 100644 --- a/nbpresent/present.py +++ b/nbpresent/present/__main__.py @@ -1,10 +1,10 @@ import os import sys -from .exporter import PresentExporter - - -APP_ROOT = os.path.abspath(os.path.dirname(__file__)) +from ..exporters import ( + PresentExporter, + APP_ROOT +) def main(nb): diff --git a/nbpresent/present/pdf.py b/nbpresent/present/pdf.py new file mode 100644 index 0000000..f8c3fbc --- /dev/null +++ b/nbpresent/present/pdf.py @@ -0,0 +1,20 @@ +import os +import sys + +from ..exporters import ( + PDFPresentExporter, + APP_ROOT +) + + +def main(nb): + exp = PDFPresentExporter( + template_file="nbpresent", + template_path=[os.path.join(APP_ROOT, "templates")] + ) + output, resources = exp.from_filename(nb) + with open("output.pdf", "wb+", ) as f: + f.write(output) + +if __name__ == "__main__": + main(sys.argv[1]) diff --git a/src/es6/mode/base.es6 b/src/es6/mode/base.es6 index 333f720..221369e 100644 --- a/src/es6/mode/base.es6 +++ b/src/es6/mode/base.es6 @@ -20,7 +20,8 @@ export class Mode { .attr({id: "nbpresent-css"}) .attr({ rel: "stylesheet", - href: `${this.root}/nbpresent.min.css` + href: `${this.root}nbpresent.min.css` + .replace("//nbpresent", "/nbpresent") }); } } diff --git a/src/js/index.js b/src/js/index.js index 9a2cc74..89e15a1 100644 --- a/src/js/index.js +++ b/src/js/index.js @@ -3,7 +3,8 @@ function(require){ var ns = "nbpresent-", _here = [require.toUrl(".").split("?")[0]], here = function(frag){ - return _here.concat(frag).join("/"); + return _here.concat(frag).join("/") + .replace("//", "/"); }; requirejs.config({ @@ -15,8 +16,9 @@ function(require){ }); function init(env){ - requirejs(["require", "./nbpresent-deps"], function(require){ - requirejs(["require", "./" + ns + env], function(require, Mode){ + requirejs(["require", ns + "deps"], function(require, deps){ + console.log(deps); + requirejs(["require", ns + env], function(require, Mode){ new Mode(_here[0]); }); }); From 41912046ae300a34dd587258c6f4f3eed461db1b Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Tue, 17 Nov 2015 00:15:34 -0500 Subject: [PATCH 03/23] inlining more assets --- nbpresent/exporters/base.py | 6 ++++ nbpresent/exporters/html.py | 6 ++-- nbpresent/exporters/pdf_capture.py | 1 - nbpresent/templates/nbpresent.tpl | 51 ++++++++++++++++++++++++++---- 4 files changed, 55 insertions(+), 9 deletions(-) diff --git a/nbpresent/exporters/base.py b/nbpresent/exporters/base.py index 3291cd4..e10421c 100644 --- a/nbpresent/exporters/base.py +++ b/nbpresent/exporters/base.py @@ -1,4 +1,10 @@ import os +from notebook import DEFAULT_STATIC_FILES_PATH + APP_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) ASSETS = os.path.join(APP_ROOT, "static", "nbpresent") +NB_ASSETS = [os.path.join(DEFAULT_STATIC_FILES_PATH, *bits) for bits in [ + ["components", "requirejs", "require.js"], + ["components", "jquery", "jquery.min.js"] +]] diff --git a/nbpresent/exporters/html.py b/nbpresent/exporters/html.py index 4182adc..944a5ca 100644 --- a/nbpresent/exporters/html.py +++ b/nbpresent/exporters/html.py @@ -6,7 +6,8 @@ from .base import ( APP_ROOT, - ASSETS + ASSETS, + NB_ASSETS ) @@ -29,7 +30,8 @@ def from_notebook_node(self, nb, resources=None, **kw): }, outputs={ filename: open(filename).read() - for filename in glob(os.path.join(ASSETS, "*.*")) + for filename + in list(glob(os.path.join(ASSETS, "*.*"))) + NB_ASSETS } ) diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py index b37756a..716e38c 100644 --- a/nbpresent/exporters/pdf_capture.py +++ b/nbpresent/exporters/pdf_capture.py @@ -45,7 +45,6 @@ def capture(self): for i, slide in enumerate(self.notebook.metadata.nbpresent.slides): filename = "notebook-{0:04d}.pdf".format(i) - print(filename) screenshot(self.notebook, session, filename) merger.append(PdfFileReader(filename, "rb")) diff --git a/nbpresent/templates/nbpresent.tpl b/nbpresent/templates/nbpresent.tpl index 0be792b..8601118 100644 --- a/nbpresent/templates/nbpresent.tpl +++ b/nbpresent/templates/nbpresent.tpl @@ -27,14 +27,53 @@ {%- endblock markdowncell %} -{% block html_head %} - {{ super() }} - {% for css in resources.nbpresent_inline.css -%} - + {% endfor %} -{% endblock html_head %} + + + + + + + + {{ mathjax() }} +{%- endblock html_head -%} {% block body %} From 57031ee71a0b524e2c8a96bd44edc9b653e2a890 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Tue, 17 Nov 2015 10:56:45 -0500 Subject: [PATCH 04/23] bokeh works in pdf! --- nbpresent/exporters/html.py | 7 ++- nbpresent/exporters/pdf.py | 9 ++-- nbpresent/exporters/pdf_capture.py | 75 +++++++++++++++++++++--------- nbpresent/templates/nbpresent.tpl | 11 +++-- src/es6/mode/base.es6 | 5 +- src/js/index.js | 12 ++++- 6 files changed, 83 insertions(+), 36 deletions(-) diff --git a/nbpresent/exporters/html.py b/nbpresent/exporters/html.py index 944a5ca..417631f 100644 --- a/nbpresent/exporters/html.py +++ b/nbpresent/exporters/html.py @@ -21,6 +21,8 @@ def __init__(self, *args, **kwargs): super(PresentExporter, self).__init__(*args, **kwargs) def from_notebook_node(self, nb, resources=None, **kw): + bin_ext = ["woff", "ttf"] + resources = self._init_resources(resources) resources.update( nbpresent={ @@ -29,7 +31,10 @@ def from_notebook_node(self, nb, resources=None, **kw): sort_keys=True) }, outputs={ - filename: open(filename).read() + filename: open( + filename, + "rb" if filename.split(".")[-1] in bin_ext else "r" + ).read() for filename in list(glob(os.path.join(ASSETS, "*.*"))) + NB_ASSETS } diff --git a/nbpresent/exporters/pdf.py b/nbpresent/exporters/pdf.py index 6559743..6e5fce2 100644 --- a/nbpresent/exporters/pdf.py +++ b/nbpresent/exporters/pdf.py @@ -39,13 +39,16 @@ def from_notebook_node(self, nb, resources=None, **kw): with open(index_html, "w+") as f: f.write(output) + self.log.info("Building PDF...") pdf_capture(nb, td) - self.log.info("Building PDF") - pdf_file = 'notebook.pdf' + pdf_file = "notebook.pdf" + if not os.path.isfile(pdf_file): raise IOError("PDF creating failed") - self.log.info('PDF successfully created') + + self.log.info("PDF successfully created") + with open(pdf_file, 'rb') as f: pdf_data = f.read() diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py index 716e38c..119e32e 100644 --- a/nbpresent/exporters/pdf_capture.py +++ b/nbpresent/exporters/pdf_capture.py @@ -1,13 +1,18 @@ from concurrent import futures from glob import glob import os - -try: - from PySide.QtGui import QApplication, QImage, QPainter, QPrinter -except ImportError as err: - from PyQt4.QtGui import QApplication, QImage, QPainter, QPrinter +import logging +import time from ghost import Ghost +from ghost.bindings import ( + # QApplication, + # QImage, + QPainter, + QPrinter, + QtWebKit, + QtCore, +) import tornado.web @@ -21,6 +26,8 @@ PdfFileMerger, ) +from .base import DEFAULT_STATIC_FILES_PATH + class CaptureServer(HTTPServer): executor = futures.ThreadPoolExecutor(max_workers=1) @@ -31,44 +38,63 @@ def __init__(self, *args, **kwargs): @run_on_executor def capture(self): # DO SOME MAGIC - ghost = Ghost() + ghost = Ghost( + log_level=logging.INFO, + defaults=dict( + viewport_size=(1920, 1080), + ) + ) session = ghost.start() + merger = PdfFileMerger() + session.open("http://localhost:9999/index.html") + session.wait_for_page_loaded() - merger = PdfFileMerger() # try: - # session.wait_for_selector("#nbpresent_present_btn") + # session.wait_for_selector("#nbpresent-css") # except Exception as err: # print(err) - for i, slide in enumerate(self.notebook.metadata.nbpresent.slides): + result, resources = session.evaluate( + """ + console.log(nbpresent); + """) + print("printing slide", i, result) filename = "notebook-{0:04d}.pdf".format(i) screenshot(self.notebook, session, filename) + # session.print_to_pdf(filename, + # paper_size=(11.0, 8.5)) merger.append(PdfFileReader(filename, "rb")) + time.sleep(1) out = merger.write("notebook.pdf") - # while nbpresent.mayAdvance() - # screenshot(self.notebook, session) IOLoop.instance().stop() -def screenshot(nb, session, dest="notebook.pdf"): - printer = QPrinter(QPrinter.HighResolution) - printer.setResolution(600) - printer.setOutputFileName(dest) - printer.setPaperSize(QPrinter.A3) - printer.setOrientation(QPrinter.Landscape) - printer.setOutputFormat(QPrinter.PdfFormat) +def screenshot(nb, session, dest="notebook.pdf", as_print=False): + """ + big thanks to https://gist.github.com/jmaupetit/4217925 + """ + session.set_viewport_size(1920, 1080) - painter = QPainter(printer) - painter.scale(10, 10) - - session.main_frame.render(painter) + printer = QPrinter(mode=QPrinter.ScreenResolution) + printer.setOutputFormat(QPrinter.PdfFormat) + printer.setPaperSize(QtCore.QSizeF(8.5, 11), QPrinter.Inch) + printer.setOrientation(QPrinter.Landscape) + printer.setOutputFileName(dest) + printer.setPageMargins(0, 0, 0, 0, QPrinter.Inch) - painter.end() + if as_print: + webview = QtWebKit.QWebView() + webview.setPage(session.page) + webview.print_(printer) + else: + painter = QPainter(printer) + session.main_frame.render(painter) + painter.end() def pdf_capture(nb, static_path): @@ -77,6 +103,9 @@ def pdf_capture(nb, static_path): } app = tornado.web.Application([ + (r"/components/(.*)", tornado.web.StaticFileHandler, { + "path": os.path.join(DEFAULT_STATIC_FILES_PATH, "components") + }), (r"/(.*)", tornado.web.StaticFileHandler, { "path": settings['static_path'] }), diff --git a/nbpresent/templates/nbpresent.tpl b/nbpresent/templates/nbpresent.tpl index 8601118..6211342 100644 --- a/nbpresent/templates/nbpresent.tpl +++ b/nbpresent/templates/nbpresent.tpl @@ -84,9 +84,9 @@ \n", + "\n", + " \n", + "\n", + "
\n", + " \n", + " BokehJS successfully loaded.\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from bokeh.sampledata.iris import flowers\n", + "from bokeh.plotting import figure, show, output_notebook\n", + "output_notebook()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "nbpresent": { + "id": "7d0e1892-a7c0-467f-abfc-259acf3e117d" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "colormap = {'setosa': 'red', 'versicolor': 'green', 'virginica': 'blue'}\n", + "flowers['color'] = flowers['species'].map(lambda x: colormap[x])\n", + "\n", + "p = figure(title = \"Iris Morphology\")\n", + "p.xaxis.axis_label = 'Petal Length'\n", + "p.yaxis.axis_label = 'Petal Width'\n", + "\n", + "p.circle(flowers[\"petal_length\"], flowers[\"petal_width\"],\n", + " color=flowers[\"color\"], fill_alpha=0.2, size=10, )\n", + "\n", + "show(p)" + ] + }, { "cell_type": "markdown", "metadata": { @@ -13,14 +304,23 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": { "collapsed": false, "nbpresent": { "id": "dac29cf1-f0f2-4d89-9a12-6eedf5af313f" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weg/miniconda3/envs/nbpresent/lib/python3.5/site-packages/IPython/html.py:14: ShimWarning: The `IPython.html` package has been deprecated. You should import from `notebook` instead. `IPython.html.widgets` has moved to `ipywidgets`.\n", + " \"`IPython.html.widgets` has moved to `ipywidgets`.\", ShimWarning)\n" + ] + } + ], "source": [ "from ipywidgets import widgets\n", "import numpy as np \n", @@ -33,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -44,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": { "collapsed": false, "nbpresent": { @@ -54,9 +354,9 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6wAAAIXCAYAAACYQdNGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAIXCAYAAABzdmhFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSl4VCoVCoVAoFAqFQiEe/xtYQv9QD3WH0wAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -75,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": { "collapsed": false, "nbpresent": { @@ -92,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": { "collapsed": false, "nbpresent": { @@ -114,7 +414,7 @@ "}\n", "\n", "
\n", - "
\n", + "
\n", "
" ] }, @@ -167,15 +467,15 @@ " 'slick_data_view'\n", "],\n", "function($){\n", - " $('#ecd5a809-e984-4bb0-b494-0618f6008f2d').closest('.rendered_html').removeClass('rendered_html');\n", + " $('#c4130d8e-5d6a-4d9f-96e8-718a5d0d5bd4').closest('.rendered_html').removeClass('rendered_html');\n", " require([\n", " 'slick_check_box_column',\n", " 'slick_row_selection_model',\n", " 'slick_grid'\n", " ], function(){\n", " require([\"data_grid\"], function(dgrid){\n", - " var grid = new dgrid.QGrid('#ecd5a809-e984-4bb0-b494-0618f6008f2d', [{\"null\":0,\"0\":0.1576,\"1\":-0.8525,\"2\":-0.8028},{\"null\":1,\"0\":0.468,\"1\":-0.0165,\"2\":-0.3131},{\"null\":2,\"0\":-0.5796,\"1\":-1.0921,\"2\":0.3912},{\"null\":3,\"0\":-1.0399,\"1\":0.0874,\"2\":-0.201},{\"null\":4,\"0\":0.0001,\"1\":0.2859,\"2\":-0.9409},{\"null\":5,\"0\":0.2301,\"1\":1.2382,\"2\":-0.7903},{\"null\":6,\"0\":-0.9929,\"1\":-0.3223,\"2\":-0.7604},{\"null\":7,\"0\":-0.475,\"1\":-1.3666,\"2\":1.0643},{\"null\":8,\"0\":2.3684,\"1\":-1.4788,\"2\":-0.0769},{\"null\":9,\"0\":-0.164,\"1\":-1.1089,\"2\":0.2514},{\"null\":10,\"0\":0.4634,\"1\":0.2074,\"2\":0.2313},{\"null\":11,\"0\":0.4976,\"1\":-1.212,\"2\":-1.7076},{\"null\":12,\"0\":0.9624,\"1\":-1.3493,\"2\":-0.1956},{\"null\":13,\"0\":-0.9127,\"1\":-0.6179,\"2\":0.4619},{\"null\":14,\"0\":0.1612,\"1\":0.5738,\"2\":-0.2952},{\"null\":15,\"0\":-0.4389,\"1\":1.4307,\"2\":-0.4307},{\"null\":16,\"0\":-1.227,\"1\":-0.7467,\"2\":-1.9746},{\"null\":17,\"0\":0.2182,\"1\":-0.6092,\"2\":0.6508},{\"null\":18,\"0\":1.1172,\"1\":-0.9409,\"2\":-1.1159},{\"null\":19,\"0\":-0.4586,\"1\":0.1945,\"2\":-1.6913},{\"null\":20,\"0\":-0.6444,\"1\":0.9035,\"2\":-0.4209},{\"null\":21,\"0\":-0.5443,\"1\":-0.0752,\"2\":0.4766},{\"null\":22,\"0\":0.113,\"1\":-0.5049,\"2\":1.5022},{\"null\":23,\"0\":-1.2258,\"1\":-1.7799,\"2\":-0.4865},{\"null\":24,\"0\":-1.1476,\"1\":0.0455,\"2\":0.1081},{\"null\":25,\"0\":1.1409,\"1\":-0.0239,\"2\":-0.1966},{\"null\":26,\"0\":0.1254,\"1\":-0.5354,\"2\":0.1575},{\"null\":27,\"0\":-0.0867,\"1\":-1.6525,\"2\":1.6724},{\"null\":28,\"0\":2.237,\"1\":-1.1607,\"2\":0.522},{\"null\":29,\"0\":-1.2837,\"1\":-1.2108,\"2\":0.5214},{\"null\":30,\"0\":0.2287,\"1\":0.3216,\"2\":2.0703},{\"null\":31,\"0\":-0.63,\"1\":1.1598,\"2\":-0.6507},{\"null\":32,\"0\":0.8297,\"1\":-0.8896,\"2\":0.5875},{\"null\":33,\"0\":-0.9265,\"1\":-0.1327,\"2\":-0.4583},{\"null\":34,\"0\":-0.4924,\"1\":1.0509,\"2\":1.309},{\"null\":35,\"0\":-1.0224,\"1\":-0.4004,\"2\":0.2993},{\"null\":36,\"0\":0.1503,\"1\":0.7264,\"2\":0.0868},{\"null\":37,\"0\":1.0793,\"1\":-2.0087,\"2\":-0.312},{\"null\":38,\"0\":0.6096,\"1\":0.5094,\"2\":-0.0735},{\"null\":39,\"0\":-1.0701,\"1\":-0.2555,\"2\":0.9374},{\"null\":40,\"0\":0.8959,\"1\":0.7196,\"2\":1.1952},{\"null\":41,\"0\":0.0621,\"1\":-0.3363,\"2\":-0.4369},{\"null\":42,\"0\":1.2842,\"1\":-0.3849,\"2\":0.8642},{\"null\":43,\"0\":0.3422,\"1\":-0.1074,\"2\":0.3488},{\"null\":44,\"0\":0.6695,\"1\":0.3429,\"2\":0.6339},{\"null\":45,\"0\":0.6975,\"1\":-0.1197,\"2\":0.3417},{\"null\":46,\"0\":-0.5025,\"1\":-1.2729,\"2\":-0.0117},{\"null\":47,\"0\":-1.3425,\"1\":-2.2497,\"2\":-1.0437},{\"null\":48,\"0\":0.3389,\"1\":-0.6858,\"2\":-0.4756},{\"null\":49,\"0\":1.2571,\"1\":1.8864,\"2\":-0.1842},{\"null\":50,\"0\":0.5132,\"1\":-0.9549,\"2\":0.3332},{\"null\":51,\"0\":2.037,\"1\":3.4529,\"2\":0.445},{\"null\":52,\"0\":1.0567,\"1\":-0.3252,\"2\":-0.2004},{\"null\":53,\"0\":0.3716,\"1\":0.2609,\"2\":0.2662},{\"null\":54,\"0\":-0.2118,\"1\":-1.4183,\"2\":-0.1605},{\"null\":55,\"0\":-0.7632,\"1\":0.0026,\"2\":0.1021},{\"null\":56,\"0\":0.045,\"1\":0.6526,\"2\":2.1827},{\"null\":57,\"0\":0.5368,\"1\":-0.9169,\"2\":-0.0204},{\"null\":58,\"0\":-1.3202,\"1\":-0.177,\"2\":0.2989},{\"null\":59,\"0\":-0.7041,\"1\":-2.2422,\"2\":-1.2207},{\"null\":60,\"0\":-0.2392,\"1\":-0.4017,\"2\":0.5624},{\"null\":61,\"0\":-0.097,\"1\":-1.7786,\"2\":-0.0632},{\"null\":62,\"0\":1.1483,\"1\":0.3438,\"2\":-0.4907},{\"null\":63,\"0\":0.325,\"1\":0.8227,\"2\":-1.1947},{\"null\":64,\"0\":0.4857,\"1\":0.1536,\"2\":-1.0176},{\"null\":65,\"0\":-0.5242,\"1\":0.3443,\"2\":-1.6863},{\"null\":66,\"0\":0.9235,\"1\":-0.5204,\"2\":0.1419},{\"null\":67,\"0\":-0.9636,\"1\":-0.9164,\"2\":-0.9517},{\"null\":68,\"0\":2.6696,\"1\":-0.2964,\"2\":-1.1158},{\"null\":69,\"0\":0.5419,\"1\":1.3768,\"2\":1.6689},{\"null\":70,\"0\":-0.1335,\"1\":-0.6163,\"2\":0.8037},{\"null\":71,\"0\":-0.7871,\"1\":1.1316,\"2\":0.3588},{\"null\":72,\"0\":-0.6234,\"1\":0.0281,\"2\":-1.0809},{\"null\":73,\"0\":-1.1474,\"1\":-1.1824,\"2\":-0.2544},{\"null\":74,\"0\":0.3275,\"1\":0.505,\"2\":0.1794},{\"null\":75,\"0\":1.3907,\"1\":1.851,\"2\":0.4833},{\"null\":76,\"0\":-0.0327,\"1\":-0.4919,\"2\":-0.9575},{\"null\":77,\"0\":0.9552,\"1\":-0.7157,\"2\":-1.6583},{\"null\":78,\"0\":-0.2129,\"1\":-0.288,\"2\":-1.5016},{\"null\":79,\"0\":-0.1439,\"1\":-0.1858,\"2\":-0.2653},{\"null\":80,\"0\":-1.6201,\"1\":-0.9254,\"2\":0.1642},{\"null\":81,\"0\":0.9251,\"1\":1.3347,\"2\":-0.3901},{\"null\":82,\"0\":-0.1726,\"1\":-1.0985,\"2\":1.5175},{\"null\":83,\"0\":-0.5562,\"1\":-0.6818,\"2\":0.0514},{\"null\":84,\"0\":-0.479,\"1\":-0.3498,\"2\":0.9456},{\"null\":85,\"0\":1.6583,\"1\":0.8725,\"2\":0.8824},{\"null\":86,\"0\":-0.1014,\"1\":0.5797,\"2\":-0.1037},{\"null\":87,\"0\":1.6522,\"1\":0.7713,\"2\":0.4575},{\"null\":88,\"0\":-0.5286,\"1\":-0.0194,\"2\":-1.5928},{\"null\":89,\"0\":-0.67,\"1\":-0.1367,\"2\":-1.2142},{\"null\":90,\"0\":0.0856,\"1\":-1.2743,\"2\":0.5168},{\"null\":91,\"0\":-1.4348,\"1\":-0.6472,\"2\":1.4711},{\"null\":92,\"0\":-1.0077,\"1\":0.8953,\"2\":0.7083},{\"null\":93,\"0\":-1.0206,\"1\":-0.3988,\"2\":-0.1294},{\"null\":94,\"0\":1.3693,\"1\":0.1925,\"2\":0.5641},{\"null\":95,\"0\":-0.8072,\"1\":-0.7645,\"2\":-2.1946},{\"null\":96,\"0\":-1.6765,\"1\":0.8076,\"2\":0.5252},{\"null\":97,\"0\":0.4635,\"1\":0.8828,\"2\":1.1999},{\"null\":98,\"0\":0.0576,\"1\":0.2023,\"2\":0.4396},{\"null\":99,\"0\":2.786,\"1\":-0.496,\"2\":0.2926}], [{\"type\": \"Integer\", \"field\": null}, {\"type\": \"Float\", \"field\": 0}, {\"type\": \"Float\", \"field\": 1}, {\"type\": \"Float\", \"field\": 2}]);\n", - " grid.initialize_slick_grid({\"fullWidthRows\": true, \"rowHeight\": 28, \"syncColumnCellResize\": true, \"forceFitColumns\": true, \"enableTextSelectionOnCells\": true, \"enableColumnReorder\": false});\n", + " var grid = new dgrid.QGrid('#c4130d8e-5d6a-4d9f-96e8-718a5d0d5bd4', [{\"null\":0,\"0\":-0.3524,\"1\":0.7963,\"2\":-0.3489},{\"null\":1,\"0\":0.0775,\"1\":0.288,\"2\":-0.2979},{\"null\":2,\"0\":0.2611,\"1\":0.4999,\"2\":1.2097},{\"null\":3,\"0\":0.1037,\"1\":-0.7408,\"2\":-2.1547},{\"null\":4,\"0\":-0.1707,\"1\":-0.5142,\"2\":-0.9634},{\"null\":5,\"0\":0.5749,\"1\":-0.8162,\"2\":0.288},{\"null\":6,\"0\":0.437,\"1\":1.4391,\"2\":-0.3008},{\"null\":7,\"0\":-0.0039,\"1\":-0.2077,\"2\":-1.7681},{\"null\":8,\"0\":0.6971,\"1\":-1.2387,\"2\":-0.4416},{\"null\":9,\"0\":-0.7901,\"1\":-0.3141,\"2\":1.3737},{\"null\":10,\"0\":0.8337,\"1\":0.6032,\"2\":1.2853},{\"null\":11,\"0\":0.4965,\"1\":-0.7313,\"2\":-1.6658},{\"null\":12,\"0\":0.2382,\"1\":-0.7575,\"2\":0.228},{\"null\":13,\"0\":0.5933,\"1\":1.1561,\"2\":0.4777},{\"null\":14,\"0\":0.1262,\"1\":0.4172,\"2\":0.3238},{\"null\":15,\"0\":1.1456,\"1\":-0.6155,\"2\":1.4879},{\"null\":16,\"0\":2.15,\"1\":1.0374,\"2\":0.0107},{\"null\":17,\"0\":1.7552,\"1\":0.7138,\"2\":-0.4682},{\"null\":18,\"0\":-1.3754,\"1\":-0.6326,\"2\":-1.3715},{\"null\":19,\"0\":0.4311,\"1\":-1.6294,\"2\":-0.0943},{\"null\":20,\"0\":0.4673,\"1\":1.9723,\"2\":1.3564},{\"null\":21,\"0\":1.0022,\"1\":0.2409,\"2\":-0.7119},{\"null\":22,\"0\":-1.7003,\"1\":-1.0533,\"2\":0.2404},{\"null\":23,\"0\":0.4896,\"1\":1.0258,\"2\":0.7289},{\"null\":24,\"0\":0.617,\"1\":-0.4017,\"2\":-1.8726},{\"null\":25,\"0\":-0.7384,\"1\":-0.5759,\"2\":-0.5252},{\"null\":26,\"0\":0.4327,\"1\":-0.4443,\"2\":0.4657},{\"null\":27,\"0\":0.6405,\"1\":0.1469,\"2\":2.5617},{\"null\":28,\"0\":-0.6378,\"1\":0.2285,\"2\":-0.2714},{\"null\":29,\"0\":1.4619,\"1\":0.3023,\"2\":-0.157},{\"null\":30,\"0\":-0.3329,\"1\":-0.4613,\"2\":1.365},{\"null\":31,\"0\":0.3691,\"1\":0.5219,\"2\":0.1607},{\"null\":32,\"0\":-0.5748,\"1\":0.4266,\"2\":-1.9448},{\"null\":33,\"0\":0.7701,\"1\":1.2875,\"2\":0.475},{\"null\":34,\"0\":0.1112,\"1\":0.1639,\"2\":-1.088},{\"null\":35,\"0\":0.6424,\"1\":-0.502,\"2\":-1.0102},{\"null\":36,\"0\":0.1765,\"1\":1.4625,\"2\":-0.394},{\"null\":37,\"0\":-0.4911,\"1\":-0.556,\"2\":-0.2848},{\"null\":38,\"0\":-0.4132,\"1\":-0.3704,\"2\":-1.7969},{\"null\":39,\"0\":0.5826,\"1\":0.9922,\"2\":0.5152},{\"null\":40,\"0\":1.1435,\"1\":0.9524,\"2\":0.6012},{\"null\":41,\"0\":1.2602,\"1\":-0.4886,\"2\":-0.0877},{\"null\":42,\"0\":-0.8683,\"1\":-1.0522,\"2\":-0.4396},{\"null\":43,\"0\":1.1019,\"1\":-0.3598,\"2\":1.1656},{\"null\":44,\"0\":-1.4034,\"1\":0.0315,\"2\":0.5544},{\"null\":45,\"0\":-0.4922,\"1\":1.6786,\"2\":1.5356},{\"null\":46,\"0\":0.1024,\"1\":1.9849,\"2\":0.1},{\"null\":47,\"0\":0.8003,\"1\":0.8336,\"2\":-0.2673},{\"null\":48,\"0\":-0.5654,\"1\":0.1517,\"2\":-2.1328},{\"null\":49,\"0\":-1.6714,\"1\":-0.0878,\"2\":2.0025},{\"null\":50,\"0\":0.2659,\"1\":0.8033,\"2\":-0.352},{\"null\":51,\"0\":0.5504,\"1\":-1.5222,\"2\":0.7646},{\"null\":52,\"0\":0.2282,\"1\":-0.2142,\"2\":-2.1749},{\"null\":53,\"0\":-1.6126,\"1\":0.36,\"2\":1.7001},{\"null\":54,\"0\":-0.1022,\"1\":0.1484,\"2\":-0.9899},{\"null\":55,\"0\":0.7827,\"1\":-0.2901,\"2\":0.5516},{\"null\":56,\"0\":1.59,\"1\":-0.1361,\"2\":0.4554},{\"null\":57,\"0\":-0.3121,\"1\":-0.8033,\"2\":0.4078},{\"null\":58,\"0\":-0.5925,\"1\":-0.4395,\"2\":-0.5018},{\"null\":59,\"0\":0.2876,\"1\":-0.741,\"2\":-1.4375},{\"null\":60,\"0\":1.006,\"1\":-1.1441,\"2\":-1.0753},{\"null\":61,\"0\":0.1734,\"1\":0.9196,\"2\":-1.3446},{\"null\":62,\"0\":0.3052,\"1\":0.1733,\"2\":0.7032},{\"null\":63,\"0\":-1.7581,\"1\":-0.5118,\"2\":-1.7652},{\"null\":64,\"0\":-0.4091,\"1\":-0.0306,\"2\":-0.5656},{\"null\":65,\"0\":-0.1944,\"1\":0.2556,\"2\":-1.0443},{\"null\":66,\"0\":-1.3851,\"1\":-0.5177,\"2\":0.35},{\"null\":67,\"0\":-0.3161,\"1\":-0.3664,\"2\":0.1415},{\"null\":68,\"0\":0.3552,\"1\":-1.262,\"2\":0.669},{\"null\":69,\"0\":0.331,\"1\":-0.5324,\"2\":-1.6928},{\"null\":70,\"0\":0.492,\"1\":-0.154,\"2\":-0.892},{\"null\":71,\"0\":-0.3538,\"1\":1.1748,\"2\":0.6505},{\"null\":72,\"0\":-1.1636,\"1\":-1.1385,\"2\":1.4768},{\"null\":73,\"0\":0.8039,\"1\":-0.0777,\"2\":0.4054},{\"null\":74,\"0\":1.3357,\"1\":0.2145,\"2\":-0.8135},{\"null\":75,\"0\":1.2515,\"1\":0.5457,\"2\":0.0592},{\"null\":76,\"0\":0.6526,\"1\":0.7995,\"2\":-2.252},{\"null\":77,\"0\":0.31,\"1\":1.0169,\"2\":-0.077},{\"null\":78,\"0\":-1.8385,\"1\":-0.7622,\"2\":0.6279},{\"null\":79,\"0\":-1.53,\"1\":-2.0976,\"2\":-1.3166},{\"null\":80,\"0\":2.1532,\"1\":0.9315,\"2\":-0.0794},{\"null\":81,\"0\":0.6225,\"1\":1.0901,\"2\":-0.9236},{\"null\":82,\"0\":-0.0647,\"1\":-0.2641,\"2\":-0.012},{\"null\":83,\"0\":-1.0602,\"1\":-0.1759,\"2\":0.3062},{\"null\":84,\"0\":-0.0221,\"1\":0.1387,\"2\":3.2778},{\"null\":85,\"0\":0.2502,\"1\":0.2463,\"2\":-1.3211},{\"null\":86,\"0\":-0.6213,\"1\":0.1044,\"2\":-2.246},{\"null\":87,\"0\":0.5551,\"1\":0.7954,\"2\":-0.1843},{\"null\":88,\"0\":2.1548,\"1\":0.4782,\"2\":1.15},{\"null\":89,\"0\":-1.5096,\"1\":0.4072,\"2\":-1.396},{\"null\":90,\"0\":0.983,\"1\":-0.6514,\"2\":0.4497},{\"null\":91,\"0\":1.5418,\"1\":-0.0856,\"2\":0.7943},{\"null\":92,\"0\":0.3347,\"1\":0.317,\"2\":-0.2968},{\"null\":93,\"0\":-0.7241,\"1\":-1.353,\"2\":-1.1688},{\"null\":94,\"0\":0.0695,\"1\":2.6368,\"2\":-0.0595},{\"null\":95,\"0\":0.2575,\"1\":0.5266,\"2\":0.7574},{\"null\":96,\"0\":0.4532,\"1\":0.4176,\"2\":-1.2303},{\"null\":97,\"0\":-0.9982,\"1\":1.1423,\"2\":0.4568},{\"null\":98,\"0\":-1.2921,\"1\":-1.4398,\"2\":-1.3691},{\"null\":99,\"0\":0.1909,\"1\":0.2032,\"2\":1.1968}], [{\"field\": null, \"type\": \"Integer\"}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", + " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"fullWidthRows\": true, \"forceFitColumns\": true, \"enableColumnReorder\": false, \"rowHeight\": 28});\n", " });\n", " });\n", "});\n" @@ -191,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": { "collapsed": false, "nbpresent": { @@ -213,7 +513,7 @@ "}\n", "\n", "
\n", - "
\n", + "
\n", "
" ] }, @@ -266,15 +566,15 @@ " 'slick_data_view'\n", "],\n", "function($){\n", - " $('#8b63eb11-a059-4eb7-8f50-9b4c1cb52c70').closest('.rendered_html').removeClass('rendered_html');\n", + " $('#dc95e4ea-92b2-4e40-a97f-6037a3752a4a').closest('.rendered_html').removeClass('rendered_html');\n", " require([\n", " 'slick_check_box_column',\n", " 'slick_row_selection_model',\n", " 'slick_grid'\n", " ], function(){\n", " require([\"data_grid\"], function(dgrid){\n", - " var grid = new dgrid.QGrid('#8b63eb11-a059-4eb7-8f50-9b4c1cb52c70', [{\"null\":\"count\",\"0\":100.0,\"1\":100.0,\"2\":100.0},{\"null\":\"mean\",\"0\":0.0584,\"1\":-0.1857,\"2\":-0.0126},{\"null\":\"std\",\"0\":0.9616,\"1\":0.9606,\"2\":0.8945},{\"null\":\"min\",\"0\":-1.6765,\"1\":-2.2497,\"2\":-2.1946},{\"null\":\"25%\",\"0\":-0.6336,\"1\":-0.8618,\"2\":-0.4783},{\"null\":\"50%\",\"0\":0.0225,\"1\":-0.2717,\"2\":0.0691},{\"null\":\"75%\",\"0\":0.5588,\"1\":0.3439,\"2\":0.518},{\"null\":\"max\",\"0\":2.786,\"1\":3.4529,\"2\":2.1827}], [{\"field\": null}, {\"type\": \"Float\", \"field\": 0}, {\"type\": \"Float\", \"field\": 1}, {\"type\": \"Float\", \"field\": 2}]);\n", - " grid.initialize_slick_grid({\"fullWidthRows\": true, \"rowHeight\": 28, \"syncColumnCellResize\": true, \"forceFitColumns\": true, \"enableTextSelectionOnCells\": true, \"enableColumnReorder\": false});\n", + " var grid = new dgrid.QGrid('#dc95e4ea-92b2-4e40-a97f-6037a3752a4a', [{\"null\":\"count\",\"0\":100.0,\"1\":100.0,\"2\":100.0},{\"null\":\"mean\",\"0\":0.1194,\"1\":0.0594,\"2\":-0.1358},{\"null\":\"std\",\"0\":0.9028,\"1\":0.8555,\"2\":1.1166},{\"null\":\"min\",\"0\":-1.8385,\"1\":-2.0976,\"2\":-2.252},{\"null\":\"25%\",\"0\":-0.4327,\"1\":-0.5151,\"2\":-0.995},{\"null\":\"50%\",\"0\":0.2539,\"1\":0.1216,\"2\":-0.0835},{\"null\":\"75%\",\"0\":0.627,\"1\":0.5601,\"2\":0.5523},{\"null\":\"max\",\"0\":2.1548,\"1\":2.6368,\"2\":3.2778}], [{\"field\": null}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", + " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"fullWidthRows\": true, \"forceFitColumns\": true, \"enableColumnReorder\": false, \"rowHeight\": 28});\n", " });\n", " });\n", "});\n" @@ -364,9 +664,28 @@ } } }, + "8c4ca91b-593f-4a56-af36-685783016d16": { + "id": "8c4ca91b-593f-4a56-af36-685783016d16", + "prev": null, + "regions": { + "946de288-8e32-47a3-8eda-2ab8426cf7ca": { + "attrs": { + "height": 0.8, + "width": 0.8, + "x": 0.1, + "y": 0.1 + }, + "content": { + "cell": "7d0e1892-a7c0-467f-abfc-259acf3e117d", + "part": "outputs" + }, + "id": "946de288-8e32-47a3-8eda-2ab8426cf7ca" + } + } + }, "9edf888c-000b-47cf-a501-0b3f624ee851": { "id": "9edf888c-000b-47cf-a501-0b3f624ee851", - "prev": null, + "prev": "8c4ca91b-593f-4a56-af36-685783016d16", "regions": { "d74608b3-662a-4833-8ceb-d155968e1a14": { "attrs": { @@ -382,6 +701,25 @@ "id": "d74608b3-662a-4833-8ceb-d155968e1a14" } } + }, + "b6464755-9891-4f10-bb5f-e84e54913e5c": { + "id": "b6464755-9891-4f10-bb5f-e84e54913e5c", + "prev": "35b159c2-a505-4cf0-a484-5fa773aa0827", + "regions": { + "2c1159ac-071d-4e7d-8fe1-4e5d0604138e": { + "attrs": { + "height": 0.8, + "width": 0.8, + "x": 0.1, + "y": 0.1 + }, + "content": { + "cell": "6dd75bcd-39e8-4254-a6c8-bbdf55498c5b", + "part": "outputs" + }, + "id": "2c1159ac-071d-4e7d-8fe1-4e5d0604138e" + } + } } } } From da9429c2ac6363cb1dfb4ca86fce7eb2a8cb4922 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Tue, 17 Nov 2015 22:00:31 -0500 Subject: [PATCH 08/23] adding Function.bind polyfill --- .babelrc | 3 ++ nbpresent/exporters/pdf.py | 1 - nbpresent/exporters/pdf_capture.py | 9 +++--- nbpresent/templates/nbpresent.tpl | 44 ++++++++++++++++++++++-------- package.json | 10 ++++--- src/es6/cells/standalone.es6 | 29 ++++++++++---------- src/es6/mode/notebook.es6 | 4 +-- src/es6/mode/standalone.es6 | 6 ++-- src/es6/presenter/base.es6 | 2 +- src/es6/vendor.es6 | 8 ++---- src/js/index.js | 24 +++------------- 11 files changed, 72 insertions(+), 68 deletions(-) create mode 100644 .babelrc diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..c13c5f6 --- /dev/null +++ b/.babelrc @@ -0,0 +1,3 @@ +{ + "presets": ["es2015"] +} diff --git a/nbpresent/exporters/pdf.py b/nbpresent/exporters/pdf.py index 9a5b1f9..4c98a88 100644 --- a/nbpresent/exporters/pdf.py +++ b/nbpresent/exporters/pdf.py @@ -33,7 +33,6 @@ def from_notebook_node(self, nb, resources=None, **kw): with TemporaryWorkingDirectory() as td: for path, res in resources.get("outputs", {}).items(): dest = os.path.join(td, os.path.basename(path)) - print("copying", path, dest) shutil.copyfile(path, dest) index_html = os.path.join(td, "index.html") diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py index 5f48710..21f4da8 100644 --- a/nbpresent/exporters/pdf_capture.py +++ b/nbpresent/exporters/pdf_capture.py @@ -43,12 +43,11 @@ def capture(self): print(self.static_path) # DO SOME MAGIC ghost = Ghost( - log_level=logging.DEBUG, - defaults=dict( - viewport_size=(1920, 1080), - ) + log_level=logging.DEBUG + ) + session = ghost.start( + display=True ) - session = ghost.start() merger = PdfFileMerger() join = lambda *bits: os.path.join(self.static_path, *bits) diff --git a/nbpresent/templates/nbpresent.tpl b/nbpresent/templates/nbpresent.tpl index 2a8c744..55c9bae 100644 --- a/nbpresent/templates/nbpresent.tpl +++ b/nbpresent/templates/nbpresent.tpl @@ -82,16 +82,40 @@ + \n", - "
\n", + "
\n", "\n" ] }, @@ -281,7 +292,7 @@ "colormap = {'setosa': 'red', 'versicolor': 'green', 'virginica': 'blue'}\n", "flowers['color'] = flowers['species'].map(lambda x: colormap[x])\n", "\n", - "p = figure(title = \"Iris Morphology\")\n", + "p = figure(title=\"Iris Morphology\", width=1200, height=800)\n", "p.xaxis.axis_label = 'Petal Length'\n", "p.yaxis.axis_label = 'Petal Width'\n", "\n", @@ -291,20 +302,9 @@ "show(p)" ] }, - { - "cell_type": "markdown", - "metadata": { - "nbpresent": { - "id": "8438b2c1-2e72-40e6-bfd4-89a9bff2628e" - } - }, - "source": [ - "# NBPresent" - ] - }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": { "collapsed": false, "nbpresent": { @@ -333,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": { "collapsed": true }, @@ -344,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": { "collapsed": false, "nbpresent": { @@ -356,7 +356,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAIXCAYAAABzdmhFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSl4VCoVCoVAoFAqFQiEe/xtYQv9QD3WH0wAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -375,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": { "collapsed": false, "nbpresent": { @@ -392,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "collapsed": false, "nbpresent": { @@ -414,7 +414,7 @@ "}\n", "\n", "
\n", - "
\n", + "
\n", "
" ] }, @@ -467,15 +467,15 @@ " 'slick_data_view'\n", "],\n", "function($){\n", - " $('#c4130d8e-5d6a-4d9f-96e8-718a5d0d5bd4').closest('.rendered_html').removeClass('rendered_html');\n", + " $('#12a37f09-8c1e-42e7-8e47-636ece657c90').closest('.rendered_html').removeClass('rendered_html');\n", " require([\n", " 'slick_check_box_column',\n", " 'slick_row_selection_model',\n", " 'slick_grid'\n", " ], function(){\n", " require([\"data_grid\"], function(dgrid){\n", - " var grid = new dgrid.QGrid('#c4130d8e-5d6a-4d9f-96e8-718a5d0d5bd4', [{\"null\":0,\"0\":-0.3524,\"1\":0.7963,\"2\":-0.3489},{\"null\":1,\"0\":0.0775,\"1\":0.288,\"2\":-0.2979},{\"null\":2,\"0\":0.2611,\"1\":0.4999,\"2\":1.2097},{\"null\":3,\"0\":0.1037,\"1\":-0.7408,\"2\":-2.1547},{\"null\":4,\"0\":-0.1707,\"1\":-0.5142,\"2\":-0.9634},{\"null\":5,\"0\":0.5749,\"1\":-0.8162,\"2\":0.288},{\"null\":6,\"0\":0.437,\"1\":1.4391,\"2\":-0.3008},{\"null\":7,\"0\":-0.0039,\"1\":-0.2077,\"2\":-1.7681},{\"null\":8,\"0\":0.6971,\"1\":-1.2387,\"2\":-0.4416},{\"null\":9,\"0\":-0.7901,\"1\":-0.3141,\"2\":1.3737},{\"null\":10,\"0\":0.8337,\"1\":0.6032,\"2\":1.2853},{\"null\":11,\"0\":0.4965,\"1\":-0.7313,\"2\":-1.6658},{\"null\":12,\"0\":0.2382,\"1\":-0.7575,\"2\":0.228},{\"null\":13,\"0\":0.5933,\"1\":1.1561,\"2\":0.4777},{\"null\":14,\"0\":0.1262,\"1\":0.4172,\"2\":0.3238},{\"null\":15,\"0\":1.1456,\"1\":-0.6155,\"2\":1.4879},{\"null\":16,\"0\":2.15,\"1\":1.0374,\"2\":0.0107},{\"null\":17,\"0\":1.7552,\"1\":0.7138,\"2\":-0.4682},{\"null\":18,\"0\":-1.3754,\"1\":-0.6326,\"2\":-1.3715},{\"null\":19,\"0\":0.4311,\"1\":-1.6294,\"2\":-0.0943},{\"null\":20,\"0\":0.4673,\"1\":1.9723,\"2\":1.3564},{\"null\":21,\"0\":1.0022,\"1\":0.2409,\"2\":-0.7119},{\"null\":22,\"0\":-1.7003,\"1\":-1.0533,\"2\":0.2404},{\"null\":23,\"0\":0.4896,\"1\":1.0258,\"2\":0.7289},{\"null\":24,\"0\":0.617,\"1\":-0.4017,\"2\":-1.8726},{\"null\":25,\"0\":-0.7384,\"1\":-0.5759,\"2\":-0.5252},{\"null\":26,\"0\":0.4327,\"1\":-0.4443,\"2\":0.4657},{\"null\":27,\"0\":0.6405,\"1\":0.1469,\"2\":2.5617},{\"null\":28,\"0\":-0.6378,\"1\":0.2285,\"2\":-0.2714},{\"null\":29,\"0\":1.4619,\"1\":0.3023,\"2\":-0.157},{\"null\":30,\"0\":-0.3329,\"1\":-0.4613,\"2\":1.365},{\"null\":31,\"0\":0.3691,\"1\":0.5219,\"2\":0.1607},{\"null\":32,\"0\":-0.5748,\"1\":0.4266,\"2\":-1.9448},{\"null\":33,\"0\":0.7701,\"1\":1.2875,\"2\":0.475},{\"null\":34,\"0\":0.1112,\"1\":0.1639,\"2\":-1.088},{\"null\":35,\"0\":0.6424,\"1\":-0.502,\"2\":-1.0102},{\"null\":36,\"0\":0.1765,\"1\":1.4625,\"2\":-0.394},{\"null\":37,\"0\":-0.4911,\"1\":-0.556,\"2\":-0.2848},{\"null\":38,\"0\":-0.4132,\"1\":-0.3704,\"2\":-1.7969},{\"null\":39,\"0\":0.5826,\"1\":0.9922,\"2\":0.5152},{\"null\":40,\"0\":1.1435,\"1\":0.9524,\"2\":0.6012},{\"null\":41,\"0\":1.2602,\"1\":-0.4886,\"2\":-0.0877},{\"null\":42,\"0\":-0.8683,\"1\":-1.0522,\"2\":-0.4396},{\"null\":43,\"0\":1.1019,\"1\":-0.3598,\"2\":1.1656},{\"null\":44,\"0\":-1.4034,\"1\":0.0315,\"2\":0.5544},{\"null\":45,\"0\":-0.4922,\"1\":1.6786,\"2\":1.5356},{\"null\":46,\"0\":0.1024,\"1\":1.9849,\"2\":0.1},{\"null\":47,\"0\":0.8003,\"1\":0.8336,\"2\":-0.2673},{\"null\":48,\"0\":-0.5654,\"1\":0.1517,\"2\":-2.1328},{\"null\":49,\"0\":-1.6714,\"1\":-0.0878,\"2\":2.0025},{\"null\":50,\"0\":0.2659,\"1\":0.8033,\"2\":-0.352},{\"null\":51,\"0\":0.5504,\"1\":-1.5222,\"2\":0.7646},{\"null\":52,\"0\":0.2282,\"1\":-0.2142,\"2\":-2.1749},{\"null\":53,\"0\":-1.6126,\"1\":0.36,\"2\":1.7001},{\"null\":54,\"0\":-0.1022,\"1\":0.1484,\"2\":-0.9899},{\"null\":55,\"0\":0.7827,\"1\":-0.2901,\"2\":0.5516},{\"null\":56,\"0\":1.59,\"1\":-0.1361,\"2\":0.4554},{\"null\":57,\"0\":-0.3121,\"1\":-0.8033,\"2\":0.4078},{\"null\":58,\"0\":-0.5925,\"1\":-0.4395,\"2\":-0.5018},{\"null\":59,\"0\":0.2876,\"1\":-0.741,\"2\":-1.4375},{\"null\":60,\"0\":1.006,\"1\":-1.1441,\"2\":-1.0753},{\"null\":61,\"0\":0.1734,\"1\":0.9196,\"2\":-1.3446},{\"null\":62,\"0\":0.3052,\"1\":0.1733,\"2\":0.7032},{\"null\":63,\"0\":-1.7581,\"1\":-0.5118,\"2\":-1.7652},{\"null\":64,\"0\":-0.4091,\"1\":-0.0306,\"2\":-0.5656},{\"null\":65,\"0\":-0.1944,\"1\":0.2556,\"2\":-1.0443},{\"null\":66,\"0\":-1.3851,\"1\":-0.5177,\"2\":0.35},{\"null\":67,\"0\":-0.3161,\"1\":-0.3664,\"2\":0.1415},{\"null\":68,\"0\":0.3552,\"1\":-1.262,\"2\":0.669},{\"null\":69,\"0\":0.331,\"1\":-0.5324,\"2\":-1.6928},{\"null\":70,\"0\":0.492,\"1\":-0.154,\"2\":-0.892},{\"null\":71,\"0\":-0.3538,\"1\":1.1748,\"2\":0.6505},{\"null\":72,\"0\":-1.1636,\"1\":-1.1385,\"2\":1.4768},{\"null\":73,\"0\":0.8039,\"1\":-0.0777,\"2\":0.4054},{\"null\":74,\"0\":1.3357,\"1\":0.2145,\"2\":-0.8135},{\"null\":75,\"0\":1.2515,\"1\":0.5457,\"2\":0.0592},{\"null\":76,\"0\":0.6526,\"1\":0.7995,\"2\":-2.252},{\"null\":77,\"0\":0.31,\"1\":1.0169,\"2\":-0.077},{\"null\":78,\"0\":-1.8385,\"1\":-0.7622,\"2\":0.6279},{\"null\":79,\"0\":-1.53,\"1\":-2.0976,\"2\":-1.3166},{\"null\":80,\"0\":2.1532,\"1\":0.9315,\"2\":-0.0794},{\"null\":81,\"0\":0.6225,\"1\":1.0901,\"2\":-0.9236},{\"null\":82,\"0\":-0.0647,\"1\":-0.2641,\"2\":-0.012},{\"null\":83,\"0\":-1.0602,\"1\":-0.1759,\"2\":0.3062},{\"null\":84,\"0\":-0.0221,\"1\":0.1387,\"2\":3.2778},{\"null\":85,\"0\":0.2502,\"1\":0.2463,\"2\":-1.3211},{\"null\":86,\"0\":-0.6213,\"1\":0.1044,\"2\":-2.246},{\"null\":87,\"0\":0.5551,\"1\":0.7954,\"2\":-0.1843},{\"null\":88,\"0\":2.1548,\"1\":0.4782,\"2\":1.15},{\"null\":89,\"0\":-1.5096,\"1\":0.4072,\"2\":-1.396},{\"null\":90,\"0\":0.983,\"1\":-0.6514,\"2\":0.4497},{\"null\":91,\"0\":1.5418,\"1\":-0.0856,\"2\":0.7943},{\"null\":92,\"0\":0.3347,\"1\":0.317,\"2\":-0.2968},{\"null\":93,\"0\":-0.7241,\"1\":-1.353,\"2\":-1.1688},{\"null\":94,\"0\":0.0695,\"1\":2.6368,\"2\":-0.0595},{\"null\":95,\"0\":0.2575,\"1\":0.5266,\"2\":0.7574},{\"null\":96,\"0\":0.4532,\"1\":0.4176,\"2\":-1.2303},{\"null\":97,\"0\":-0.9982,\"1\":1.1423,\"2\":0.4568},{\"null\":98,\"0\":-1.2921,\"1\":-1.4398,\"2\":-1.3691},{\"null\":99,\"0\":0.1909,\"1\":0.2032,\"2\":1.1968}], [{\"field\": null, \"type\": \"Integer\"}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", - " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"fullWidthRows\": true, \"forceFitColumns\": true, \"enableColumnReorder\": false, \"rowHeight\": 28});\n", + " var grid = new dgrid.QGrid('#12a37f09-8c1e-42e7-8e47-636ece657c90', [{\"null\":0,\"0\":0.4004,\"1\":0.3949,\"2\":1.3422},{\"null\":1,\"0\":0.7967,\"1\":0.8361,\"2\":0.0244},{\"null\":2,\"0\":-1.667,\"1\":-3.4344,\"2\":-1.017},{\"null\":3,\"0\":-0.4952,\"1\":-0.9961,\"2\":-0.6825},{\"null\":4,\"0\":-1.6544,\"1\":0.663,\"2\":-0.215},{\"null\":5,\"0\":-0.9014,\"1\":-0.4155,\"2\":0.2233},{\"null\":6,\"0\":-0.1933,\"1\":0.629,\"2\":-1.3713},{\"null\":7,\"0\":-0.885,\"1\":-2.1683,\"2\":0.6541},{\"null\":8,\"0\":0.7005,\"1\":0.2311,\"2\":0.33},{\"null\":9,\"0\":-0.4134,\"1\":1.421,\"2\":-0.797},{\"null\":10,\"0\":2.0281,\"1\":-0.2618,\"2\":-0.8008},{\"null\":11,\"0\":-0.6124,\"1\":-0.4245,\"2\":1.6942},{\"null\":12,\"0\":-1.035,\"1\":0.5812,\"2\":-0.5774},{\"null\":13,\"0\":-0.6118,\"1\":-1.5242,\"2\":0.8291},{\"null\":14,\"0\":-1.459,\"1\":0.9266,\"2\":1.3556},{\"null\":15,\"0\":0.1907,\"1\":0.5975,\"2\":0.1163},{\"null\":16,\"0\":0.8657,\"1\":-0.5308,\"2\":0.7254},{\"null\":17,\"0\":0.0781,\"1\":-1.177,\"2\":1.548},{\"null\":18,\"0\":-0.7743,\"1\":-0.3906,\"2\":1.0647},{\"null\":19,\"0\":-0.3541,\"1\":1.1163,\"2\":0.2622},{\"null\":20,\"0\":-2.2528,\"1\":0.7622,\"2\":0.9788},{\"null\":21,\"0\":2.5766,\"1\":0.3267,\"2\":0.7226},{\"null\":22,\"0\":-0.7134,\"1\":0.5731,\"2\":2.0518},{\"null\":23,\"0\":1.4684,\"1\":0.9613,\"2\":-0.1215},{\"null\":24,\"0\":-1.4108,\"1\":-0.5573,\"2\":1.5299},{\"null\":25,\"0\":-0.7762,\"1\":-0.4178,\"2\":-0.441},{\"null\":26,\"0\":-1.4537,\"1\":-0.0423,\"2\":0.1633},{\"null\":27,\"0\":0.1653,\"1\":-0.8443,\"2\":-1.1529},{\"null\":28,\"0\":-0.4477,\"1\":-0.7207,\"2\":-1.3283},{\"null\":29,\"0\":-0.4097,\"1\":1.2984,\"2\":0.8075},{\"null\":30,\"0\":-0.0048,\"1\":-1.9661,\"2\":1.5415},{\"null\":31,\"0\":1.4931,\"1\":-0.2196,\"2\":-1.4398},{\"null\":32,\"0\":0.9583,\"1\":1.5519,\"2\":-0.3868},{\"null\":33,\"0\":0.0376,\"1\":-1.5197,\"2\":-1.3994},{\"null\":34,\"0\":0.3707,\"1\":-0.5863,\"2\":-0.0366},{\"null\":35,\"0\":1.3528,\"1\":1.5842,\"2\":-0.1574},{\"null\":36,\"0\":-0.7828,\"1\":0.0864,\"2\":0.9377},{\"null\":37,\"0\":-0.1169,\"1\":0.106,\"2\":-0.3961},{\"null\":38,\"0\":-0.7163,\"1\":2.1102,\"2\":-0.4987},{\"null\":39,\"0\":-0.2495,\"1\":-0.5567,\"2\":1.4371},{\"null\":40,\"0\":-0.6355,\"1\":-1.0226,\"2\":1.3728},{\"null\":41,\"0\":0.1057,\"1\":-0.5391,\"2\":-1.0296},{\"null\":42,\"0\":0.0305,\"1\":0.436,\"2\":1.8915},{\"null\":43,\"0\":0.37,\"1\":-0.0792,\"2\":1.2858},{\"null\":44,\"0\":0.3863,\"1\":0.6382,\"2\":0.5657},{\"null\":45,\"0\":0.1555,\"1\":0.6301,\"2\":0.9825},{\"null\":46,\"0\":-0.1351,\"1\":0.4512,\"2\":-0.1251},{\"null\":47,\"0\":0.781,\"1\":1.4574,\"2\":0.3849},{\"null\":48,\"0\":0.7466,\"1\":1.3712,\"2\":-2.3106},{\"null\":49,\"0\":-0.3081,\"1\":-2.5745,\"2\":-1.1468},{\"null\":50,\"0\":-0.502,\"1\":-1.3712,\"2\":0.709},{\"null\":51,\"0\":0.8328,\"1\":0.1463,\"2\":1.555},{\"null\":52,\"0\":0.3415,\"1\":1.9731,\"2\":-1.1339},{\"null\":53,\"0\":-0.2427,\"1\":-0.5377,\"2\":-0.9134},{\"null\":54,\"0\":0.875,\"1\":-0.2626,\"2\":1.4305},{\"null\":55,\"0\":0.8064,\"1\":-2.4572,\"2\":-0.8976},{\"null\":56,\"0\":-1.5658,\"1\":-0.2162,\"2\":-1.3632},{\"null\":57,\"0\":-0.0806,\"1\":-2.5373,\"2\":1.3999},{\"null\":58,\"0\":-2.9166,\"1\":-1.1231,\"2\":0.1556},{\"null\":59,\"0\":-1.109,\"1\":-0.4538,\"2\":1.0065},{\"null\":60,\"0\":-0.0168,\"1\":-0.4271,\"2\":1.1905},{\"null\":61,\"0\":-0.8977,\"1\":0.5924,\"2\":0.5482},{\"null\":62,\"0\":-0.3079,\"1\":0.2856,\"2\":1.9026},{\"null\":63,\"0\":-0.355,\"1\":-1.4452,\"2\":1.2759},{\"null\":64,\"0\":1.3737,\"1\":1.1948,\"2\":-0.4619},{\"null\":65,\"0\":-2.5163,\"1\":3.2031,\"2\":-0.7782},{\"null\":66,\"0\":0.2041,\"1\":-1.1471,\"2\":-0.0653},{\"null\":67,\"0\":1.0106,\"1\":0.5095,\"2\":-0.0731},{\"null\":68,\"0\":0.1376,\"1\":1.4233,\"2\":1.0231},{\"null\":69,\"0\":-1.6558,\"1\":-1.1306,\"2\":0.7252},{\"null\":70,\"0\":-0.0796,\"1\":0.3438,\"2\":-0.6444},{\"null\":71,\"0\":-1.4101,\"1\":-0.0656,\"2\":0.7506},{\"null\":72,\"0\":-1.0519,\"1\":0.6618,\"2\":-1.2867},{\"null\":73,\"0\":-0.9858,\"1\":-0.3183,\"2\":0.414},{\"null\":74,\"0\":-0.0431,\"1\":-0.7324,\"2\":0.0991},{\"null\":75,\"0\":0.4619,\"1\":-1.0869,\"2\":-0.3816},{\"null\":76,\"0\":0.2622,\"1\":-2.0083,\"2\":-0.6748},{\"null\":77,\"0\":-0.7336,\"1\":-0.6282,\"2\":-1.1201},{\"null\":78,\"0\":0.326,\"1\":-1.4855,\"2\":0.7711},{\"null\":79,\"0\":-0.1458,\"1\":-0.5848,\"2\":0.5219},{\"null\":80,\"0\":1.6281,\"1\":-0.7908,\"2\":-0.6157},{\"null\":81,\"0\":0.1812,\"1\":-1.1674,\"2\":0.4604},{\"null\":82,\"0\":-0.2407,\"1\":-0.1202,\"2\":-1.1932},{\"null\":83,\"0\":-1.681,\"1\":0.592,\"2\":1.2357},{\"null\":84,\"0\":-0.706,\"1\":0.4004,\"2\":-1.5097},{\"null\":85,\"0\":-1.6634,\"1\":-0.0167,\"2\":0.0304},{\"null\":86,\"0\":-0.4029,\"1\":-1.7599,\"2\":-1.6885},{\"null\":87,\"0\":0.4026,\"1\":0.3648,\"2\":1.1705},{\"null\":88,\"0\":1.5769,\"1\":1.6142,\"2\":-0.2446},{\"null\":89,\"0\":0.5236,\"1\":-1.1752,\"2\":-0.3707},{\"null\":90,\"0\":0.0176,\"1\":-0.0796,\"2\":0.0248},{\"null\":91,\"0\":-0.6054,\"1\":0.4054,\"2\":1.3983},{\"null\":92,\"0\":-0.039,\"1\":0.9363,\"2\":-0.9731},{\"null\":93,\"0\":1.2401,\"1\":-0.244,\"2\":-0.8327},{\"null\":94,\"0\":-0.3232,\"1\":0.2191,\"2\":-0.64},{\"null\":95,\"0\":0.7218,\"1\":-0.93,\"2\":0.226},{\"null\":96,\"0\":-0.9764,\"1\":-0.9812,\"2\":0.9903},{\"null\":97,\"0\":2.3867,\"1\":1.4694,\"2\":-0.5278},{\"null\":98,\"0\":-0.0969,\"1\":0.0474,\"2\":-0.3348},{\"null\":99,\"0\":-0.8825,\"1\":0.3212,\"2\":-1.6813}], [{\"field\": null, \"type\": \"Integer\"}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", + " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"rowHeight\": 28, \"forceFitColumns\": true, \"fullWidthRows\": true, \"enableColumnReorder\": false});\n", " });\n", " });\n", "});\n" @@ -491,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "collapsed": false, "nbpresent": { @@ -513,7 +513,7 @@ "}\n", "\n", "
\n", - "
\n", + "
\n", "
" ] }, @@ -566,15 +566,15 @@ " 'slick_data_view'\n", "],\n", "function($){\n", - " $('#dc95e4ea-92b2-4e40-a97f-6037a3752a4a').closest('.rendered_html').removeClass('rendered_html');\n", + " $('#d1873f36-77b5-4621-9b5d-fc162ca55fa5').closest('.rendered_html').removeClass('rendered_html');\n", " require([\n", " 'slick_check_box_column',\n", " 'slick_row_selection_model',\n", " 'slick_grid'\n", " ], function(){\n", " require([\"data_grid\"], function(dgrid){\n", - " var grid = new dgrid.QGrid('#dc95e4ea-92b2-4e40-a97f-6037a3752a4a', [{\"null\":\"count\",\"0\":100.0,\"1\":100.0,\"2\":100.0},{\"null\":\"mean\",\"0\":0.1194,\"1\":0.0594,\"2\":-0.1358},{\"null\":\"std\",\"0\":0.9028,\"1\":0.8555,\"2\":1.1166},{\"null\":\"min\",\"0\":-1.8385,\"1\":-2.0976,\"2\":-2.252},{\"null\":\"25%\",\"0\":-0.4327,\"1\":-0.5151,\"2\":-0.995},{\"null\":\"50%\",\"0\":0.2539,\"1\":0.1216,\"2\":-0.0835},{\"null\":\"75%\",\"0\":0.627,\"1\":0.5601,\"2\":0.5523},{\"null\":\"max\",\"0\":2.1548,\"1\":2.6368,\"2\":3.2778}], [{\"field\": null}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", - " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"fullWidthRows\": true, \"forceFitColumns\": true, \"enableColumnReorder\": false, \"rowHeight\": 28});\n", + " var grid = new dgrid.QGrid('#d1873f36-77b5-4621-9b5d-fc162ca55fa5', [{\"null\":\"count\",\"0\":100.0,\"1\":100.0,\"2\":100.0},{\"null\":\"mean\",\"0\":-0.1433,\"1\":-0.1181,\"2\":0.1},{\"null\":\"std\",\"0\":0.9995,\"1\":1.127,\"2\":1.0067},{\"null\":\"min\",\"0\":-2.9166,\"1\":-3.4344,\"2\":-2.3106},{\"null\":\"25%\",\"0\":-0.7438,\"1\":-0.8042,\"2\":-0.6767},{\"null\":\"50%\",\"0\":-0.126,\"1\":-0.0794,\"2\":0.0648},{\"null\":\"75%\",\"0\":0.3898,\"1\":0.5937,\"2\":0.9797},{\"null\":\"max\",\"0\":2.5766,\"1\":3.2031,\"2\":2.0518}], [{\"field\": null}, {\"field\": 0, \"type\": \"Float\"}, {\"field\": 1, \"type\": \"Float\"}, {\"field\": 2, \"type\": \"Float\"}]);\n", + " grid.initialize_slick_grid({\"syncColumnCellResize\": true, \"enableTextSelectionOnCells\": true, \"rowHeight\": 28, \"forceFitColumns\": true, \"fullWidthRows\": true, \"enableColumnReorder\": false});\n", " });\n", " });\n", "});\n" @@ -621,14 +621,14 @@ "slides": { "35b159c2-a505-4cf0-a484-5fa773aa0827": { "id": "35b159c2-a505-4cf0-a484-5fa773aa0827", - "prev": "9edf888c-000b-47cf-a501-0b3f624ee851", + "prev": "8c4ca91b-593f-4a56-af36-685783016d16", "regions": { "37109bc0-f7bc-4728-b47a-bf1f2ce41ee9": { "attrs": { "height": 0.2, "width": 0.4, - "x": 0.5, - "y": 0.7 + "x": 0.5579010856453559, + "y": 0.7300227851494437 }, "content": { "cell": "738c9c60-4e56-4357-b895-3e89a7e4cd04", @@ -640,8 +640,8 @@ "attrs": { "height": 0.2, "width": 0.4, - "x": 0.1, - "y": 0.7 + "x": 0.025211097708081998, + "y": 0.7321672698029754 }, "content": { "cell": "738c9c60-4e56-4357-b895-3e89a7e4cd04", @@ -651,10 +651,10 @@ }, "fde37c23-eb32-4532-bf92-e9e550d7e08d": { "attrs": { - "height": 0.6, - "width": 0.8, - "x": 0.1, - "y": 0.1 + "height": 0.6167185940447121, + "width": 0.9302774427020507, + "x": 0.025211097708081998, + "y": 0.04896965149878062 }, "content": { "cell": "738c9c60-4e56-4357-b895-3e89a7e4cd04", @@ -666,14 +666,16 @@ }, "8c4ca91b-593f-4a56-af36-685783016d16": { "id": "8c4ca91b-593f-4a56-af36-685783016d16", - "prev": null, + "layout": "treemap", + "prev": "9edf888c-000b-47cf-a501-0b3f624ee851", "regions": { "946de288-8e32-47a3-8eda-2ab8426cf7ca": { "attrs": { - "height": 0.8, - "width": 0.8, - "x": 0.1, - "y": 0.1 + "height": 1, + "treemap:weight": 1, + "width": 1, + "x": 0, + "y": 0 }, "content": { "cell": "7d0e1892-a7c0-467f-abfc-259acf3e117d", @@ -685,14 +687,14 @@ }, "9edf888c-000b-47cf-a501-0b3f624ee851": { "id": "9edf888c-000b-47cf-a501-0b3f624ee851", - "prev": "8c4ca91b-593f-4a56-af36-685783016d16", + "prev": null, "regions": { "d74608b3-662a-4833-8ceb-d155968e1a14": { "attrs": { - "height": 0.8, - "width": 0.8, - "x": 0.1, - "y": 0.1 + "height": 0.864931872927304, + "width": 0.8808202653799759, + "x": 0.019179734620024133, + "y": 0.03506812707269606 }, "content": { "cell": "8438b2c1-2e72-40e6-bfd4-89a9bff2628e", @@ -709,8 +711,8 @@ "2c1159ac-071d-4e7d-8fe1-4e5d0604138e": { "attrs": { "height": 0.8, - "width": 0.8, - "x": 0.1, + "width": 0.8405903996873125, + "x": 0.07750368957686112, "y": 0.1 }, "content": { From c3eecc66685900f705c1d012c0d3542328fcfc72 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 18:03:45 -0500 Subject: [PATCH 15/23] cleaning imports from pdf exporter --- nbpresent/exporters/pdf.py | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/nbpresent/exporters/pdf.py b/nbpresent/exporters/pdf.py index 3bbc57a..ca83594 100644 --- a/nbpresent/exporters/pdf.py +++ b/nbpresent/exporters/pdf.py @@ -1,26 +1,12 @@ import os -from glob import glob import shutil import sys from subprocess import check_call - -try: - from PySide.QtGui import QApplication, QImage, QPainter, QPrinter -except ImportError as err: - from PyQt4.QtGui import QApplication, QImage, QPainter, QPrinter -from ghost import Ghost - - -import tornado.ioloop -import tornado.web - - from ipython_genutils.tempdir import TemporaryWorkingDirectory import nbformat from .html import PresentExporter -from .pdf_capture import pdf_capture class PDFPresentExporter(PresentExporter): @@ -53,7 +39,7 @@ def from_notebook_node(self, nb, resources=None, **kw): "-m", "nbpresent.exporters.pdf_capture", td ]) - + pdf_file = "notebook.pdf" if not os.path.isfile(pdf_file): From 5513622650c008b9cd06286f42e8a1dfda08962b Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 18:21:57 -0500 Subject: [PATCH 16/23] using keyboard interrupt to kill tornado --- nbpresent/exporters/pdf_capture.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py index 64147a4..1503736 100644 --- a/nbpresent/exporters/pdf_capture.py +++ b/nbpresent/exporters/pdf_capture.py @@ -87,8 +87,7 @@ def capture(self): with open(join("notebook.pdf"), "wb") as fp: meta.write(fp) - raise SystemExit() - + raise KeyboardInterrupt() def screenshot(nb, session, dest, as_print=False): """ @@ -136,7 +135,11 @@ def pdf_capture(static_path): ioloop = IOLoop() ioloop.add_callback(server.capture) server.listen(9999) - ioloop.start() + + try: + ioloop.start() + except KeyboardInterrupt: + print("stopped") if __name__ == "__main__": pdf_capture(sys.argv[1]) From d4f8a52d8578a119b8798a83db369afbcf4e0ad9 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 19:29:38 -0500 Subject: [PATCH 17/23] using conda packages from nbcio channel --- .binstar.yml | 5 ++++- conda.recipe/meta.yaml | 8 +++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/.binstar.yml b/.binstar.yml index 0d240da..6de2c7d 100644 --- a/.binstar.yml +++ b/.binstar.yml @@ -9,6 +9,9 @@ engine: - python=3.5 script: - - conda build -c javascript conda.recipe + - > + conda build conda.recipe + -c javascript + -c nbcio build_targets: conda diff --git a/conda.recipe/meta.yaml b/conda.recipe/meta.yaml index a0b2385..f5137aa 100644 --- a/conda.recipe/meta.yaml +++ b/conda.recipe/meta.yaml @@ -14,19 +14,17 @@ requirements: build: - nodejs - python - - notebook - - jupyter - - funcsigs run: - python - notebook - - jupyter - funcsigs + - pypdf2 + - ghost.py test: imports: - - notebook - nbpresent + - nbpresent.exporters.pdf_capture about: summary: Next generation slides for Jupyter Notebooks From ea343417f6d3b90219496be269f0c1a1cf21cc18 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 19:32:00 -0500 Subject: [PATCH 18/23] remove multiline in binstar.yml --- .binstar.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.binstar.yml b/.binstar.yml index 6de2c7d..26846db 100644 --- a/.binstar.yml +++ b/.binstar.yml @@ -9,9 +9,6 @@ engine: - python=3.5 script: - - > - conda build conda.recipe - -c javascript - -c nbcio + - conda build conda.recipe -c javascript -c nbcio build_targets: conda From 35ffe1e71305ed37347ec6c3f216db5d6fb79891 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 20:16:00 -0500 Subject: [PATCH 19/23] pull back testing the qt stuff for now --- conda.recipe/meta.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/conda.recipe/meta.yaml b/conda.recipe/meta.yaml index f5137aa..f264d4c 100644 --- a/conda.recipe/meta.yaml +++ b/conda.recipe/meta.yaml @@ -24,7 +24,6 @@ requirements: test: imports: - nbpresent - - nbpresent.exporters.pdf_capture about: summary: Next generation slides for Jupyter Notebooks From af5755fb65fd21057256593fee70b8595985961f Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 20:47:30 -0500 Subject: [PATCH 20/23] refresh environment.yml --- environment.yml | 81 ++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 66 insertions(+), 15 deletions(-) diff --git a/environment.yml b/environment.yml index 3e2a6a3..e83b61f 100644 --- a/environment.yml +++ b/environment.yml @@ -1,28 +1,79 @@ -name: nbindex +name: nbpresent dependencies: -- anaconda-client=1.0.2=py35_0 -- clyent=0.4.0=py35_0 -- freetype=2.5.2=2 +- anaconda-client=1.1.2=py35_0 +- bokeh=0.10.0=py35_0 +- clyent=1.0.0=py35_0 +- cycler=0.9.0=py35_0 +- decorator=4.0.4=py35_0 +- flask=0.10.1=py35_1 +- fontconfig=2.11.1=5 +- freetype=2.5.5=0 +- ipykernel=4.1.1=py35_0 +- ipython=4.0.0=py35_0 +- ipython_genutils=0.1.0=py35_0 +- ipywidgets=4.1.0=py35_0 +- itsdangerous=0.24=py35_0 +- jbig=2.1=0 +- jinja2=2.8=py35_0 - jpeg=8d=0 +- jsonschema=2.4.0=py35_0 +- jupyter_client=4.1.1=py35_0 +- jupyter_core=4.0.6=py35_0 +- libgfortran=1.0=0 - libpng=1.6.17=0 -- libtiff=4.0.2=1 -- openssl=1.0.1k=1 -- pillow=2.9.0=py35_0 +- libsodium=1.0.3=0 +- libtiff=4.0.6=1 +- libxml2=2.9.2=0 +- markupsafe=0.23=py35_0 +- matplotlib=1.5.0=np110py35_0 +- mistune=0.7.1=py35_0 +- nbconvert=4.0.0=py35_0 +- nbformat=4.0.1=py35_0 +- nodejs=4.2.0=1 +- notebook=4.0.6=py35_0 +- numpy=1.10.1=py35_0 +- openblas=0.2.14=3 +- openssl=1.0.2d=0 +- pandas=0.17.0=np110py35_0 +- path.py=8.1.2=py35_0 +- pexpect=3.3=py35_0 +- pickleshare=0.5=py35_0 +- pillow=3.0.0=py35_1 - pip=7.1.2=py35_0 -- python=3.5.0=0 +- ptyprocess=0.5=py35_0 +- pygments=2.0.2=py35_0 +- pyparsing=2.0.3=py35_0 +- pyqt=4.11.4=py35_0 +- python=3.5.0=1 - python-dateutil=2.4.2=py35_0 -- pytz=2015.6=py35_0 +- pytz=2015.7=py35_0 - pyyaml=3.11=py35_1 +- pyzmq=14.7.0=py35_1 +- qt=4.8.7=1 - readline=6.2=2 -- requests=2.7.0=py35_0 -- setuptools=18.1=py35_0 -- six=1.9.0=py35_0 +- requests=2.8.1=py35_0 +- setuptools=18.4=py35_0 +- simplegeneric=0.8.1=py35_0 +- sip=4.16.9=py35_0 +- six=1.10.0=py35_0 - sqlite=3.8.4.1=1 +- terminado=0.5=py35_1 - tk=8.5.18=0 -- wheel=0.26.0=py35_0 +- tornado=4.2.1=py35_1 +- traitlets=4.0.0=py35_0 +- werkzeug=0.11.2=py35_0 +- wheel=0.26.0=py35_1 - xz=5.0.5=0 - yaml=0.1.6=0 +- zeromq=4.1.3=0 - zlib=1.2.8=0 - pip: - - elasticsearch==1.7.0 - - urllib3==1.12 + - bqplot==0.4.2 + - ghost.py==0.2.3 + - ipython-genutils==0.1.0 + - jupyter-client==4.1.1 + - jupyter-core==4.0.6 + - nbpresent (/home/weg/Documents/projects/nbpresent)==0.3.0.dev0 + - pypdf2==1.25.1 + - qgrid==0.2.0 + From 51864f6bf4e61a0f7c9705bacf1c0eb8b8a11d34 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Thu, 19 Nov 2015 23:28:33 -0500 Subject: [PATCH 21/23] style tweaks --- src/es6/editor.es6 | 11 ++++++++- src/es6/sorter.es6 | 57 +++++++++++++++++++++++++------------------ src/es6/templates.es6 | 2 +- src/es6/toolbar.es6 | 2 +- src/less/editor.less | 32 ++++++++++++++++++------ src/less/mini.less | 19 +++++++++------ 6 files changed, 80 insertions(+), 43 deletions(-) diff --git a/src/es6/editor.es6 b/src/es6/editor.es6 index da3c486..5589c2e 100644 --- a/src/es6/editor.es6 +++ b/src/es6/editor.es6 @@ -1,5 +1,7 @@ import {d3} from "nbpresent-deps"; +import {PART} from "./parts"; + import {RegionTree} from "./regiontree"; import {CellManager} from "./cells/notebook"; @@ -88,6 +90,10 @@ class Editor{ }, {})); } + hasContent(part){ + return (d) => (d.value.content || {}).part === part; + } + update(){ let that = this, uibb = this.$ui.node().getBoundingClientRect(), @@ -151,7 +157,10 @@ class Editor{ $region .classed({ - active: (d) => selected && (d.key == selected.region) + active: (d) => selected && (d.key == selected.region), + content_source: this.hasContent(PART.source), + content_outputs: this.hasContent(PART.outputs), + content_widgets: this.hasContent(PART.widgets) }) .select(".region_bg") .transition() diff --git a/src/es6/sorter.es6 b/src/es6/sorter.es6 index 4c8a498..aaeb5b7 100644 --- a/src/es6/sorter.es6 +++ b/src/es6/sorter.es6 @@ -48,9 +48,15 @@ class Sorter { if(visible) { this.draw(); - }else if(this.editor){ - this.editor.destroy(); - this.editor = null; + }else { + if(this.editor){ + this.editor.destroy(); + this.editor = null; + } + if(this.templates){ + this.templates.destroy(); + this.templates = null; + } } this.update(); @@ -203,7 +209,7 @@ class Sorter { let slides = this.tree.get("sortedSlides"); - this.scale.x.range([0, this.slideWidth()]); + this.scale.x.range([20, this.slideWidth() + 20]); let $slide = this.$slides.selectAll(".slide") .data(slides, (d) => d.key); @@ -253,7 +259,7 @@ class Sorter { .style({ opacity: selectedRegion ? 1 : 0, display: selectedRegion ? "block" : "none", - left: `${selectedSlideLeft}px` + left: `${selectedSlideLeft - 30}px` }); this.$empty @@ -314,22 +320,22 @@ class Sorter { .classed({deck_toolbar: 1}) .datum([ [{ - icon: "plus-square-o", + icon: "plus-square-o fa-2x", click: () => this.addSlide(), tip: "Add Slide" }], [{ - icon: "edit", + icon: "edit fa-2x", click: () => this.editSlide(this.selectedSlide.get()), tip: "Edit Slide", visible: () => this.selectedSlide.get() && !this.editor }, { - icon: "chevron-circle-down", + icon: "chevron-circle-down fa-2x", click: () => this.editSlide(this.selectedSlide.get()), tip: "Back to Sorter", visible: () => this.editor }], [{ - icon: "trash", + icon: "trash fa-2x", click: () => { this.removeSlide(this.selectedSlide.get()); this.selectedSlide.set(null); @@ -345,12 +351,12 @@ class Sorter { .classed({region_toolbar: 1}) .datum([ [{ - icon: "external-link-square", + icon: "terminal", click: () => this.linkContent(PART.source), tip: "Link Region to Cell Input" }, { - icon: "external-link", + icon: "image", click: () => this.linkContent(PART.outputs), tip: "Link Region to Cell Output" }, @@ -358,8 +364,8 @@ class Sorter { icon: "sliders", click: () => this.linkContent(PART.widgets), tip: "Link Region to Cell Widgets" - }], - [{ + }, + { icon: "unlink", click: () => this.linkContent(null), tip: "Unlink Region" @@ -403,20 +409,23 @@ class Sorter { } templatePicked(slide){ - let last = this.tree.get("sortedSlides").slice(-1), - selected = this.selectedSlide.get(); - - this.slides.set([slide.key], slide.value); + if(slide && this.templates && !this.templates.killed){ + let last = this.tree.get("sortedSlides").slice(-1), + selected = this.selectedSlide.get(); - let appended = this.appendSlide( - selected ? selected : last.length ? last[0].key : null, - slide.key - ); + this.slides.set([slide.key], slide.value); - this.selectedSlide.set(appended); + let appended = this.appendSlide( + selected ? selected : last.length ? last[0].key : null, + slide.key + ); - this.templates.destroy(); - this.templates = null; + this.selectedSlide.set(appended); + } + if(this.templates){ + this.templates.destroy(); + this.templates = null; + } } editSlide(id){ diff --git a/src/es6/templates.es6 b/src/es6/templates.es6 index f517222..0ad00d9 100644 --- a/src/es6/templates.es6 +++ b/src/es6/templates.es6 @@ -78,7 +78,7 @@ class TemplateLibrary { this.$ui.append("button") .classed({btn: 1, hide_library: 1, "btn-default": 1}) - .on("click", () => this.destroy()) + .on("click", () => this.picked(null)) .append("i") .classed({fa: 1, "fa-remove": 1}); diff --git a/src/es6/toolbar.es6 b/src/es6/toolbar.es6 index 5bfbb85..9ec2cd7 100644 --- a/src/es6/toolbar.es6 +++ b/src/es6/toolbar.es6 @@ -64,7 +64,7 @@ class Toolbar { .on("click", (d) => d.click() ) .select("i") .attr({ - "class": (d) => `fa fa-fw fa-${d.icon}`, + "class": (d) => `fa fa-fw fa-2x fa-${d.icon}`, }); let clean = function(){ diff --git a/src/less/editor.less b/src/less/editor.less index ac3aa6b..2b4805b 100644 --- a/src/less/editor.less +++ b/src/less/editor.less @@ -17,17 +17,33 @@ fill: transparent; opacity: 0.50; stroke: grey; + stroke-width: 2px; + stroke-dasharray: 5,5; } - .handle { - visibility: hidden; + + &.content_source .region_bg{ + stroke: rgba(0, 0, 128, 0.25); + stroke-dasharray: none; } - &.active { - .region_bg{ - stroke: @jpy-brand; - opacity: 0.9; - stroke-width: 10px; - } + + &.content_outputs .region_bg{ + stroke: rgba(139, 0, 0, 0.25); + stroke-dasharray: none; + } + + &.content_widgets .region_bg{ + stroke: rgba(139, 0, 128, 0.25); + stroke-dasharray: none; } + + + &.active .region_bg{ + stroke: @jpy-brand; + opacity: 0.9; + stroke-width: 10px; + stroke-dasharray: none; + } + } } diff --git a/src/less/mini.less b/src/less/mini.less index 64cb1ad..7882100 100644 --- a/src/less/mini.less +++ b/src/less/mini.less @@ -24,23 +24,26 @@ background-color: rgba(255,255,255,0.5); background-repeat: no-repeat; - border: solid 1px rgba(128,128,128,0.5); + border: dashed 3px rgba(128,128,128,0.5); + border-radius: 3px; - &.active{ - border-color: @jpy-brand; - box-shadow: @nbpresent-z-shadow; - } + transition: border 0.2s; &.content_source{ - background-color: rgba(0, 0, 128, 0.25); + border: solid 3px rgba(0, 0, 128, 0.25); } &.content_outputs{ - background-color: rgba(139, 0, 0, 0.25); + border: solid 3px rgba(139, 0, 0, 0.25); } &.content_widgets{ - background-color: rgba(139, 0, 128, 0.25); + border: solid 3px rgba(139, 0, 128, 0.25); + } + + &.active{ + transition: border 0.2s; + border: solid 3px @jpy-brand; } } } From 34dc5c5d63397e7dc028298e96f9c3c1fecfc5b2 Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Tue, 24 Nov 2015 08:03:14 -0500 Subject: [PATCH 22/23] demo tweaks --- src/less/sorter.less | 1 + 1 file changed, 1 insertion(+) diff --git a/src/less/sorter.less b/src/less/sorter.less index b348f54..b2c4d45 100644 --- a/src/less/sorter.less +++ b/src/less/sorter.less @@ -54,6 +54,7 @@ padding-bottom: 30px; height: @sorter-height; overflow-x: auto; + overflow-y: hidden; position: relative; margin: 0; right: 0; From bd79f8dda2c2093cdc3c80af0e4fa6c5b952824e Mon Sep 17 00:00:00 2001 From: Nicholas Bollweg Date: Sat, 28 Nov 2015 08:37:52 -0500 Subject: [PATCH 23/23] refactoring to use nbbrowserpdf --- conda.recipe/meta.yaml | 2 - nbpresent/__init__.py | 20 +++- nbpresent/exporters/__init__.py | 2 - nbpresent/exporters/pdf.py | 63 ++---------- nbpresent/exporters/pdf_capture.py | 156 +++++++++-------------------- nbpresent/install.py | 50 +++++++-- nbpresent/present/__main__.py | 2 +- nbpresent/present/pdf.py | 2 +- 8 files changed, 112 insertions(+), 185 deletions(-) diff --git a/conda.recipe/meta.yaml b/conda.recipe/meta.yaml index f264d4c..7093cbb 100644 --- a/conda.recipe/meta.yaml +++ b/conda.recipe/meta.yaml @@ -18,8 +18,6 @@ requirements: - python - notebook - funcsigs - - pypdf2 - - ghost.py test: imports: diff --git a/nbpresent/__init__.py b/nbpresent/__init__.py index ce42c47..492fcf0 100644 --- a/nbpresent/__init__.py +++ b/nbpresent/__init__.py @@ -4,11 +4,23 @@ def load_jupyter_server_extension(nbapp): from nbconvert.exporters.export import exporter_map - from .exporters import ( - PresentExporter, - PDFPresentExporter, - ) + from .exporters.html import PresentExporter + + nbapp.log.info("Enabling nbpresent HTML export") exporter_map.update( nbpresent=PresentExporter, + ) + + try: + from .exporters.pdf import PDFPresentExporter + except Exception as err: + nbapp.log.warn( + "nbbrowserpdf not available, PDF generation disabled: {}" + .format(err) + ) + return + + nbapp.log.info("Enabling nbpresent PDF export") + exporter_map.update( nbpresent_pdf=PDFPresentExporter ) diff --git a/nbpresent/exporters/__init__.py b/nbpresent/exporters/__init__.py index a648ab2..f250de6 100644 --- a/nbpresent/exporters/__init__.py +++ b/nbpresent/exporters/__init__.py @@ -3,5 +3,3 @@ ASSETS, APP_ROOT ) -from .html import PresentExporter -from .pdf import PDFPresentExporter diff --git a/nbpresent/exporters/pdf.py b/nbpresent/exporters/pdf.py index ca83594..1cfc5db 100644 --- a/nbpresent/exporters/pdf.py +++ b/nbpresent/exporters/pdf.py @@ -1,60 +1,11 @@ -import os -import shutil -import sys -from subprocess import check_call - -from ipython_genutils.tempdir import TemporaryWorkingDirectory -import nbformat - from .html import PresentExporter +from nbbrowserpdf.exporters.pdf import BrowserPDFExporter -class PDFPresentExporter(PresentExporter): - def __init__(self, *args, **kwargs): - super(PDFPresentExporter, self).__init__(*args, **kwargs) - - def from_notebook_node(self, nb, resources=None, **kw): - output, resources = super(PDFPresentExporter, self).from_notebook_node( - nb, resources=resources, **kw - ) - - with TemporaryWorkingDirectory() as td: - for path, res in resources.get("outputs", {}).items(): - dest = os.path.join(td, os.path.basename(path)) - shutil.copyfile(path, dest) - - index_html = os.path.join(td, "index.html") - - with open(index_html, "w+") as fp: - fp.write(output) - - ipynb = "notebook.ipynb" - - with open(os.path.join(td, ipynb), "w") as fp: - nbformat.write(nb, fp) - - self.log.info("Building PDF...") - check_call([ - sys.executable, - "-m", "nbpresent.exporters.pdf_capture", - td - ]) - - pdf_file = "notebook.pdf" - - if not os.path.isfile(pdf_file): - raise IOError("PDF creating failed") - - self.log.info("PDF successfully created") - - with open(pdf_file, 'rb') as f: - pdf_data = f.read() - - # convert output extension to pdf - # the writer above required it to be tex - resources['output_extension'] = '.pdf' - # clear figure outputs, extracted by latex export, - # so we don't claim to be a multi-file export. - resources.pop('outputs', None) - return pdf_data, resources +class PDFPresentExporter(PresentExporter, BrowserPDFExporter): + def pdf_capture_args(self): + return [ + "--capture-server-class", + "nbpresent.exporters.pdf_capture:SlideCaptureServer" + ] diff --git a/nbpresent/exporters/pdf_capture.py b/nbpresent/exporters/pdf_capture.py index 1503736..9eaa8d8 100644 --- a/nbpresent/exporters/pdf_capture.py +++ b/nbpresent/exporters/pdf_capture.py @@ -1,145 +1,83 @@ -from concurrent import futures -import os -import logging import time -import sys -from ghost import Ghost from ghost.bindings import ( - # QApplication, - # QImage, QPainter, QPrinter, - QtWebKit, QtCore, ) - -import tornado.web -from tornado.httpserver import HTTPServer - -from tornado.ioloop import IOLoop -from tornado.concurrent import run_on_executor - -import nbformat - from PyPDF2 import ( PdfFileReader, - PdfFileWriter, PdfFileMerger, ) -from .base import DEFAULT_STATIC_FILES_PATH +from nbbrowserpdf.exporters.pdf_capture import CaptureServer +VIEWPORT = (1920, 1080) -class CaptureServer(HTTPServer): - executor = futures.ThreadPoolExecutor(max_workers=1) - def __init__(self, *args, **kwargs): - super(CaptureServer, self).__init__(*args, **kwargs) - - @run_on_executor - def capture(self): - # DO SOME MAGIC - ghost = Ghost( - log_level=logging.DEBUG - ) - session = ghost.start( +class SlideCaptureServer(CaptureServer): + """ CaptureServer to generate multi-page PDF based on nbpresent metadata + """ + def init_session(self): + """ create a session with a some tweaked settings + """ + return self.ghost.start( # display=True, - viewport_size=(1920, 1080), + # TODO: read this off config + viewport_size=VIEWPORT, + show_scrollbars=False, ) - merger = PdfFileMerger() - join = lambda *bits: os.path.join(self.static_path, *bits) - session.open("http://localhost:9999/index.html") + def page_ready(self): + """ Wait until nbpresent-css gets created + """ + self.session.wait_for_page_loaded() + self.session.wait_for_selector("#nbpresent-css") + time.sleep(1) - try: - session.wait_for_selector("#nbpresent-css") - time.sleep(1) - except Exception as err: - print(err) + def print_to_pdf(self, path): + """ Custom print based on metadata: generate one per slide + """ + merger = PdfFileMerger() for i, slide in enumerate(self.notebook.metadata.nbpresent.slides): print("\n\n\nprinting slide", i, slide) - filename = join("notebook-{0:04d}.pdf".format(i)) - session.show() - screenshot(self.notebook, session, filename) + # science help you if you have 9999 slides + filename = self.in_static("notebook-{0:04d}.pdf".format(i)) + # this is weird, but it seems to always need it + self.session.show() + self.screenshot(filename) merger.append(PdfFileReader(filename, "rb")) - result, resources = session.evaluate( + + # advance the slides + result, resources = self.session.evaluate( """ console.log(window.nbpresent); console.log(window.nbpresent.mode.presenter.speaker.advance()); """) - time.sleep(1) - - merger.write(join("notebook-unmeta.pdf")) - - unmeta = PdfFileReader(join("notebook-unmeta.pdf"), "rb") - meta = PdfFileWriter() - meta.appendPagesFromReader(unmeta) - - ipynb = "notebook.ipynb" + # always seem to get some weirdness... perhaps could inttegrate + # ioloop... + time.sleep(1) - with open(join(ipynb), "rb") as fp: - meta.addAttachment(ipynb, fp.read()) + # all done! + merger.write(path) - with open(join("notebook.pdf"), "wb") as fp: - meta.write(fp) + def screenshot(self, filename): + """ do an individual slide screenshot + big thanks to https://gist.github.com/jmaupetit/4217925 + """ - raise KeyboardInterrupt() + printer = QPrinter(mode=QPrinter.ScreenResolution) + printer.setOutputFormat(QPrinter.PdfFormat) + printer.setPaperSize(QtCore.QSizeF(*reversed(VIEWPORT)), + QPrinter.DevicePixel) + printer.setOrientation(QPrinter.Landscape) + printer.setOutputFileName(filename) + printer.setPageMargins(0, 0, 0, 0, QPrinter.DevicePixel) -def screenshot(nb, session, dest, as_print=False): - """ - big thanks to https://gist.github.com/jmaupetit/4217925 - """ - - printer = QPrinter(mode=QPrinter.ScreenResolution) - printer.setOutputFormat(QPrinter.PdfFormat) - printer.setPaperSize(QtCore.QSizeF(1080, 1920), QPrinter.DevicePixel) - printer.setOrientation(QPrinter.Landscape) - printer.setOutputFileName(dest) - printer.setPageMargins(0, 0, 0, 0, QPrinter.DevicePixel) - - if as_print: - webview = QtWebKit.QWebView() - webview.setPage(session.page) - webview.print_(printer) - else: painter = QPainter(printer) painter.scale(1.45, 1.45) - session.main_frame.render(painter) + self.session.main_frame.render(painter) painter.end() - - -def pdf_capture(static_path): - settings = { - "static_path": static_path - } - - app = tornado.web.Application([ - (r"/components/(.*)", tornado.web.StaticFileHandler, { - "path": os.path.join(DEFAULT_STATIC_FILES_PATH, "components") - }), - (r"/(.*)", tornado.web.StaticFileHandler, { - "path": settings['static_path'] - }), - ], **settings) - - server = CaptureServer(app) - server.static_path = static_path - - with open(os.path.join(static_path, "notebook.ipynb")) as fp: - server.notebook = nbformat.read(fp, 4) - - ioloop = IOLoop() - ioloop.add_callback(server.capture) - server.listen(9999) - - try: - ioloop.start() - except KeyboardInterrupt: - print("stopped") - -if __name__ == "__main__": - pdf_capture(sys.argv[1]) diff --git a/nbpresent/install.py b/nbpresent/install.py index e97f5e1..2397b59 100644 --- a/nbpresent/install.py +++ b/nbpresent/install.py @@ -2,12 +2,20 @@ import argparse import os -from os.path import dirname, abspath, join, exists +from os.path import ( + abspath, + dirname, + exists, + join, +) +from pprint import pprint try: from inspect import signature except ImportError: from funcsigs import signature +from jupyter_core.paths import jupyter_config_dir + def install(enable=False, **kwargs): """Install the nbpresent nbextension assets and optionally enables the @@ -34,19 +42,41 @@ def install(enable=False, **kwargs): if "prefix" in kwargs: path = join(kwargs["prefix"], "etc", "jupyter") if not exists(path): + print("Making directory", path) os.makedirs(path) cm = ConfigManager(config_dir=path) - print("Enabling for", cm.config_dir) - print("Enabling nbpresent server component...") + print("Enabling nbpresent server component in", cm.config_dir) + cfg = cm.get("jupyter_notebook_config") + print("Existing config...") + pprint(cfg) + server_extensions = ( + cfg.setdefault("NotebookApp", {}) + .setdefault("server_extensions", []) + ) + if "nbpresent" not in server_extensions: + cfg["NotebookApp"]["server_extensions"] += ["nbpresent"] + + cm.update("jupyter_notebook_config", cfg) + print("New config...") + pprint(cm.get("jupyter_notebook_config")) + + cm = ConfigManager(config_dir=join(jupyter_config_dir(), "nbconfig")) + print( + "Enabling nbpresent nbextension at notebook launch in", + cm.config_dir + ) + + if not exists(cm.config_dir): + print("Making directory", cm.config_dir) + os.makedirs(cm.config_dir) + + cm.update( - "jupyter_notebook_config", { - "notebook": { - "load_extensions": {"nbpresent/nbpresent.min": True} + "notebook", { + "load_extensions": { + "nbpresent/nbpresent.min": True }, - "NotebookApp": { - "server_extensions": ["nbpresent"] - } } ) @@ -60,7 +90,7 @@ def install(enable=False, **kwargs): description="Installs nbpresent nbextension") parser.add_argument( "-e", "--enable", - help="Automatically load extension on notebook launch", + help="Automatically load server and nbextension on notebook launch", action="store_true") default_kwargs = dict( diff --git a/nbpresent/present/__main__.py b/nbpresent/present/__main__.py index 40ae999..cd99d32 100644 --- a/nbpresent/present/__main__.py +++ b/nbpresent/present/__main__.py @@ -2,9 +2,9 @@ import sys from ..exporters import ( - PresentExporter, APP_ROOT ) +from ..exporters.html import PresentExporter def main(nb): diff --git a/nbpresent/present/pdf.py b/nbpresent/present/pdf.py index f8c3fbc..4ac4414 100644 --- a/nbpresent/present/pdf.py +++ b/nbpresent/present/pdf.py @@ -2,9 +2,9 @@ import sys from ..exporters import ( - PDFPresentExporter, APP_ROOT ) +from ..exporters.pdf import PDFPresentExporter def main(nb):