Merge pull request #8214 from takluyver/split-utils-path

Split IPython specific functions out of utils.path

IPython/core/tests/test_paths.py

@@ -0,0 +1,246 b''
+from contextlib import contextmanager
+import errno
+import os
+import shutil
+import sys
+import tempfile
+import warnings
+
+try:
+    reload
+except NameError:   # Python 3
+    from imp import reload
+
+from nose import with_setup
+import nose.tools as nt
+
+import IPython
+from IPython import paths
+from IPython.testing.decorators import skip_win32
+from IPython.utils.tempdir import TemporaryDirectory
+
+env = os.environ
+TMP_TEST_DIR = tempfile.mkdtemp()
+HOME_TEST_DIR = os.path.join(TMP_TEST_DIR, "home_test_dir")
+XDG_TEST_DIR = os.path.join(HOME_TEST_DIR, "xdg_test_dir")
+XDG_CACHE_DIR = os.path.join(HOME_TEST_DIR, "xdg_cache_dir")
+IP_TEST_DIR = os.path.join(HOME_TEST_DIR,'.ipython')
+
+def setup():
+    """Setup testenvironment for the module:
+
+            - Adds dummy home dir tree
+    """
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    os.makedirs(IP_TEST_DIR)
+    os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
+    os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython'))
+
+
+def teardown():
+    """Teardown testenvironment for the module:
+
+            - Remove dummy home dir tree
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+
+
+def setup_environment():
+    """Setup testenvironment for some functions that are tested
+    in this module. In particular this functions stores attributes
+    and other things that we need to stub in some test functions.
+    This needs to be done on a function level and not module level because
+    each testfunction needs a pristine environment.
+    """
+    global oldstuff, platformstuff
+    oldstuff = (env.copy(), os.name, sys.platform, paths.get_home_dir, IPython.__file__, os.getcwd())
+
+def teardown_environment():
+    """Restore things that were remembered by the setup_environment function
+    """
+    (oldenv, os.name, sys.platform, paths.get_home_dir, IPython.__file__, old_wd) = oldstuff
+    os.chdir(old_wd)
+    reload(paths)
+
+    for key in list(env):
+        if key not in oldenv:
+            del env[key]
+    env.update(oldenv)
+    if hasattr(sys, 'frozen'):
+        del sys.frozen
+
+# Build decorator that uses the setup_environment/setup_environment
+with_environment = with_setup(setup_environment, teardown_environment)
+
+@contextmanager
+def patch_get_home_dir(dirpath):
+    orig_get_home_dir = paths.get_home_dir
+    paths.get_home_dir = lambda : dirpath
+    try:
+        yield
+    finally:
+        paths.get_home_dir = orig_get_home_dir
+
+
+@with_environment
+def test_get_ipython_dir_1():
+    """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    env_ipdir = os.path.join("someplace", ".ipython")
+    paths._writable_dir = lambda path: True
+    env['IPYTHONDIR'] = env_ipdir
+    ipdir = paths.get_ipython_dir()
+    nt.assert_equal(ipdir, env_ipdir)
+
+
+@with_environment
+def test_get_ipython_dir_2():
+    """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    with patch_get_home_dir('someplace'):
+        paths.get_xdg_dir = lambda : None
+        paths._writable_dir = lambda path: True
+        os.name = "posix"
+        env.pop('IPYTHON_DIR', None)
+        env.pop('IPYTHONDIR', None)
+        env.pop('XDG_CONFIG_HOME', None)
+        ipdir = paths.get_ipython_dir()
+        nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
+
+@with_environment
+def test_get_ipython_dir_3():
+    """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist."""
+    tmphome = TemporaryDirectory()
+    try:
+        with patch_get_home_dir(tmphome.name):
+            os.name = "posix"
+            env.pop('IPYTHON_DIR', None)
+            env.pop('IPYTHONDIR', None)
+            env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
+
+            with warnings.catch_warnings(record=True) as w:
+                ipdir = paths.get_ipython_dir()
+
+            nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython"))
+            if sys.platform != 'darwin':
+                nt.assert_equal(len(w), 1)
+                nt.assert_in('Moving', str(w[0]))
+    finally:
+        tmphome.cleanup()
+
+@with_environment
+def test_get_ipython_dir_4():
+    """test_get_ipython_dir_4, warn if XDG and home both exist."""
+    with patch_get_home_dir(HOME_TEST_DIR):
+        os.name = "posix"
+        env.pop('IPYTHON_DIR', None)
+        env.pop('IPYTHONDIR', None)
+        env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
+        try:
+            os.mkdir(os.path.join(XDG_TEST_DIR, 'ipython'))
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        with warnings.catch_warnings(record=True) as w:
+            ipdir = paths.get_ipython_dir()
+
+        nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython"))
+        if sys.platform != 'darwin':
+            nt.assert_equal(len(w), 1)
+            nt.assert_in('Ignoring', str(w[0]))
+
+@with_environment
+def test_get_ipython_dir_5():
+    """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
+    with patch_get_home_dir(HOME_TEST_DIR):
+        os.name = "posix"
+        env.pop('IPYTHON_DIR', None)
+        env.pop('IPYTHONDIR', None)
+        env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
+        try:
+            os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+        ipdir = paths.get_ipython_dir()
+        nt.assert_equal(ipdir, IP_TEST_DIR)
+
+@with_environment
+def test_get_ipython_dir_6():
+    """test_get_ipython_dir_6, use home over XDG if defined and neither exist."""
+    xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
+    os.mkdir(xdg)
+    shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
+    with patch_get_home_dir(HOME_TEST_DIR):
+        orig_get_xdg_dir = paths.get_xdg_dir
+        paths.get_xdg_dir = lambda : xdg
+        try:
+            os.name = "posix"
+            env.pop('IPYTHON_DIR', None)
+            env.pop('IPYTHONDIR', None)
+            env.pop('XDG_CONFIG_HOME', None)
+            with warnings.catch_warnings(record=True) as w:
+                ipdir = paths.get_ipython_dir()
+
+            nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython'))
+            nt.assert_equal(len(w), 0)
+        finally:
+            paths.get_xdg_dir = orig_get_xdg_dir
+
+@with_environment
+def test_get_ipython_dir_7():
+    """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
+    paths._writable_dir = lambda path: True
+    home_dir = os.path.normpath(os.path.expanduser('~'))
+    env['IPYTHONDIR'] = os.path.join('~', 'somewhere')
+    ipdir = paths.get_ipython_dir()
+    nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
+
+@skip_win32
+@with_environment
+def test_get_ipython_dir_8():
+    """test_get_ipython_dir_8, test / home directory"""
+    old = paths._writable_dir, paths.get_xdg_dir
+    try:
+        paths._writable_dir = lambda path: bool(path)
+        paths.get_xdg_dir = lambda: None
+        env.pop('IPYTHON_DIR', None)
+        env.pop('IPYTHONDIR', None)
+        env['HOME'] = '/'
+        nt.assert_equal(paths.get_ipython_dir(), '/.ipython')
+    finally:
+        paths._writable_dir, paths.get_xdg_dir = old
+
+
+@with_environment
+def test_get_ipython_cache_dir():
+    os.environ["HOME"] = HOME_TEST_DIR
+    if os.name == 'posix' and sys.platform != 'darwin':
+        # test default
+        os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
+        os.environ.pop("XDG_CACHE_HOME", None)
+        ipdir = paths.get_ipython_cache_dir()
+        nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
+                        ipdir)
+        nt.assert_true(os.path.isdir(ipdir))
+
+        # test env override
+        os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR
+        ipdir = paths.get_ipython_cache_dir()
+        nt.assert_true(os.path.isdir(ipdir))
+        nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
+    else:
+        nt.assert_equal(paths.get_ipython_cache_dir(),
+                        paths.get_ipython_dir())
+
+def test_get_ipython_package_dir():
+    ipdir = paths.get_ipython_package_dir()
+    nt.assert_true(os.path.isdir(ipdir))
+
+
+def test_get_ipython_module_path():
+    ipapp_path = paths.get_ipython_module_path('IPython.terminal.ipapp')
+    nt.assert_true(os.path.isfile(ipapp_path))

IPython/paths.py

@@ -0,0 +1,118 b''
+import os.path
+import shutil
+import tempfile
+from warnings import warn
+
+import IPython
+from IPython.utils.importstring import import_item
+from IPython.utils.path import (
+    get_home_dir, get_xdg_dir, get_xdg_cache_dir, compress_user, _writable_dir,
+    ensure_dir_exists, fs_encoding, filefind
+)
+from IPython.utils import py3compat
+
+def get_ipython_dir():
+    """Get the IPython directory for this platform and user.
+
+    This uses the logic in `get_home_dir` to find the home directory
+    and then adds .ipython to the end of the path.
+    """
+
+    env = os.environ
+    pjoin = os.path.join
+
+
+    ipdir_def = '.ipython'
+
+    home_dir = get_home_dir()
+    xdg_dir = get_xdg_dir()
+
+    # import pdb; pdb.set_trace()  # dbg
+    if 'IPYTHON_DIR' in env:
+        warn('The environment variable IPYTHON_DIR is deprecated. '
+                'Please use IPYTHONDIR instead.')
+    ipdir = env.get('IPYTHONDIR', env.get('IPYTHON_DIR', None))
+    if ipdir is None:
+        # not set explicitly, use ~/.ipython
+        ipdir = pjoin(home_dir, ipdir_def)
+        if xdg_dir:
+            # Several IPython versions (up to 1.x) defaulted to .config/ipython
+            # on Linux. We have decided to go back to using .ipython everywhere
+            xdg_ipdir = pjoin(xdg_dir, 'ipython')
+
+            if _writable_dir(xdg_ipdir):
+                cu = compress_user
+                if os.path.exists(ipdir):
+                    warn(('Ignoring {0} in favour of {1}. Remove {0} to '
+                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
+                elif os.path.islink(xdg_ipdir):
+                    warn(('{0} is deprecated. Move link to {1} to '
+                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
+                else:
+                    warn('Moving {0} to {1}'.format(cu(xdg_ipdir), cu(ipdir)))
+                    shutil.move(xdg_ipdir, ipdir)
+
+    ipdir = os.path.normpath(os.path.expanduser(ipdir))
+
+    if os.path.exists(ipdir) and not _writable_dir(ipdir):
+        # ipdir exists, but is not writable
+        warn("IPython dir '{0}' is not a writable location,"
+                " using a temp directory.".format(ipdir))
+        ipdir = tempfile.mkdtemp()
+    elif not os.path.exists(ipdir):
+        parent = os.path.dirname(ipdir)
+        if not _writable_dir(parent):
+            # ipdir does not exist and parent isn't writable
+            warn("IPython parent '{0}' is not a writable location,"
+                    " using a temp directory.".format(parent))
+            ipdir = tempfile.mkdtemp()
+
+    return py3compat.cast_unicode(ipdir, fs_encoding)
+
+
+def get_ipython_cache_dir():
+    """Get the cache directory it is created if it does not exist."""
+    xdgdir = get_xdg_cache_dir()
+    if xdgdir is None:
+        return get_ipython_dir()
+    ipdir = os.path.join(xdgdir, "ipython")
+    if not os.path.exists(ipdir) and _writable_dir(xdgdir):
+        ensure_dir_exists(ipdir)
+    elif not _writable_dir(xdgdir):
+        return get_ipython_dir()
+
+    return py3compat.cast_unicode(ipdir, fs_encoding)
+
+
+def get_ipython_package_dir():
+    """Get the base directory where IPython itself is installed."""
+    ipdir = os.path.dirname(IPython.__file__)
+    return py3compat.cast_unicode(ipdir, fs_encoding)
+
+
+def get_ipython_module_path(module_str):
+    """Find the path to an IPython module in this version of IPython.
+
+    This will always find the version of the module that is in this importable
+    IPython package. This will always return the path to the ``.py``
+    version of the module.
+    """
+    if module_str == 'IPython':
+        return os.path.join(get_ipython_package_dir(), '__init__.py')
+    mod = import_item(module_str)
+    the_path = mod.__file__.replace('.pyc', '.py')
+    the_path = the_path.replace('.pyo', '.py')
+    return py3compat.cast_unicode(the_path, fs_encoding)
+
+def locate_profile(profile='default'):
+    """Find the path to the folder associated with a given profile.
+
+    I.e. find $IPYTHONDIR/profile_whatever.
+    """
+    from IPython.core.profiledir import ProfileDir, ProfileDirError
+    try:
+        pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
+    except ProfileDirError:
+        # IOError makes more sense when people are expecting a path
+        raise IOError("Couldn't find profile %r" % profile)
+    return pd.location

IPython/terminal/ipapp.py

@@ -34,7 +34,7 b' from IPython.core.shellapp import ('
 from IPython.extensions.storemagic import StoreMagics
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.utils import warn
-from IPython.utils.path import get_ipython_dir, check_for_old_config
+from IPython.utils.path import get_ipython_dir
 from IPython.utils.traitlets import (
     Bool, List, Dict,
 )
@@ -246,16 +246,12 b' class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):'
     # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
     # configurables
-    ignore_old_config=Bool(False, config=True,
-        help="Suppress warning messages about legacy config files"
-    )
     quick = Bool(False, config=True,
         help="""Start IPython quickly by skipping the loading of config files."""
     )
     def _quick_changed(self, name, old, new):
         if new:
             self.load_config_file = lambda *a, **kw: None
-            self.ignore_old_config=True
 
     display_banner = Bool(True, config=True,
         help="Whether to display a banner upon starting IPython."
@@ -307,8 +303,6 b' class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):'
         if self.subapp is not None:
             # don't bother initializing further, starting subapp
             return
-        if not self.ignore_old_config:
-            check_for_old_config(self.ipython_dir)
         # print self.extra_args
         if self.extra_args and not self.something_to_run:
             self.file_to_run = self.extra_args[0]

IPython/utils/path.py

@@ -16,11 +16,11 b' import glob'
 from warnings import warn
 from hashlib import md5
 
-import IPython
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.process import system
-from IPython.utils.importstring import import_item
 from IPython.utils import py3compat
+from IPython.utils.decorators import undoc
+
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
@@ -254,111 +254,35 b' def get_xdg_cache_dir():'
     return None
 
 
+@undoc
 def get_ipython_dir():
-    """Get the IPython directory for this platform and user.
-
-    This uses the logic in `get_home_dir` to find the home directory
-    and then adds .ipython to the end of the path.
-    """
-
-    env = os.environ
-    pjoin = os.path.join
-
-
-    ipdir_def = '.ipython'
-
-    home_dir = get_home_dir()
-    xdg_dir = get_xdg_dir()
-    
-    # import pdb; pdb.set_trace()  # dbg
-    if 'IPYTHON_DIR' in env:
-        warn('The environment variable IPYTHON_DIR is deprecated. '
-                'Please use IPYTHONDIR instead.')
-    ipdir = env.get('IPYTHONDIR', env.get('IPYTHON_DIR', None))
-    if ipdir is None:
-        # not set explicitly, use ~/.ipython
-        ipdir = pjoin(home_dir, ipdir_def)
-        if xdg_dir:
-            # Several IPython versions (up to 1.x) defaulted to .config/ipython
-            # on Linux. We have decided to go back to using .ipython everywhere
-            xdg_ipdir = pjoin(xdg_dir, 'ipython')
-
-            if _writable_dir(xdg_ipdir):
-                cu = compress_user
-                if os.path.exists(ipdir):
-                    warn(('Ignoring {0} in favour of {1}. Remove {0} to '
-                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
-                elif os.path.islink(xdg_ipdir):
-                    warn(('{0} is deprecated. Move link to {1} to '
-                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
-                else:
-                    warn('Moving {0} to {1}'.format(cu(xdg_ipdir), cu(ipdir)))
-                    shutil.move(xdg_ipdir, ipdir)
-
-    ipdir = os.path.normpath(os.path.expanduser(ipdir))
-
-    if os.path.exists(ipdir) and not _writable_dir(ipdir):
-        # ipdir exists, but is not writable
-        warn("IPython dir '{0}' is not a writable location,"
-                " using a temp directory.".format(ipdir))
-        ipdir = tempfile.mkdtemp()
-    elif not os.path.exists(ipdir):
-        parent = os.path.dirname(ipdir)
-        if not _writable_dir(parent):
-            # ipdir does not exist and parent isn't writable
-            warn("IPython parent '{0}' is not a writable location,"
-                    " using a temp directory.".format(parent))
-            ipdir = tempfile.mkdtemp()
-
-    return py3compat.cast_unicode(ipdir, fs_encoding)
-
+    warn("get_ipython_dir has moved to the IPython.paths module")
+    from IPython.paths import get_ipython_dir
+    return get_ipython_dir()
 
+@undoc
 def get_ipython_cache_dir():
-    """Get the cache directory it is created if it does not exist."""
-    xdgdir = get_xdg_cache_dir()
-    if xdgdir is None:
-        return get_ipython_dir()
-    ipdir = os.path.join(xdgdir, "ipython")
-    if not os.path.exists(ipdir) and _writable_dir(xdgdir):
-        ensure_dir_exists(ipdir)
-    elif not _writable_dir(xdgdir):
-        return get_ipython_dir()
-
-    return py3compat.cast_unicode(ipdir, fs_encoding)
-
+    warn("get_ipython_cache_dir has moved to the IPython.paths module")
+    from IPython.paths import get_ipython_cache_dir
+    return get_ipython_cache_dir()
 
+@undoc
 def get_ipython_package_dir():
-    """Get the base directory where IPython itself is installed."""
-    ipdir = os.path.dirname(IPython.__file__)
-    return py3compat.cast_unicode(ipdir, fs_encoding)
-
+    warn("get_ipython_package_dir has moved to the IPython.paths module")
+    from IPython.paths import get_ipython_package_dir
+    return get_ipython_package_dir()
 
+@undoc
 def get_ipython_module_path(module_str):
-    """Find the path to an IPython module in this version of IPython.
-
-    This will always find the version of the module that is in this importable
-    IPython package. This will always return the path to the ``.py``
-    version of the module.
-    """
-    if module_str == 'IPython':
-        return os.path.join(get_ipython_package_dir(), '__init__.py')
-    mod = import_item(module_str)
-    the_path = mod.__file__.replace('.pyc', '.py')
-    the_path = the_path.replace('.pyo', '.py')
-    return py3compat.cast_unicode(the_path, fs_encoding)
+    warn("get_ipython_module_path has moved to the IPython.paths module")
+    from IPython.paths import get_ipython_module_path
+    return get_ipython_module_path(module_str)
 
+@undoc
 def locate_profile(profile='default'):
-    """Find the path to the folder associated with a given profile.
-    
-    I.e. find $IPYTHONDIR/profile_whatever.
-    """
-    from IPython.core.profiledir import ProfileDir, ProfileDirError
-    try:
-        pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
-    except ProfileDirError:
-        # IOError makes more sense when people are expecting a path
-        raise IOError("Couldn't find profile %r" % profile)
-    return pd.location
+    warn("locate_profile has moved to the IPython.paths module")
+    from IPython.paths import locate_profile
+    return locate_profile(profile=profile)
 
 def expand_path(s):
     """Expand $VARS and ~names in a string, like a shell
@@ -443,83 +367,14 b' def target_update(target,deps,cmd):'
     if target_outdated(target,deps):
         system(cmd)
 
+@undoc
 def filehash(path):
     """Make an MD5 hash of a file, ignoring any differences in line
     ending characters."""
+    warn("filehash() is deprecated")
     with open(path, "rU") as f:
         return md5(py3compat.str_to_bytes(f.read())).hexdigest()
 
-# If the config is unmodified from the default, we'll just delete it.
-# These are consistent for 0.10.x, thankfully. We're not going to worry about
-# older versions.
-old_config_md5 = {'ipy_user_conf.py': 'fc108bedff4b9a00f91fa0a5999140d3',
-                  'ipythonrc': '12a68954f3403eea2eec09dc8fe5a9b5'}
-
-def check_for_old_config(ipython_dir=None):
-    """Check for old config files, and present a warning if they exist.
-
-    A link to the docs of the new config is included in the message.
-
-    This should mitigate confusion with the transition to the new
-    config system in 0.11.
-    """
-    if ipython_dir is None:
-        ipython_dir = get_ipython_dir()
-
-    old_configs = ['ipy_user_conf.py', 'ipythonrc', 'ipython_config.py']
-    warned = False
-    for cfg in old_configs:
-        f = os.path.join(ipython_dir, cfg)
-        if os.path.exists(f):
-            if filehash(f) == old_config_md5.get(cfg, ''):
-                os.unlink(f)
-            else:
-                warn("Found old IPython config file {!r} (modified by user)".format(f))
-                warned = True
-
-    if warned:
-        warn("""
-  The IPython configuration system has changed as of 0.11, and these files will
-  be ignored. See http://ipython.github.com/ipython-doc/dev/config for details
-  of the new config system.
-  To start configuring IPython, do `ipython profile create`, and edit
-  `ipython_config.py` in <ipython_dir>/profile_default.
-  If you need to leave the old config files in place for an older version of
-  IPython and want to suppress this warning message, set
-  `c.InteractiveShellApp.ignore_old_config=True` in the new config.""")
-
-def get_security_file(filename, profile='default'):
-    """Return the absolute path of a security file given by filename and profile
-    
-    This allows users and developers to find security files without
-    knowledge of the IPython directory structure. The search path
-    will be ['.', profile.security_dir]
-    
-    Parameters
-    ----------
-    
-    filename : str
-        The file to be found. If it is passed as an absolute path, it will
-        simply be returned.
-    profile : str [default: 'default']
-        The name of the profile to search.  Leaving this unspecified
-        The file to be found. If it is passed as an absolute path, fname will
-        simply be returned.
-    
-    Returns
-    -------
-    Raises :exc:`IOError` if file not found or returns absolute path to file.
-    """
-    # import here, because profiledir also imports from utils.path
-    from IPython.core.profiledir import ProfileDir
-    try:
-        pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
-    except Exception:
-        # will raise ProfileDirError if no such profile
-        raise IOError("Profile %r not found")
-    return filefind(filename, ['.', pd.security_dir])
-
-
 ENOLINK = 1998
 
 def link(src, dst):

