Fixes for py2.6

IPython/nbconvert/filters/strings.py

@@ -1,155 +1,152 b''
 # coding: utf-8
 """String filters.
 
 Contains a collection of useful string manipulation filters for use in Jinja
 templates.
 """
 #-----------------------------------------------------------------------------
 # 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 re
 import textwrap
 from xml.etree import ElementTree
+from types import StringTypes
 
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'wrap',
     'html_text',
     'add_anchor',
     'strip_dollars',
     'rm_fake',
     'python_comment',
     'get_lines'
 ]
 
 
 def wrap(text, width=100):
     """ 
     Intelligently wrap text.
     Wrap text without breaking words if possible.
     
     Parameters
     ----------
     text : str
         Text to wrap.
     width : int, optional
         Number of characters to wrap to, default 100.
     """
 
     split_text = text.split('\n')
     wrp = map(lambda x:textwrap.wrap(x,width), split_text)
     wrpd = map('\n'.join, wrp)
     return '\n'.join(wrpd)
 
 
 def html_text(element):
     """extract inner text from html
     
     Analog of jQuery's $(element).text()
     """
-    instance_element_tree = isinstance(ElementTree.ElementTree, type) and \
-                            isinstance(element, (ElementTree.ElementTree))
-    instance_element = isinstance(ElementTree.Element, type) and \
-                       isinstance(element, (ElementTree.Element))
-    if not (instance_element or instance_element_tree):
+    if isinstance(element, StringTypes):
         element = ElementTree.fromstring(element)
     
     text = element.text or ""
     for child in element:
         text += html_text(child)
     text += (element.tail or "")
     return text
 
 
 def add_anchor(html):
     """Add an anchor-link to an html header tag
     
     For use in heading cells
     """
     h = ElementTree.fromstring(py3compat.cast_bytes_py2(html))
     link = html_text(h).replace(' ', '-')
     h.set('id', link)
     a = ElementTree.Element("a", {"class" : "anchor-link", "href" : "#" + link})
     a.text = u'¶'
     h.append(a)
     return ElementTree.tostring(h)
 
 
 def strip_dollars(text):
     """
     Remove all dollar symbols from text
     
     Parameters
     ----------
     text : str
         Text to remove dollars from
     """
 
     return text.strip('$')
 
 
 files_url_pattern = re.compile(r'(src|href)\=([\'"]?)files/')
 
 def rm_fake(text):
     """
     Fix all fake URLs that start with `files/`,
     stripping out the `files/` prefix.
     
     Parameters
     ----------
     text : str
         Text in which to replace 'src="files/real...' with 'src="real...'
     """
     return files_url_pattern.sub(r"\1=\2", text)
 
 
 def python_comment(text):
     """
     Build a Python comment line from input text.
     
     Parameters
     ----------
     text : str
         Text to comment out.
     """
     
     #Replace line breaks with line breaks and comment symbols.
     #Also add a comment symbol at the beginning to comment out
     #the first line.
     return '# '+'\n# '.join(text.split('\n')) 
 
 
 def get_lines(text, start=None,end=None):
     """
     Split the input text into separate lines and then return the 
     lines that the caller is interested in.
     
     Parameters
     ----------
     text : str
         Text to parse lines from.
     start : int, optional
         First line to grab from.
     end : int, optional
         Last line to grab from.
     """
     
     # Split the input into lines.
     lines = text.split("\n")
     
     # Return the right lines.
     return "\n".join(lines[start:end]) #re-join

IPython/nbconvert/tests/base.py

@@ -1,170 +1,171 b''
 #!/usr/bin/env python
 """
 Contains base test class for nbconvert
 """
 #-----------------------------------------------------------------------------
 #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 subprocess
 import os
 import glob
 import shutil
