Merge pull request #73 from scopatz/master

Updated to relative imports in converters sub-package

converters/base.py

@@ -1,411 +1,411 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 codecs
 import io
 import logging
 import os
 import pprint
 import re
 from types import FunctionType
 
 # IPython imports
 from IPython.nbformat import current as nbformat
 
 # Our own imports
-from converters.utils import remove_fake_files_url
+from .utils import remove_fake_files_url
 
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 def clean_filename(filename):
     """
     Remove non-alphanumeric characters from filenames.
 
     Parameters
     ----------
     filename : str
         The filename to be sanitized.
 
     Returns
     -------
     clean : str
         A sanitized filename that contains only alphanumeric
         characters and underscores.
     """
     filename = re.sub(r'[^a-zA-Z0-9_]', '_', filename)
     return filename
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ConversionException(Exception):
     pass
 
 
 class DocStringInheritor(type):
     """
     This metaclass will walk the list of bases until the desired
     superclass method is found AND if that method has a docstring and only
     THEN does it attach the superdocstring to the derived class method.
 
     Please use carefully, I just did the metaclass thing by following
     Michael Foord's Metaclass tutorial
     (http://www.voidspace.org.uk/python/articles/metaclasses.shtml), I may
     have missed a step or two.
 
     source:
     http://groups.google.com/group/comp.lang.python/msg/26f7b4fcb4d66c95
     by Paul McGuire
     """
     def __new__(meta, classname, bases, classDict):
         newClassDict = {}
         for attributeName, attribute in classDict.items():
             if type(attribute) == FunctionType:
                 # look through bases for matching function by name
                 for baseclass in bases:
                     if hasattr(baseclass, attributeName):
                         basefn = getattr(baseclass, attributeName)
                         if basefn.__doc__:
                             attribute.__doc__ = basefn.__doc__
                             break
             newClassDict[attributeName] = attribute
         return type.__new__(meta, classname, bases, newClassDict)
 
 
 class Converter(object):
     __metaclass__ = DocStringInheritor
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     default_encoding = 'utf-8'
     extension = str()
     blank_symbol = " "
     # Which display data format is best? Subclasses can override if
     # they have specific requirements.
     display_data_priority = ['pdf', 'svg', 'png', 'jpg', 'text']
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     infile = str()
     highlight_source = True
     infile_dir = str()
     infile_root = str()
     clean_name = str()
     files_dir = str()
     outbase = str()
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set by other methods in the base
     # class.
     #-------------------------------------------------------------------------
     figures_counter = 0
     output = unicode()
     #-------------------------------------------------------------------------
     # Instance-level attributes that are not actually mentioned further
     # in this class. TODO: Could they be usefully moved to a subclass?
     #-------------------------------------------------------------------------
     with_preamble = True
     user_preamble = None
     raw_as_verbatim = False
 
     def __init__(self, infile, highlight_source=True, exclude=[]):
         # N.B. Initialized in the same order as defined above. Please try to
         # keep in this way for readability's sake.
         self.exclude_cells = exclude
         self.infile = infile
         self.highlight_source = highlight_source
         self.infile_dir, infile_root = os.path.split(infile)
         self.infile_root = os.path.splitext(infile_root)[0]
         self.clean_name = clean_filename(self.infile_root)
         # Handle the creation of a directory for ancillary files, for
         # formats that need one.
         files_dir = os.path.join(self.infile_dir, self.clean_name + '_files')
         if not os.path.isdir(files_dir):
             os.mkdir(files_dir)
         self.files_dir = files_dir
         self.outbase = os.path.join(self.infile_dir, self.infile_root)
 
     def __del__(self):
         if os.path.isdir(self.files_dir) and not os.listdir(self.files_dir):
             os.rmdir(self.files_dir)
 
     def _get_prompt_number(self, cell):
         return cell.prompt_number if hasattr(cell, 'prompt_number') \
             else self.blank_symbol
 
     def dispatch(self, cell_type):
         """return cell_type dependent render method,  for example render_code
         """
         return getattr(self, 'render_' + cell_type, self.render_unknown)
 
     def dispatch_display_format(self, format):
         """
         return output_type dependent render method,  for example
         render_output_text
         """
         return getattr(self, 'render_display_format_' + format,
                        self.render_unknown_display)
 
     def convert(self, cell_separator='\n'):
         """
         Generic method to converts notebook to a string representation.
 
         This is accomplished by dispatching on the cell_type, so subclasses of
         Convereter class do not need to re-implement this method, but just
         need implementation for the methods that will be dispatched.
 
         Parameters
         ----------
         cell_separator : string
           Character or string to join cells with. Default is "\n"
 
         Returns
         -------
         out : string
         """
         lines = []
         lines.extend(self.optional_header())
         lines.extend(self.main_body(cell_separator))
         lines.extend(self.optional_footer())
         return u'\n'.join(lines)
 
     def main_body(self, cell_separator='\n'):
         converted_cells = []
         for worksheet in self.nb.worksheets:
             for cell in worksheet.cells:
                 #print(cell.cell_type)  # dbg
                 conv_fn = self.dispatch(cell.cell_type)
                 if cell.cell_type in ('markdown', 'raw'):
                     remove_fake_files_url(cell)
                 converted_cells.append('\n'.join(conv_fn(cell)))
         cell_lines = cell_separator.join(converted_cells).split('\n')
         return cell_lines
 
     def render(self):
         "read, convert, and save self.infile"
         if not hasattr(self, 'nb'):
             self.read()
         self.output = self.convert()
         assert(type(self.output) == unicode)
         return self.save()
 
     def read(self):
         "read and parse notebook into NotebookNode called self.nb"
         with open(self.infile) as f:
             self.nb = nbformat.read(f, 'json')
 
     def save(self, outfile=None, encoding=None):
         "read and parse notebook into self.nb"
         if outfile is None:
             outfile = self.outbase + '.' + self.extension
         if encoding is None:
             encoding = self.default_encoding
         with io.open(outfile, 'w', encoding=encoding) as f:
             f.write(self.output)
         return os.path.abspath(outfile)
 
     def optional_header(self):
         """
         Optional header to insert at the top of the converted notebook
 
         Returns a list
         """
         return []
 
     def optional_footer(self):
         """
         Optional footer to insert at the end of the converted notebook
 
         Returns a list
         """
         return []
 
     def _new_figure(self, data, fmt):
         """Create a new figure file in the given format.
 
         Returns a path relative to the input file.
         """
         figname = '%s_fig_%02i.%s' % (self.clean_name,
                                       self.figures_counter, fmt)
         self.figures_counter += 1
         fullname = os.path.join(self.files_dir, figname)
 
         # Binary files are base64-encoded, SVG is already XML
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
             fopen = lambda fname: open(fname, 'wb')
         else:
             fopen = lambda fname: codecs.open(fname, 'wb',
                                               self.default_encoding)
 
         with fopen(fullname) as f:
             f.write(data)
 
         return fullname
 
     def render_heading(self, cell):
         """convert a heading cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_code(self, cell):
         """Convert a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_markdown(self, cell):
         """convert a markdown cell
 
         Returns list."""
         raise NotImplementedError
 
     def _img_lines(self, img_file):
         """Return list of lines to include an image file."""
         # Note: subclasses may choose to implement format-specific _FMT_lines
         # methods if they so choose (FMT in {png, svg, jpg, pdf}).
         raise NotImplementedError
 
     def render_display_data(self, output):
         """convert display data from the output of a code cell
 
         Returns list.
         """
         for fmt in self.display_data_priority:
             if fmt in output:
                 break
         else:
             for fmt in output:
                 if fmt != 'output_type':
                     break
             else:
                 raise RuntimeError('no display data')
 
         # Is it an image?
         if fmt in ['png', 'svg', 'jpg', 'pdf']:
             img_file = self._new_figure(output[fmt], fmt)
             # Subclasses can have format-specific render functions (e.g.,
             # latex has to auto-convert all SVG to PDF first).
             lines_fun = getattr(self, '_%s_lines' % fmt, None)
             if not lines_fun:
                 lines_fun = self._img_lines
             lines = lines_fun(img_file)
         else:
             lines_fun = self.dispatch_display_format(fmt)
             lines = lines_fun(output)
 
         return lines
 
     def render_raw(self, cell):
         """convert a cell with raw text
 
         Returns list."""
         raise NotImplementedError
 
     def render_unknown(self, cell):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(cell)
         logging.warning('Unknown cell: %s' % cell.cell_type)
         return self._unknown_lines(data)
 
     def render_unknown_display(self, output, type):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(output)
         logging.warning('Unknown output: %s' % output.output_type)
         return self._unknown_lines(data)
 
     def render_stream(self, output):
         """render the stream part of an output
 
         Returns list.
 
         Identical to render_display_format_text
         """
         return self.render_display_format_text(output)
 
     def render_pyout(self, output):
         """convert pyout part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_pyerr(self, output):
         """convert pyerr part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def _unknown_lines(self, data):
         """Return list of lines for an unknown cell.
 
         Parameters
         ----------
         data : str
           The content of the unknown data as a single string.
         """
         raise NotImplementedError
 
     # These are the possible format types in an output node
 
     def render_display_format_text(self, output):
         """render the text part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_html(self, output):
         """render the html part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_latex(self, output):
         """render the latex part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_json(self, output):
         """render the json part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_javascript(self, output):
         """render the javascript part of an output
 
         Returns list.
         """
         raise NotImplementedError

