start tex template

converters/template.py

@@ -1,218 +1,221 b''
 """Base classes for the notebook conversion pipeline.
 
 This module defines Converter, from which all objects designed to implement
 a conversion of IPython notebooks to some other format should inherit.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2012, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
 import re
 from IPython.utils import path
 
 from jinja2 import Environment, FileSystemLoader
 env = Environment(
         loader=FileSystemLoader('./templates/'),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 texenv = Environment(
         loader=FileSystemLoader('./templates/tex/'),
         extensions=['jinja2.ext.loopcontrols']
         )
 
 # IPython imports
 from IPython.nbformat import current as nbformat
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import ( Unicode, Any)
 
 # Our own imports
 from IPython.utils.text import indent
 from .utils import remove_ansi
 from markdown import markdown
 from .utils import highlight, ansi2html
+from .utils import markdown2latex
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 def rm_fake(strng):
     return strng.replace('/files/', '')
 
 class ConversionException(Exception):
     pass
 
 
 def python_comment(string):
     return '# '+'\n# '.join(string.split('\n'))
 
 
 
 def header_body():
     """Return the body of the header as a list of strings."""
 
     from pygments.formatters import HtmlFormatter
 
     header = []
     static = os.path.join(path.get_ipython_package_dir(),
     'frontend', 'html', 'notebook', 'static',
     )
     here = os.path.split(os.path.realpath(__file__))[0]
     css = os.path.join(static, 'css')
     for sheet in [
         # do we need jquery and prettify?
         # os.path.join(static, 'jquery', 'css', 'themes', 'base',
         # 'jquery-ui.min.css'),
         # os.path.join(static, 'prettify', 'prettify.css'),
         os.path.join(css, 'boilerplate.css'),
         os.path.join(css, 'fbm.css'),
         os.path.join(css, 'notebook.css'),
         os.path.join(css, 'renderedhtml.css'),
         # our overrides:
         os.path.join(here, '..', 'css', 'static_html.css'),
     ]:
 
         with io.open(sheet, encoding='utf-8') as f:
             s = f.read()
             header.append(s)
 
     pygments_css = HtmlFormatter().get_style_defs('.highlight')
     header.append(pygments_css)
     return header
 
 inlining = {}
 inlining['css'] = header_body()
 
 
 def filter_data_type(output):
     for fmt in ['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text']:
         if fmt in output:
             return [fmt]
 
 
 env.filters['filter_data_type'] = filter_data_type
 env.filters['pycomment'] = python_comment
 env.filters['indent'] = indent
 env.filters['rm_fake'] = rm_fake
 env.filters['rm_ansi'] = remove_ansi
 env.filters['markdown'] = markdown
 env.filters['highlight'] = highlight
 env.filters['ansi2html'] = ansi2html
 
 
 
 LATEX_SUBS = (
     (re.compile(r'\\'), r'\\textbackslash'),
     (re.compile(r'([{}_#%&$])'), r'\\\1'),
     (re.compile(r'~'), r'\~{}'),
     (re.compile(r'\^'), r'\^{}'),
     (re.compile(r'"'), r"''"),
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 def escape_tex(value):
     newval = value
     for pattern, replacement in LATEX_SUBS:
         newval = pattern.sub(replacement, newval)
     return newval
 
 texenv.block_start_string = '((*'
 texenv.block_end_string = '*))'
 texenv.variable_start_string = '((('
 texenv.variable_end_string = ')))'
 texenv.comment_start_string = '((='
 texenv.comment_end_string = '=))'
 texenv.filters['escape_tex'] = escape_tex
 
 texenv.filters['filter_data_type'] = filter_data_type
 texenv.filters['pycomment'] = python_comment
 texenv.filters['indent'] = indent
 texenv.filters['rm_fake'] = rm_fake
 texenv.filters['rm_ansi'] = remove_ansi
 texenv.filters['markdown'] = markdown
 texenv.filters['highlight'] = highlight
 texenv.filters['ansi2html'] = ansi2html
+texenv.filters['markdown2latex'] = markdown2latex
+markdown2latex
 
 
 def haspyout_transformer(nb,_):
     print('calling...')
     for worksheet in nb.worksheets:
         print('worksheet')
         for cell in worksheet.cells:
             cell.type = cell.cell_type
             cell.haspyout = False
             for out in cell.get('outputs', []):
                 if out.output_type == 'pyout':
                     cell.haspyout = True
                     break
     return nb
 
 class ConverterTemplate(Configurable):
     """ A Jinja2 base converter templates"""
 
     display_data_priority = ['pdf', 'svg', 'png', 'jpg', 'text']
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     infile = Any()
 
 
     infile_dir = Unicode()
 
     def __init__(self, tplfile='fullhtml', preprocessors=[], config=None,tex_environement=False, **kw):
         """
         tplfile : jinja template file to process.
 
         config: the Configurable confg object to pass around
 
         preprocessors: list of function to run on ipynb json data before conversion
         to extract/inline file,
 
         """
         self.env = texenv if tex_environement else env
         self.ext = '.tplx' if tex_environement else '.tpl' 
         self.template = self.env.get_template(tplfile+self.ext)
         self.nb = None
         self.preprocessors = preprocessors
         self.preprocessors.append(haspyout_transformer)
         super(ConverterTemplate, self).__init__(config=config, **kw)
 
 
     def process(self):
         """
         preprocess the notebook json for easier use with the templates. 
         will call all the `preprocessor`s in order before returning it. 
         """
         nb = self.nb
 
         for preprocessor in self.preprocessors:
             nb = preprocessor(nb,{})
 
         return nb
 
     def convert(self):
         """ convert the ipynb file
 
         return both the converted ipynb file and a dict containing potential
         other resources
         """
         return self.template.render(nb=self.process(), inlining=inlining), {}
 
 
     def read(self, filename):
         "read and parse notebook into NotebookNode called self.nb"
         with io.open(filename) as f:
             self.nb = nbformat.read(f, 'json')
 

templates/tex/latex_base.tplx

@@ -1,56 +1,198 b''
 ((*- extends 'null.tplx' -*))
 
 ((* block in_prompt *))
 # In[(((cell.prompt_number if cell.prompt_number else ' ')))]:
 ((* endblock in_prompt *))
 
 ((* block output_prompt *))
 # Out[(((cell.prompt_number)))]:((* endblock output_prompt *))
 
-((* block input *))((( cell.input )))
+((* block codecell *))
+\begin{codecell}
+((( super() )))
+\end{codecell}
+((* endblock *))
+
+((* block input *))
+\begin{codeinput}
+\begin{lstlisting}
+((( cell.input )))
+\end{lstlisting}
+\end{codeinput}
 ((* endblock input *))
 
 
 ((= Those Two are for error displaying
 even if the first one seem to do nothing, 
 it introduces a new line
 
 =))
 ((* block pyerr *))((( super() )))
 ((* endblock pyerr *))
 
 ((* block traceback_line *))
 ((( line |indent| rm_ansi )))((* endblock traceback_line *))
 ((= .... =))
 
 
 ((* block pyout *))
 ((( output.text| indent | pycomment)))
 ((* endblock pyout *))
 
 ((* block stream *))
 ((( output.text| indent | pycomment)))
 ((* endblock stream *))
 
 
 
 
 ((* block display_data scoped *))
 # image file:
 ((* endblock display_data *))
 
 ((* block markdowncell scoped *))
-((( cell.source | pycomment )))
+((( cell.source | markdown2latex )))
 ((* endblock markdowncell *))
 
 ((* block headingcell scoped *))
-((( '#' * cell.level )))((( cell.source | pycomment)))
+\section{((( cell.source)))}
 ((* endblock headingcell *))
 
 ((* block rawcell scoped *))
 ((( cell.source | pycomment )))
 ((* endblock rawcell *))
 
 ((* block unknowncell scoped *))
 unknown type  (((cell.type)))
 ((* endblock unknowncell *))
+
+
+
+((* block body *))
+\begin{document}
+((( super() )))
+\end{document}
+((* endblock*))
+
+((* block header *))
+%% This file was auto-generated by IPython.
+%% Conversion from the original notebook file:
+%% tests/ipynbref/Gun_Data.orig.ipynb
+%%
+\documentclass[11pt,english]{article}
+
+%% This is the automatic preamble used by IPython.  Note that it does *not*
+%% include a documentclass declaration, that is added at runtime to the overall
+%% document.
+
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{graphicx}
+\usepackage{ucs}
+\usepackage[utf8x]{inputenc}
+
+% needed for markdown enumerations to work
+\usepackage{enumerate}
+
+% Slightly bigger margins than the latex defaults
+\usepackage{geometry}
+\geometry{verbose,tmargin=3cm,bmargin=3cm,lmargin=2.5cm,rmargin=2.5cm}
+
+% Define a few colors for use in code, links and cell shading
+\usepackage{color}
+\definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+\definecolor{darkorange}{rgb}{.71,0.21,0.01}
+\definecolor{darkgreen}{rgb}{.12,.54,.11}
+\definecolor{myteal}{rgb}{.26, .44, .56}
+\definecolor{gray}{gray}{0.45}
+\definecolor{lightgray}{gray}{.95}
+\definecolor{mediumgray}{gray}{.8}
+\definecolor{inputbackground}{rgb}{.95, .95, .85}
+\definecolor{outputbackground}{rgb}{.95, .95, .95}
+\definecolor{traceback}{rgb}{1, .95, .95}
+
+% Framed environments for code cells (inputs, outputs, errors, ...).  The
+% various uses of \unskip (or not) at the end were fine-tuned by hand, so don't
+% randomly change them unless you're sure of the effect it will have.
+\usepackage{framed}
+
+% remove extraneous vertical space in boxes
+\setlength\fboxsep{0pt}
+
+% codecell is the whole input+output set of blocks that a Code cell can
+% generate.
+
+% TODO: unfortunately, it seems that using a framed codecell environment breaks
+% the ability of the frames inside of it to be broken across pages.  This
+% causes at least the problem of having lots of empty space at the bottom of
+% pages as new frames are moved to the next page, and if a single frame is too
+% long to fit on a page, will completely stop latex from compiling the
+% document.  So unless we figure out a solution to this, we'll have to instead
+% leave the codecell env. as empty.  I'm keeping the original codecell
+% definition here (a thin vertical bar) for reference, in case we find a
+% solution to the page break issue.
+
+%% \newenvironment{codecell}{%
+%%     \def\FrameCommand{\color{mediumgray} \vrule width 1pt \hspace{5pt}}%
+%%    \MakeFramed{\vspace{-0.5em}}}
+%%  {\unskip\endMakeFramed}
+
+% For now, make this a no-op...
+\newenvironment{codecell}{}
+
+ \newenvironment{codeinput}{%
+   \def\FrameCommand{\colorbox{inputbackground}}%
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\unskip\endMakeFramed}
+
+\newenvironment{codeoutput}{%
+   \def\FrameCommand{\colorbox{outputbackground}}%
+   \vspace{-1.4em}
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\unskip\medskip\endMakeFramed}
+
+\newenvironment{traceback}{%
+   \def\FrameCommand{\colorbox{traceback}}%
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\endMakeFramed}
+
+% Use and configure listings package for nicely formatted code
+\usepackage{listingsutf8}
+\lstset{
+  language=python,
+  inputencoding=utf8x,
+  extendedchars=\true,
+  aboveskip=\smallskipamount,
+  belowskip=\smallskipamount,
+  xleftmargin=2mm,
+  breaklines=true,
+  basicstyle=\small \ttfamily,
+  showstringspaces=false,
+  keywordstyle=\color{blue}\bfseries,
+  commentstyle=\color{myteal},
+  stringstyle=\color{darkgreen},
+  identifierstyle=\color{darkorange},
+  columns=fullflexible,  % tighter character kerning, like verb
+}
+
+% The hyperref package gives us a pdf with properly built
+% internal navigation ('pdf bookmarks' for the table of contents,
+% internal cross-reference links, web links for URLs, etc.)
+\usepackage{hyperref}
+\hypersetup{
+  breaklinks=true,  % so long urls are correctly broken across lines
+  colorlinks=true,
+  urlcolor=blue,
+  linkcolor=darkorange,
+  citecolor=darkgreen,
+  }
+
+% hardcode size of all verbatim environments to be a bit smaller
+\makeatletter 
+\g@addto@macro\@verbatim\small\topsep=0.5em\partopsep=0pt
+\makeatother 
+
+% Prevent overflowing lines due to urls and other hard-to-break entities.
+\sloppy
+
+((* endblock *))