s within subslides. Subslide and fragment
# elements can contain content:
#
#
# (content)
#
#
# Get the slide type. If type is subslide or slide,
# end the last slide/subslide/fragment as applicable.
if cell.metadata.slide_type == 'slide':
previous_cell.metadata.slide_end = True
cell.metadata.slide_start = True
if cell.metadata.slide_type in {'subslide', 'slide'}:
previous_cell.metadata.fragment_end = in_fragment
previous_cell.metadata.subslide_end = True
cell.metadata.subslide_start = True
in_fragment = False
elif cell.metadata.slide_type == 'fragment':
cell.metadata.fragment_start = True
if in_fragment:
previous_cell.metadata.fragment_end = True
else:
in_fragment = True
if cell.metadata.get('cell_style') == 'split':
cell.metadata.split = True
# The last cell will always be the end of a slide
nb.cells[-1].metadata.fragment_end = in_fragment
nb.cells[-1].metadata.subslide_end = True
nb.cells[-1].metadata.slide_end = True
return nb
class SlidesExporter(HTMLExporter):
"""Exports HTML slides with reveal.js"""
reveal_url_prefix = Unicode(
help="""The URL prefix for reveal.js.
This can be a a relative URL for a local copy of reveal.js,
or point to a CDN.
For speaker notes to work, a local reveal.js prefix must be used.
"""
).tag(config=True)
@default('reveal_url_prefix')
def _reveal_url_prefix_default(self):
if 'RevealHelpPreprocessor.url_prefix' in self.config:
warn("Please update RevealHelpPreprocessor.url_prefix to "
"SlidesExporter.reveal_url_prefix in config files.")
return self.config.RevealHelpPreprocessor.url_prefix
return 'reveal.js'
font_size = Unicode(help="The size of the fonts").tag(config=True)
@default('font_size')
def _font_size_default(self):
return '25px'
pdf_format = Unicode(help="Set the pdf format").tag(config=True)
@default('pdf_format')
def _pdf_format(self):
return 'False'
@default('file_extension')
def _file_extension_default(self):
return '.slides.html'
@default('template_file')
def _template_file_default(self):
return 'slides_reveal'
output_mimetype = 'text/html'
def from_notebook_node(self, nb, resources=None, **kw):
resources = self._init_resources(resources)
if 'reveal' not in resources:
resources['reveal'] = {}
resources['reveal']['url_prefix'] = self.reveal_url_prefix
if self.pdf_format.lower() == 'true':
css = os.path.join(os.path.split(__file__)[
0], 'templates', 'html.css')
else:
css = os.path.join(os.path.split(__file__)[
0], 'templates', 'reveal.css')
resources['css'] = open(css).read()
resources['css'] = resources['css'].replace(
'{{font_size}}', self.font_size)
nb = prepare(nb)
- return super(SlidesExporter, self).from_notebook_node(nb, resources=resources, **kw)
+ return super(SlidesExporter, self).from_notebook_node(
+ nb, resources=resources, **kw)
diff --git a/Slides/presentation_helper.py b/Slides/presentation_helper.py
index e36d50c..6683708 100644
--- a/Slides/presentation_helper.py
+++ b/Slides/presentation_helper.py
@@ -1,307 +1,309 @@
#!/usr/bin/env pyton
################################################################
from sympy import *
import base64
import sympy
import PyPDF2
import io
import IPython
from IPython.display import display
from IPython.display import HTML
import os
import fnmatch
import shutil
import subprocess
import matplotlib.pyplot as plt
import matplotlib.figure
from IPython.core.interactiveshell import InteractiveShell
from wand.image import Image as WImage
from wand.color import Color
from io import BytesIO
from tempfile import NamedTemporaryFile
from tempfile import mkdtemp
################################################################
def findImageFile(filename):
if os.path.isfile(filename):
return filename
tool_dir = os.path.dirname(__file__)
image_dir = os.path.join(tool_dir, '..', 'images')
pattern = os.path.basename(filename)
found = []
for root, dirnames, filenames in os.walk(image_dir):
for filename in fnmatch.filter(filenames, pattern):
found.append(os.path.join(root, filename))
if len(found) == 0:
raise Exception("file not found: {0}".format(filename))
if len(found) == 1:
return found[0]
raise Exception("Several files were found:\n{0}".format(found))
################################################################
def _print_latex_png(o):
o = o._repr_latex_()
dvioptions = None
exprbuffer = BytesIO()
# from IPython.core.debugger import Tracer
# Tracer()()
preview(o, output='png', viewer='BytesIO',
outputbuffer=exprbuffer, packages=('xcolor',),
dvioptions=dvioptions)
return exprbuffer.getvalue()
################################################################
def registerFormatter(_type, _format, formatter_functor):
f = InteractiveShell.instance().display_formatter.formatters[_format]
f.for_type(_type, func=formatter_functor)
################################################################
def init_printing():
sympy.init_printing()
registerFormatter(IPython.core.display.Math, 'image/png', _print_latex_png)
# f = InteractiveShell.instance().display_formatter.formatters['image/png']
# f.for_type(IPython.core.display.Math, func=_print_latex_png)
################################################################
VIDEO_TAG = """"""
def anim_to_html(anim):
if not hasattr(anim, '_encoded_video'):
with NamedTemporaryFile(suffix='.mp4') as f:
anim.save(f.name, fps=1./(anim._interval*1e-3),
extra_args=['-vcodec', 'libx264',
'-pix_fmt', 'yuv420p'])
video = open(f.name, "rb").read()
toto = base64.b64encode(video).decode()
# print anim._encoded_video
return VIDEO_TAG.format(toto)
################################################################
def display_animation(anim):
plt.close(anim._fig)
return HTML(anim_to_html(anim))
################################################################
def display_images(objs, display_flag=True, **kwargs):
htmls = [display_image(o, display_flag=False, **kwargs)
for o in objs]
width = 100/len(htmls)
htmls_withdiv = ["" for h in htmls]
for i, h in enumerate(htmls):
htmls_withdiv[i] = '
'.format(
+ html = r'![You cannot see the image with this browser/mailer]()
'.format(
base64.b64encode(data).decode('utf8'), size_tag)
display(HTML(html))
return html
################################################################
def makeClassDiagramImage(classes, resolution=150,
width=None, height=None):
with NamedTemporaryFile(suffix='.classes', delete=False) as f:
f.write(classes.encode('utf-8'))
f.flush()
fout = os.path.splitext(f.name)[0] + '.png'
_command = ('class_dumper_dot.py --collaboration_no '
'-c {0} -o {1} -f svg'.format(f.name, fout))
# print(_command)
subprocess.call(_command, shell=True)
return fout
################################################################
def pdf_page_to_png(src_filename, pagenums=None, resolution=72):
"""
Returns specified PDF page as wand.image.Image png.
:param PyPDF2.PdfFileReader src_pdf: PDF from which to take pages.
:param int pagenum: Page number to take.
:param int resolution: Resolution for resulting png in DPI.
"""
src_pdf = PyPDF2.PdfFileReader(file(src_filename, "rb"))
# print dir(src_pdf)
# print src_pdf.numPages
if pagenums is None:
pagenums = [0]
res = []
for n in pagenums:
dst_pdf = PyPDF2.PdfFileWriter()
dst_pdf.addPage(src_pdf.getPage(n))
pdf_bytes = io.BytesIO()
dst_pdf.write(pdf_bytes)
pdf_bytes.seek(0)
img = WImage(file=pdf_bytes, resolution=resolution)
img.convert("png")
res.append(img)
return res
################################################################
init_printing()
diff --git a/Slides/slides_config.py b/Slides/slides_config.py
index 8f2246f..44412ee 100644
--- a/Slides/slides_config.py
+++ b/Slides/slides_config.py
@@ -1,18 +1,21 @@
+#! /usr/bin/env python3
-from __future__ import print_function
import os
import sys
dirname = os.path.dirname(__file__)
print(dirname)
sys.path.append(dirname)
c = get_config()
c.Exporter.template_file = 'presentation.tpl'
print(c.Exporter.__dict__)
-#c.Exporter.template_file = 'mybasic.tpl'
-c.Exporter.template_path.append(os.path.join(dirname,'templates'))
-#c.Exporter.preprocessors = ['execute_markdown.ExecutePreprocessor','pre_pymarkdown.PyMarkdownPreprocessor']
-c.Exporter.preprocessors = ['jupyter_contrib_nbextensions.nbconvert_support.pre_pymarkdown.PyMarkdownPreprocessor']
+# c.Exporter.template_file = 'mybasic.tpl'
+c.Exporter.template_path.append(os.path.join(dirname, 'templates'))
+# c.Exporter.preprocessors = ['execute_markdown.ExecutePreprocessor',
+# 'pre_pymarkdown.PyMarkdownPreprocessor']
+c.Exporter.preprocessors = [
+ 'jupyter_contrib_nbextensions.nbconvert_support.pre_pymarkdown.'
+ 'PyMarkdownPreprocessor']
diff --git a/Slides/snippet_helper.py b/Slides/snippet_helper.py
index 1597a04..60a4c57 100644
--- a/Slides/snippet_helper.py
+++ b/Slides/snippet_helper.py
@@ -1,405 +1,406 @@
#!/usr/bin/env python3
import subprocess
import os
import re
from pygments import highlight
from pygments.lexers import CppLexer
from pygments.lexers import PythonLexer
# from pygments.lexer import RegexLexer
from pygments.lexers import MatlabLexer
from pygments.formatters import HtmlFormatter
from pygments.formatters import LatexFormatter
from pygments import token
from IPython.display import HTML
from tempfile import NamedTemporaryFile
################################################################
class Snippet(object):
"""
Snippet objects manipulate codes.
At construction it can be formatted using clang-format
and it can be compiled to check for consistency.
"""
class CompilationError(Exception):
""" Compilation error """
pass
default_output = 'html'
default_line_numbering = False
def __getitem__(self, slice):
return self.pigment(start=slice.start, end=slice.stop)
def __init__(self, inp, format_flag=False,
compile_flag=False, include_paths=None,
language='cpp'):
try:
self.loadfile(inp)
except Exception:
self.content = inp.strip()
if include_paths is None:
self.include_paths = []
else:
self.include_paths = [
os.path.abspath(i) for i in include_paths]
if format_flag:
self.clang_format()
if compile_flag:
self.compile()
if language == 'cpp':
self.lexer = CppLexer()
elif language == 'python':
self.lexer = PythonLexer()
elif language == 'matlab':
self.lexer = MatlabLexer()
def save(self, filename):
"""
Saves the snippet in another file
:param filename: The filename to save the snippet to
"""
f = open(filename, 'w')
f.write(self.content)
f.close()
def loadfile(self, inp):
filename = inp
full_filename = os.path.realpath(filename)
f = open(full_filename)
self.content = f.read()
f.close()
def clang_format(self):
f = NamedTemporaryFile()
f.write(self.content.encode())
f.flush()
p = subprocess.Popen(
'clang-format {0}'.format(f.name),
shell=True, stdout=subprocess.PIPE)
stdout, stderr = p.communicate()
formatted_file = stdout
self.content = formatted_file.decode('utf-8')
def execute(self, working_dir='/tmp', args='', libraries=''):
self.compile(working_dir=working_dir)
f = NamedTemporaryFile(suffix='.cpp', delete=False)
f.write(self.content.encode())
f.flush()
working_dir = os.path.dirname(f.name)
# file_dir = os.path.dirname(self.full_filename)
previous_dir = os.getcwd()
os.chdir(working_dir)
include_paths = self.include_paths + [working_dir]
include_paths = ['-I {0}'.format(a) for a in include_paths]
include_paths = ' '.join(include_paths)
p = subprocess.Popen(
'g++ -Wall -Wextra {1} {2} -o exec {0}'.format(
f.name, include_paths, libraries),
shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
ret = p.returncode
if ret != 0:
return ret, stdout, stderr
p = subprocess.Popen(
'./exec {0}'.format(args), shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
ret = p.returncode
os.chdir(previous_dir)
return ret, stdout, stderr
def compile(self, working_dir='/tmp'):
f = NamedTemporaryFile(suffix='.cpp', delete=False)
f.write(self.content.encode())
f.flush()
working_dir = os.path.dirname(f.name)
# file_dir = os.path.dirname(self.full_filename)
previous_dir = os.getcwd()
os.chdir(working_dir)
include_paths = self.include_paths + [working_dir]
include_paths = ['-I {0}'.format(a) for a in include_paths]
include_paths = ' '.join(include_paths)
p = subprocess.Popen(
'g++ -Wall -Wextra {1} -c {0}'.format(f.name, include_paths),
shell=True, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
ret = p.returncode
os.chdir(previous_dir)
if ret != 0:
- raise Snippet.CompilationError('compilation failed\n' + stderr.decode('utf-8'))
+ raise Snippet.CompilationError('compilation failed\n' +
+ stderr.decode('utf-8'))
os.remove(f.name)
o_file = os.path.splitext(f.name)[0] + '.o'
os.remove(o_file)
def get_lines(self):
return self.content.split('\n')
def get_content(self):
return self.content
def __str__(self):
_content = self.content.split('\n')
ret = ""
for i, line in enumerate(_content):
ret += '{0}: {1}\n'.format(i, line)
return ret
class KeywordLexer(object):
def __init__(self, keyword):
if keyword == 'curly_brackets':
keyword = '{|}'
self.keyword = keyword
def get_tokens(self, text):
pattern = '(' + self.keyword + ')'
splits = re.split(pattern, text)
if len(splits) == 1:
return [(token.Text, text)]
res = []
# print(splits)
# print(token.Keyword.Type)
for count, s in enumerate(splits):
# print(count, s)
if count % 2 == 0:
res.append((token.Text, s))
else:
res.append((token.Keyword.Type, s))
# print(res)
return res
class LineLexer(object):
def __init__(self, line_number):
self.line_number = line_number
def get_tokens(self, text):
splits = text.split('\n')
res = []
splits1 = '\n'.join(splits[:self.line_number]) + '\n'
splits2 = splits[self.line_number] + '\n'
splits3 = '\n' + '\n'.join(splits[self.line_number + 1:]) + '\n'
splits = [splits1] + [splits2] + [splits3]
# print(splits)
for count, s in enumerate(splits):
if count == 1:
res.append((token.Keyword.Type, s))
else:
res.append((token.Text, s))
# print(res)
return res
class CustomLatexFormatter(LatexFormatter):
def __init__(self, **kwargs):
LatexFormatter.__init__(self, **kwargs)
def format(self, tokens, outfile):
res = []
for t, s in tokens:
if t == token.Keyword.Type:
import pygments.formatters.latex as la
s = la.escape_tex(s, self.commandprefix)
s = '\color{red}{\huge{' + s + '}}'
t = token.Escape
res.append((t, s))
LatexFormatter.format(self, res, outfile)
class CustomHtmlFormatter(HtmlFormatter):
def __init__(self, **kwargs):
HtmlFormatter.__init__(self, **kwargs)
def format(self, tokens, outfile_final):
# HtmlFormatter.format(self, tokens, outfile_final)
# return
from io import StringIO
outfile = StringIO()
res = []
ss = []
for t, s in tokens:
if t == token.Keyword.Type:
ss.append(s)
s = 'A' * 24
t = token.Text
res.append((t, s))
# print(res)
HtmlFormatter.format(self, res, outfile)
final = outfile.getvalue()
while ss:
s = ss.pop(0)
final = final.replace(
'A' * 24,
'{0}'.format(
s),
1)
outfile_final.write(final)
def pigment(self,
keyword=None, line_highlight=None,
start=None, end=None,
output=None, line_numbering=None):
_content = self.content.split('\n')
_content = [(c + '\n') for c in _content]
if start is None:
start = 1
if end is None:
end = len(_content)
if output is None:
output = self.default_output
lexer = self.lexer
if keyword is not None:
lexer = self.KeywordLexer(keyword)
elif line_highlight is not None:
if line_highlight < start or line_highlight > end:
raise RuntimeError('line_highlight out of the sub snippet')
line_highlight -= start
lexer = self.LineLexer(line_highlight)
if line_numbering is None:
line_numbering = self.default_line_numbering
if output == 'html':
formatter = HtmlFormatter(
full=False, linenos=line_numbering, linenostart=start)
elif output == 'latex':
formatter = LatexFormatter(
full=False, linenos=line_numbering, linenostart=start)
if (keyword is not None) or (line_highlight is not None):
format_class = self.CustomHtmlFormatter
if output == 'latex':
format_class = self.CustomLatexFormatter
formatter = format_class(
full=False, linenos=line_numbering,
linenostart=start)
snip = _content[start - 1:end]
snip = ''.join(snip)
colored_snippet = highlight(snip, lexer, formatter)
# print(colored_snippet)
if output == 'html':
HTML_TEMPLATE = """
{}
"""
css = formatter.get_style_defs()
colored_snippet = HTML(HTML_TEMPLATE.format(css, colored_snippet))
return colored_snippet
@staticmethod
def getLatexStyleDefs():
return LatexFormatter(full=True).get_style_defs()
################################################################
class SnippetCollection(Snippet):
def __init__(self):
self.functions = dict()
self.func_names = []
def addFunction(self, f_name, code):
if f_name in self.functions:
raise RuntimeError('function already declared')
self.func_names.append(f_name)
self.functions[f_name] = Snippet(code, format_flag=True)
self.compile()
def __getitem__(self, key):
return self.functions[key]
def flatten(self):
global_input = """
#include
#include
#include
#include
""" + '/' * 70 + '\n\n'
for f_name in self.func_names:
global_input += "void {0}(){{\n".format(f_name)
global_input += self.functions[f_name].content
global_input += '\n}\n\n' + '/' * 70 + '\n\n'
global_input += """
int main(int argc, char ** argv){\n"""
for f_name in self.func_names:
global_input += f_name + '();\n'
global_input += '\n}\n'
flat = Snippet(global_input,
format_flag=True)
return flat
def compile(self, **kwargs):
global_snippet = self.flatten()
global_snippet.compile(**kwargs)
def save(self, filename):
global_snippet = self.flatten()
open(filename, 'w').write(global_snippet.content)
def pigment(self, *args):
return self.flatten().pigment(*args)
def last(self):
return self.functions[self.func_names[-1]]
################################################################
# def printMatlab(code):
#
# html_snippet = highlight(
# code, MatlabLexer(),
# HtmlFormatter(full=True, style='colorful',
# classprefix='matlab_'))
#
# display(HTML(html_snippet))
# # return html_snippet
# ## testing
-#Snippet.default_output = 'latex'
-#Snippet.default_line_numbering = True
+# Snippet.default_output = 'latex'
+# Snippet.default_line_numbering = True
#
-#snippet = SnippetCollection()
-# snippet.addFunction('if_syntax', '''
-# int p, q;
-# if (p > q) {
-# /*
-# Statement1;
-# Statement2;
-# */
-# }
-#''')
+# snippet = SnippetCollection()
+# snippet.addFunction('if_syntax', '''
+# int p, q;
+# if (p > q) {
+# /*
+# Statement1;
+# Statement2;
+# */
+# }
+# ''')
#
-#print (snippet['if_syntax'].pigment())
+# print (snippet['if_syntax'].pigment())
diff --git a/scripts/platex2slides b/scripts/platex2slides
index 9fc90f0..9e2fec4 100755
--- a/scripts/platex2slides
+++ b/scripts/platex2slides
@@ -1,77 +1,77 @@
-#!/usr/bin/env python
+#!/bin/env python3
import sys
import nbformat
from PythonLatex.latex_structure import LatexStructure
from PythonLatex.latex_structure import LatexEnvironment
filename_in = sys.argv[1]
filename_out = sys.argv[2]
tex_struct = LatexStructure()
tex_struct.parseLatexFile(filename_in)
print(str(tex_struct))
nb = nbformat.notebooknode.NotebookNode({
u'nbformat_minor': 2,
u'cells': [],
u'nbformat': 4,
u'metadata': {u'kernelspec': {u'display_name': u'Python 2',
u'name': u'python2',
u'language': u'python'},
u'toc': {u'nav_menu': {u'width': u'252px',
u'height': u'12px'},
u'toc_window_display': False,
u'widenNotebook': False,
u'toc_section_display': u'block',
u'colors': {u'hover_highlight': u'#DAA520',
u'running_highlight': u'#FF0000',
u'selected_highlight': u'#FFD700'},
u'navigate_menu': True,
u'number_sections': True,
u'threshold': 4,
u'moveMenuLeft': True,
u'sideBar': True,
u'toc_cell': False},
u'hide_input': False,
u'language_info': {u'mimetype': u'text/x-python',
u'nbconvert_exporter': u'python',
u'version': u'2.7.13',
u'name': u'python',
u'file_extension': u'.py',
u'pygments_lexer': u'ipython2',
u'codemirror_mode': {
u'version': 2,
u'name': u'ipython'}}}})
nb['cells'] = []
################################################################
def createNewCell():
print('create new cell')
new_cell = nbformat.notebooknode.NotebookNode()
new_cell['cell_type'] = 'markdown'
new_cell['source'] = ''
new_cell['metadata'] = {}
nb['cells'].append(new_cell)
return new_cell
################################################################
current_cell = None
for c in tex_struct.content:
if current_cell is None:
current_cell = createNewCell()
if isinstance(c, LatexEnvironment):
current_cell = createNewCell()
print ('AAA:', type(c), str(c))
print ('adding:', type(c), str(c))
current_cell['source'] += str(c)
# print(nb)
# print(type(nb))
nbformat.write(nb, 'test.ipynb')
diff --git a/scripts/slides b/scripts/slides
index 4d0fa7c..9866465 100755
--- a/scripts/slides
+++ b/scripts/slides
@@ -1,110 +1,109 @@
#!/usr/bin/python3
-from __future__ import print_function
"""
This executable permits to generate an advanced presentation
from a Jupyter notebook.
The capabilities are:
- a server of reveal content
- a pptx (under developement)
- a beamer tex file (TODO)
"""
################################################################
import argparse
import os
import Slides.count_slides as count_slides
import Slides.cell_manager as cell_manager
################################################################
def getNotebookFilenames(slides_file):
"""
When a directory is provided to the executable,
a file named 'slides' is searched for with
the expected list of ipython notebooks.
The list of notebooks to consider is then
returned.
"""
if not os.path.isfile(slides_file):
raise Exception("Cannot find slides file")
f = open(slides_file)
slides = [l.strip() for l in f.readlines() if l != ""]
return slides
################################################################
def main():
parser = argparse.ArgumentParser(description='Slide launcher')
parser.add_argument(
"--execute", action='store_true',
help=('Requests to execute all the notebooks launching '
'the slides server'))
parser.add_argument("--no_count", action='store_false',
help="Requests not to count slides generated")
parser.add_argument("notebooks", nargs='*',
help="The notebooks to associate in a presentation")
parser.add_argument(
"--internet", action='store_true',
help="Weather the http server should serve on the internet")
parser.add_argument("--html", action='store_true',
help="only produce a html file")
parser.add_argument("--beamer", action='store_true',
help="produce a beamer/latex file and the pdf")
parser.add_argument("--add_cell_number", action='store_true',
help="add the cell number before each cell")
parser.add_argument("--select_cells", type=int, nargs='*',
help="Provides a list of cells to select")
parser.add_argument("--font_size", type=str, default='25px',
help="Provides the font size of the presentation")
arguments = parser.parse_args()
if len(arguments.notebooks) == 1:
if os.path.isdir(arguments.notebooks[0]):
slides_path = arguments.notebooks[0]
slides_file = os.path.join(slides_path, 'slides')
arguments.notebooks = getNotebookFilenames(slides_file)
else:
_file = arguments.notebooks[0]
f, ext = os.path.splitext(_file)
if ext == '.sld':
arguments.notebooks = getNotebookFilenames(_file)
if arguments.execute:
for n in arguments.notebooks:
cell_manager.executeNotebook(n)
try:
cell_manager.mergeNotebooks(arguments.notebooks,
add_cell_number=arguments.add_cell_number,
select_cells=arguments.select_cells)
except cell_manager.NotFoundNotebooks:
print('Could not find the notebooks to treat: check path provided')
return
if arguments.no_count:
nb_slides = count_slides.countSlides(['talk.ipynb'])
print("*" * 20)
print("You generated a talk with {0} slides".format(nb_slides))
print("*" * 20)
if arguments.html:
cell_manager.generateHTML(font_size=arguments.font_size)
elif arguments.beamer:
cell_manager.generateBeamer(font_size=arguments.font_size)
elif arguments.internet:
cell_manager.launchSlideServer(options="--ServePostProcessor.ip='*'",
font_size=arguments.font_size)
else:
cell_manager.launchSlideServer(font_size=arguments.font_size)
################################################################
if __name__ == "__main__":
main()
diff --git a/setup.py b/setup.py
index 606a939..f8e7ad1 100644
--- a/setup.py
+++ b/setup.py
@@ -1,45 +1,46 @@
from setuptools import setup, find_packages
try:
from sphinx.setup_command import BuildDoc
cmdclass={'doc': BuildDoc}
except Exception:
cmdclass={}
name = 'slides'
version = '1.0'
release = '1.0.0'
setup(name=name,
packages=find_packages(),
version="0.0.1",
author="Guillaume Anciaux",
author_email="guillaume.anciaux@epfl.ch",
description=("Slides making/convertion tools"),
install_requires=["sphinx", "jupyter", "sympy", "pypdf2",
- "matplotlib", "wand", "dill"],
+ "matplotlib", "wand", "dill",
+ "jupyter_contrib_nbextensions"],
tests_requires=["pytest"],
setup_requires=["pytest-runner"],
test_suite="tests",
cmdclass=cmdclass,
command_options={
'doc': {
'project': ('setup.py', name),
'version': ('setup.py', version),
'release': ('setup.py', release),
'source_dir': ('setup.py', 'doc')}},
scripts=['scripts/slides',
'scripts/pLatex'],
license="""
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see
(content)
# {0}
'.format(h)
html = '\n'.join(htmls_withdiv)
html = '' + html + '
'
if display_flag:
display(HTML(html))
return html
def display_image(obj, resolution=150, width=None, height=None,
display_flag=True):
if type(obj) == matplotlib.figure.Figure:
png = InteractiveShell.instance().display_formatter.format(obj)
elif type(obj) == str:
try:
fname = findImageFile(obj)
except Exception as e:
return str(e)
img = WImage(filename=fname, resolution=resolution)
img.trim()
with Color('#FDFDFD') as white:
twenty_percent = int(65535 * 0.2)
img.transparent_color(white, alpha=0.0, fuzz=twenty_percent)
if (width is None) and (height is None):
display(img)
return img
png = InteractiveShell.instance().display_formatter.format(img)
else:
raise Exception('unknown obj type for an image')
size_tag = ""
if width is not None:
size_tag += 'width="{0}"'.format(width)
if height is not None:
size_tag += 'height="{0}"'.format(height)
data = png[0]['image/png']
data = base64.b64encode(data).decode('utf-8')
- html = r''.format(
+ html = r'