IPython/utils/tests/test_path.py

@@ -60,12 +60,8 b' except NameError: # Python 3'
 # Globals
 #-----------------------------------------------------------------------------
 env = os.environ
-TEST_FILE_PATH = split(abspath(__file__))[0]
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
-XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir")
-XDG_CACHE_DIR = join(HOME_TEST_DIR, "xdg_cache_dir")
-IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython')
 #
 # Setup/teardown functions/decorators
 #
@@ -77,9 +73,7 b' def setup():'
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
-    os.makedirs(IP_TEST_DIR)
-    os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
-    os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython'))
+    os.makedirs(os.path.join(HOME_TEST_DIR, 'ipython'))
 
 
 def teardown():
@@ -120,15 +114,6 b' def teardown_environment():'
 # Build decorator that uses the setup_environment/setup_environment
 with_environment = with_setup(setup_environment, teardown_environment)
 
-@contextmanager
-def patch_get_home_dir(dirpath):
-    orig_get_home_dir = path.get_home_dir
-    path.get_home_dir = lambda : dirpath
-    try:
-        yield
-    finally:
-        path.get_home_dir = orig_get_home_dir
-
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_1():
@@ -205,135 +190,6 b' def test_get_home_dir_8():'
         home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
-
-@with_environment
-def test_get_ipython_dir_1():
-    """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
-    env_ipdir = os.path.join("someplace", ".ipython")
-    path._writable_dir = lambda path: True
-    env['IPYTHONDIR'] = env_ipdir
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, env_ipdir)
-
-
-@with_environment
-def test_get_ipython_dir_2():
-    """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
-    with patch_get_home_dir('someplace'):
-        path.get_xdg_dir = lambda : None
-        path._writable_dir = lambda path: True
-        os.name = "posix"
-        env.pop('IPYTHON_DIR', None)
-        env.pop('IPYTHONDIR', None)
-        env.pop('XDG_CONFIG_HOME', None)
-        ipdir = path.get_ipython_dir()
-        nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
-
-@with_environment
-def test_get_ipython_dir_3():
-    """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist."""
-    tmphome = TemporaryDirectory()
-    try:
-        with patch_get_home_dir(tmphome.name):
-            os.name = "posix"
-            env.pop('IPYTHON_DIR', None)
-            env.pop('IPYTHONDIR', None)
-            env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-
-            with warnings.catch_warnings(record=True) as w:
-                ipdir = path.get_ipython_dir()
-
-            nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython"))
-            if sys.platform != 'darwin':
-                nt.assert_equal(len(w), 1)
-                nt.assert_in('Moving', str(w[0]))
-    finally:
-        tmphome.cleanup()
-
-@with_environment
-def test_get_ipython_dir_4():
-    """test_get_ipython_dir_4, warn if XDG and home both exist."""
-    with patch_get_home_dir(HOME_TEST_DIR):
-        os.name = "posix"
-        env.pop('IPYTHON_DIR', None)
-        env.pop('IPYTHONDIR', None)
-        env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-        try:
-            os.mkdir(os.path.join(XDG_TEST_DIR, 'ipython'))
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
-
-        with warnings.catch_warnings(record=True) as w:
-            ipdir = path.get_ipython_dir()
-
-        nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython"))
-        if sys.platform != 'darwin':
-            nt.assert_equal(len(w), 1)
-            nt.assert_in('Ignoring', str(w[0]))
-
-@with_environment
-def test_get_ipython_dir_5():
-    """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
-    with patch_get_home_dir(HOME_TEST_DIR):
-        os.name = "posix"
-        env.pop('IPYTHON_DIR', None)
-        env.pop('IPYTHONDIR', None)
-        env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-        try:
-            os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
-        except OSError as e:
-            if e.errno != errno.ENOENT:
-                raise
-        ipdir = path.get_ipython_dir()
-        nt.assert_equal(ipdir, IP_TEST_DIR)
-
-@with_environment
-def test_get_ipython_dir_6():
-    """test_get_ipython_dir_6, use home over XDG if defined and neither exist."""
-    xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
-    os.mkdir(xdg)
-    shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
-    with patch_get_home_dir(HOME_TEST_DIR):
-        orig_get_xdg_dir = path.get_xdg_dir
-        path.get_xdg_dir = lambda : xdg
-        try:
-            os.name = "posix"
-            env.pop('IPYTHON_DIR', None)
-            env.pop('IPYTHONDIR', None)
-            env.pop('XDG_CONFIG_HOME', None)
-            with warnings.catch_warnings(record=True) as w:
-                ipdir = path.get_ipython_dir()
-
-            nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython'))
-            nt.assert_equal(len(w), 0)
-        finally:
-            path.get_xdg_dir = orig_get_xdg_dir
-
-@with_environment
-def test_get_ipython_dir_7():
-    """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
-    path._writable_dir = lambda path: True
-    home_dir = os.path.normpath(os.path.expanduser('~'))
-    env['IPYTHONDIR'] = os.path.join('~', 'somewhere')
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
-
-@skip_win32
-@with_environment
-def test_get_ipython_dir_8():
-    """test_get_ipython_dir_8, test / home directory"""
-    old = path._writable_dir, path.get_xdg_dir
-    try:
-        path._writable_dir = lambda path: bool(path)
-        path.get_xdg_dir = lambda: None
-        env.pop('IPYTHON_DIR', None)
-        env.pop('IPYTHONDIR', None)
-        env['HOME'] = '/'
-        nt.assert_equal(path.get_ipython_dir(), '/.ipython')
-    finally:
-        path._writable_dir, path.get_xdg_dir = old
-
 @with_environment
 def test_get_xdg_dir_0():
     """test_get_xdg_dir_0, check xdg_dir"""