converters/bloggerhtml.py

@@ -1,46 +1,46 b''
 """Notebook export in Blogger-aware HTML.
 
 This file contains `ConverterBloggerHTML`, a subclass of `ConverterHTML` that
 provides output suitable for easy pasting into a blog hosted on the Blogger
 platform. See the class docstring for more information.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import io
 
 # Our own imports
-from converters.html import ConverterHTML
+from .html import ConverterHTML
 
 
 #-----------------------------------------------------------------------------
 # Classes declarations
 #-----------------------------------------------------------------------------
 
 class ConverterBloggerHTML(ConverterHTML):
     """Convert a notebook to html suitable for easy pasting into Blogger.
 
     It generates an html file that has *only* the pure HTML contents, and a
     separate file with `_header` appended to the name with all header contents.
     Typically, the header file only needs to be used once when setting up a
     blog, as the CSS for all posts is stored in a single location in Blogger.
     """
 
     def optional_header(self):
         with io.open(self.outbase + '_header.html', 'w',
                      encoding=self.default_encoding) as f:
             f.write('\n'.join(self.header_body()))
         return []
 
     def optional_footer(self):
         return []

converters/html.py

@@ -1,218 +1,218 b''
 """Implements conversion to ordinary HTML output.
 
 This file implements a class that handles rendering IPython notebooks as
 HTML, suitable for posting to the web.
 
 Converters for more specific HTML generation needs (suitable for posting to
 a particular web service) can usefully subclass `ConverterHTML` and override
 certain methods. For output tuned to the Blogger blogging platform, see the
 `ConverterBloggerHTML` class.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 # Stdlib imports
 import io
 import os
 
 # Third-party imports
 from markdown import markdown
 
 # IPython imports
 from IPython.utils import path
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import text_cell, output_container
-from converters.utils import highlight, coalesce_streams, ansi2html
+from .base import Converter
+from .utils import text_cell, output_container
+from .utils import highlight, coalesce_streams, ansi2html
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ConverterHTML(Converter):
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     extension = 'html'
     blank_symbol = ' '
 
     def in_tag(self, tag, src, attrs=None):
         """Return a list of elements bracketed by the given tag"""
         attr_s = '' if attrs is None else \
                  ' '.join("%s=%s" % (attr, value)
                           for attr, value in attrs.iteritems())
         return ['<%s %s>' % (tag, attr_s), src, '</%s>' % tag]
 
     def _ansi_colored(self, text):
         return ['<pre>%s</pre>' % ansi2html(text)]
 
     def _stylesheet(self, fname):
         with io.open(fname, encoding='utf-8') as f:
             s = f.read()
         return self.in_tag('style', s, dict(type='"text/css"'))
 
     def _out_prompt(self, output):
         if output.output_type == 'pyout':
             content = 'Out[%s]:' % self._get_prompt_number(output)
         else:
             content = ''
         return ['<div class="prompt output_prompt">%s</div>' % content]
 
     def header_body(self):
         """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'),
         ]:
             header.extend(self._stylesheet(sheet))
 
         # pygments css
         pygments_css = HtmlFormatter().get_style_defs('.highlight')
         header.extend(['<meta charset="UTF-8">'])
         header.extend(self.in_tag('style', pygments_css,
                                   dict(type='"text/css"')))
 
         # TODO: this should be allowed to use local mathjax:
         header.extend(self.in_tag('script', '', {'type': '"text/javascript"',
             'src': '"https://c328740.ssl.cf1.rackcdn.com/mathjax/'
                    'latest/MathJax.js?config=TeX-AMS_HTML"',
         }))
         with io.open(os.path.join(here, '..', 'js', 'initmathjax.js'),
                      encoding='utf-8') as f:
             header.extend(self.in_tag('script', f.read(),
                                       {'type': '"text/javascript"'}))
         return header
 
     def optional_header(self):
         return ['<html>', '<head>'] + self.header_body() + \
           ['</head>', '<body>']
 
     def optional_footer(self):
         return ['</body>', '</html>']
 
     @text_cell
     def render_heading(self, cell):
         marker = cell.level
         return [u'<h{1}>\n  {0}\n</h{1}>'.format(cell.source, marker)]
 
     def render_code(self, cell):
         if not cell.input:
             return []
 
         lines = ['<div class="cell border-box-sizing code_cell vbox">']
 
         lines.append('<div class="input hbox">')
         n = self._get_prompt_number(cell)
         lines.append(
             '<div class="prompt input_prompt">In&nbsp;[%s]:</div>' % n
         )
         lines.append('<div class="input_area box-flex1">')
         lines.append(highlight(cell.input) if self.highlight_source
                      else cell.input)
         lines.append('</div>')  # input_area
         lines.append('</div>')  # input
 
         if cell.outputs:
             lines.append('<div class="vbox output_wrapper">')
             lines.append('<div class="output vbox">')
 
             for output in coalesce_streams(cell.outputs):
                 conv_fn = self.dispatch(output.output_type)
                 lines.extend(conv_fn(output))
 
             lines.append('</div>')  # output
             lines.append('</div>')  # output_wrapper
 
         lines.append('</div>')  # cell
 
         return lines
 
     @text_cell
     def render_markdown(self, cell):
         return [markdown(cell.source)]
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return self.in_tag('pre', cell.source)
         else:
             return [cell.source]
 
     @output_container
     def render_pyout(self, output):
         for fmt in ['html', 'latex', 'png', 'jpeg', 'svg', 'text']:
             if fmt in output:
                 conv_fn = self.dispatch_display_format(fmt)
                 return conv_fn(output)
         return []
 
     render_display_data = render_pyout
 
     @output_container
     def render_stream(self, output):
         return self._ansi_colored(output.text)
 
     @output_container
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         # lines = []
 
         # stb =
         return self._ansi_colored('\n'.join(output.traceback))
 
     def _img_lines(self, img_file):
         return ['<img src="%s">' % img_file, '</img>']
 
     def _unknown_lines(self, data):
         return ['<h2>Warning:: Unknown cell</h2>'] + self.in_tag('pre', data)
 
     def render_display_format_png(self, output):
         return ['<img src="data:image/png;base64,%s"></img>' % output.png]
 
     def render_display_format_svg(self, output):
         return [output.svg]
 
     def render_display_format_jpeg(self, output):
         return ['<img src="data:image/jpeg;base64,%s"></img>' % output.jpeg]
 
     def render_display_format_text(self, output):
         return self._ansi_colored(output.text)
 
     def render_display_format_html(self, output):
         return [output.html]
 
     def render_display_format_latex(self, output):
         return [output.latex]
 
     def render_display_format_json(self, output):
         # html ignores json
         return []
 
     def render_display_format_javascript(self, output):
         return [output.javascript]

converters/latex.py

@@ -1,231 +1,231 b''
 """Notebook export to LaTeX.
 
 This file implements a converter class for rendering IPython notebooks as
 LaTeX, suitable for rendering by pdflatex.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import subprocess
 import sys
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import markdown2latex, remove_ansi
+from .base import Converter
+from .utils import markdown2latex, remove_ansi
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 # XXX: This is a hack that needs to be addressed in a more principled fashion.
 inkscape = 'inkscape'
 if sys.platform == 'darwin':
     inkscape = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape'
     if not os.path.exists(inkscape):
         inkscape = None
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ConverterLaTeX(Converter):
     """Converts a notebook to a .tex file suitable for pdflatex.
 
     Note: this converter *needs*:
 
     - `pandoc`: for all conversion of markdown cells.  If your notebook only
        has Raw cells, pandoc will not be needed.
 
     -  `inkscape`: if your notebook has SVG figures.  These need to be
        converted to PDF before inclusion in the TeX file, as LaTeX doesn't
        understand SVG natively.
 
     You will in general obtain much better final PDF results if you configure
     the matplotlib backend to create SVG output with
 
     %config InlineBackend.figure_format = 'svg'
 
     (or set the equivalent flag at startup or in your configuration profile).
     """
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     extension = 'tex'
     # LaTeX specific class configuration.
     inkscape = inkscape
     documentclass = 'article'
     documentclass_options = '11pt,english'
     equation_env = 'equation*'
     heading_map = {1: r'\section',
                    2: r'\subsection',
                    3: r'\subsubsection',
                    4: r'\paragraph',
                    5: r'\subparagraph',
                    6: r'\subparagraph'}
     user_preamble = None
     display_data_priority = ['latex', 'pdf', 'svg', 'png', 'jpg', 'text']
 
     def in_env(self, environment, lines):
         """Return list of environment lines for input lines
 
         Parameters
         ----------
         env : string
           Name of the environment to bracket with begin/end.
 
         lines: """
         out = [ur'\begin{%s}' % environment]
         if isinstance(lines, basestring):
             out.append(lines)
         else:  # list
             out.extend(lines)
         out.append(ur'\end{%s}' % environment)
         return out
 
     def convert(self, *args, **kwargs):
         # The main body is done by the logic in the parent class, and that's
         # all we need if preamble support has been turned off.
         body = super(ConverterLaTeX, self).convert(*args, **kwargs)
         if not self.with_preamble:
             return body
         # But if preamble is on, then we need to construct a proper, standalone
         # tex file.
 
         # Tag the document at the top and set latex class
         final = [r'%% This file was auto-generated by IPython.',
                  r'%% Conversion from the original notebook file:',
                  r'%% {0}'.format(self.infile),
                  r'%%',
                  r'\documentclass[%s]{%s}' % (self.documentclass_options,
                                               self.documentclass),
                  '',
                  ]
         # Load our own preamble, which is stored next to the main file.  We
         # need to be careful in case the script entry point is a symlink
         myfile = os.path.realpath(__file__)
         preamble = '../preamble.tex'
         with open(os.path.join(os.path.dirname(myfile), preamble)) as f:
             final.append(f.read())
 
         # Load any additional user-supplied preamble
         if self.user_preamble:
             final.extend(['', '%% Adding user preamble from file:',
                           '%% {0}'.format(self.user_preamble), ''])
             with open(self.user_preamble) as f:
                 final.append(f.read())
 
         # Include document body
         final.extend([r'\begin{document}', '',
                       body,
                       r'\end{document}', ''])
         # Return value must be a string
         return '\n'.join(final)
 
     def render_heading(self, cell):
         marker = self.heading_map[cell.level]
         return ['%s{%s}' % (marker, cell.source)]
 
     def render_code(self, cell):
         if not cell.input:
             return []
 
         # Cell codes first carry input code, we use lstlisting for that
         lines = [ur'\begin{codecell}']
 
         if 'source' not in self.exclude_cells:
             lines.extend(self.in_env('codeinput',
                                      self.in_env('lstlisting', cell.input)))
         else:
             # Empty output is still needed for LaTeX formatting
             lines.extend(self.in_env('codeinput', ''))
 
         outlines = []
         if 'output' not in self.exclude_cells:
             for output in cell.outputs:
                 conv_fn = self.dispatch(output.output_type)
                 outlines.extend(conv_fn(output))
 
         # And then output of many possible types; use a frame for all of it.
         if outlines:
             lines.extend(self.in_env('codeoutput', outlines))
 
         lines.append(ur'\end{codecell}')
 
         return lines
 
     def _img_lines(self, img_file):
         rel_img_position = os.path.relpath(img_file, self.infile_dir)
         return self.in_env('center', 
             [r'\includegraphics[width=0.7\textwidth]{%s}' % rel_img_position, 
              r'\par'])
 
     def _svg_lines(self, img_file):
         base_file = os.path.splitext(img_file)[0]
         pdf_file = base_file + '.pdf'
         subprocess.check_call([self.inkscape, '--export-pdf=%s' % pdf_file,
                                img_file])
         return self._img_lines(pdf_file)
 
     def render_markdown(self, cell):
         return [markdown2latex(cell.source)]
 
     def render_pyout(self, output):
         lines = []
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             lines.extend(self.in_env(self.equation_env, 
                          output.latex.lstrip('$$').rstrip('$$')))
         #use text only if no latex representation is available
         elif 'text' in output:
             lines.extend(self.in_env('verbatim', output.text))
 
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return self.in_env('traceback',
                         self.in_env('verbatim',
                                  remove_ansi('\n'.join(output.traceback))))
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return self.in_env('verbatim', cell.source)
         else:
             return [cell.source]
 
     def _unknown_lines(self, data):
         return [r'{\vspace{5mm}\bf WARNING:: unknown cell:}'] + \
           self.in_env('verbatim', data)
 
     def render_display_format_text(self, output):
         return self.in_env('verbatim', output.text.strip())
 
     def render_display_format_html(self, output):
         return []
 
     def render_display_format_latex(self, output):
         return self.in_env(self.equation_env, 
                            output.latex.lstrip('$$').rstrip('$$'))
 
     def render_display_format_json(self, output):
         # latex ignores json
         return []
 
     def render_display_format_javascript(self, output):
         # latex ignores javascript
         return []

