Fixes for Py3.3

IPython/nbconvert/exporters/exporter.py

@@ -20,7 +20,6 b' from __future__ import print_function, absolute_import'
 import io
 import os
 import inspect
-import types
 import copy
 import collections
 import datetime
@@ -35,6 +34,7 b' from IPython.nbformat import current as nbformat'
 from IPython.utils.traitlets import MetaHasTraits, DottedObjectName, Unicode, List, Dict
 from IPython.utils.importstring import import_item
 from IPython.utils.text import indent
+from IPython.utils import py3compat
 
 from IPython.nbconvert import transformers as nbtransformers
 from IPython.nbconvert import filters
@@ -247,11 +247,11 b' class Exporter(Configurable):'
         """
         if transformer is None:
             raise TypeError('transformer')
-        isclass = inspect.isclass(transformer)
+        isclass = isinstance(transformer, type)
         constructed = not isclass
 
         #Handle transformer's registration based on it's type
-        if constructed and isinstance(transformer, types.StringTypes):
+        if constructed and isinstance(transformer, py3compat.string_types):
             #Transformer is a string, import the namespace and recursively call
             #this register_transformer method
             transformer_cls = import_item(transformer)
@@ -280,7 +280,7 b' class Exporter(Configurable):'
             raise TypeError('transformer')
 
 
-    def register_filter(self, name, filter):
+    def register_filter(self, name, jinja_filter):
         """
         Register a filter.
         A filter is a function that accepts and acts on one string.  
@@ -292,31 +292,33 b' class Exporter(Configurable):'
             name to give the filter in the Jinja engine
         filter : filter
         """
-        if filter is None:
+        if jinja_filter is None:
             raise TypeError('filter')
-        isclass = inspect.isclass(filter)
+        isclass = isinstance(jinja_filter, type)
         constructed = not isclass
 
         #Handle filter's registration based on it's type
-        if constructed and isinstance(filter, types.StringTypes):
+        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(filter)
+            filter_cls = import_item(jinja_filter)
             return self.register_filter(name, filter_cls)
         
-        if constructed and hasattr(filter, '__call__'):
+        if constructed and hasattr(jinja_filter, '__call__'):
             #filter is a function, no need to construct it.
-            self.environment.filters[name] = filter
-            return filter
+            self.environment.filters[name] = jinja_filter
+            return jinja_filter
 
-        elif isclass and isinstance(filter, MetaHasTraits):
+        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.
-            self.register_filter(name, filter(parent=self))
+            filter_instance = jinja_filter(parent=self)
+            self.register_filter(name, filter_instance )
 
         elif isclass:
             #filter is not configurable, construct it
-            self.register_filter(name, filter())
+            filter_instance = jinja_filter()
+            self.register_filter(name, filter_instance)
 
         else:
             #filter is an instance of something without a __call__ 
@@ -382,12 +384,12 b' class Exporter(Configurable):'
         """
         
         #Add default filters to the Jinja2 environment
-        for key, value in default_filters.iteritems():
+        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.iteritems():
+            for key, user_filter in self.filters.items():
                 self.register_filter(key, user_filter)
 
 

IPython/nbconvert/filters/ansi.py

@@ -145,7 +145,7 b' def ansi2latex(text):'
         if openbrack:
             outstring += '}'*openbrack
             openbrack = 0
-        if match.group() <> coloransi.TermColors.Normal and not openbrack:
+        if not (match.group() == coloransi.TermColors.Normal or openbrack):
             texform, openbrack = single_ansi2latex(match.group())
             outstring += texform
         last_end = match.end()

IPython/nbconvert/filters/datatypefilter.py

@@ -23,7 +23,7 b" __all__ = ['DataTypeFilter']"
 
 class DataTypeFilter(NbConvertBase):
     """ Returns the preferred display format """
-
+        
     def __call__(self, output):
         """ Return the first available format in the priority """
 

IPython/nbconvert/filters/strings.py

@@ -19,8 +19,6 b' templates.'
 import re
 import textwrap
 from xml.etree import ElementTree
