Fix some more tests for Python 3.

IPython/extensions/autoreload.py

@@ -1,483 +1,487 b''
 """
 ``autoreload`` is an IPython extension that reloads modules
 automatically before executing the line of code typed.
 
 This makes for example the following workflow possible:
 
 .. sourcecode:: ipython
 
    In [1]: %load_ext autoreload
 
    In [2]: %autoreload 2
 
    In [3]: from foo import some_function
 
    In [4]: some_function()
    Out[4]: 42
 
    In [5]: # open foo.py in an editor and change some_function to return 43
 
    In [6]: some_function()
    Out[6]: 43
 
 The module was reloaded without reloading it explicitly, and the
 object imported with ``from foo import ...`` was also updated.
 
 Usage
 =====
 
 The following magic commands are provided:
 
 ``%autoreload``
 
     Reload all modules (except those excluded by ``%aimport``)
     automatically now.
 
 ``%autoreload 0``
 
     Disable automatic reloading.
 
 ``%autoreload 1``
 
     Reload all modules imported with ``%aimport`` every time before
     executing the Python code typed.
 
 ``%autoreload 2``
 
     Reload all modules (except those excluded by ``%aimport``) every
     time before executing the Python code typed.
 
 ``%aimport``
 
     List modules which are to be automatically imported or not to be imported.
 
 ``%aimport foo``
 
     Import module 'foo' and mark it to be autoreloaded for ``%autoreload 1``
 
 ``%aimport -foo``
 
     Mark module 'foo' to not be autoreloaded.
 
 Caveats
 =======
 
 Reloading Python modules in a reliable way is in general difficult,
 and unexpected things may occur. ``%autoreload`` tries to work around
 common pitfalls by replacing function code objects and parts of
 classes previously in the module with new versions. This makes the
 following things to work:
 
 - Functions and classes imported via 'from xxx import foo' are upgraded
   to new versions when 'xxx' is reloaded.
 
 - Methods and properties of classes are upgraded on reload, so that
   calling 'c.foo()' on an object 'c' created before the reload causes
   the new code for 'foo' to be executed.
 
 Some of the known remaining caveats are:
 
 - Replacing code objects does not always succeed: changing a @property
   in a class to an ordinary method or a method to a member variable
   can cause problems (but in old objects only).
 
 - Functions that are removed (eg. via monkey-patching) from a module
   before it is reloaded are not upgraded.
 
 - C extension modules cannot be reloaded, and so cannot be
   autoreloaded.
 
 """
 
 skip_doctest = True
 
 # Pauli Virtanen <[e-mail]>, 2008.
 # Thomas Heller, 2000.
 #
 # This IPython module is written by Pauli Virtanen, based on the autoreload
 # code by Thomas Heller.
 
 #------------------------------------------------------------------------------
 # Autoreload functionality
 #------------------------------------------------------------------------------
 
 import time, os, threading, sys, types, imp, inspect, traceback, atexit
 import weakref