converters/markdown.py

@@ -1,128 +1,128 b''
 """Converter implementing Markdown export.
 
 Implements a Converter that allows IPython notebooks to reasonably rendered
 as a Markdown document.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import highlight, remove_ansi
+from .base import Converter
+from .utils import highlight, remove_ansi
 from IPython.utils.text import indent
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConverterMarkdown(Converter):
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     extension = 'md'
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     # show_prompts controls the display of In[} and Out[] prompts for code
     # cells.
     show_prompts = False
     # If inline_prompt is False, display prompts on a separate line.
     inline_prompt = False
 
     def __init__(self, infile, highlight_source=True, show_prompts=False,
                  inline_prompt=False, **kw):
         super(ConverterMarkdown, self).__init__(infile, **kw)
         self.highlight_source = highlight_source
         self.show_prompts = show_prompts
         self.inline_prompt = inline_prompt
 
     def render_heading(self, cell):
         return ['{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         if not cell.input:
             return []
         lines = []
         n = self._get_prompt_number(cell)
         if self.show_prompts:
             if not self.inline_prompt:
                 lines.extend(['*In[%s]:*' % n, ''])
             else:
                 prompt = 'In[%s]: ' % n
                 input_lines = cell.input.split('\n')
                 src = (prompt + input_lines[0] + '\n' +
                        indent('\n'.join(input_lines[1:]), nspaces=len(prompt)))
         else:
             src = cell.input
         src = highlight(src) if self.highlight_source else indent(src)
         lines.extend([src, ''])
         if cell.outputs and self.show_prompts and not self.inline_prompt:
             lines.extend(['*Out[%s]:*' % n, ''])
         for output in cell.outputs:
             conv_fn = self.dispatch(output.output_type)
             lines.extend(conv_fn(output))
 
         #lines.append('----')
         lines.append('')
         return lines
 
     def render_markdown(self, cell):
         return [cell.source, '']
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return [indent(cell.source), '']
         else:
             return [cell.source, '']
 
     def render_pyout(self, output):
         lines = []
 
         ## if 'text' in output:
         ##     lines.extend(['*Out[%s]:*' % self._get_prompt_number(cell), ''])
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             pass
 
         if 'text' in output:
             lines.extend(['<pre>', indent(output.text), '</pre>'])
 
         lines.append('')
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return [indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return ['', '![](%s)' % img_file, '']
 
     def render_display_format_text(self, output):
         return [indent(output.text)]
 
     def _unknown_lines(self, data):
         return ['Warning: Unknown cell', data]
 
     def render_display_format_html(self, output):
         return [output.html]
 
     def render_display_format_latex(self, output):
         return ['LaTeX::', indent(output.latex)]
 
     def render_display_format_json(self, output):
         return ['JSON:', indent(output.json)]
 
     def render_display_format_javascript(self, output):
         return ['JavaScript:', indent(output.javascript)]

converters/notebook.py

@@ -1,107 +1,107 b''
 """Base class for doing notebook-to-notebook transformations.
 
 This implements a converter class that turns an IPython notebook into another
 IPython notebook, mainly so that it can be subclassed to perform more useful
 and sophisticated transformations.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2011, 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import json
 import os
 from shutil import rmtree
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import cell_to_lines
+from .base import Converter
+from .utils import cell_to_lines
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConverterNotebook(Converter):
     """
     A converter that is essentially a null-op.
     This exists so it can be subclassed
     for custom handlers of .ipynb files
     that create new .ipynb files.
 
     What distinguishes this from JSONWriter is that
     subclasses can specify what to do with each type of cell.
 
     Writes out a notebook file.
 
     """
     extension = 'ipynb'
 
     def __init__(self, infile, outbase, **kw):
         Converter.__init__(self, infile, **kw)
         self.outbase = outbase
         rmtree(self.files_dir)
 
     def convert(self):
         return unicode(json.dumps(json.loads(Converter.convert(self, ',')),
                                   indent=1, sort_keys=True))
 
     def optional_header(self):
         s = \
 """{
  "metadata": {
  "name": "%(name)s"
  },
  "nbformat": 3,
  "worksheets": [
  {
  "cells": [""" % {'name': os.path.basename(self.outbase)}
         return s.split('\n')
 
     def optional_footer(self):
         s = \
 """]
   }
  ]
 }"""
         return s.split('\n')
 
     def render_heading(self, cell):
         return cell_to_lines(cell)
 
     def render_code(self, cell):
         return cell_to_lines(cell)
 
     def render_markdown(self, cell):
         return cell_to_lines(cell)
 
     def render_raw(self, cell):
         return cell_to_lines(cell)
 
     def render_pyout(self, output):
         return cell_to_lines(output)
 
     def render_pyerr(self, output):
         return cell_to_lines(output)
 
     def render_display_format_text(self, output):
         return [output.text]
 
     def render_display_format_html(self, output):
         return [output.html]
 
     def render_display_format_latex(self, output):
         return [output.latex]
 
     def render_display_format_json(self, output):
         return [output.json]
 
     def render_display_format_javascript(self, output):
         return [output.javascript]

