upstream/ipython Commit - r8749:712b994d

PEP8-ify rest of the repository.

David Warde-Farley -

r8749:712b994d

parent child

converters/html.py

0 +40 -35

             from __future__ import absolute_import
             from converters.base import Converter
             from converters.utils import text_cell, output_container
             from converters.utils import highlight, coalesce_streams, ansi2html
             from IPython.utils import path
             from markdown import markdown
             import os
             import io
             class ConverterHTML(Converter):
                 extension = 'html'
                 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)
+                             ' '.join("%s=%s" % (attr, value)
-                                       for attr, value in attrs.iteritems() )
+                                      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':
-                        n = output.prompt_number if output.prompt_number is not None else '&nbsp;'
+                        n = (output.prompt_number if output.prompt_number is not None
+                             else '&nbsp;')
                         content = 'Out[%s]:' % n
                     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, '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'),
+                        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"')))
+                    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"',
+                    header.extend(self.in_tag('script', '', {'type': '"text/javascript"',
-                        'src': '"https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML"',
+                        '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 = cell.prompt_number if getattr(cell, 'prompt_number', None) is not None else '&nbsp;'
+                    n = (cell.prompt_number
-                    lines.append('<div class="prompt input_prompt">In&nbsp;[%s]:</div>' % n)
+                         if getattr(cell, 'prompt_number', None) is not None
+                         else '&nbsp;')
+                    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))
-                    lines.append('</div>') # input_area
+                    lines.append('</div>')  # input_area
-                    lines.append('</div>') # input
+                    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
-                        lines.append('</div>') # output_wrapper
+                        lines.append('</div>')  # output_wrapper
-                    lines.append('</div>') # cell
+                    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

0 +29 -30

             from converters.base import Converter
             from converters.utils import markdown2latex, remove_ansi
-            import os, sys
+            import os
             import subprocess
+            import sys
             inkscape = 'inkscape'
             if sys.platform == 'darwin':
                 inkscape = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape'
                 if not os.path.exists(inkscape):
                     inkscape = None
             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).
                 """
                 inkscape = inkscape
                 extension = 'tex'
                 documentclass = 'article'
                 documentclass_options = '11pt,english'
                 heading_map = {1: r'\section',
 : r'\subsection',
 : r'\subsubsection',
 : r'\paragraph',
 : r'\subparagraph',
 : r'\subparagraph'}
                 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, *kwargs):
+                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(*kwargs)
+                    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, do NOT edit',
+                    final = [r'%% This file was auto-generated by IPython, do NOT edit',
-                              r'%% Conversion from the original notebook file:',
+                             r'%% Conversion from the original notebook file:',
-                              r'%% {0}'.format(self.infile),
+                             r'%% {0}'.format(self.infile),
-                              r'%%',
+                             r'%%',
-                              r'\documentclass[%s]{%s}' % (self.documentclass_options,
+                             r'\documentclass[%s]{%s}' % (self.documentclass_options,
-                                                           self.documentclass),
+                                                          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__)
-                    with open(os.path.join(os.path.dirname(myfile), '../preamble.tex')) as f:
+                    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}', '',
+                    final.extend([r'\begin{document}', '',
-                                   body,
+                                  body,
-                                   r'\end{document}', ''])
+                                  r'\end{document}', ''])
                     # Retun 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) ]
+                    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}']
                     lines.extend(self.in_env('codeinput',
                                           self.in_env('lstlisting', cell.input)))
                     outlines = []
                     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):
                     return self.in_env('center',
                             [r'\includegraphics[width=6in]{%s}' % img_file, 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,
+                    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(output.latex)
                     if '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):
                     lines = []
                     if 'text' in output:
                         lines.extend(self.in_env('verbatim', output.text.strip()))
                     return lines
                 def render_display_format_html(self, output):
                     return []
                 def render_display_format_latex(self, output):
                     if type(output.latex) == type([]):
                         return output.latex
                     return [output.latex]
                 def render_display_format_json(self, output):
                     # latex ignores json
                     return []
                 def render_display_format_javascript(self, output):
                     # latex ignores javascript
                     return []

converters/lexers.py

0 +2 -1

             #-----------------------------------------------------------------------------
             # Imports
             #-----------------------------------------------------------------------------
             from pygments.lexers import PythonLexer, BashLexer
             from pygments.lexer import bygroups, using
             from pygments.token import Keyword, Operator, Text
             #-----------------------------------------------------------------------------
             # Classes
             #-----------------------------------------------------------------------------
             class IPythonLexer(PythonLexer):
                 name = 'IPython'
                 aliases = ['ip', 'ipython']
                 filenames = ['*.ipy']
                 tokens = PythonLexer.tokens.copy()
                 tokens['root'] = [
-                    (r'(\%+)(\w+)\s+(\.*)(\n)', bygroups(Operator, Keyword, using(BashLexer), Text)),
+                    (r'(\%+)(\w+)\s+(\.*)(\n)', bygroups(Operator, Keyword,
+                                                         using(BashLexer), Text)),
                     (r'(\%+)(\w+)\b', bygroups(Operator, Keyword)),
                     (r'^(!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
                 ] + tokens['root']

converters/markdown.py

0 +6 -4

             from converters.base import Converter
             from converters.utils import highlight, remove_ansi
             from IPython.utils.text import indent
             class ConverterMarkdown(Converter):
                 extension = 'md'
                 def __init__(self, infile, highlight_source=True, show_prompts=False,
                              inline_prompt=False):
                     super(ConverterMarkdown, self).__init__(infile)
                     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), '']
+                    return ['{0} {1}'.format('#' * cell.level, cell.source), '']
                 def render_code(self, cell):
                     if not cell.input:
                         return []
                     lines = []
                     if self.show_prompts and not self.inline_prompt:
                         lines.extend(['*In[%s]:*' % cell.prompt_number, ''])
                     if self.show_prompts and self.inline_prompt:
                         prompt = 'In[%s]: ' % cell.prompt_number
                         input_lines = cell.input.split('\n')
-                        src = prompt + input_lines[0] + '\n' + indent('\n'.join(input_lines[1:]), nspaces=len(prompt))
+                        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]:*' % cell.prompt_number, ''])
                     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]:*' % output.prompt_number, ''])
                     # 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

0 +3 -3

             import os
             from converters.base import Converter
             from converters.utils import cell_to_lines
             from shutil import rmtree
             import json
             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):
                     Converter.__init__(self, infile)
                     self.outbase = outbase
                     rmtree(self.files_dir)
                 def convert(self):
-                    return unicode(json.dumps(json.loads(Converter.convert(self, ',')), indent=1, sort_keys=True))
+                    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

0 +6 -5

             from converters.base import Converter
             from IPython.utils.text import indent
             from converters.utils import remove_ansi
             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, show_prompts=True, show_output=True):
                     super(ConverterPy, self).__init__(infile)
                     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# ")
+                    return "# " + input.replace("\n", "\n# ")
                 def render_heading(self, cell):
-                    return ['#{0} {1}'.format('#'*cell.level, cell.source), '']
+                    return ['#{0} {1}'.format('#' * cell.level, cell.source), '']
                 def render_code(self, cell):
                     if not cell.input:
                         return []
                     lines = []
                     if self.show_prompts:
                         lines.extend(['# In[%s]:' % cell.prompt_number])
                     src = cell.input
                     lines.extend([src, ''])
                     if self.show_output:
-                        if cell.outputs :
+                        if cell.outputs:
                             lines.extend(['# Out[%s]:' % cell.prompt_number])
                         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]:*' % output.prompt_number, ''])
                     # 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), '']
+                    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))]
+                    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 []

custom_converter.py

0 +1 -1

             """
             This module gives a simple example of a custom notebook converter that only
             captures display data and deletes the cell inputs.
             """
             import copy
             import nbconvert as nb
             class CustomNotebookConverter(nb.ConverterNotebook):
                 def render_code(self, cell):
                     captured_outputs = ['text', 'html', 'svg', 'latex', 'javascript']
                     cell = copy.deepcopy(cell)
                     cell['input'] = ''
                     for output in cell.outputs:
                         if output.output_type != 'display_data':
                             cell.outputs.remove(output)
                     return nb.ConverterNotebook.render_code(self, cell)
             if __name__ == '__main__':
                 infile = 'tests/test_display.ipynb'
                 converter = CustomNotebookConverter(infile, 'test_only_display')
                 converter.render()

dollarmath.py

0 +10 -1

             # dollarmath.py by Akihiro Uchida *public domain*
             # the original one is written by Paul Kienzle
             # and published as public domain in [sphinx-dev]: $math$ extension
             r"""
             Allow $math$ markup in text and docstrings, ignoring \$.
             The $math$ markup should be separated from the surrounding text by spaces.
             To embed markup within a word, place backslash-space before and after.
             For convenience, the final $ can be followed by punctuation
             (period, comma or semicolon).
             """
             import re
             dollar_pat = r"(?:^|(?<=\s))[$]([^\n]*?)(?<![\\])[$](?:$|(?=\s|[.,;\\]))"
             _dollar = re.compile(dollar_pat)
             _notdollar = re.compile(r"\\[$]")
             def replace_dollar(content):
                 content = _dollar.sub(r":math:`\1`", content)
                 content = _notdollar.sub("$", content)
                 return content
             def rewrite_rst(app, docname, source):
                 source[0] = replace_dollar(source[0])
             def rewrite_autodoc(app, what, name, obj, options, lines):
                 lines[:] = [replace_dollar(L) for L in lines]
             def setup(app):
                 app.connect('source-read', rewrite_rst)
                 if 'autodoc-process-docstring' in app._events:
                     app.connect('autodoc-process-docstring', rewrite_autodoc)
             def test_expr(expr, expect):
                 result = replace_dollar(expr)
                 print 'A math expression: %s' % expr
                 print 'A expected output: %s' % expect
                 if result == expect:
                     print 'OK: A result match expected one'
                 else:
                     print 'NG: A result %s does not match expected one!' % result
             def test_dollar():
                 samples = {
                     u"no dollar": u"no dollar",
                     u"$only$": u":math:`only`",
                     u"$first$ is good": u":math:`first` is good",
                     u"so is $last$": u"so is :math:`last`",
                     u"and $mid$ too": u"and :math:`mid` too",
                     u"$first$, $mid$, $last$": u":math:`first`, :math:`mid`, :math:`last`",
                     u"dollar\$ escape": u"dollar$ escape",
                     u"dollar \$escape\$ too": u"dollar $escape$ too",
                     u"emb\ $ed$\ ed": u"emb\ :math:`ed`\ ed",
                     u"$first$a": u"$first$a",
                     u"a$last$": u"a$last$",
                     u"a $mid$dle a": u"a $mid$dle a",
                 }
                 for expr, expect in samples.items():
                     test_expr(expr, expect)
             if __name__ == "__main__":
-                import sys, locale, codecs
+                import sys
+                import locale
+                import codecs
                 encoding = locale.getpreferredencoding()
                 sys.stdout = codecs.getwriter(encoding)(sys.stdout)
                 sys.stdin = codecs.getreader(encoding)(sys.stdin)
                 import optparse
                 parser = optparse.OptionParser(usage='usage: %prog [options]')
                 parser.add_option("-i", "--input", dest="expr", type="string",
                                   help="input $math$ expression to test")
                 parser.add_option("-o", "--output", dest="expect", type="string",
                                   help="output result you expect")
                 opts, args = parser.parse_args()
                 if opts.expr:
                     expression = unicode(opts.expr, encoding)
                     if opts.expect:
                         expected = unicode(opts.expect, encoding)
                         test_expr(expression, expected)
                     else:
                         print replace_dollar(expression)
                 else:
                     if opts.expect:
                         parser.print_help()
                         parser.error("output option requires input expression")
                     else:
                         test_dollar()

nbconvert.py

0 +2 -1

             #!/usr/bin/env python
             """Convert IPython notebooks to other formats, such as ReST, and HTML.
             Example:
               ./nbconvert.py --format rst file.ipynb
             Produces 'file.rst', along with auto-generated figure files
             called nb_figure_NN.png.
             """
             #-----------------------------------------------------------------------------
             # Imports
             #-----------------------------------------------------------------------------
             from __future__ import print_function
             # From IPython
             from IPython.external import argparse
             # local
             from converters.html import ConverterHTML
             from converters.markdown import ConverterMarkdown
             from converters.bloggerhtml import ConverterBloggerHTML
             from converters.rst import ConverterRST
             from converters.latex import ConverterLaTeX
             from converters.python import ConverterPy
             # When adding a new format, make sure to add it to the `converters`
             # dictionary below. This is used to create the list of known formats,
             # which gets printed in case an unknown format is encounteres, as well
             # as in the help
             converters = {
                 'rst': ConverterRST,
                 'markdown': ConverterMarkdown,
                 'html': ConverterHTML,
                 'blogger-html': ConverterBloggerHTML,
                 'latex': ConverterLaTeX,
                 'py': ConverterPy,
                 }
             default_format = 'rst'
             # Extract the list of known formats and mark the first format as the default.
             known_formats = ', '.join([key + " (default)" if key == default_format else key
                                        for key in converters])
             def main(infile, format='rst'):
                 """Convert a notebook to html in one step"""
                 try:
                     ConverterClass = converters[format]
                 except KeyError:
                     raise SystemExit("Unknown format '%s', " % format +
                             "known formats are: " + known_formats)
                 converter = ConverterClass(infile)
                 converter.render()
             #-----------------------------------------------------------------------------
             # Script main
             #-----------------------------------------------------------------------------
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser(description=__doc__,
                         formatter_class=argparse.RawTextHelpFormatter)
                 # TODO: consider passing file like object around, rather than filenames
                 # would allow us to process stdin, or even http streams
-                #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)
+                #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
+                #                    default=sys.stdin)
                 #Require a filename as a positional argument
                 parser.add_argument('infile', nargs=1)
                 parser.add_argument('-f', '--format', default='rst',
                                     help='Output format. Supported formats: \n' +
                                     known_formats)
                 args = parser.parse_args()
                 main(infile=args.infile[0], format=args.format)

rst2ipynblib/__init__.py

0 0 -1

             """
             Simple ipython notebook document tree Writer.
             """
             __docformat__ = 'reStructuredText'
             import sys
             import os
             import os.path
             import time
             import re
             import urllib
             import docutils
             from docutils import frontend, nodes, utils, writers, languages, io
             from docutils.error_reporting import SafeString
             from docutils.transforms import writer_aux
             from docutils.math import unichar2tex, pick_math_environment
             from docutils.math.latex2mathml import parse_latex_math
             from docutils.math.math2html import math2html
             from IPython.nbformat import current as nbformat
             class Writer(writers.Writer):
                 supported = ('ipynb')
                 """Formats this writer supports."""
                 visitor_attributes = ()
                 def get_transforms(self):
                     return writers.Writer.get_transforms(self) + [writer_aux.Admonitions]
                 def __init__(self):
                     writers.Writer.__init__(self)
                     self.translator_class = IPYNBTranslator
                 def translate(self):
                     self.visitor = visitor = self.translator_class(self.document)
                     self.document.walkabout(visitor)
                     for attr in self.visitor_attributes:
                         setattr(self, attr, getattr(visitor, attr))
                     self.output = '{0}'.format(nbformat.writes(visitor.nb, 'ipynb'))
             class IPYNBTranslator(nodes.GenericNodeVisitor):
                 """
                 """
                 def __init__(self, document):
                     nodes.NodeVisitor.__init__(self, document)
                     self.settings = settings = document.settings
                     lcode = settings.language_code
                     self.language = languages.get_language(lcode, document.reporter)
                     # A heterogenous stack used in conjunction with the tree traversal.
                     # Make sure that the pops correspond to the pushes:
                     self.context = []
                     self.body = []
                     self.section_level = 0
                     ws = nbformat.new_worksheet()
                     self.nb = nbformat.new_notebook(worksheets=[ws])
                 def astext(self):
                     return '{0}'.format(nbformat.writes(self.nb, 'ipynb'))
                 def is_ref_error_paragraph(self, p):
                     return p == "Unknown interpreted text role \"ref\"."
                 def add_cell(self, cell):
                     self.nb.worksheets[0].cells.append(cell)
                 def visit_literal_block(self, node):
                     raw_text = node.astext()
                     #only include lines that begin with >>>
                     #we want the example code and not the example output
                     processed_text = '\n'.join([line.split('>>>')[1][1:]
                                                 for line in raw_text.split('\n')
                                                 if line.startswith('>>>')])
                     c = nbformat.new_code_cell(input=processed_text)
                     self.add_cell(c)
                 def visit_paragraph(self, node):
                     text = node.astext()
                     # For every ref directive a paragraph contains
                     # docutils will generate a paragraph complaining
                     # "Unknown interpreted text role \"ref\"."
                     # this is because ref is a sphinx directive
                     # that does not exist in docutils
                     # looking for a better way to handle this
                     # for now filtering such pargraphs from the output
                     if not self.is_ref_error_paragraph(text):
                         p = nbformat.new_text_cell('markdown', source=text)
                         self.add_cell(p)
                 def visit_section(self, node):
                     self.section_level += 1
                     self.default_visit(node)
                 def depart_section(self, node):
                     self.section_level -= 1
                     self.default_departure(node)
                 def visit_title(self, node):
                     #make sure we have a valid heading level between 1 and 6
                     heading_level = min(self.section_level, 5) + 1
                     h = nbformat.new_heading_cell(source=node.astext(),
                                                   level=heading_level)
                     self.add_cell(h)
                 def default_visit(self, node):
                     node_class = node.__class__.__name__
                     #print '*default_visit', node_class
                     #if node_class in ['reference','paragraph','literal_block','title']:
                     if node_class in []:
                         print '*default_visit', node_class
                         print node.astext()
                 def default_departure(self, node):
                     #print '*default depart', node.__class__.__name__
                     pass

tests/test_nbconverter.py

0 0 -2

             from nbconvert import ConverterNotebook
             import nose.tools as nt
             import os
             import json
             import shutil
             import tempfile
             # name = os.path.join(os.path.dirname(os.path.abspath(__file__), test.ipynb')
             outbase1 = 'newtest1'
             outbase2 = 'test'  # will output to ./test.ipynb
             def test_roundtrip():
                 directory = tempfile.mkdtemp()
                 out1 = os.path.join(directory, outbase1)
                 out2 = os.path.join(directory, outbase2)
                 fname = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                      'test.ipynb')
                 converter = ConverterNotebook(fname, out1)
                 converter.render()
                 converter2 = ConverterNotebook(out1 + '.ipynb', out2)
                 converter2.render()
                 with open(out1 + '.ipynb', 'rb') as f:
                     s1 = f.read()
                 with open(out2 + '.ipynb', 'rb') as f:
                     s2 = f.read()
                 nt.assert_true(s1.replace(outbase1, outbase2) == s2)
                 shutil.rmtree(directory)
                 s0 = json.dumps(json.load(file(fname)), indent=1, sort_keys=True)
                 nt.assert_true(s0 == s2)

tests/test_references.py

0 +3 -3

             import io
             import nose.tools as nt
-            from nbconvert import (
+            from nose.tools import nottest
+            from converts import (
                 ConverterLaTeX, ConverterMarkdown, ConverterPy, ConverterHTML
             )
-            from nose.tools import nottest
             def test_evens():
                 ######
                 # for now, we don't need to really run inkscape to extract svg
                 # from file, on unix, for test, we monkeypathc it to 'true'
                 # which does not fail as doing anything.
                 ####
                 ConverterLaTeX.inkscape = 'true'
                 # commenting rst for now as travis build
                 # fail because of pandoc version.
                 converters = [
-                             #(ConverterRST,'rst'),
+                             #(ConverterRST, 'rst'),
                               (ConverterMarkdown, 'md'),
                               (ConverterLaTeX, 'tex'),
                               (ConverterPy, 'py'),
                               (ConverterHTML, 'html')
                             ]
                 reflist = [
                         'tests/ipynbref/IntroNumPy.orig'
                         ]
                 for root in reflist:
                     for conv, ext in converters:
                         yield test_conversion, conv, root + '.ipynb', root + '.' + ext
             @nottest
             def compfiles(stra, strb):
                 nt.assert_equal(map(unicode.strip, stra.split('\n')),
                                 map(unicode.strip, strb.split('\n')))
             @nottest
             def test_conversion(ConverterClass, ipynb, ref_file):
                 converter = ConverterClass(ipynb)
                 converter.read()
                 cv = converter.convert()
                 with io.open(ref_file) as ref:
                     value = ref.read()
                     compfiles(cv, value)

tests/test_simple.py

0 +1 -1

             from nbconvert import ConverterRST, main
             import nose.tools as nt
             import os
             import glob
             from IPython.nbformat import current as nbformat
             fname = 'tests/test.ipynb'
             out_fname = 'tests/test.rst'
             def clean_dir():
                 "Remove .rst files created during conversion"
                 map(os.remove, glob.glob("./tests/*.rst"))
                 map(os.remove, glob.glob("./tests/*.png"))
                 map(os.remove, glob.glob("./tests/*.html"))
                 map(os.remove, glob.glob("./tests/test_files/*"))
             @nt.with_setup(clean_dir, clean_dir)
             def test_simple():
                 c = ConverterRST(fname)
                 f = c.render()
                 nt.assert_true(f.endswith('.rst'), 'changed file extension to rst')
             @nt.with_setup(clean_dir, clean_dir)
             def test_main():
                 """
                 Test main entry point
                 """
                 main(fname)
                 nt.assert_true(os.path.exists(out_fname))
             def test_render_heading():
                 """ Unit test for cell type "heading" """
                 # Generate and test heading cells level 1-6
                 for level in xrange(1, 7):
                     cell = {
                         'cell_type': 'heading',
                         'level': level,
-                        'source':  ['Test for heading type H{0}'.format(level)]
+                        'source': ['Test for heading type H{0}'.format(level)]
                         }
                     # Convert cell dictionaries to NotebookNode
                     cell_nb = nbformat.NotebookNode(cell)
                     # Make sure "source" attribute is uniconde not list.
                     # For some reason, creating a NotebookNode manually like
                     # this isn't converting source to a string like using
                     # the create-from-file routine.
                     if type(cell_nb.source) is list:
                         cell_nb.source = '\n'.join(cell_nb.source)
                     # Render to rst
                     c = ConverterRST('')
                     rst_list = c.render_heading(cell_nb)
                     # render should return a list
                     nt.assert_true(isinstance(rst_list, list))
                     rst_str = "".join(rst_list)
                     # Confirm rst content
                     chk_str = "Test for heading type H{0}\n{1}\n".format(
                          level, c.heading_level[level] * 24)
                     nt.assert_equal(rst_str, chk_str)
             @nt.with_setup(clean_dir, clean_dir)
             def test_main_html():
                 """
                 Test main entry point
                 """
                 main(fname, format='html')
                 nt.assert_true(os.path.exists('tests/test.html'))

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages