Merging with upstream trunk.

IPython/config/loader.py

@@ -1,373 +1,373 b''
 # coding: utf-8
 """A simple configuration system.
 
 Authors
 -------
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  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 __builtin__
 import os
 import sys
 
 from IPython.external import argparse
 from IPython.utils.genutils import filefind
 
 #-----------------------------------------------------------------------------
 # Exceptions
 #-----------------------------------------------------------------------------
 
 
 class ConfigError(Exception):
     pass
 
 
 class ConfigLoaderError(ConfigError):
     pass
 
 #-----------------------------------------------------------------------------
 # Argparse fix
 #-----------------------------------------------------------------------------
 # Unfortunately argparse by default prints help messages to stderr instead of
 # stdout.  This makes it annoying to capture long help screens at the command
 # line, since one must know how to pipe stderr, which many users don't know how
 # to do.  So we override the print_help method with one that defaults to
 # stdout and use our class instead.
 
 class ArgumentParser(argparse.ArgumentParser):
     """Simple argparse subclass that prints help to stdout by default."""
     
     def print_help(self, file=None):
         if file is None:
             file = sys.stdout
         return super(ArgumentParser, self).print_help(file)
     
     print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__
     
 #-----------------------------------------------------------------------------
 # Config class for holding config information
 #-----------------------------------------------------------------------------
 
 
 class Config(dict):
     """An attribute based dict that can do smart merges."""
 
     def __init__(self, *args, **kwds):
         dict.__init__(self, *args, **kwds)
         # This sets self.__dict__ = self, but it has to be done this way
         # because we are also overriding __setattr__.
         dict.__setattr__(self, '__dict__', self)
 
     def _merge(self, other):
         to_update = {}
         for k, v in other.items():
             if not self.has_key(k):
                 to_update[k] = v
             else: # I have this key
                 if isinstance(v, Config):
                     # Recursively merge common sub Configs
                     self[k]._merge(v)
                 else:
                     # Plain updates for non-Configs
                     to_update[k] = v
 
         self.update(to_update)
 
     def _is_section_key(self, key):
         if key[0].upper()==key[0] and not key.startswith('_'):
             return True
         else:
             return False
 
     def has_key(self, key):
         if self._is_section_key(key):
             return True
         else:
             return dict.has_key(self, key)
 
     def _has_section(self, key):
         if self._is_section_key(key):
             if dict.has_key(self, key):
                 return True
         return False
 
     def copy(self):
         return type(self)(dict.copy(self))
 
     def __copy__(self):
         return self.copy()
 
     def __deepcopy__(self, memo):
         import copy
         return type(self)(copy.deepcopy(self.items()))
 
     def __getitem__(self, key):
         # Because we use this for an exec namespace, we need to delegate
         # the lookup of names in __builtin__ to itself.  This means
         # that you can't have section or attribute names that are 
         # builtins.
         try:
             return getattr(__builtin__, key)
         except AttributeError:
             pass
         if self._is_section_key(key):
             try:
                 return dict.__getitem__(self, key)
             except KeyError:
                 c = Config()
                 dict.__setitem__(self, key, c)
                 return c
         else:
             return dict.__getitem__(self, key)
 
     def __setitem__(self, key, value):
         # Don't allow names in __builtin__ to be modified.
         if hasattr(__builtin__, key):
             raise ConfigError('Config variable names cannot have the same name '
                               'as a Python builtin: %s' % key)
         if self._is_section_key(key):
             if not isinstance(value, Config):
                 raise ValueError('values whose keys begin with an uppercase '
                                  'char must be Config instances: %r, %r' % (key, value))
         else:
             dict.__setitem__(self, key, value)
 
     def __getattr__(self, key):
         try:
             return self.__getitem__(key)
         except KeyError, e:
             raise AttributeError(e)
 
     def __setattr__(self, key, value):
         try:
             self.__setitem__(key, value)
         except KeyError, e:
             raise AttributeError(e)
 
     def __delattr__(self, key):
         try:
             dict.__delitem__(self, key)
         except KeyError, e:
             raise AttributeError(e)
 
 
 #-----------------------------------------------------------------------------
 # Config loading classes
 #-----------------------------------------------------------------------------
 
 
 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 = Config()
 
     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=None):
         """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_config()
         return self.config
 
     def _find_file(self):
         """Try to find the file by searching the paths."""
         self.full_filename = filefind(self.filename, self.path)
 
     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.  This 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.
         def load_subconfig(fname):
             loader = PyFileConfigLoader(fname, self.path)
             try:
                 sub_config = loader.load_config()
             except IOError:
                 # Pass silently if the sub config is not there. This happens
                 # when a user us 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():
             return self.config
 
         namespace = dict(load_subconfig=load_subconfig, get_config=get_config)
         execfile(self.full_filename, namespace)
 
     def _convert_to_config(self):
         if self.data is None:
             ConfigLoaderError('self.data does not exist')
 
 
 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 NoConfigDefault(object): pass