-from types import StringTypes
-
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
@@ -62,7 +60,7 b' def html_text(element):'
     
     Analog of jQuery's $(element).text()
     """
-    if isinstance(element, StringTypes):
+    if isinstance(element, py3compat.string_types):
         element = ElementTree.fromstring(element)
     
     text = element.text or ""

IPython/nbconvert/tests/base.py

@@ -22,6 +22,7 b' import sys'
 
 import IPython
 from IPython.utils.tempdir import TemporaryDirectory
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Classes and functions
@@ -167,5 +168,11 b' class TestsBase(object):'
 
 
     def call(self, parameters):
-        return subprocess.Popen(parameters, stdout=subprocess.PIPE).communicate()[0]
+        output = subprocess.Popen(parameters, stdout=subprocess.PIPE).communicate()[0]
+        
+        #Convert the output to a string if running Python3
+        if py3compat.PY3:
+            return output.decode('utf-8')
+        else:
+            return output
      
  No newline at end of file

IPython/nbconvert/tests/test_nbconvertapp.py

@@ -16,6 +16,20 b' Contains tests for the nbconvertapp'
 import os
 from .base import TestsBase
 
+from IPython.utils import py3compat
+
+    
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+#Define ipython commandline name
+if py3compat.PY3:
+    IPYTHON = 'ipython3'
+else:
+    IPYTHON = 'ipython'
+
+
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
@@ -29,7 +43,7 b' class TestNbConvertApp(TestsBase):'
         Will help show if no notebooks are specified?
         """
         with self.create_temp_cwd():
-            assert "see '--help-all'" in self.call(['ipython', 'nbconvert'])
+            assert "see '--help-all'" in self.call([IPYTHON, 'nbconvert'])
 
 
     def test_glob(self):
@@ -37,7 +51,7 b' class TestNbConvertApp(TestsBase):'
         Do search patterns work for notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
-            assert not 'error' in self.call(['ipython', 'nbconvert', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', 
                 '--format="python"', '--notebooks=["*.ipynb"]']).lower()
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
@@ -49,7 +63,7 b' class TestNbConvertApp(TestsBase):'
         """
         with self.create_temp_cwd() as cwd:
             self.copy_files_to(['notebook*.ipynb'], 'subdir/')
-            assert not 'error' in self.call(['ipython', 'nbconvert', '--format="python"', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--format="python"', 
                 '--notebooks=["%s"]' % os.path.join('subdir', '*.ipynb')]).lower()
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
@@ -60,7 +74,7 b' class TestNbConvertApp(TestsBase):'
         Do explicit notebook names work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
-            assert not 'error' in self.call(['ipython', 'nbconvert', '--format="python"', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--format="python"', 
                 '--notebooks=["notebook2.ipynb"]']).lower()
             assert not os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
@@ -71,7 +85,7 b' class TestNbConvertApp(TestsBase):'
         Can a search pattern be used along with matching explicit notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
-            assert not 'error' in self.call(['ipython', 'nbconvert', '--format="python"', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--format="python"', 
                 '--notebooks=["*.ipynb", "notebook1.ipynb", "notebook2.ipynb"]']).lower()
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
@@ -82,7 +96,7 b' class TestNbConvertApp(TestsBase):'
         Can explicit notebook names be used and then a matching search pattern?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
-            assert not 'error' in self.call(['ipython', 'nbconvert', '--format="python"', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--format="python"', 
                 '--notebooks=["notebook1.ipynb", "notebook2.ipynb", "*.ipynb"]']).lower()
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
@@ -93,7 +107,7 b' class TestNbConvertApp(TestsBase):'
         Does the default config work?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py']):
-            assert not 'error' in self.call(['ipython', 'nbconvert']).lower()
+            assert not 'error' in self.call([IPYTHON, 'nbconvert']).lower()
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert not os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))
 
@@ -104,6 +118,6 b' class TestNbConvertApp(TestsBase):'
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py', 
                                    'override.py']):
-            assert not 'error' in self.call(['ipython', 'nbconvert', '--config="override.py"']).lower()
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--config="override.py"']).lower()
             assert not os.path.isfile(os.path.join('nbconvert_build', 'notebook1.py'))
             assert os.path.isfile(os.path.join('nbconvert_build', 'notebook2.py'))

IPython/nbconvert/transformers/extractfigure.py

@@ -16,6 +16,7 b" notebook file. The extracted figures are returned in the 'resources' dictionary"
 import sys
 from IPython.utils.traitlets import Unicode
 from .base import Transformer
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Classes
@@ -64,7 +65,15 b' class ExtractFigureTransformer(Transformer):'
 
                     #Binary files are base64-encoded, SVG is already XML
                     if out_type in ('png', 'jpg', 'jpeg', 'pdf'):
-                        data = data.decode('base64')
+                        
+                        #Python3 base64 is in a separate library...
+                        if py3compat.PY3:
+                            
+                            #Base 64 decode the bytes
+                            import base64
+                            data = base64.b64decode(data)
+                        else:
+                            data = data.decode('base64')
                     elif sys.platform == 'win32':
                         data = data.replace('\n', '\r\n').encode("UTF-8")
                     else:

IPython/nbconvert/writers/debug.py

@@ -27,7 +27,7 b' class DebugWriter(WriterBase):'
     resources that were extracted from the notebook(s) during export."""
 
 
-    def write(self, output, resources, **kw):
+    def write(self, output, resources, notebook_name='notebook', **kw):
         """
         Consume and write Jinja output.