Condense raw_mimetype and mime_type traitlets into output_mimetype

IPython/html/nbconvert/handlers.py

@@ -1,83 +1,85
 import os
 
 from tornado import web
 
 from ..base.handlers import IPythonHandler
 from IPython.nbformat.current import to_notebook_json
 from IPython.nbconvert.exporters.export import exporter_map
 from IPython.utils import tz
 
 
 def has_resource_files(resources):
     output_files_dir = resources.get('output_files_dir', "")
     return bool(os.path.isdir(output_files_dir) and \
                     os.listdir(output_files_dir))
 
 class NbconvertFileHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET',)
     
     @web.authenticated
     def get(self, format, path='', name=None):
         exporter = exporter_map[format]()
         
         path = path.strip('/')
         os_path = self.notebook_manager.get_os_path(name, path)
         if not os.path.isfile(os_path):
             raise web.HTTPError(404, u'Notebook does not exist: %s' % name)
 
         info = os.stat(os_path)
         self.set_header('Last-Modified', tz.utcfromtimestamp(info.st_mtime))
 
         # Force download if requested
         if self.get_argument('download', 'false').lower() == 'true':
             filename = os.path.splitext(name)[0] + '.' + exporter.file_extension
             self.set_header('Content-Disposition',
                             'attachment; filename="%s"' % filename)
         
         # MIME type
-        if exporter.mime_type:
-            self.set_header('Content-Type', '%s; charset=utf-8' % exporter.mime_type)
+        if exporter.output_mimetype:
+            self.set_header('Content-Type',
+                            '%s; charset=utf-8' % exporter.output_mimetype)
 
         output, resources = exporter.from_filename(os_path)
         
         # TODO: If there are resources, combine them into a zip file
         assert not has_resource_files(resources)
         
         self.finish(output)
 
 class NbconvertPostHandler(IPythonHandler):
     SUPPORTED_METHODS = ('POST',)
 
     @web.authenticated 
     def post(self, format):
         exporter = exporter_map[format]()
         
         model = self.get_json_body()
         nbnode = to_notebook_json(model['content'])
         
         # MIME type
-        if exporter.mime_type:
-            self.set_header('Content-Type', '%s; charset=utf-8' % exporter.mime_type)
+        if exporter.output_mimetype:
+            self.set_header('Content-Type',
+            '%s; charset=utf-8' % exporter.output_mimetype)
 
         output, resources = exporter.from_notebook_node(nbnode)
 
         # TODO: If there are resources, combine them into a zip file
         assert not has_resource_files(resources)
         
         self.finish(output)
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _format_regex = r"(?P<format>\w+)"
 _path_regex = r"(?P<path>(?:/.*)*)"
 _notebook_name_regex = r"(?P<name>[^/]+\.ipynb)"
 _notebook_path_regex = "%s/%s" % (_path_regex, _notebook_name_regex)
 
 default_handlers = [
     (r"/nbconvert/%s%s" % (_format_regex, _notebook_path_regex),
          NbconvertFileHandler),
     (r"/nbconvert/%s" % _format_regex, NbconvertPostHandler),
 ]
  No newline at end of file

IPython/html/static/notebook/js/celltoolbarpresets/rawcell.js

@@ -1,90 +1,90
 //----------------------------------------------------------------------------
 //  Copyright (C) 2012  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // CellToolbar Example
 //============================================================================
 
 (function(IPython) {
   "use strict";
 
   var CellToolbar = IPython.CellToolbar;
   var raw_cell_preset = [];
   var utils = IPython.utils;
 
   var select_type = CellToolbar.utils.select_ui_generator([
     ["None", "-"],
     ["LaTeX", "text/latex"],
     ["reST", "text/restructuredtext"],
     ["HTML", "text/html"],
     ["Markdown", "text/markdown"],
-    ["Python", "application/x-python"],
+    ["Python", "text/x-python"],
     ["Custom", "dialog"],
 
     ],
       // setter
       function(cell, value) {
         if (value === "-") {
           delete cell.metadata.raw_mimetype;
         } else if (value === 'dialog'){
             var dialog = $('<div/>').append(
                 $("<p/>")
                     .html("Set the MIME type of the raw cell:")
             ).append(
                 $("<br/>")
             ).append(
                 $('<input/>').attr('type','text').attr('size','25')
                 .val(cell.metadata.raw_mimetype || "-")
             );
             IPython.dialog.modal({
                 title: "Raw Cell MIME Type",
                 body: dialog,
                 buttons : {
                     "Cancel": {},
                     "OK": {
                         class: "btn-primary",
                         click: function () {
                             console.log(cell);
                             cell.metadata.raw_mimetype = $(this).find('input').val();
                             console.log(cell.metadata);
                         }
                     }
                 },
                 open : function (event, ui) {
                     var that = $(this);
                     // Upon ENTER, click the OK button.
                     that.find('input[type="text"]').keydown(function (event, ui) {
                         if (event.which === utils.keycodes.ENTER) {
                             that.find('.btn-primary').first().click();
                             return false;
                         }
                     });
                     that.find('input[type="text"]').focus().select();
                 }
             });
         } else {
           cell.metadata.raw_mimetype = value;
         }
       },
       //getter
       function(cell) {
         return cell.metadata.raw_mimetype || "";
       },
       // name
       "Raw NBConvert Format",
       // cell_types
       ["raw"]
   );
 
   CellToolbar.register_callback('raw_cell.select', select_type);
 
   raw_cell_preset.push('raw_cell.select');
 
   CellToolbar.register_preset('Raw Cell Format', raw_cell_preset);
   console.log('Raw Cell Format toolbar preset loaded.');
 
-}(IPython));
  No newline at end of file
