imp module deprecated in 3.4

We still use imp.find_module,(in IPython/utils/module_paths.py)  but
this as no newer drop-in replacement as far as I understand.

Some alternative suggested here:

https://docs.python.org/3/library/importlib.html#importlib.abc.Finder

Deprecated since version 3.3: Use MetaPathFinder or PathEntryFinder
instead.

The various error messages are not clear of the exact version where
this is deprecated.

IPython/core/extensions.py

@@ -1,176 +1,180 b''
 # encoding: utf-8
 """A class for managing IPython extensions."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 from shutil import copyfile
 import sys
 
 from traitlets.config.configurable import Configurable
 from IPython.utils.path import ensure_dir_exists
 from traitlets import Instance
 from IPython.utils.py3compat import PY3
 if PY3:
-    from imp import reload
+    try: 
+        from importlib import reload
+    except ImportError :
+        ## deprecated since 3.4
+        from imp import reload
 
 #-----------------------------------------------------------------------------
 # Main class
 #-----------------------------------------------------------------------------
 
 class ExtensionManager(Configurable):
     """A class to manage IPython extensions.
 
     An IPython extension is an importable Python module that has
     a function with the signature::
 
         def load_ipython_extension(ipython):
             # Do things with ipython
 
     This function is called after your extension is imported and the
     currently active :class:`InteractiveShell` instance is passed as
     the only argument.  You can do anything you want with IPython at
     that point, including defining new magic and aliases, adding new
     components, etc.
     
     You can also optionally define an :func:`unload_ipython_extension(ipython)`
     function, which will be called if the user unloads or reloads the extension.
     The extension manager will only call :func:`load_ipython_extension` again
     if the extension is reloaded.
 
     You can put your extension modules anywhere you want, as long as
     they can be imported by Python's standard import mechanism.  However,
     to make it easy to write extensions, you can also put your extensions
     in ``os.path.join(self.ipython_dir, 'extensions')``.  This directory
     is added to ``sys.path`` automatically.
     """
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
 
     def __init__(self, shell=None, **kwargs):
         super(ExtensionManager, self).__init__(shell=shell, **kwargs)
         self.shell.on_trait_change(
             self._on_ipython_dir_changed, 'ipython_dir'
         )
         self.loaded = set()
 
     def __del__(self):
         self.shell.on_trait_change(
             self._on_ipython_dir_changed, 'ipython_dir', remove=True
         )
 
     @property
     def ipython_extension_dir(self):
         return os.path.join(self.shell.ipython_dir, u'extensions')
 
     def _on_ipython_dir_changed(self):
         ensure_dir_exists(self.ipython_extension_dir)
 
     def load_extension(self, module_str):
         """Load an IPython extension by its module name.
 
         Returns the string "already loaded" if the extension is already loaded,
         "no load function" if the module doesn't have a load_ipython_extension
         function, or None if it succeeded.
         """
         if module_str in self.loaded:
             return "already loaded"
         
         from IPython.utils.syspathcontext import prepended_to_syspath
         
         with self.shell.builtin_trap:
             if module_str not in sys.modules:
                 with prepended_to_syspath(self.ipython_extension_dir):
                     __import__(module_str)
             mod = sys.modules[module_str]
             if self._call_load_ipython_extension(mod):
                 self.loaded.add(module_str)
             else:
                 return "no load function"
 
     def unload_extension(self, module_str):
         """Unload an IPython extension by its module name.
 
         This function looks up the extension's name in ``sys.modules`` and
         simply calls ``mod.unload_ipython_extension(self)``.
         
         Returns the string "no unload function" if the extension doesn't define
         a function to unload itself, "not loaded" if the extension isn't loaded,
         otherwise None.
         """
         if module_str not in self.loaded:
             return "not loaded"
         
         if module_str in sys.modules:
             mod = sys.modules[module_str]
             if self._call_unload_ipython_extension(mod):
                 self.loaded.discard(module_str)
             else:
                 return "no unload function"
 
     def reload_extension(self, module_str):
         """Reload an IPython extension by calling reload.
 
         If the module has not been loaded before,
         :meth:`InteractiveShell.load_extension` is called. Otherwise
         :func:`reload` is called and then the :func:`load_ipython_extension`
         function of the module, if it exists is called.
         """
         from IPython.utils.syspathcontext import prepended_to_syspath
 
         if (module_str in self.loaded) and (module_str in sys.modules):
             self.unload_extension(module_str)
             mod = sys.modules[module_str]
             with prepended_to_syspath(self.ipython_extension_dir):
                 reload(mod)
             if self._call_load_ipython_extension(mod):
                 self.loaded.add(module_str)
         else:
             self.load_extension(module_str)
 
     def _call_load_ipython_extension(self, mod):
         if hasattr(mod, 'load_ipython_extension'):
             mod.load_ipython_extension(self.shell)
             return True
 
     def _call_unload_ipython_extension(self, mod):
         if hasattr(mod, 'unload_ipython_extension'):
             mod.unload_ipython_extension(self.shell)
             return True
 
     def install_extension(self, url, filename=None):
         """Download and install an IPython extension. 
 
         If filename is given, the file will be so named (inside the extension
         directory). Otherwise, the name from the URL will be used. The file must
         have a .py or .zip extension; otherwise, a ValueError will be raised.
 
         Returns the full path to the installed file.
         """
         # Ensure the extension directory exists
         ensure_dir_exists(self.ipython_extension_dir)
 
         if os.path.isfile(url):
             src_filename = os.path.basename(url)
             copy = copyfile
         else:
             # Deferred imports
             try:
                 from urllib.parse import urlparse  # Py3
                 from urllib.request import urlretrieve
             except ImportError:
                 from urlparse import urlparse
                 from urllib import urlretrieve
             src_filename = urlparse(url).path.split('/')[-1]
             copy = urlretrieve
 
         if filename is None:
             filename = src_filename
         if os.path.splitext(filename)[1] not in ('.py', '.zip'):
             raise ValueError("The file must have a .py or .zip extension", filename)
 
         filename = os.path.join(self.ipython_extension_dir, filename)
         copy(url, filename)
         return filename

IPython/utils/openpy.py

@@ -1,245 +1,249 b''
 """
 Tools to open .py files as Unicode, using the encoding specified within the file,
 as per PEP 263.
 
 Much of the code is taken from the tokenize module in Python 3.2.
 """
 from __future__ import absolute_import
 
 import io
 from io import TextIOWrapper, BytesIO
 import os.path
 import re
 
 from .py3compat import unicode_type
 
 cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)", re.UNICODE)
 cookie_comment_re = re.compile(r"^\s*#.*coding[:=]\s*([-\w.]+)", re.UNICODE)
 
 try:
     # Available in Python 3
     from tokenize import detect_encoding
 except ImportError:
     from codecs import lookup, BOM_UTF8
     
     # Copied from Python 3.2 tokenize
     def _get_normal_name(orig_enc):
         """Imitates get_normal_name in tokenizer.c."""
         # Only care about the first 12 characters.
         enc = orig_enc[:12].lower().replace("_", "-")
         if enc == "utf-8" or enc.startswith("utf-8-"):
             return "utf-8"
         if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
            enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
             return "iso-8859-1"
         return orig_enc
     
     # Copied from Python 3.2 tokenize
     def detect_encoding(readline):
         """
         The detect_encoding() function is used to detect the encoding that should
         be used to decode a Python source file.  It requires one argment, readline,
         in the same way as the tokenize() generator.
 
         It will call readline a maximum of twice, and return the encoding used
         (as a string) and a list of any lines (left as bytes) it has read in.
 
         It detects the encoding from the presence of a utf-8 bom or an encoding
         cookie as specified in pep-0263.  If both a bom and a cookie are present,
         but disagree, a SyntaxError will be raised.  If the encoding cookie is an
         invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
         'utf-8-sig' is returned.
 
         If no encoding is specified, then the default of 'utf-8' will be returned.
         """
         bom_found = False
         encoding = None
         default = 'utf-8'
         def read_or_stop():
             try:
                 return readline()
             except StopIteration:
                 return b''
 
         def find_cookie(line):
             try:
                 line_string = line.decode('ascii')
             except UnicodeDecodeError:
                 return None
 
             matches = cookie_re.findall(line_string)
             if not matches:
                 return None
             encoding = _get_normal_name(matches[0])
             try:
                 codec = lookup(encoding)
             except LookupError:
                 # This behaviour mimics the Python interpreter
                 raise SyntaxError("unknown encoding: " + encoding)
 
             if bom_found:
                 if codec.name != 'utf-8':
                     # This behaviour mimics the Python interpreter
                     raise SyntaxError('encoding problem: utf-8')
                 encoding += '-sig'
             return encoding
 
         first = read_or_stop()
         if first.startswith(BOM_UTF8):
             bom_found = True
             first = first[3:]
             default = 'utf-8-sig'
         if not first:
             return default, []
 
         encoding = find_cookie(first)
         if encoding:
             return encoding, [first]
 
         second = read_or_stop()
         if not second:
             return default, [first]
 
         encoding = find_cookie(second)
         if encoding:
             return encoding, [first, second]
 
         return default, [first, second]
 
 try:
     # Available in Python 3.2 and above.
     from tokenize import open
 except ImportError:
     # Copied from Python 3.2 tokenize
     def open(filename):
         """Open a file in read only mode using the encoding detected by
         detect_encoding().
         """
         buffer = io.open(filename, 'rb')   # Tweaked to use io.open for Python 2
         encoding, lines = detect_encoding(buffer.readline)
         buffer.seek(0)
         text = TextIOWrapper(buffer, encoding, line_buffering=True)
         text.mode = 'r'
         return text   
 
 def source_to_unicode(txt, errors='replace', skip_encoding_cookie=True):
     """Converts a bytes string with python source code to unicode.
 
     Unicode strings are passed through unchanged. Byte strings are checked
     for the python source file encoding cookie to determine encoding.
     txt can be either a bytes buffer or a string containing the source
     code.
     """
     if isinstance(txt, unicode_type):
         return txt
     if isinstance(txt, bytes):
         buffer = BytesIO(txt)
     else:
         buffer = txt
     try:
         encoding, _ = detect_encoding(buffer.readline)
     except SyntaxError:
         encoding = "ascii"
     buffer.seek(0)
     text = TextIOWrapper(buffer, encoding, errors=errors, line_buffering=True)
     text.mode = 'r'
     if skip_encoding_cookie:
         return u"".join(strip_encoding_cookie(text))
     else:
         return text.read()
 
 def strip_encoding_cookie(filelike):
     """Generator to pull lines from a text-mode file, skipping the encoding
     cookie if it is found in the first two lines.
     """
     it = iter(filelike)
     try:
         first = next(it)
         if not cookie_comment_re.match(first):
             yield first
         second = next(it)
         if not cookie_comment_re.match(second):
             yield second
     except StopIteration:
         return
     
     for line in it:
         yield line
 
 def read_py_file(filename, skip_encoding_cookie=True):
     """Read a Python file, using the encoding declared inside the file.
     
     Parameters
     ----------
     filename : str
       The path to the file to read.
     skip_encoding_cookie : bool
       If True (the default), and the encoding declaration is found in the first
       two lines, that line will be excluded from the output - compiling a
       unicode string with an encoding declaration is a SyntaxError in Python 2.
     
     Returns
     -------
     A unicode string containing the contents of the file.
     """
     with open(filename) as f:   # the open function defined in this module.
         if skip_encoding_cookie:
             return "".join(strip_encoding_cookie(f))
         else:
             return f.read()
 
 def read_py_url(url, errors='replace', skip_encoding_cookie=True):
     """Read a Python file from a URL, using the encoding declared inside the file.
     
     Parameters
     ----------
     url : str
       The URL from which to fetch the file.
     errors : str
       How to handle decoding errors in the file. Options are the same as for
       bytes.decode(), but here 'replace' is the default.
     skip_encoding_cookie : bool
       If True (the default), and the encoding declaration is found in the first
       two lines, that line will be excluded from the output - compiling a
       unicode string with an encoding declaration is a SyntaxError in Python 2.
     
     Returns
     -------
     A unicode string containing the contents of the file.
     """
     # Deferred import for faster start
     try:
         from urllib.request import urlopen # Py 3
     except ImportError:
         from urllib import urlopen
     response = urlopen(url)
     buffer = io.BytesIO(response.read())
     return source_to_unicode(buffer, errors, skip_encoding_cookie)
 
 def _list_readline(x):
     """Given a list, returns a readline() function that returns the next element
     with each call.
     """
     x = iter(x)
     def readline():
         return next(x)
     return readline
 
 # Code for going between .py files and cached .pyc files ----------------------
 
 try:    # Python 3.2, see PEP 3147
-    from imp import source_from_cache, cache_from_source
+    try: 
+        from importlib.util import source_from_cache, cache_from_source
+    except ImportError :
+        ## deprecated since 3.4
+        from imp import source_from_cache, cache_from_source
 except ImportError:
     # Python <= 3.1: .pyc files go next to .py
     def source_from_cache(path):
         basename, ext = os.path.splitext(path)
         if ext not in ('.pyc', '.pyo'):
             raise ValueError('Not a cached Python file extension', ext)
         # Should we look for .pyw files?
         return basename + '.py'
     
     def cache_from_source(path, debug_override=None):
         if debug_override is None:
             debug_override = __debug__
         basename, ext = os.path.splitext(path)
         return basename + '.pyc' if debug_override else '.pyo'