converters/python.py

@@ -1,130 +1,130 b''
 """Notebook export to .py source code files.
 
 Since Python export is provided in the notebook itself (provided by classes
 in `IPython.nbformat`), this class serves mainly as a base class for other
 converters that may wish to implement cell-type-specific behaviors.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # IPython imports
 from IPython.utils.text import indent
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import remove_ansi
+from .base import Converter
+from .utils import remove_ansi
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConverterPy(Converter):
     """
     A converter that takes a notebook and converts it to a .py file.
 
     What distinguishes this from PyWriter and PyReader in IPython.nbformat is
     that subclasses can specify what to do with each type of cell.
     Additionally, unlike PyWriter, this does not preserve the '# <markdown>'
     opening and closing comments style comments in favor of a cleaner looking
     python program.
 
     Note:
         Even though this produces a .py file, it is not guaranteed to be valid
         python file, since the notebook may be using magics and even cell
         magics.
     """
     extension = 'py'
 
     def __init__(self, infile, highlight_source=False, show_prompts=True,
                  show_output=True, **kw):
         # Note that highlight_source is meaningless here, so even if it
         # is passed as True we ignore it and propagate False to the
         # superclass.
         super(ConverterPy, self).__init__(infile,
                                           highlight_source=False, **kw)
         self.show_prompts = show_prompts
         self.show_output = show_output
 
     @staticmethod
     def comment(input):
         "returns every line in input as commented out"
         return "# " + input.replace("\n", "\n# ")
 
     def render_heading(self, cell):
         return ['#{0} {1}'.format('#' * cell.level, cell.source), '']
 
     def render_code(self, cell):
         n = self._get_prompt_number(cell)
         if not cell.input:
             return []
         lines = []
         if self.show_prompts:
             lines.extend(['# In[%s]:' % n])
         src = cell.input
         lines.extend([src, ''])
         if self.show_output:
             if cell.outputs:
                 lines.extend(['# Out[%s]:' % n])
             for output in cell.outputs:
                 conv_fn = self.dispatch(output.output_type)
                 lines.extend(conv_fn(output))
         return lines
 
     def render_markdown(self, cell):
         return [self.comment(cell.source), '']
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return [self.comment(indent(cell.source)), '']
         else:
             return [self.comment(cell.source), '']
 
     def render_pyout(self, output):
         lines = []
 
         ## if 'text' in output:
         ##     lines.extend(['*Out[%s]:*' % self._get_prompt_number(cell), ''])
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             pass
 
         if 'text' in output:
             lines.extend([self.comment(indent(output.text)), ''])
 
         lines.append('')
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return [indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return [self.comment('image file: %s' % img_file), '']
 
     def render_display_format_text(self, output):
         return [self.comment(indent(output.text))]
 
     def _unknown_lines(self, data):
         return [self.comment('Warning: Unknown cell' + str(data))]
 
     def render_display_format_html(self, output):
         return [self.comment(output.html)]
 
     def render_display_format_latex(self, output):
         return []
 
     def render_display_format_json(self, output):
         return []
 
     def render_display_format_javascript(self, output):
         return []

converters/rst.py

@@ -1,100 +1,100 b''
 """Notebook export to reStructuredText (rST).
 
 This file provides a converter class for rendering IPython notebooks as valid
 reStructuredText, suitable for inclusion in e.g. Sphinx documentation.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 # IPython imports
 from IPython.utils.text import indent
 
 # Our own imports
