Minor changes to a few files to reflect design discussion.

IPython/config/loader.py

@@ -1,198 +1,198 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """A factory for creating configuration objects.
 """
 
 #-----------------------------------------------------------------------------
 #  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 os
 import sys
 
 from IPython.external import argparse
 from IPython.utils.ipstruct import Struct
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class ConfigLoaderError(Exception):
     pass
 
 
 class ConfigLoader(object):
     """A object for loading configurations from just about anywhere.
     
     The resulting configuration is packaged as a :class:`Struct`.
     
     Notes
     -----
     A :class:`ConfigLoader` does one thing: load a config from a source 
     (file, command line arguments) and returns the data as a :class:`Struct`.
     There are lots of things that :class:`ConfigLoader` does not do.  It does
     not implement complex logic for finding config files.  It does not handle
     default values or merge multiple configs.  These things need to be 
     handled elsewhere.
     """
 
     def __init__(self):
         """A base class for config loaders.
         
         Examples
         --------
         
         >>> cl = ConfigLoader()
         >>> config = cl.load_config()
         >>> config
         {}
         """
         self.clear()
 
     def clear(self):
         self.config = Struct()
 
     def load_config(self):
         """Load a config from somewhere, return a Struct.
         
         Usually, this will cause self.config to be set and then returned.
         """
         return self.config
 
 
 class FileConfigLoader(ConfigLoader):
     """A base class for file based configurations.
 
     As we add more file based config loaders, the common logic should go
     here.
     """
     pass
 
 
 class PyFileConfigLoader(FileConfigLoader):
     """A config loader for pure python files.
     
     This calls execfile on a plain python file and looks for attributes
     that are all caps.  These attribute are added to the config Struct.
     """
 
     def __init__(self, filename, path='.'):
         """Build a config loader for a filename and path.
 
         Parameters
         ----------
         filename : str
             The file name of the config file.
         path : str, list, tuple
             The path to search for the config file on, or a sequence of
             paths to try in order.
         """
         super(PyFileConfigLoader, self).__init__()
         self.filename = filename
         self.path = path
         self.full_filename = ''
         self.data = None
 
     def load_config(self):
         """Load the config from a file and return it as a Struct."""
         self._find_file()
         self._read_file_as_dict()
         self._convert_to_struct()
         return self.config
 
     def _find_file(self):
         """Try to find the file by searching the paths."""
         if os.path.isfile(os.path.expanduser(self.filename)):
             self.full_filename = os.path.expanduser(self.filename)
             return
         if self.path == '.':
             self.path = [os.getcwd()]
         if not isinstance(path, (list, tuple)):
             raise TypeError("path must be a list or tuple, got: %r" % self.path)
         for p in self.path:
             if p == '.': p = os.getcwd()
             full_filename = os.path.expanduser(os.path.join(p, self.filename))
             if os.path.isfile(full_filename):
                 self.full_filename = full_filename
                 return
         raise IOError("Config file does not exist in any "
                       "of the search paths: %r, %r" % \
                       (self.filename, self.path))
 
     def _read_file_as_dict(self):
         self.data = {}
         execfile(self.full_filename, self.data)
 
     def _convert_to_struct(self):
         if self.data is None:
             ConfigLoaderError('self.data does not exist')
         for k, v in self.data.iteritems():
             if k == k.upper():
                 self.config[k] = v
 
 
 class CommandLineConfigLoader(ConfigLoader):
     """A config loader for command line arguments.
 
     As we add more command line based loaders, the common logic should go
     here.
     """
 
 
 class NoDefault(object): pass
 NoDefault = NoDefault()
 
 class ArgParseConfigLoader(CommandLineConfigLoader):
     
     # arguments = [(('-f','--file'),dict(type=str,dest='file'))]
-    arguments = []
+    arguments = ()
 
     def __init__(self, *args, **kw):
         """Create a config loader for use with argparse.
 
         The args and kwargs arguments here are passed onto the constructor
         of :class:`argparse.ArgumentParser`.
         """
         super(CommandLineConfigLoader, self).__init__()
         self.args = args
         self.kw = kw
 
     def load_config(self, args=None):
         """Parse command line arguments and return as a Struct."""
         self._create_parser()
         self._parse_args(args)
         self._convert_to_struct()
         return self.config
 
     def _create_parser(self):
         self.parser = argparse.ArgumentParser(*self.args, **self.kw)
         self._add_arguments()
 
     def _add_arguments(self):
         for argument in self.arguments:
             if not argument[1].has_key('default'):
                 argument[1]['default'] = NoDefault
             self.parser.add_argument(*argument[0],**argument[1])
 
     def _parse_args(self, args=None):
         """self.parser->self.parsed_data"""
         if args is None:
             self.parsed_data = self.parser.parse_args()
         else:
             self.parsed_data = self.parser.parse_args(args)
 
     def _convert_to_struct(self):
         """self.parsed_data->self.config"""
         self.config = Struct()
         for k, v in vars(self.parsed_data).items():
             if v is not NoDefault:
                 setattr(self.config, k, v)
 

IPython/config/tests/test_loader.py

@@ -1,92 +1,93 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Tests for IPython.config.loader
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  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 os
 from tempfile import mkstemp
 from unittest import TestCase
 
 from IPython.config.loader import PyFileConfigLoader, ArgParseConfigLoader
 
 #-----------------------------------------------------------------------------
 # Actual tests
 #-----------------------------------------------------------------------------
 
 
 pyfile = """
 A = 10
 B = range(10)
 C = True
 D = 'hi there'
 """
 
 class TestPyFileCL(TestCase):
 
     def test_basic(self):
         fd, fname = mkstemp()
         f = os.fdopen(fd, 'w')
         f.write(pyfile)
         f.close()