+import sys
 
 import IPython
 from IPython.utils.tempdir import TemporaryDirectory
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class TemporaryWorkingDirectory(TemporaryDirectory):
     """
     Creates a temporary directory and sets the cwd to that directory.
     Automatically reverts to previous cwd upon cleanup.
     Usage example:
 
         with TemporaryWorakingDirectory() as tmpdir:
             ...
     """
 
     def __init__(self, **kw):
         """
         Constructor
         """
         super(TemporaryWorkingDirectory, self).__init__(**kw)
 
         #Change cwd to new temp dir.  Remember old cwd.
         self.old_wd = os.getcwd()
         os.chdir(self.name)
 
 
     def cleanup(self):
         """
         Destructor
         """
 
         #Revert to old cwd.
         os.chdir(self.old_wd)
 
         #Cleanup
         super(TemporaryWorkingDirectory, self).cleanup()
 
 
 class TestsBase(object):
     """Base tests class.  Contains usefull fuzzy comparison and nbconvert
     functions."""
 
 
     def fuzzy_compare(self, a, b, newlines_are_spaces=True, tabs_are_spaces=True, 
                       fuzzy_spacing=True, ignore_spaces=False, 
                       ignore_newlines=False, case_sensitive=False):
         """
         Performs a fuzzy comparison of two strings.  A fuzzy comparison is a
         comparison that ignores insignificant differences in the two comparands.
         The significance of certain differences can be specified via the keyword
         parameters of this method.
         """
 
         if newlines_are_spaces:
             a = a.replace('\n', ' ')
             b = b.replace('\n', ' ')
 
         if tabs_are_spaces:
             a = a.replace('\t', ' ')
             b = b.replace('\t', ' ')
 
         if ignore_spaces:
             a = a.replace(' ', '')
             b = b.replace(' ', '')
 
         if fuzzy_spacing:
             a = self.recursive_replace(a, '  ', ' ')
             b = self.recursive_replace(b, '  ', ' ')
 
         if ignore_newlines:
             a = a.replace('\n', '')
             b = b.replace('\n', '')
 
         if not case_sensitive:
             a = a.lower()
             b = b.lower()
 
         return a == b
 
 
     def recursive_replace(self, text, search, replacement):
         """
         Performs a recursive replacement operation.  Replaces all instances
         of a search string in a text string with a replacement string until
         the search string no longer exists.  Recursion is needed because the
         replacement string may generate additional search strings.
 
         For example:
            Replace "ii" with "i" in the string "Hiiii" yields "Hii"
            Another replacement yields "Hi" (the desired output)
 
         Parameters:
         -----------
         text : string
             Text to replace in.
         search : string
             String to search for within "text"
         replacement : string
             String to replace "search" with
         """
         while search in text:
             text = text.replace(search, replacement)
         return text
 
             
     def create_temp_cwd(self, copy_filenames=None):
         temp_dir = TemporaryWorkingDirectory()
 
         #Copy the files if requested.
         if not copy_filenames is None:
             self.copy_files_to(copy_filenames)
 
         #Return directory handler
         return temp_dir
 
 
     def copy_files_to(self, copy_filenames=None, destination=None):
         
         #Copy test files into the destination directory.
         if copy_filenames:
             for pattern in copy_filenames:
                 for match in glob.glob(os.path.join(self._get_files_path(), pattern)):
                     if destination is None:
                         shutil.copyfile(match, os.path.basename(match))
                     else:
                         if not os.path.isdir(destination):
                             os.makedirs(destination)
                         shutil.copyfile(match, os.path.join(destination, os.path.basename(match)))
 
 
     def _get_files_path(self):
 
         #Get the relative path to this module in the IPython directory.
         names = self.__module__.split('.')[1:-1]
         names.append('files')
         
         #Build a path using the IPython directory and the relative path we just
         #found.
         path = IPython.__path__[0]
         for name in names:
             path = os.path.join(path, name)
         return path
 
 
     def call(self, parameters):
-        return subprocess.check_output(parameters)
+        return subprocess.Popen(parameters, stdout=subprocess.PIPE).communicate()[0]
      
  No newline at end of file