+try:
+    reload
+except NameError:
+    from imp import reload
 
 def _get_compiled_ext():
     """Official way to get the extension of compiled files (.pyc or .pyo)"""
     for ext, mode, typ in imp.get_suffixes():
         if typ == imp.PY_COMPILED:
             return ext
 
 PY_COMPILED_EXT = _get_compiled_ext()
 
 class ModuleReloader(object):
     enabled = False
     """Whether this reloader is enabled"""
 
     failed = {}
     """Modules that failed to reload: {module: mtime-on-failed-reload, ...}"""
 
     modules = {}
     """Modules specially marked as autoreloadable."""
 
     skip_modules = {}
     """Modules specially marked as not autoreloadable."""
 
     check_all = True
     """Autoreload all modules, not just those listed in 'modules'"""
 
     old_objects = {}
     """(module-name, name) -> weakref, for replacing old code objects"""
 
     def mark_module_skipped(self, module_name):
         """Skip reloading the named module in the future"""
         try:
             del self.modules[module_name]
         except KeyError:
             pass
         self.skip_modules[module_name] = True
 
     def mark_module_reloadable(self, module_name):
         """Reload the named module in the future (if it is imported)"""
         try:
             del self.skip_modules[module_name]
         except KeyError:
             pass
         self.modules[module_name] = True
 
     def aimport_module(self, module_name):
         """Import a module, and mark it reloadable
 
         Returns
         -------
         top_module : module
             The imported module if it is top-level, or the top-level
         top_name : module
             Name of top_module
 
         """
         self.mark_module_reloadable(module_name)
 
         __import__(module_name)
         top_name = module_name.split('.')[0]
         top_module = sys.modules[top_name]
         return top_module, top_name
 
     def check(self, check_all=False):
         """Check whether some modules need to be reloaded."""
 
         if not self.enabled and not check_all:
             return
 
         if check_all or self.check_all:
             modules = sys.modules.keys()
         else:
             modules = self.modules.keys()
 
         for modname in modules:
             m = sys.modules.get(modname, None)
 
             if modname in self.skip_modules:
                 continue
 
             if not hasattr(m, '__file__'):
                 continue
 
             if m.__name__ == '__main__':
                 # we cannot reload(__main__)
                 continue
 
             filename = m.__file__
             path, ext = os.path.splitext(filename)
 
             if ext.lower() == '.py':
                 ext = PY_COMPILED_EXT
                 pyc_filename = path + PY_COMPILED_EXT
                 py_filename = filename
             else:
                 pyc_filename = filename
                 py_filename = filename[:-1]
 
             if ext != PY_COMPILED_EXT:
                 continue
 
             try:
                 pymtime = os.stat(py_filename).st_mtime
                 if pymtime <= os.stat(pyc_filename).st_mtime:
                     continue
                 if self.failed.get(py_filename, None) == pymtime:
                     continue
             except OSError:
                 continue
 
             try:
                 superreload(m, reload, self.old_objects)
                 if py_filename in self.failed:
                     del self.failed[py_filename]
             except:
                 print >> sys.stderr, "[autoreload of %s failed: %s]" % (
                         modname, traceback.format_exc(1))
                 self.failed[py_filename] = pymtime
 
 #------------------------------------------------------------------------------
 # superreload
 #------------------------------------------------------------------------------
 
 def update_function(old, new):
     """Upgrade the code object of a function"""
     for name in ['func_code', 'func_defaults', 'func_doc',
                  'func_closure', 'func_globals', 'func_dict']:
         try:
             setattr(old, name, getattr(new, name))
         except (AttributeError, TypeError):
             pass
 
 def update_class(old, new):
     """Replace stuff in the __dict__ of a class, and upgrade
     method code objects"""
     for key in old.__dict__.keys():
         old_obj = getattr(old, key)
 
         try:
             new_obj = getattr(new, key)
         except AttributeError:
             # obsolete attribute: remove it
             try:
                 delattr(old, key)
             except (AttributeError, TypeError):
                 pass
             continue
 
         if update_generic(old_obj, new_obj): continue
 
         try:
             setattr(old, key, getattr(new, key))
         except (AttributeError, TypeError):
             pass # skip non-writable attributes
 
 def update_property(old, new):
     """Replace get/set/del functions of a property"""
     update_generic(old.fdel, new.fdel)
     update_generic(old.fget, new.fget)
     update_generic(old.fset, new.fset)
 
 def isinstance2(a, b, typ):
     return isinstance(a, typ) and isinstance(b, typ)
 
 UPDATE_RULES = [
     (lambda a, b: isinstance2(a, b, types.ClassType),
      update_class),
     (lambda a, b: isinstance2(a, b, types.TypeType),
      update_class),
     (lambda a, b: isinstance2(a, b, types.FunctionType),
      update_function),
     (lambda a, b: isinstance2(a, b, property),
      update_property),
     (lambda a, b: isinstance2(a, b, types.MethodType),
      lambda a, b: update_function(a.im_func, b.im_func)),
 ]
 
 def update_generic(a, b):
     for type_check, update in UPDATE_RULES:
         if type_check(a, b):
             update(a, b)
             return True
     return False
 
 class StrongRef(object):
     def __init__(self, obj):
         self.obj = obj
     def __call__(self):
         return self.obj
 
 def superreload(module, reload=reload, old_objects={}):
     """Enhanced version of the builtin reload function.
 
     superreload remembers objects previously in the module, and
 
     - upgrades the class dictionary of every old class in the module
     - upgrades the code object of every old function and method
     - clears the module's namespace before reloading
 
     """
 
     # collect old objects in the module
     for name, obj in module.__dict__.items():
         if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
             continue
         key = (module.__name__, name)
         try:
             old_objects.setdefault(key, []).append(weakref.ref(obj))
         except TypeError:
             # weakref doesn't work for all types;
             # create strong references for 'important' cases
             if isinstance(obj, types.ClassType):
                 old_objects.setdefault(key, []).append(StrongRef(obj))
 
     # reload module
     try:
         # clear namespace first from old cruft
         old_dict = module.__dict__.copy()
         old_name = module.__name__
         module.__dict__.clear()
         module.__dict__['__name__'] = old_name
     except (TypeError, AttributeError, KeyError):
         pass
 
     try:
         module = reload(module)
     except:
         # restore module dictionary on failed reload
         module.__dict__.update(old_dict)
         raise
 
     # iterate over all objects and update functions & classes
     for name, new_obj in module.__dict__.items():
         key = (module.__name__, name)
         if key not in old_objects: continue
 
         new_refs = []
         for old_ref in old_objects[key]:
             old_obj = old_ref()
             if old_obj is None: continue
             new_refs.append(old_ref)
             update_generic(old_obj, new_obj)
 
         if new_refs:
             old_objects[key] = new_refs
         else:
             del old_objects[key]
 
     return module
 
 #------------------------------------------------------------------------------
 # IPython connectivity
 #------------------------------------------------------------------------------
 
 from IPython.core.plugin import Plugin
 from IPython.core.hooks import TryNext
 
 class AutoreloadInterface(object):
     def __init__(self, *a, **kw):
         super(AutoreloadInterface, self).__init__(*a, **kw)
         self._reloader = ModuleReloader()
         self._reloader.check_all = False
 
     def magic_autoreload(self, ipself, parameter_s=''):
         r"""%autoreload => Reload modules automatically
 
         %autoreload
         Reload all modules (except those excluded by %aimport) automatically
         now.
 
         %autoreload 0
         Disable automatic reloading.
 
         %autoreload 1
         Reload all modules imported with %aimport every time before executing
         the Python code typed.
 
         %autoreload 2
         Reload all modules (except those excluded by %aimport) every time
         before executing the Python code typed.
 
         Reloading Python modules in a reliable way is in general
         difficult, and unexpected things may occur. %autoreload tries to
         work around common pitfalls by replacing function code objects and
         parts of classes previously in the module with new versions. This
         makes the following things to work:
 
         - Functions and classes imported via 'from xxx import foo' are upgraded
           to new versions when 'xxx' is reloaded.
 
         - Methods and properties of classes are upgraded on reload, so that
           calling 'c.foo()' on an object 'c' created before the reload causes
           the new code for 'foo' to be executed.
 
         Some of the known remaining caveats are:
 
         - Replacing code objects does not always succeed: changing a @property
           in a class to an ordinary method or a method to a member variable
           can cause problems (but in old objects only).
 
         - Functions that are removed (eg. via monkey-patching) from a module
           before it is reloaded are not upgraded.
 
         - C extension modules cannot be reloaded, and so cannot be
           autoreloaded.
 
         """
         if parameter_s == '':
             self._reloader.check(True)
         elif parameter_s == '0':
             self._reloader.enabled = False
         elif parameter_s == '1':
             self._reloader.check_all = False
             self._reloader.enabled = True
         elif parameter_s == '2':
             self._reloader.check_all = True
             self._reloader.enabled = True
 
     def magic_aimport(self, ipself, parameter_s='', stream=None):
         """%aimport => Import modules for automatic reloading.
 
         %aimport
         List modules to automatically import and not to import.
 
         %aimport foo
         Import module 'foo' and mark it to be autoreloaded for %autoreload 1
 
         %aimport -foo
         Mark module 'foo' to not be autoreloaded for %autoreload 1
 
         """
 
         modname = parameter_s
         if not modname:
             to_reload = self._reloader.modules.keys()
             to_reload.sort()
             to_skip = self._reloader.skip_modules.keys()
             to_skip.sort()
             if stream is None:
                 stream = sys.stdout
             if self._reloader.check_all:
                 stream.write("Modules to reload:\nall-except-skipped\n")
             else:
                 stream.write("Modules to reload:\n%s\n" % ' '.join(to_reload))
             stream.write("\nModules to skip:\n%s\n" % ' '.join(to_skip))
         elif modname.startswith('-'):
             modname = modname[1:]
             self._reloader.mark_module_skipped(modname)
         else:
             top_module, top_name = self._reloader.aimport_module(modname)
 
             # Inject module to user namespace
             ipself.push({top_name: top_module})
 
     def pre_run_code_hook(self, ipself):
         if not self._reloader.enabled:
             raise TryNext
         try:
             self._reloader.check()
         except:
             pass
 
 class AutoreloadPlugin(AutoreloadInterface, Plugin):
     def __init__(self, shell=None, config=None):
         super(AutoreloadPlugin, self).__init__(shell=shell, config=config)
 
         self.shell.define_magic('autoreload', self.magic_autoreload)
         self.shell.define_magic('aimport', self.magic_aimport)
         self.shell.set_hook('pre_run_code_hook', self.pre_run_code_hook)
 
 _loaded = False
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     global _loaded
     if not _loaded:
         plugin = AutoreloadPlugin(shell=ip, config=ip.config)
         ip.plugin_manager.register_plugin('autoreload', plugin)
         _loaded = True