+        # Unlink the file
         cl = PyFileConfigLoader(fname)
         config = cl.load_config()
         self.assertEquals(config.A, 10)
         self.assertEquals(config.B, range(10))
         self.assertEquals(config.C, True)
         self.assertEquals(config.D, 'hi there')
 
 
 class TestArgParseCL(TestCase):
 
     def test_basic(self):
 
         class MyLoader(ArgParseConfigLoader):
-            arguments = [
+            arguments = (
                 (('-f','--foo'), dict(dest='FOO', type=str)),
                 (('-b',), dict(dest='BAR', type=int)),
                 (('-n',), dict(dest='N', action='store_true')),
                 (('BAM',), dict(type=str))
-            ]
+            )
 
         cl = MyLoader()
         config = cl.load_config('-f hi -b 10 -n wow'.split())
         self.assertEquals(config.FOO, 'hi')
         self.assertEquals(config.BAR, 10)
         self.assertEquals(config.N, True)
         self.assertEquals(config.BAM, 'wow')
 
     def test_add_arguments(self):
 
         class MyLoader(ArgParseConfigLoader):
             def _add_arguments(self):
                 subparsers = self.parser.add_subparsers(dest='subparser_name')
                 subparser1 = subparsers.add_parser('1')
                 subparser1.add_argument('-x')
                 subparser2 = subparsers.add_parser('2')
                 subparser2.add_argument('y')
 
         cl = MyLoader()
         config = cl.load_config('2 frobble'.split())
         self.assertEquals(config.subparser_name, '2')
         self.assertEquals(config.y, 'frobble')
         config = cl.load_config('1 -x frobble'.split())
         self.assertEquals(config.subparser_name, '1')
         self.assertEquals(config.x, 'frobble')
 

IPython/core/application.py

@@ -1,159 +1,161 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 An application for IPython
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 
 Notes
 -----
 
 The following directories are relevant in the startup of an app:
 
 * The ipythondir.  This has a default, but can be set by IPYTHONDIR or at
   the command line.
 * The current working directory.
 * Another runtime directory.  With some applications (engine, controller) we
   need the ability to have different cluster configs.  Each of these needs
   to have its own config, security dir and log dir.  We could simply treat
   these as regular ipython dirs.  
 
 There are number of ways in which these directories are used:
 
 * For config files.
 * For other assets and resources needed to run.  These include 
   plugins, magics, furls files.
 * For writing various things created at runtime like logs, furl files, etc.
 
 Questions:
 
 
 * Can we limit ourselves to 1 config file or do we want to have a sequence
-  of them like IPYTHONDIR->RUNTIMEDIR->CWD?
+  of them like IPYTHONDIR->RUNTIMEDIR->CWD? [1]
 * Do we need a debug mode that has custom exception handling and can drop
-  into pdb upno startup?
+  into pdb upno startup? N
 * Do we need to use an OutputTrap to capture output and then present it
-  to a user if startup fails?
+  to a user if startup fails? N
 * Do we want the location of the config file(s) to be independent of the
   ipython/runtime dir or coupled to it.  In other words, can the user select
   a config file that is outside their runtime/ipython dir.  One model is 
   that we could have a very strict model of IPYTHONDIR=runtimed dir=
   dir used for all config.
-* Do we install default config files or not?
+* Do we install default config files or not? N
+
+* attempt needs to either clash or to die
 """
 
 #-----------------------------------------------------------------------------
 #  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 copy import deepcopy
 from IPython.utils.ipstruct import Struct
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
 class ApplicationError(Exception):
     pass
 
 
 class Application(object):
 
     runtime_dirs = []
     default_config = Struct()
     runtime_dir = ''
     config_file = ''
     name = ''
 
     def __init__(self):
         pass
 
     def start(self):
         """Start the application."""
         self.attempt(self.create_command_line_config)
         self.attempt(self.find_runtime_dirs)
         self.attempt(self.create_runtime_dirs)
         self.attempt(self.find_config_files)
         self.attempt(self.create_file_configs)
         self.attempt(self.merge_configs)
         self.attempt(self.construct)
         self.attempt(self.start_logging)
         self.attempt(self.start_app)
 
     #-------------------------------------------------------------------------
     # Various stages of Application creation
     #-------------------------------------------------------------------------
 
     def create_command_line_config(self):
         """Read the command line args and return its config object."""
         self.command_line_config = Struct()
 
     def find_runtime_dirs(self):
         """Find the runtime directory for this application.
 
         This should set self.runtime_dir.
         """
         pass
 
     def create_runtime_dirs(self):
         """Create the runtime dirs if they don't exist."""
         pass
 
     def find_config_files(self):
         """Find the config file for this application."""
         pass
 
     def create_file_configs(self):
         self.file_configs = [Struct()]
 
     def merge_configs(self):
         config = Struct()
         all_configs = self.file_configs + self.command_line_config
         for c in all_configs:
             config.update(c)
         self.master_config = config
 
     def construct(self, config):
         """Construct the main components that make up this app."""
         pass
 
     def start_logging(self):
         """Start logging, if needed, at the last possible moment."""
         pass
 
     def start_app(self):
         """Actually start the app."""
         pass
 
     #-------------------------------------------------------------------------
     # Utility methods
     #-------------------------------------------------------------------------
 
     def abort(self):
         """Abort the starting of the application."""
         print "Aborting application: ", self.name
         sys.exit(1)
 
     def attempt(self, func):
         try:
             func()
         except:
             self.handle_error()
             self.abort()
 
     def handle_error(self):
         print "I am dying!"
      
         
  No newline at end of file