Merge pull request #8137 from minrk/config-profile

remove profiles from IPython.config

IPython/config/application.py

@@ -118,6 +118,9 b' class Application(SingletonConfigurable):'
     option_description = Unicode(option_description)
     keyvalue_description = Unicode(keyvalue_description)
     subcommand_description = Unicode(subcommand_description)
+    
+    python_config_loader_class = PyFileConfigLoader
+    json_config_loader_class = JSONFileConfigLoader
 
     # The usage and example string that goes at the end of the help string.
     examples = Unicode()
@@ -507,8 +510,8 b' class Application(SingletonConfigurable):'
             path = [path]
         for path in path[::-1]:
             # path list is in descending priority order, so load files backwards:
-            pyloader = PyFileConfigLoader(basefilename+'.py', path=path, log=log)
-            jsonloader = JSONFileConfigLoader(basefilename+'.json', path=path, log=log)
+            pyloader = cls.python_config_loader_class(basefilename+'.py', path=path, log=log)
+            jsonloader = cls.json_config_loader_class(basefilename+'.json', path=path, log=log)
             config = None
             for loader in [pyloader, jsonloader]:
                 try:
@@ -551,9 +554,7 b' class Application(SingletonConfigurable):'
 
     def generate_config_file(self):
         """generate default config file from Configurables"""
-        lines = ["# Configuration file for %s."%self.name]
-        lines.append('')
-        lines.append('c = get_config()')
+        lines = ["# Configuration file for %s." % self.name]
         lines.append('')
         for cls in self._config_classes:
             lines.append(cls.class_config_section())

IPython/config/loader.py

@@ -436,52 +436,31 b' class PyFileConfigLoader(FileConfigLoader):'
             raise ConfigFileNotFound(str(e))
         self._read_file_as_dict()
         return self.config
-
-
+    
+    def load_subconfig(self, fname, path=None):
+        """Injected into config file namespace as load_subconfig"""
+        if path is None:
+            path = self.path
+        
+        loader = self.__class__(fname, path)
+        try:
+            sub_config = loader.load_config()
+        except ConfigFileNotFound:
+            # Pass silently if the sub config is not there,
+            # treat it as an empty config file.
+            pass
+        else:
+            self.config.merge(sub_config)
+    
     def _read_file_as_dict(self):
         """Load the config file into self.config, with recursive loading."""
-        # This closure is made available in the namespace that is used
-        # to exec the config file.  It allows users to call
-        # load_subconfig('myconfig.py') to load config files recursively.
-        # It needs to be a closure because it has references to self.path
-        # and self.config.  The sub-config is loaded with the same path
-        # as the parent, but it uses an empty config which is then merged
-        # with the parents.
-
-        # If a profile is specified, the config file will be loaded
-        # from that profile
-
-        def load_subconfig(fname, profile=None):
-            # import here to prevent circular imports
-            from IPython.core.profiledir import ProfileDir, ProfileDirError
-            if profile is not None:
-                try:
-                    profile_dir = ProfileDir.find_profile_dir_by_name(
-                            get_ipython_dir(),
-                            profile,
-                    )
-                except ProfileDirError:
-                    return
-                path = profile_dir.location
-            else:
-                path = self.path
-            loader = PyFileConfigLoader(fname, path)
-            try:
-                sub_config = loader.load_config()
-            except ConfigFileNotFound:
-                # Pass silently if the sub config is not there. This happens
-                # when a user s using a profile, but not the default config.
-                pass
-            else:
-                self.config.merge(sub_config)
-
-        # Again, this needs to be a closure and should be used in config
-        # files to get the config being loaded.
         def get_config():
+            """Unnecessary now, but a deprecation warning is more trouble than it's worth."""
             return self.config
-
+        
         namespace = dict(
-            load_subconfig=load_subconfig,
+            c=self.config,
+            load_subconfig=self.load_subconfig,
             get_config=get_config,
             __file__=self.full_filename,
         )

IPython/config/manager.py

@@ -8,7 +8,6 b' import json'
 import os
 
 from IPython.config import LoggingConfigurable
-from IPython.utils.path import locate_profile
 from IPython.utils.py3compat import PY3
 from IPython.utils.traitlets import Unicode
 
@@ -35,22 +34,12 b' def recursive_update(target, new):'
 
 
 class BaseJSONConfigManager(LoggingConfigurable):
-    """General config manager 
+    """General JSON config manager
     
     Deals with persisting/storing config in a json file