+}(IPython));

IPython/nbconvert/exporters/exporter.py

@@ -1,274 +1,274
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
 import copy
 import collections
 import datetime
 
 
 # IPython imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class Exporter(LoggingConfigurable):
     """
     Class containing methods that sequentially run a list of preprocessors on a 
     NotebookNode object and then return the modified NotebookNode object and 
     accompanying resources dict.
     """
 
     file_extension = Unicode(
         'txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
-    mime_type = Unicode('', config=True,
+    output_mimetype = Unicode('', config=True,
         help="MIME type of the result file, for HTTP response headers."
         )
 
     #Configurability, allows the user to easily add filters and preprocessors.
     preprocessors = List(config=True,
         help="""List of preprocessors, by name or namespace, to enable.""")
 
     _preprocessors = None
 
     default_preprocessors = List(['IPython.nbconvert.preprocessors.coalesce_streams',
                                   'IPython.nbconvert.preprocessors.SVG2PDFPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExtractOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
                                   'IPython.nbconvert.preprocessors.RevealHelpPreprocessor',
                                   'IPython.nbconvert.preprocessors.LatexPreprocessor',
                                   'IPython.nbconvert.preprocessors.HighlightMagicsPreprocessor'],
         config=True,
         help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
 
         Parameters
         ----------
         config : config
             User configuration instance.
         """
         with_default_config = self.default_config
         if config:
             with_default_config.merge(config)
         
         super(Exporter, self).__init__(config=with_default_config, **kw)
 
         self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     @nbformat.docstring_nbformat_mod
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : :class:`~{nbformat_mod}.nbbase.NotebookNode`
           Notebook node
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         **kw
           Ignored (?)
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
 
         # Preprocess
         nb_copy, resources = self._preprocess(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         # Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename, encoding='utf-8') as f:
             return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
     def register_preprocessor(self, preprocessor, enabled=False):
         """
         Register a preprocessor.
         Preprocessors are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
 
         Parameters
         ----------
         preprocessor : preprocessor
         """
         if preprocessor is None:
             raise TypeError('preprocessor')
         isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
         # Handle preprocessor's registration based on it's type
         if constructed and isinstance(preprocessor, py3compat.string_types):
             # Preprocessor is a string, import the namespace and recursively call
             # this register_preprocessor method
             preprocessor_cls = import_item(preprocessor)
             return self.register_preprocessor(preprocessor_cls, enabled)
 
         if constructed and hasattr(preprocessor, '__call__'):
             # Preprocessor is a function, no need to construct it.
             # Register and return the preprocessor.
             if enabled:
                 preprocessor.enabled = True
             self._preprocessors.append(preprocessor)
             return preprocessor
 
         elif isclass and isinstance(preprocessor, MetaHasTraits):
             # Preprocessor is configurable.  Make sure to pass in new default for 
             # the enabled flag if one was specified.
             self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
             # Preprocessor is not configurable, construct it
             self.register_preprocessor(preprocessor(), enabled)
 
         else:
             # Preprocessor is an instance of something without a __call__ 
             # attribute.  
             raise TypeError('preprocessor')
 
 
     def _init_preprocessors(self):
         """
         Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
         if self._preprocessors is None:
             self._preprocessors = []
 
         #Load default preprocessors (not necessarly enabled by default).
         if self.default_preprocessors:
             for preprocessor in self.default_preprocessors:
                 self.register_preprocessor(preprocessor)
 
         #Load user preprocessors.  Enable by default.
         if self.preprocessors:
             for preprocessor in self.preprocessors:
                 self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the
 
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
         # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
         #Run each preprocessor on the notebook.  Carry the output along
         #to each preprocessor
         for preprocessor in self._preprocessors:
             nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/html.py

@@ -1,60 +1,60
 """HTML Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 IPython.utils.traitlets import Unicode, List
 
 from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class HTMLExporter(TemplateExporter):
     """
     Exports a basic HTML document.  This exporter assists with the export of
     HTML.  Inherit from it if you are writing your own HTML template and need
     custom preprocessors/filters.  If you don't need custom preprocessors/
     filters, just change the 'template_file' config option.  
     """
     
     file_extension = Unicode(
         'html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     mime_type = Unicode('text/html', config=True,
         help="MIME type of the result file, for HTTP response headers."
         )
 
     default_template = Unicode('full', config=True, help="""Flavor of the data 
         format to use.  I.E. 'full' or 'basic'""")
     
-    def _raw_mimetype_default(self):
+    def _output_mimetype_default(self):
         return 'text/html'
     
     @property
     def default_config(self):
         c = Config({
             'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 },
             'HighlightMagicsPreprocessor': {
                 'enabled':True
                 }
             })
         c.merge(super(HTMLExporter,self).default_config)
         return c

IPython/nbconvert/exporters/latex.py

@@ -1,97 +1,93
 """LaTeX Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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
 
 # IPython imports
 from IPython.utils.traitlets import Unicode, List
 from IPython.config import Config
 
 from IPython.nbconvert import filters, preprocessors
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class LatexExporter(TemplateExporter):
     """
     Exports to a Latex template.  Inherit from this class if your template is
     LaTeX based and you need custom tranformers/filters.  Inherit from it if 
     you are writing your own HTML template and need custom tranformers/filters.  
     If you don't need custom tranformers/filters, just change the 
     'template_file' config option.  Place your template in the special "/latex" 
     subfolder of the "../templates" folder.
     """
     
     file_extension = Unicode(
         'tex', config=True, 
         help="Extension of the file that should be written to disk")
 
-    mime_type = Unicode('application/x-tex', config=True,
-        help="MIME type of the result file, for HTTP response headers."
-        )
-
     default_template = Unicode('article', config=True, help="""Template of the 
         data format to use.  I.E. 'article' or 'report'""")
 
     #Latex constants
     default_template_path = Unicode(
         os.path.join("..", "templates", "latex"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "latex", "skeleton"), config=True,
         help="Path where the template skeleton files are located.") 
 
     #Special Jinja2 syntax that will not conflict when exporting latex.
     jinja_comment_block_start = Unicode("((=", config=True)
     jinja_comment_block_end = Unicode("=))", config=True)
     jinja_variable_block_start = Unicode("(((", config=True)
     jinja_variable_block_end = Unicode(")))", config=True)
     jinja_logic_block_start = Unicode("((*", config=True)
     jinja_logic_block_end = Unicode("*))", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tplx", config=True)
 
-    def _raw_mimetype_default(self):
+    def _output_mimetype_default(self):
         return 'text/latex'
 
 
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['latex', 'pdf', 'png', 'jpg', 'svg', 'jpeg', 'text']
                 },
              'ExtractOutputPreprocessor': {
                     'enabled':True
                  },
              'SVG2PDFPreprocessor': {
                     'enabled':True
                  },
              'LatexPreprocessor': {
                     'enabled':True
                  },
              'SphinxPreprocessor': {
                     'enabled':True
                  },
              'HighlightMagicsPreprocessor': {
                     'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c

IPython/nbconvert/exporters/markdown.py

@@ -1,47 +1,43
 """Markdown Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 IPython.config import Config
 from IPython.utils.traitlets import Unicode
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class MarkdownExporter(TemplateExporter):
     """
     Exports to a markdown document (.md)
     """
     
     file_extension = Unicode(
         'md', config=True, 
         help="Extension of the file that should be written to disk")
 
-    def _raw_mimetype_default(self):
+    def _output_mimetype_default(self):
         return 'text/markdown'
     
     def _raw_mimetypes_default(self):
-        return ['text/markdown', 'text/html']
-
-    mime_type = Unicode('text/x-markdown', config=True,
-        help="MIME type of the result file, for HTTP response headers."
-        )
+        return ['text/markdown', 'text/html', '']
 
     @property
     def default_config(self):
         c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(MarkdownExporter,self).default_config)
         return c

IPython/nbconvert/exporters/python.py

@@ -1,37 +1,33
 """Python script Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 IPython.utils.traitlets import Unicode
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class PythonExporter(TemplateExporter):
     """
     Exports a Python code file.
     """
     
     file_extension = Unicode(
         'py', config=True, 
         help="Extension of the file that should be written to disk")
 
-    def _raw_mimetype_default(self):
-        return 'application/x-python'
-
-    mime_type = Unicode('text/x-python', config=True,
-        help="MIME type of the result file, for HTTP response headers."
-        )
+    def _output_mimetype_default(self):
+        return 'text/x-python'

IPython/nbconvert/exporters/rst.py

@@ -1,44 +1,40
 """restructuredText Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 IPython.utils.traitlets import Unicode
 from IPython.config import Config
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class RSTExporter(TemplateExporter):
     """
     Exports restructured text documents.
     """
     
     file_extension = Unicode(
         'rst', config=True, 
         help="Extension of the file that should be written to disk")
 
-    def _raw_mimetype_default(self):
+    def _output_mimetype_default(self):
         return 'text/restructuredtext'
 
-    mime_type = Unicode('text/x-rst', config=True,
-        help="MIME type of the result file, for HTTP response headers."
-        )
-
     @property
     def default_config(self):
         c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(RSTExporter,self).default_config)
         return c

IPython/nbconvert/exporters/slides.py

@@ -1,49 +1,48
 """HTML slide show Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 IPython.utils.traitlets import Unicode
 
 from IPython.nbconvert import preprocessors
 from IPython.config import Config
 
 from .html import HTMLExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SlidesExporter(HTMLExporter):
     """Exports HTML slides with reveal.js"""
     
     file_extension = Unicode(
         'slides.html', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
-    mime_type = Unicode('text/html', config=True,
-        help="MIME type of the result file, for HTTP response headers."
-        )
+    def _output_mimetype_default(self):
+        return 'text/html'
 
     default_template = Unicode('reveal', config=True, help="""Template of the 
         data format to use.  I.E. 'reveal'""")
 
     @property
     def default_config(self):
         c = Config({
             'RevealHelpPreprocessor': {
                 'enabled': True,
                 },
             })
         c.merge(super(SlidesExporter,self).default_config)
         return c

IPython/nbconvert/exporters/templateexporter.py

@@ -1,324 +1,324
 """This module defines TemplateExporter, a highly configurable converter
 that uses Jinja2 to export notebook files into different formats.
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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 os
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader, TemplateNotFound
 
 # IPython imports
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Dict, Any
 from IPython.utils.importstring import import_item
 from IPython.utils import py3compat, text
 
 from IPython.nbformat.current import docstring_nbformat_mod
 from IPython.nbconvert import filters
 from .exporter import Exporter
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 default_filters = {
         'indent': text.indent,
         'markdown2html': filters.markdown2html,
         'ansi2html': filters.ansi2html,
         'filter_data_type': filters.DataTypeFilter,
         'get_lines': filters.get_lines,
         'highlight2html': filters.Highlight2Html,
         'highlight2latex': filters.Highlight2Latex,
         'ipython2python': filters.ipython2python,
         'posix_path': filters.posix_path,
         'markdown2latex': filters.markdown2latex,
         'markdown2rst': filters.markdown2rst,
         'comment_lines': filters.comment_lines,
         'strip_ansi': filters.strip_ansi,
         'strip_dollars': filters.strip_dollars,
         'strip_files_prefix': filters.strip_files_prefix,
         'html2text' : filters.html2text,
         'add_anchor': filters.add_anchor,
         'ansi2latex': filters.ansi2latex,
         'wrap_text': filters.wrap_text,
         'escape_latex': filters.escape_latex,
         'citation2latex': filters.citation2latex,
         'path2url': filters.path2url,
         'add_prompts': filters.add_prompts,
 }
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TemplateExporter(Exporter):
     """
     Exports notebooks into other file formats.  Uses Jinja 2 templating engine
     to output new formats.  Inherit from this class if you are creating a new
     template type along with new filters/preprocessors.  If the filters/
     preprocessors provided by default suffice, there is no need to inherit from
     this class.  Instead, override the template_file and file_extension
     traits via a config file.
 
     {filters}
     """
     
     # finish the docstring
     __doc__ = __doc__.format(filters = '- '+'\n    - '.join(default_filters.keys()))
 
 
     template_file = Unicode(u'default',
             config=True,
             help="Name of the template file to use")
     def _template_file_changed(self, name, old, new):
         if new == 'default':
             self.template_file = self.default_template
         else:
             self.template_file = new
         self.template = None
         self._load_template()
     
     default_template = Unicode(u'')
     template = Any()
     environment = Any()
 
     template_path = List(['.'], config=True)
     def _template_path_changed(self, name, old, new):
         self._load_template()
 
     default_template_path = Unicode(
         os.path.join("..", "templates"), 
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "templates", "skeleton"), 
         help="Path where the template skeleton files are located.") 
 
     #Jinja block definitions
     jinja_comment_block_start = Unicode("", config=True)
     jinja_comment_block_end = Unicode("", config=True)
     jinja_variable_block_start = Unicode("", config=True)
     jinja_variable_block_end = Unicode("", config=True)
     jinja_logic_block_start = Unicode("", config=True)
     jinja_logic_block_end = Unicode("", config=True)
     
     #Extension that the template files use.    
     template_extension = Unicode(".tpl", config=True)
 
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
 
-    raw_mimetype = Unicode('')
+    output_mimetype = Unicode('')
+
     raw_mimetypes = List(config=True,
         help="""formats of raw cells to be included in this Exporter's output."""
     )
     def _raw_mimetypes_default(self):
-        return [self.raw_mimetype]
+        return [self.output_mimetype, '']
 
 
     def __init__(self, config=None, extra_loaders=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
         config : config
             User configuration instance.
         extra_loaders : list[of Jinja Loaders]
             ordered list of Jinja loader to find templates. Will be tried in order
             before the default FileSystem ones.
         template : str (optional, kw arg)
             Template to use when exporting.
         """
         super(TemplateExporter, self).__init__(config=config, **kw)
 
         #Init
         self._init_template()
         self._init_environment(extra_loaders=extra_loaders)
         self._init_preprocessors()
         self._init_filters()
 
 
     def _load_template(self):
         """Load the Jinja template object from the template file
         
         This is a no-op if the template attribute is already defined,
         or the Jinja environment is not setup yet.
         
         This is triggered by various trait changes that would change the template.
         """
         if self.template is not None:
             return
         # called too early, do nothing
         if self.environment is None:
             return
         # Try different template names during conversion.  First try to load the
         # template by name with extension added, then try loading the template
         # as if the name is explicitly specified, then try the name as a 
         # 'flavor', and lastly just try to load the template by module name.
         module_name = self.__module__.rsplit('.', 1)[-1]
         try_names = []
         if self.template_file:
             try_names.extend([
                 self.template_file + self.template_extension,
                 self.template_file,
                 module_name + '_' + self.template_file + self.template_extension,
             ])
         try_names.append(module_name + self.template_extension)
         for try_name in try_names:
             self.log.debug("Attempting to load template %s", try_name)
             try:
                 self.template = self.environment.get_template(try_name)
             except (TemplateNotFound, IOError):
                 pass
             except Exception as e:
                 self.log.warn("Unexpected exception loading template: %s", try_name, exc_info=True)
             else:
                 self.log.info("Loaded template %s", try_name)
                 break
 
     @docstring_nbformat_mod
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : :class:`~{nbformat_mod}.nbbase.NotebookNode`
           Notebook node
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         """
         nb_copy, resources = super(TemplateExporter, self).from_notebook_node(nb, resources, **kw)
-        resources.setdefault('raw_mimetype', self.raw_mimetype)
         resources.setdefault('raw_mimetypes', self.raw_mimetypes)
 
         self._load_template()
 
         if self.template is not None:
             output = self.template.render(nb=nb_copy, resources=resources)
         else:
             raise IOError('template file "%s" could not be found' % self.template_file)
         return output, resources
 
 
     def register_filter(self, name, jinja_filter):
         """
         Register a filter.
         A filter is a function that accepts and acts on one string.  
         The filters are accesible within the Jinja templating engine.
     
         Parameters
         ----------
         name : str
             name to give the filter in the Jinja engine
         filter : filter
         """
         if jinja_filter is None:
             raise TypeError('filter')
         isclass = isinstance(jinja_filter, type)
         constructed = not isclass
 
         #Handle filter's registration based on it's type
         if constructed and isinstance(jinja_filter, py3compat.string_types):
             #filter is a string, import the namespace and recursively call
             #this register_filter method
             filter_cls = import_item(jinja_filter)
             return self.register_filter(name, filter_cls)
         
         if constructed and hasattr(jinja_filter, '__call__'):
             #filter is a function, no need to construct it.
             self.environment.filters[name] = jinja_filter
             return jinja_filter
 
         elif isclass and isinstance(jinja_filter, MetaHasTraits):
             #filter is configurable.  Make sure to pass in new default for 
             #the enabled flag if one was specified.
             filter_instance = jinja_filter(parent=self)
             self.register_filter(name, filter_instance )
 
         elif isclass:
             #filter is not configurable, construct it
             filter_instance = jinja_filter()
             self.register_filter(name, filter_instance)
 
         else:
             #filter is an instance of something without a __call__ 
             #attribute.  
             raise TypeError('filter')
 
         
     def _init_template(self):
         """
         Make sure a template name is specified.  If one isn't specified, try to
         build one from the information we know.
         """
         self._template_file_changed('template_file', self.template_file, self.template_file)
         
 
     def _init_environment(self, extra_loaders=None):
         """
         Create the Jinja templating environment.
         """
         here = os.path.dirname(os.path.realpath(__file__))
         loaders = []
         if extra_loaders:
             loaders.extend(extra_loaders)
 
         paths = self.template_path
         paths.extend([os.path.join(here, self.default_template_path),
                       os.path.join(here, self.template_skeleton_path)])
         loaders.append(FileSystemLoader(paths))
 
         self.environment = Environment(
             loader= ChoiceLoader(loaders),
             extensions=JINJA_EXTENSIONS
             )
         
         #Set special Jinja2 syntax that will not conflict with latex.
         if self.jinja_logic_block_start:
             self.environment.block_start_string = self.jinja_logic_block_start
         if self.jinja_logic_block_end:
             self.environment.block_end_string = self.jinja_logic_block_end
         if self.jinja_variable_block_start:
             self.environment.variable_start_string = self.jinja_variable_block_start
         if self.jinja_variable_block_end:
             self.environment.variable_end_string = self.jinja_variable_block_end
         if self.jinja_comment_block_start:
             self.environment.comment_start_string = self.jinja_comment_block_start
         if self.jinja_comment_block_end:
             self.environment.comment_end_string = self.jinja_comment_block_end
 
     
     def _init_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Add default filters to the Jinja2 environment
         for key, value in default_filters.items():
             self.register_filter(key, value)
 
         #Load user filters.  Overwrite existing filters if need be.
         if self.filters:
             for key, user_filter in self.filters.items():
                 self.register_filter(key, user_filter)

IPython/nbconvert/exporters/tests/base.py

@@ -1,54 +1,54
 """Base TestCase class for testing Exporters"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, 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
 #-----------------------------------------------------------------------------
 
 import os
 
 from IPython.testing.decorators import onlyif_cmds_exist
 
 from ...tests.base import TestsBase
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 all_raw_mimetypes = {
-    'application/x-python',
+    'text/x-python',
     'text/markdown',
     'text/html',
     'text/restructuredtext',
     'text/latex',
 }
 
 class ExportersTestsBase(TestsBase):
     """Contains base test functions for exporters"""
     
     exporter_class = None
     should_include_raw = None
     
     def _get_notebook(self, nb_name='notebook2.ipynb'):
         return os.path.join(self._get_files_path(), nb_name)
     
     @onlyif_cmds_exist('pandoc')
     def test_raw_cell_inclusion(self):
         """test raw cell inclusion based on raw_mimetype metadata"""
         if self.should_include_raw is None:
             return
         exporter = self.exporter_class()
         (output, resources) = exporter.from_filename(self._get_notebook('rawtest.ipynb'))
         for inc in self.should_include_raw:
             self.assertIn('raw %s' % inc, output, "should include %s" % inc)
         self.assertIn('no raw_mimetype metadata', output)
         for exc in all_raw_mimetypes.difference(self.should_include_raw):
             self.assertNotIn('raw %s' % exc, output, "should exclude %s" % exc)
         self.assertNotIn('never be included', output)

IPython/nbconvert/exporters/tests/files/rawtest.ipynb

@@ -1,84 +1,84
 {
  "metadata": {
   "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "raw",
      "metadata": {
       "raw_mimetype": "text/html"
      },
      "source": [
       "<b>raw html</b>"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {
       "raw_mimetype": "text/markdown"
      },
      "source": [
       "* raw markdown\n",
       "* bullet\n",
       "* list"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {
       "raw_mimetype": "text/restructuredtext"
      },
      "source": [
       "``raw rst``\n",
       "\n",
       ".. sourcecode:: python\n",
       "\n",
       "    def foo(): pass\n"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {
-      "raw_mimetype": "application/x-python"
+      "raw_mimetype": "text/x-python"
      },
      "source": [
       "def bar():\n",
       "    \"\"\"raw python\"\"\"\n",
       "    pass"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {
       "raw_mimetype": "text/latex"
      },
      "source": [
       "\\LaTeX\n",
       "% raw latex"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {},
      "source": [
       "# no raw_mimetype metadata, should be included by default"
      ]
     },
     {
      "cell_type": "raw",
      "metadata": {
       "raw_mimetype": "doesnotexist"
      },
      "source": [
       "garbage format defined, should never be included"
      ]
     }
    ],
    "metadata": {}
   }
  ]
-}
  No newline at end of file
+}

IPython/nbconvert/templates/latex/skeleton/null.tplx

@@ -1,98 +1,98
 ((= Auto-generated template file, DO NOT edit directly!
     To edit this file, please refer to ../../skeleton/README.md =))
 
 
 ((=
 
 DO NOT USE THIS AS A BASE,
 IF YOU ARE COPY AND PASTING THIS FILE
 YOU ARE PROBABLY DOING THINGS INCORRECTLY.
 
 Null template, does nothing except defining a basic structure
 To layout the different blocks of a notebook.
 
 Subtemplates can override blocks to define their custom representation.
 
 If one of the block you do overwrite is not a leave block, consider
 calling super.
 
 ((*- block nonLeaveBlock -*))
     #add stuff at beginning
     ((( super() )))
     #add stuff at end
 ((*- endblock nonLeaveBlock -*))
 
 consider calling super even if it is a leave block, we might insert more blocks later.
 
 =))
 ((*- block header -*))
 ((*- endblock header -*))
 ((*- block body -*))
 ((*- for worksheet in nb.worksheets -*))
     ((*- for cell in worksheet.cells -*))
         ((*- block any_cell scoped -*))
             ((*- if cell.cell_type in ['code'] -*))
                 ((*- block codecell scoped -*))
                     ((*- block input_group -*))
                         ((*- block in_prompt -*))((*- endblock in_prompt -*))
                         ((*- block input -*))((*- endblock input -*))
                     ((*- endblock input_group -*))
                     ((*- if cell.outputs -*))
                     ((*- block output_group -*))
                         ((*- block output_prompt -*))((*- endblock output_prompt -*))
                         ((*- block outputs scoped -*))
                             ((*- for output in cell.outputs -*))
                                 ((*- block output scoped -*))
                                     ((*- if output.output_type in ['pyout'] -*))
                                         ((*- block pyout scoped -*))((*- endblock pyout -*))
                                     ((*- elif output.output_type in ['stream'] -*))
                                         ((*- block stream scoped -*))
                                             ((*- if output.stream in ['stdout'] -*))
                                                 ((*- block stream_stdout scoped -*))
                                                 ((*- endblock stream_stdout -*))
                                             ((*- elif output.stream in ['stderr'] -*))
                                                 ((*- block stream_stderr scoped -*))
                                                 ((*- endblock stream_stderr -*))
                                             ((*- endif -*))
                                         ((*- endblock stream -*))
                                     ((*- elif output.output_type in ['display_data'] -*))
                                         ((*- block display_data scoped -*))
                                             ((*- block data_priority scoped -*))
                                             ((*- endblock data_priority -*))
                                         ((*- endblock display_data -*))
                                     ((*- elif output.output_type in ['pyerr'] -*))
                                         ((*- block pyerr scoped -*))
                                         ((*- for line in output.traceback -*))
                                             ((*- block traceback_line scoped -*))((*- endblock traceback_line -*))
                                         ((*- endfor -*))
                                         ((*- endblock pyerr -*))
                                     ((*- endif -*))
                                 ((*- endblock output -*))
                             ((*- endfor -*))
                         ((*- endblock outputs -*))
                     ((*- endblock output_group -*))
                     ((*- endif -*))
                 ((*- endblock codecell -*))
             ((*- elif cell.cell_type in ['markdown'] -*))
                 ((*- block markdowncell scoped-*))
                 ((*- endblock markdowncell -*))
             ((*- elif cell.cell_type in ['heading'] -*))
                 ((*- block headingcell scoped-*))
                 ((*- endblock headingcell -*))
             ((*- elif cell.cell_type in ['raw'] -*))
                 ((*- block rawcell scoped -*))
-                ((* if cell.metadata.get('raw_mimetype', resources.get('raw_mimetype')) == resources.get('raw_mimetype') *))
+                ((* if cell.metadata.get('raw_mimetype', '').lower() in resources.get('raw_mimetypes', ['']) *))
                 ((( cell.source )))
                 ((* endif *))
                 ((*- endblock rawcell -*))
             ((*- else -*))
                 ((*- block unknowncell scoped-*))
                 ((*- endblock unknowncell -*))
             ((*- endif -*))
         ((*- endblock any_cell -*))
     ((*- endfor -*))
 ((*- endfor -*))
 ((*- endblock body -*))
 
 ((*- block footer -*))
 ((*- endblock footer -*))

IPython/nbconvert/templates/skeleton/null.tpl

@@ -1,94 +1,94
 {#
 
 DO NOT USE THIS AS A BASE,
 IF YOU ARE COPY AND PASTING THIS FILE
 YOU ARE PROBABLY DOING THINGS INCORRECTLY.
 
 Null template, does nothing except defining a basic structure
 To layout the different blocks of a notebook.
 
 Subtemplates can override blocks to define their custom representation.
 
 If one of the block you do overwrite is not a leave block, consider
 calling super.
 
 {%- block nonLeaveBlock -%}
     #add stuff at beginning
     {{ super() }}
     #add stuff at end
 {%- endblock nonLeaveBlock -%}
 
 consider calling super even if it is a leave block, we might insert more blocks later.
 
 #}
 {%- block header -%}
 {%- endblock header -%}
 {%- block body -%}
 {%- for worksheet in nb.worksheets -%}
     {%- for cell in worksheet.cells -%}
         {%- block any_cell scoped -%}
             {%- if cell.cell_type in ['code'] -%}
                 {%- block codecell scoped -%}
                     {%- block input_group -%}
                         {%- block in_prompt -%}{%- endblock in_prompt -%}
                         {%- block input -%}{%- endblock input -%}
                     {%- endblock input_group -%}
                     {%- if cell.outputs -%}
                     {%- block output_group -%}
                         {%- block output_prompt -%}{%- endblock output_prompt -%}
                         {%- block outputs scoped -%}
                             {%- for output in cell.outputs -%}
                                 {%- block output scoped -%}
                                     {%- if output.output_type in ['pyout'] -%}
                                         {%- block pyout scoped -%}{%- endblock pyout -%}
                                     {%- elif output.output_type in ['stream'] -%}
                                         {%- block stream scoped -%}
                                             {%- if output.stream in ['stdout'] -%}
                                                 {%- block stream_stdout scoped -%}
                                                 {%- endblock stream_stdout -%}
                                             {%- elif output.stream in ['stderr'] -%}
                                                 {%- block stream_stderr scoped -%}
                                                 {%- endblock stream_stderr -%}
                                             {%- endif -%}
                                         {%- endblock stream -%}
                                     {%- elif output.output_type in ['display_data'] -%}
                                         {%- block display_data scoped -%}
                                             {%- block data_priority scoped -%}
                                             {%- endblock data_priority -%}
                                         {%- endblock display_data -%}
                                     {%- elif output.output_type in ['pyerr'] -%}
                                         {%- block pyerr scoped -%}
                                         {%- for line in output.traceback -%}
                                             {%- block traceback_line scoped -%}{%- endblock traceback_line -%}
                                         {%- endfor -%}
                                         {%- endblock pyerr -%}
                                     {%- endif -%}
                                 {%- endblock output -%}
                             {%- endfor -%}
                         {%- endblock outputs -%}
                     {%- endblock output_group -%}
                     {%- endif -%}
                 {%- endblock codecell -%}
             {%- elif cell.cell_type in ['markdown'] -%}
                 {%- block markdowncell scoped-%}
                 {%- endblock markdowncell -%}
             {%- elif cell.cell_type in ['heading'] -%}
                 {%- block headingcell scoped-%}
                 {%- endblock headingcell -%}
             {%- elif cell.cell_type in ['raw'] -%}
                 {%- block rawcell scoped -%}
-                {% if cell.metadata.get('raw_mimetype', resources.get('raw_mimetype', '')).lower() in resources.get('raw_mimetypes', ['']) %}
+                {% if cell.metadata.get('raw_mimetype', '').lower() in resources.get('raw_mimetypes', ['']) %}
                 {{ cell.source }}
                 {% endif %}
                 {%- endblock rawcell -%}
             {%- else -%}
                 {%- block unknowncell scoped-%}
                 {%- endblock unknowncell -%}
             {%- endif -%}
         {%- endblock any_cell -%}
     {%- endfor -%}
 {%- endfor -%}
 {%- endblock body -%}
 
 {%- block footer -%}
 {%- endblock footer -%}