IPython/utils/process.py

@@ -1,147 +1,147 b''
 # encoding: utf-8
 """
 Utilities for working with external processes.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import os
 import sys
 import shlex
 
 # Our own
 if sys.platform == 'win32':
     from ._process_win32 import _find_cmd, system, getoutput, AvoidUNCPath
 else:
     from ._process_posix import _find_cmd, system, getoutput
 
 from ._process_common import getoutputerror
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class FindCmdError(Exception):
     pass
 
 
 def find_cmd(cmd):
     """Find absolute path to executable cmd in a cross platform manner.
 
     This function tries to determine the full path to a command line program
     using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
     time it will use the version that is first on the users `PATH`.  If
     cmd is `python` return `sys.executable`.
 
     Warning, don't use this to find IPython command line programs as there
     is a risk you will find the wrong one.  Instead find those using the
     following code and looking for the application itself::
 
         from IPython.utils.path import get_ipython_module_path
         from IPython.utils.process import pycmd2argv
         argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
 
     Parameters
     ----------
     cmd : str
         The command line program to look for.
     """
     if cmd == 'python':
         return os.path.abspath(sys.executable)
     try:
         path = _find_cmd(cmd).rstrip()
     except OSError:
         raise FindCmdError('command could not be found: %s' % cmd)
     # which returns empty if not found
-    if path == b'':
+    if path == '':
         raise FindCmdError('command could not be found: %s' % cmd)
     return os.path.abspath(path)
 
 
 def pycmd2argv(cmd):
     r"""Take the path of a python command and return a list (argv-style).
 
     This only works on Python based command line programs and will find the
     location of the ``python`` executable using ``sys.executable`` to make
     sure the right version is used.
 
     For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
     .com or .bat, and [, cmd] otherwise.
 
     Parameters
     ----------
     cmd : string
       The path of the command.
 
     Returns
     -------
     argv-style list.
     """
     ext = os.path.splitext(cmd)[1]
     if ext in ['.exe', '.com', '.bat']:
         return [cmd]
     else:
         if sys.platform == 'win32':
             # The -u option here turns on unbuffered output, which is required
             # on Win32 to prevent wierd conflict and problems with Twisted.
             # Also, use sys.executable to make sure we are picking up the
             # right python exe.
             return [sys.executable, '-u', cmd]
         else:
             return [sys.executable, cmd]
 
 
 def arg_split(s, posix=False):
     """Split a command line's arguments in a shell-like manner.
 
     This is a modified version of the standard library's shlex.split()
     function, but with a default of posix=False for splitting, so that quotes
     in inputs are respected."""
 
     # Unfortunately, python's shlex module is buggy with unicode input:
     # http://bugs.python.org/issue1170
     # At least encoding the input when it's unicode seems to help, but there
     # may be more problems lurking.  Apparently this is fixed in python3.
     is_unicode = False
     if (not py3compat.PY3) and isinstance(s, unicode):
         is_unicode = True
         s = s.encode('utf-8')
     lex = shlex.shlex(s, posix=posix)
     lex.whitespace_split = True
     tokens = list(lex)
     if is_unicode:
         # Convert the tokens back to unicode.
         tokens = [x.decode('utf-8') for x in tokens]
     return tokens
 
 
 def abbrev_cwd():
     """ Return abbreviated version of cwd, e.g. d:mydir """
     cwd = os.getcwdu().replace('\\','/')
     drivepart = ''
     tail = cwd
     if sys.platform == 'win32':
         if len(cwd) < 4:
             return cwd
         drivepart,tail = os.path.splitdrive(cwd)
 
 
     parts = tail.split('/')
     if len(parts) > 2:
         tail = '/'.join(parts[-2:])
 
     return (drivepart + (
         cwd == '/' and '/' or tail))

IPython/utils/tests/test_process.py

@@ -1,98 +1,98 b''
 # encoding: utf-8
 """
 Tests for platutils.py
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 from unittest import TestCase
 
 import nose.tools as nt
 
 from IPython.utils.process import (find_cmd, FindCmdError, arg_split,
                                    system, getoutput, getoutputerror)
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_find_cmd_python():
     """Make sure we find sys.exectable for python."""
     nt.assert_equals(find_cmd('python'), sys.executable)
 
     
 @dec.skip_win32
 def test_find_cmd_ls():
     """Make sure we can find the full path to ls."""
     path = find_cmd('ls')