-NoConfigDefault = NoConfigDefault()
+class __NoConfigDefault(object): pass
+NoConfigDefault = __NoConfigDefault()
 
 
 class ArgParseConfigLoader(CommandLineConfigLoader):
     
     def __init__(self, argv=None, arguments=(), *args, **kw):
         """Create a config loader for use with argparse.
 
         With the exception of ``argv`` and ``arguments``, other args and kwargs
         arguments here are passed onto the constructor of
         :class:`argparse.ArgumentParser`.
 
         Parameters
         ----------
 
         argv : optional, list
           If given, used to read command-line arguments from, otherwise
           sys.argv[1:] is used.
 
         arguments : optional, tuple
           Description of valid command-line arguments, to be called in sequence
           with parser.add_argument() to configure the parser.
         """
         super(CommandLineConfigLoader, self).__init__()
         if argv == None:
             argv = sys.argv[1:]
         self.argv = argv
         self.arguments = arguments
         self.args = args
         self.kw = kw
 
     def load_config(self, args=None):
         """Parse command line arguments and return as a Struct.
 
         Parameters
         ----------
 
         args : optional, list
           If given, a list with the structure of sys.argv[1:] to parse arguments
           from.  If not given, the instance's self.argv attribute (given at
           construction time) is used."""
         
         if args is None:
             args = self.argv
         self._create_parser()
         self._parse_args(args)
         self._convert_to_config()
         return self.config
 
     def get_extra_args(self):
         if hasattr(self, 'extra_args'):
             return self.extra_args
         else:
             return []
 
     def _create_parser(self):
         self.parser = ArgumentParser(*self.args, **self.kw)
         self._add_arguments()
         self._add_other_arguments()
 
     def _add_other_arguments(self):
         pass
 
     def _add_arguments(self):
         for argument in self.arguments:
             argument[1].setdefault('default', NoConfigDefault)
             self.parser.add_argument(*argument[0],**argument[1])
 
     def _parse_args(self, args):
         """self.parser->self.parsed_data""" 
         self.parsed_data, self.extra_args = self.parser.parse_known_args(args)
 
     def _convert_to_config(self):
         """self.parsed_data->self.config"""
         for k, v in vars(self.parsed_data).items():
             if v is not NoConfigDefault:
                 exec_str = 'self.config.' + k + '= v'
                 exec exec_str in locals(), globals()

IPython/core/builtin_trap.py