-    in IPython profile
     """
 
-    profile_dir = Unicode()
-    def _profile_dir_default(self):
-        return locate_profile()
-
-    @property
-    def config_dir(self):
-        return self._config_dir()
-
-    def _config_dir(self):
-        return self.profile_dir
+    config_dir = Unicode('.')
 
     def ensure_config_dir_exists(self):
         try:

IPython/core/application.py

@@ -20,7 +20,7 b' import shutil'
 import sys
 
 from IPython.config.application import Application, catch_config_error
-from IPython.config.loader import ConfigFileNotFound
+from IPython.config.loader import ConfigFileNotFound, PyFileConfigLoader
 from IPython.core import release, crashhandler
 from IPython.core.profiledir import ProfileDir, ProfileDirError
 from IPython.utils.path import get_ipython_dir, get_ipython_package_dir, ensure_dir_exists
@@ -63,6 +63,19 b' base_flags = dict('
             """)
 )
 
+class ProfileAwareConfigLoader(PyFileConfigLoader):
+    """A Python file config loader that is aware of IPython profiles."""
+    def load_subconfig(self, fname, path=None, profile=None):
+        if profile is not None:
+            try:
+                profile_dir = ProfileDir.find_profile_dir_by_name(
+                        get_ipython_dir(),
+                        profile,
+                )
+            except ProfileDirError:
+                return
+            path = profile_dir.location
+        return super(ProfileAwareConfigLoader, self).load_subconfig(fname, path=path)
 
 class BaseIPythonApplication(Application):
 
@@ -73,6 +86,9 b' class BaseIPythonApplication(Application):'
     aliases = Dict(base_aliases)
     flags = Dict(base_flags)
     classes = List([ProfileDir])
+    
+    # enable `load_subconfig('cfg.py', profile='name')`
+    python_config_loader_class = ProfileAwareConfigLoader
 
     # Track whether the config_file has changed,
     # because some logic happens only if we aren't using the default.

IPython/core/profileapp.py

@@ -112,7 +112,7 b' def list_profiles_in(path):'
 
 def list_bundled_profiles():
     """list profiles that are bundled with IPython."""
-    path = os.path.join(get_ipython_package_dir(), u'config', u'profile')
+    path = os.path.join(get_ipython_package_dir(), u'core', u'profile')
     files = os.listdir(path)
     profiles = []
     for profile in files:

IPython/core/profiledir.py

@@ -114,7 +114,7 b' class ProfileDir(LoggingConfigurable):'
         self._mkdir(self.startup_dir)
 
         readme = os.path.join(self.startup_dir, 'README')
-        src = os.path.join(get_ipython_package_dir(), u'config', u'profile', u'README_STARTUP')
+        src = os.path.join(get_ipython_package_dir(), u'core', u'profile', u'README_STARTUP')
 
         if not os.path.exists(src):
             self.log.warn("Could not copy README_STARTUP to startup dir. Source file %s does not exist.", src)
@@ -169,7 +169,7 b' class ProfileDir(LoggingConfigurable):'
         if os.path.isfile(dst) and not overwrite:
             return False
         if path is None:
-            path = os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default')
+            path = os.path.join(get_ipython_package_dir(), u'core', u'profile', u'default')
         src = os.path.join(path, config_file)
         shutil.copy(src, dst)
         return True

IPython/core/tests/test_profile.py

@@ -149,9 +149,8 b' def test_list_profiles_in():'
 
 def test_list_bundled_profiles():
     # This variable will need to be updated when a new profile gets bundled
-    bundled_true = [u'cluster', u'math', u'pysh', u'sympy']
     bundled = sorted(list_bundled_profiles())
-    nt.assert_equal(bundled, bundled_true)
+    nt.assert_equal(bundled, [])
 
 
 def test_profile_create_ipython_dir():

IPython/html/services/config/manager.py

@@ -3,12 +3,19 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import os
-
 from IPython.config.manager import BaseJSONConfigManager
+from IPython.utils.path import locate_profile
+from IPython.utils.traitlets import Unicode
 
 class ConfigManager(BaseJSONConfigManager):
     """Config Manager used for storing notebook frontend config"""
+    
+    profile = Unicode('default', config=True)
+    
+    profile_dir = Unicode(config=True)
+    
+    def _profile_dir_default(self):
+        return locate_profile(self.profile)
 
-    def _config_dir(self):
-        return os.path.join(self.profile_dir, 'nbconfig')
+    def _config_dir_default(self):
+        return self.profile_dir

setupbase.py

@@ -183,7 +183,7 b' def find_package_data():'
     os.chdir(cwd)
 
     package_data = {
-        'IPython.config.profile' : ['README*', '*/*.py'],
+        'IPython.core' : ['profile/README*'],
         'IPython.core.tests' : ['*.png', '*.jpg'],
         'IPython.lib.tests' : ['*.wav'],
         'IPython.testing.plugin' : ['*.txt'],