-    nt.assert_true(path.endswith(b'ls'))
+    nt.assert_true(path.endswith('ls'))
 
     
 def has_pywin32():
     try:
         import win32api
     except ImportError:
         return False
     return True
 
 
 @dec.onlyif(has_pywin32, "This test requires win32api to run")
 def test_find_cmd_pythonw():
     """Try to find pythonw on Windows."""
     path = find_cmd('pythonw')
     nt.assert_true(path.endswith('pythonw.exe'))
 
 
 @dec.onlyif(lambda : sys.platform != 'win32' or has_pywin32(),
             "This test runs on posix or in win32 with win32api installed")
 def test_find_cmd_fail():
     """Make sure that FindCmdError is raised if we can't find the cmd."""
     nt.assert_raises(FindCmdError,find_cmd,'asdfasdf')
 
     
 def test_arg_split():
     """Ensure that argument lines are correctly split like in a shell."""
     tests = [['hi', ['hi']],
              [u'hi', [u'hi']],
              ['hello there', ['hello', 'there']],
              [u'h\N{LATIN SMALL LETTER A WITH CARON}llo', [u'h\N{LATIN SMALL LETTER A WITH CARON}llo']],
              ['something "with quotes"', ['something', '"with quotes"']],
              ]
     for argstr, argv in tests:
         nt.assert_equal(arg_split(argstr), argv)
 
 
 class SubProcessTestCase(TestCase, tt.TempFileMixin):
     def setUp(self):
         """Make a valid python temp file."""
         lines = ["from __future__ import print_function",
                  "import sys",
                  "print('on stdout', end='', file=sys.stdout)",
                  "print('on stderr', end='', file=sys.stderr)",
                  "sys.stdout.flush()",
                  "sys.stderr.flush()"]
         self.mktmp('\n'.join(lines))
 
     def test_system(self):
         system('python "%s"' % self.fname)
 
     def test_getoutput(self):
         out = getoutput('python "%s"' % self.fname)
         self.assertEquals(out, 'on stdout')
 
     def test_getoutput(self):
         out, err = getoutputerror('python "%s"' % self.fname)
         self.assertEquals(out, 'on stdout')
         self.assertEquals(err, 'on stderr')