@@ -1,118 +1,118 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A context manager for managing things injected into :mod:`__builtin__`.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  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 __builtin__
 
 from IPython.core.component import Component
 from IPython.core.quitter import Quitter
 
 from IPython.utils.autoattr import auto_attr
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
-class BuiltinUndefined(object): pass
-BuiltinUndefined = BuiltinUndefined()
+class __BuiltinUndefined(object): pass
+BuiltinUndefined = __BuiltinUndefined()
 
 
 class BuiltinTrap(Component):
 
     def __init__(self, parent):
         super(BuiltinTrap, self).__init__(parent, None, None)
         self._orig_builtins = {}
         # We define this to track if a single BuiltinTrap is nested.
         # Only turn off the trap when the outermost call to __exit__ is made.
         self._nested_level = 0
 
     @auto_attr
     def shell(self):
         return Component.get_instances(
             root=self.root,
             klass='IPython.core.iplib.InteractiveShell')[0]
 
     def __enter__(self):
         if self._nested_level == 0:
             self.set()
         self._nested_level += 1
         # I return self, so callers can use add_builtin in a with clause.
         return self
 
     def __exit__(self, type, value, traceback):
         if self._nested_level == 1:
             self.unset()
         self._nested_level -= 1
         # Returning False will cause exceptions to propagate
         return False
 
     def add_builtin(self, key, value):
         """Add a builtin and save the original."""
         orig = __builtin__.__dict__.get(key, BuiltinUndefined)
         self._orig_builtins[key] = orig
         __builtin__.__dict__[key] = value
 
     def remove_builtin(self, key):
         """Remove an added builtin and re-set the original."""
         try:
             orig = self._orig_builtins.pop(key)
         except KeyError:
             pass
         else:
             if orig is BuiltinUndefined:
                 del __builtin__.__dict__[key]
             else:
                 __builtin__.__dict__[key] = orig
 
     def set(self):
         """Store ipython references in the __builtin__ namespace."""
         self.add_builtin('exit', Quitter(self.shell, 'exit'))
         self.add_builtin('quit', Quitter(self.shell, 'quit'))
         self.add_builtin('get_ipython', self.shell.get_ipython)
 
         # Recursive reload function
         try:
             from IPython.lib import deepreload
             if self.shell.deep_reload:
                 self.add_builtin('reload', deepreload.reload)
             else:
                 self.add_builtin('dreload', deepreload.reload)
             del deepreload
         except ImportError:
             pass
 
         # Keep in the builtins a flag for when IPython is active.  We set it
         # with setdefault so that multiple nested IPythons don't clobber one
         # another.  Each will increase its value by one upon being activated,
         # which also gives us a way to determine the nesting level.
         __builtin__.__dict__.setdefault('__IPYTHON__active',0)
 
     def unset(self):
         """Remove any builtins which might have been added by add_builtins, or
         restore overwritten ones to their previous values."""
         for key in self._orig_builtins.keys():
             self.remove_builtin(key)
         self._orig_builtins.clear()
         self._builtins_added = False
         try:
             del __builtin__.__dict__['__IPYTHON__active']
         except KeyError:
             pass

IPython/core/component.py