@@ -401,36 +257,6 b' def test_filefind():'
     t = path.filefind(f.name, alt_dirs)
     # print 'found:',t
 
-@with_environment
-def test_get_ipython_cache_dir():
-    os.environ["HOME"] = HOME_TEST_DIR
-    if os.name == 'posix' and sys.platform != 'darwin':
-        # test default
-        os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
-        os.environ.pop("XDG_CACHE_HOME", None)
-        ipdir = path.get_ipython_cache_dir()
-        nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
-                        ipdir)
-        nt.assert_true(os.path.isdir(ipdir))
-
-        # test env override
-        os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR
-        ipdir = path.get_ipython_cache_dir()
-        nt.assert_true(os.path.isdir(ipdir))
-        nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
-    else:
-        nt.assert_equal(path.get_ipython_cache_dir(),
-                        path.get_ipython_dir())
-
-def test_get_ipython_package_dir():
-    ipdir = path.get_ipython_package_dir()
-    nt.assert_true(os.path.isdir(ipdir))
-
-
-def test_get_ipython_module_path():
-    ipapp_path = path.get_ipython_module_path('IPython.terminal.ipapp')
-    nt.assert_true(os.path.isfile(ipapp_path))
-
 
 @dec.skip_if_not_win32
 def test_get_long_path_name_win32():

examples/Parallel Computing/iopubwatcher.py

@@ -20,7 +20,7 b' import zmq'
 
 from IPython.kernel.zmq.session import Session
 from IPython.utils.py3compat import str_to_bytes
-from IPython.utils.path import get_security_file
+from jupyter_client.connect import find_connection_file
 
 def main(connection_file):
     """watch iopub channel, and print messages"""
@@ -73,5 +73,5 b" if __name__ == '__main__':"
         cf = sys.argv[1]
     else:
         # This gets the security file for the default profile:
-        cf = get_security_file('ipcontroller-client.json')
+        cf = find_connection_file('ipcontroller-client.json')
     main(cf)