-from converters.base import Converter
-from converters.utils import markdown2rst, rst_directive, remove_ansi
+from .base import Converter
+from .utils import markdown2rst, rst_directive, remove_ansi
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 class ConverterRST(Converter):
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     extension = 'rst'
     heading_level = {1: '=', 2: '-', 3: '`', 4: '\'', 5: '.', 6: '~'}
 
     def render_heading(self, cell):
         marker = self.heading_level[cell.level]
         return ['{0}\n{1}\n'.format(cell.source, marker * len(cell.source))]
 
     def render_code(self, cell):
         # Note: cell has type 'IPython.nbformat.v3.nbbase.NotebookNode'
         if not cell.input:
             return []
 
         lines = ['In[%s]:' % self._get_prompt_number(cell), '']
         lines.extend(rst_directive('.. code:: python', cell.input))
 
         for output in cell.outputs:
             conv_fn = self.dispatch(output.output_type)
             lines.extend(conv_fn(output))
 
         return lines
 
     def render_markdown(self, cell):
         #return [cell.source]
         return [markdown2rst(cell.source)]
 
     def render_raw(self, cell):
         if self.raw_as_verbatim:
             return ['::', '', indent(cell.source), '']
         else:
             return [cell.source]
 
     def render_pyout(self, output):
         lines = ['Out[%s]:' % self._get_prompt_number(output), '']
 
         # output is a dictionary like object with type as a key
         if 'latex' in output:
             lines.extend(rst_directive('.. math::', output.latex))
 
         if 'text' in output:
             lines.extend(rst_directive('.. parsed-literal::', output.text))
 
         return lines
 
     def render_pyerr(self, output):
         # Note: a traceback is a *list* of frames.
         return ['::', '', indent(remove_ansi('\n'.join(output.traceback))), '']
 
     def _img_lines(self, img_file):
         return ['.. image:: %s' % img_file, '']
 
     def render_display_format_text(self, output):
         return rst_directive('.. parsed-literal::', output.text)
 
     def _unknown_lines(self, data):
         return rst_directive('.. warning:: Unknown cell') + [data]
 
     def render_display_format_html(self, output):
         return rst_directive('.. raw:: html', output.html)
 
     def render_display_format_latex(self, output):
         return rst_directive('.. math::', output.latex)
 
     def render_display_format_json(self, output):
         return rst_directive('.. raw:: json', output.json)
 
     def render_display_format_javascript(self, output):
         return rst_directive('.. raw:: javascript', output.javascript)