@@ -1,346 +1,346 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A lightweight component system for IPython.
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  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 copy import deepcopy
 import datetime
 from weakref import WeakValueDictionary
 
 from IPython.utils.importstring import import_item
 from IPython.config.loader import Config
 from IPython.utils.traitlets import (
     HasTraitlets, TraitletError, MetaHasTraitlets, Instance, This
 )
 
 
 #-----------------------------------------------------------------------------
 # Helper classes for Components
 #-----------------------------------------------------------------------------
 
 
 class ComponentError(Exception):
     pass
 
 class MetaComponentTracker(type):
     """A metaclass that tracks instances of Components and its subclasses."""
 
     def __init__(cls, name, bases, d):
         super(MetaComponentTracker, cls).__init__(name, bases, d)
         cls.__instance_refs = WeakValueDictionary()
         cls.__numcreated = 0
 
     def __call__(cls, *args, **kw):
         """Called when a class is called (instantiated)!!!
         
         When a Component or subclass is instantiated, this is called and
         the instance is saved in a WeakValueDictionary for tracking.
         """
         instance = cls.__new__(cls, *args, **kw)
 
         # Register the instance before __init__ is called so get_instances 
         # works inside __init__ methods!
         indices = cls.register_instance(instance)
 
         # This is in a try/except because of the __init__ method fails, the
         # instance is discarded and shouldn't be tracked.
         try:
             if isinstance(instance, cls):
                 cls.__init__(instance, *args, **kw)
         except:
             # Unregister the instance because __init__ failed!
             cls.unregister_instances(indices)
             raise
         else:
             return instance
 
     def register_instance(cls, instance):
         """Register instance with cls and its subclasses."""
         # indices is a list of the keys used to register the instance
         # with.  This list is needed if the instance needs to be unregistered.
         indices = []
         for c in cls.__mro__:
             if issubclass(cls, c) and issubclass(c, Component):
                 c.__numcreated += 1
                 indices.append(c.__numcreated)
                 c.__instance_refs[c.__numcreated] = instance
             else:
                 break
         return indices
 
     def unregister_instances(cls, indices):
         """Unregister instance with cls and its subclasses."""
         for c, index in zip(cls.__mro__, indices):
             try:
                 del c.__instance_refs[index]
             except KeyError:
                 pass
 
     def clear_instances(cls):
         """Clear all instances tracked by cls."""
         cls.__instance_refs.clear()
         cls.__numcreated = 0
 
     def get_instances(cls, name=None, root=None, klass=None):
         """Get all instances of cls and its subclasses.
 
         Parameters
         ----------
         name : str
             Limit to components with this name.
         root : Component or subclass
             Limit to components having this root.
         klass : class or str
             Limits to instances of the class or its subclasses.  If a str
             is given ut must be in the form 'foo.bar.MyClass'.  The str
             form of this argument is useful for forward declarations.
         """
         if klass is not None:
             if isinstance(klass, basestring):
                 klass = import_item(klass)
             # Limit search to instances of klass for performance
             if issubclass(klass, Component):
                 return klass.get_instances(name=name, root=root)
         instances = cls.__instance_refs.values()
         if name is not None:
             instances = [i for i in instances if i.name == name]
         if klass is not None:
             instances = [i for i in instances if isinstance(i, klass)]
         if root is not None:
             instances = [i for i in instances if i.root == root]
         return instances
 
     def get_instances_by_condition(cls, call, name=None, root=None,
                                    klass=None):
         """Get all instances of cls, i such that call(i)==True.
 
         This also takes the ``name`` and ``root`` and ``classname`` 
         arguments of :meth:`get_instance`
         """
         return [i for i in cls.get_instances(name, root, klass) if call(i)]
 
 
 def masquerade_as(instance, cls):
     """Let instance masquerade as an instance of cls.
 
     Sometimes, such as in testing code, it is useful to let a class
     masquerade as another.  Python, being duck typed, allows this by 
     default.  But, instances of components are tracked by their class type.
 
     After calling this, ``cls.get_instances()`` will return ``instance``. This
     does not, however, cause ``isinstance(instance, cls)`` to return ``True``.
 
     Parameters
     ----------
     instance : an instance of a Component or Component subclass
         The instance that will pretend to be a cls.
     cls : subclass of Component
         The Component subclass that instance will pretend to be.
     """
     cls.register_instance(instance)
 
 
-class ComponentNameGenerator(object):
+class __ComponentNameGenerator(object):
     """A Singleton to generate unique component names."""
 
     def __init__(self, prefix):
         self.prefix = prefix
         self.i = 0
 
     def __call__(self):
         count = self.i
         self.i += 1
         return "%s%s" % (self.prefix, count)
 
 
-ComponentNameGenerator = ComponentNameGenerator('ipython.component')
+ComponentNameGenerator = __ComponentNameGenerator('ipython.component')
 
 
 class MetaComponent(MetaHasTraitlets, MetaComponentTracker):
     pass
 
 
 #-----------------------------------------------------------------------------
 # Component implementation
 #-----------------------------------------------------------------------------
 
 
 class Component(HasTraitlets):
 
     __metaclass__ = MetaComponent
 
     # Traitlets are fun!
     config = Instance(Config,(),{})
     parent = This()
     root = This()
     created = None
 
     def __init__(self, parent, name=None, config=None):
         """Create a component given a parent and possibly and name and config.
 
         Parameters
         ----------
         parent : Component subclass
             The parent in the component graph.  The parent is used
             to get the root of the component graph.
         name : str
             The unique name of the component.  If empty, then a unique
             one will be autogenerated.
         config : Config
             If this is empty, self.config = parent.config, otherwise
             self.config = config and root.config is ignored.  This argument
             should only be used to *override* the automatic inheritance of 
             parent.config.  If a caller wants to modify parent.config 
             (not override), the caller should make a copy and change 
             attributes and then pass the copy to this argument.
         
         Notes
         -----
         Subclasses of Component must call the :meth:`__init__` method of
         :class:`Component` *before* doing anything else and using 
         :func:`super`::
         
             class MyComponent(Component):
                 def __init__(self, parent, name=None, config=None):
                     super(MyComponent, self).__init__(parent, name, config)
                     # Then any other code you need to finish initialization.
 
         This ensures that the :attr:`parent`, :attr:`name` and :attr:`config`
         attributes are handled properly.
         """
         super(Component, self).__init__()
         self._children = []
         if name is None:
             self.name = ComponentNameGenerator()
         else:
             self.name = name
         self.root = self # This is the default, it is set when parent is set
         self.parent = parent
         if config is not None:
             self.config = config
             # We used to deepcopy, but for now we are trying to just save
             # by reference.  This *could* have side effects as all components
             # will share config. In fact, I did find such a side effect in
             # _config_changed below. If a config attribute value was a mutable type
             # all instances of a component were getting the same copy, effectively
             # making that a class attribute.
             # self.config = deepcopy(config)
         else:
             if self.parent is not None:
                 self.config = self.parent.config
                 # We used to deepcopy, but for now we are trying to just save
                 # by reference.  This *could* have side effects as all components
                 # will share config. In fact, I did find such a side effect in
                 # _config_changed below. If a config attribute value was a mutable type
                 # all instances of a component were getting the same copy, effectively
                 # making that a class attribute.
                 # self.config = deepcopy(self.parent.config)
 
         self.created = datetime.datetime.now()
 
     #-------------------------------------------------------------------------
     # Static traitlet notifiations
     #-------------------------------------------------------------------------
 
     def _parent_changed(self, name, old, new):
         if old is not None:
             old._remove_child(self)
         if new is not None:
             new._add_child(self)
 
         if new is None:
             self.root = self
         else:
             self.root = new.root
 
     def _root_changed(self, name, old, new):
         if self.parent is None:
             if not (new is self):
                 raise ComponentError("Root not self, but parent is None.")
         else:
             if not self.parent.root is new:
                 raise ComponentError("Error in setting the root attribute: "
                                      "root != parent.root")
 
     def _config_changed(self, name, old, new):
         """Update all the class traits having ``config=True`` as metadata.
 
         For any class traitlet with a ``config`` metadata attribute that is
         ``True``, we update the traitlet with the value of the corresponding
         config entry.
         """
         # Get all traitlets with a config metadata entry that is True
         traitlets = self.traitlets(config=True)
 
         # We auto-load config section for this class as well as any parent
         # classes that are Component subclasses.  This starts with Component
         # and works down the mro loading the config for each section.
         section_names = [cls.__name__ for cls in \
             reversed(self.__class__.__mro__) if 
             issubclass(cls, Component) and issubclass(self.__class__, cls)]
 
         for sname in section_names:
             # Don't do a blind getattr as that would cause the config to 
             # dynamically create the section with name self.__class__.__name__.
             if new._has_section(sname):
                 my_config = new[sname]
                 for k, v in traitlets.items():
                     # Don't allow traitlets with config=True to start with
                     # uppercase.  Otherwise, they are confused with Config
                     # subsections.  But, developers shouldn't have uppercase
                     # attributes anyways! (PEP 6)
                     if k[0].upper()==k[0] and not k.startswith('_'):
                         raise ComponentError('Component traitlets with '
                         'config=True must start with a lowercase so they are '
                         'not confused with Config subsections: %s.%s' % \
                         (self.__class__.__name__, k))
                     try:
                         # Here we grab the value from the config
                         # If k has the naming convention of a config
                         # section, it will be auto created.
                         config_value = my_config[k]
                     except KeyError:
                         pass
                     else:
                         # print "Setting %s.%s from %s.%s=%r" % \
                         #     (self.__class__.__name__,k,sname,k,config_value)
                         # We have to do a deepcopy here if we don't deepcopy the entire
                         # config object. If we don't, a mutable config_value will be
                         # shared by all instances, effectively making it a class attribute.
                         setattr(self, k, deepcopy(config_value))
 
     @property
     def children(self):
         """A list of all my child components."""
         return self._children
 
     def _remove_child(self, child):
         """A private method for removing children components."""
         if child in self._children:
             index = self._children.index(child)
             del self._children[index]
 
     def _add_child(self, child):
         """A private method for adding children components."""
         if child not in self._children:
             self._children.append(child)
 
     def __repr__(self):
         return "<%s('%s')>" % (self.__class__.__name__, self.name)

docs/autogen_api.py

@@ -1,43 +1,65 b''
 #!/usr/bin/env python
 """Script to auto-generate our API docs.
 """
 # stdlib imports
 import os
 import sys
 
 # local imports
 sys.path.append(os.path.abspath('sphinxext'))
 from apigen import ApiDocWriter
 
 #*****************************************************************************
 if __name__ == '__main__':
     pjoin = os.path.join
     package = 'IPython'
     outdir = pjoin('source','api','generated')
     docwriter = ApiDocWriter(package,rst_extension='.txt')
     # You have to escape the . here because . is a special char for regexps.
     # You must do make clean if you change this!
     docwriter.package_skip_patterns += [r'\.fixes$',
                                         r'\.external$',
                                         r'\.extensions',
                                         r'\.kernel\.config',
                                         r'\.attic',
                                         r'\.quarantine',
                                         r'\.deathrow',
                                         r'\.config\.default',
                                         r'\.config\.profile',
                                         r'\.frontend',
                                         r'\.gui'
                                         ]
+
     docwriter.module_skip_patterns += [ r'\.core\.fakemodule',
+                                        
+                                        # XXX These need fixing, disabling for
+                                        # now but we need to figure out why
+                                        # they are breaking.  Error from sphinx
+                                        # for each group copied below
+                                        
+                                        # AttributeError: __abstractmethods__
+                                        r'\.core\.component',
+                                        r'\.utils\.traitlets',
+        
+                                        # AttributeError: __provides__
+                                        r'\.kernel\.clusterdir',
+                                        r'\.kernel\.configobjfactory',
+                                        r'\.kernel\.fcutil',
+                                        r'\.kernel\.ipcontrollerapp',
+                                        r'\.kernel\.launcher',
+                                        r'\.kernel\.task',
+                                        r'\.kernel\.winhpcjob',
+                                        r'\.testing\.util',
+    
+                                        # Keeping these disabled is OK
                                         r'\.cocoa',
                                         r'\.ipdoctest',
                                         r'\.Gnuplot',
                                         r'\.frontend\.process\.winprocess',
                                         r'\.Shell',
                                         ]
     docwriter.write_api_docs(outdir)
     docwriter.write_index(outdir, 'gen',
                           relative_to = pjoin('source','api')
                           )
     print '%d files written' % len(docwriter.written_modules)