upstream/ipython Commit - r4872:34c10438

remove all trailling spaces

Bernardo B. Marques -

r4872:34c10438

parent child

Context file:

r4872:34c10438

Expand all files

The requested changes are too big and content was truncated. Show full diff

IPython/config/application.py +39 -39

                         new = getattr(logging, new)
                         self.log_level = new
                     self.log.setLevel(new)
                 # the alias map for configurables
                 aliases = Dict({'log-level' : 'Application.log_level'})
                 # flags for loading Configurables or store_const style flags
                 # flags are loaded from this dict by '--key' flags
                 # this must be a dict of two-tuples, the first element being the Config/dict
                         assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
                         assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
                         assert isinstance(value[1], basestring), "Bad flag: %r:%s"%(key,value)
                 # subcommands for launching other applications
                 # if this is not empty, this will be a parent Application
                 # this must be a dict of two-tuples,
                 # the first element being the application class/import string
                 # and the second being the help string for the subcommand
                 subcommands = Dict()
                 # parse_command_line will initialize a subapp, if requested
                 subapp = Instance('IPython.config.application.Application', allow_none=True)
                 # extra command-line arguments that don't set config values
                 extra_args = List(Unicode)
                 def __init__(self, **kwargs):
                     SingletonConfigurable.__init__(self, **kwargs)
                     # options and config files.
                     if self.__class__ not in self.classes:
                         self.classes.insert(0, self.__class__)
                     self.init_logging()
                 def _config_changed(self, name, old, new):
                     """Start logging for this application.
                     The default is to log to stdout using a StreaHandler. The log level
                     starts at loggin.WARN, but this can be adjusted by setting the
                     ``log_level`` attribute.
                     """
                     self.log = logging.getLogger(self.__class__.__name__)
                 def initialize(self, argv=None):
                     """Do the basic steps to configure me.
                     Override in subclasses.
                     """
                     self.parse_command_line(argv)
                 def start(self):
                     """Start the app mainloop.
                     Override in subclasses.
                     """
                     if self.subapp is not None:
                         return self.subapp.start()
                 def print_alias_help(self):
                     """Print the alias part of the help."""
                     if not self.aliases:
                         return
                     lines = []
                     classdict = {}
                     for cls in self.classes:
                         # include all parents (up to, but excluding Configurable) in available names
                         for c in cls.mro()[:-3]:
                             classdict[c.__name__] = c
                     for alias, longname in self.aliases.iteritems():
                         classname, traitname = longname.split('.',1)
                         cls = classdict[classname]
                         trait = cls.class_traits(config=True)[traitname]
                         help = cls.class_get_trait_help(trait).splitlines()
                         # reformat first line
                         lines.extend(help)
                     # lines.append('')
                     print os.linesep.join(lines)
                 def print_flag_help(self):
                     """Print the flag part of the help."""
                     if not self.flags:
                         return
                     lines = []
                     for m, (cfg,help) in self.flags.iteritems():
                         prefix = '--' if len(m) > 1 else '-'
                         lines.append(indent(dedent(help.strip())))
                     # lines.append('')
                     print os.linesep.join(lines)
                 def print_options(self):
                     if not self.flags and not self.aliases:
                         return
                     self.print_flag_help()
                     self.print_alias_help()
                     print
                 def print_subcommands(self):
                     """Print the subcommand part of the help."""
                     if not self.subcommands:
                         return
                     lines = ["Subcommands"]
                     lines.append('-'*len(lines[0]))
                     lines.append('')
                             lines.append(indent(dedent(help.strip())))
                     lines.append('')
                     print os.linesep.join(lines)
                 def print_help(self, classes=False):
                     """Print the help for each Configurable class in self.classes.
                     If classes=False (the default), only flags and aliases are printed.
                     """
                     self.print_subcommands()
                     self.print_options()
                     if classes:
                         if self.classes:
                             print "Class parameters"
                             for p in wrap_paragraphs(self.keyvalue_description):
                                 print p
                                 print
                         for cls in self.classes:
                             cls.class_print_help()
                             print
                     # Save the combined config as self.config, which triggers the traits
                     # events.
                     self.config = newconfig
                 def initialize_subcommand(self, subc, argv=None):
                     """Initialize a subcommand with argv."""
                     subapp,help = self.subcommands.get(subc)
                     if isinstance(subapp, basestring):
                         subapp = import_item(subapp)
                     # clear existing instances
                     self.__class__.clear_instance()
                     # instantiate
                     self.subapp = subapp.instance()
                     # and initialize subapp
                     self.subapp.initialize(argv)
                 def parse_command_line(self, argv=None):
                     """Parse the command line arguments."""
                     argv = sys.argv[1:] if argv is None else argv
                         if re.match(r'^\w(\-?\w)*$', subc) and subc in self.subcommands:
                             # it's a subcommand, and *not* a flag or class parameter
                             return self.initialize_subcommand(subc, subargv)
                     if '-h' in argv or '--help' in argv or '--help-all' in argv:
                         self.print_description()
                         self.print_help('--help-all' in argv)
                     if '--version' in argv:
                         self.print_version()
                         self.exit(0)
                     loader = KVArgParseConfigLoader(argv=argv, aliases=self.aliases,
                                                     flags=self.flags)
                     try:
                     else:
                         self.log.debug("Loaded config file: %s", loader.full_filename)
                         self.update_config(config)
                 def generate_config_file(self):
                     """generate default config file from Configurables"""
                     lines = ["# Configuration file for %s."%self.name]
             def boolean_flag(name, configurable, set_help='', unset_help=''):
                 """Helper for building basic --trait, --no-trait flags.
                 Parameters
                 ----------
                 name : str
                     The name of the flag.
                 configurable : str
                     help string for --name flag
                 unset_help : unicode
                     help string for --no-name flag
                 Returns
                 -------
                 cfg : dict
                     A dict with two keys: 'name', and 'no-name', for setting and unsetting
                     the trait, respectively.
                 # default helpstrings
                 set_help = set_help or "set %s=True"%configurable
                 unset_help = unset_help or "set %s=False"%configurable
                 cls,trait = configurable.split('.')
                 setter = {cls : {trait : True}}
                 unsetter = {cls : {trait : False}}
                 return {name : (setter, set_help), 'no-'+name : (unsetter, unset_help)}

IPython/config/configurable.py +26 -26

                     Parameters
                     ----------
                     config : Config
                         If this is empty, default values are used. If config is a
                         :class:`Config` instance, it will be used to configure the
                         instance.
                     Notes
                     -----
                     Subclasses of Configurable must call the :meth:`__init__` method of
                     :class:`Configurable` *before* doing anything else and using
                     :func:`super`::
                         class MyConfigurable(Configurable):
                             def __init__(self, config=None):
                                 super(MyConfigurable, self).__init__(config)
                         # making that a class attribute.
                         # self.config = deepcopy(config)
                         self.config = config
                     # This should go second so individual keyword arguments override
                     # the values in config.
                     super(Configurable, self).__init__(**kwargs)
                     self.created = datetime.datetime.now()
                     # classes that are Configurable subclasses.  This starts with Configurable
                     # 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, Configurable) 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]
                         help = cls.class_get_trait_help(v)
                         final_help.append(help)
                     return '\n'.join(final_help)
                 @classmethod
                 def class_get_trait_help(cls, trait):
                     """Get the help string for a single trait."""
                     if 'Enum' in trait.__class__.__name__:
                         # include Enum choices
                         lines.append(indent('Choices: %r'%(trait.values,)))
                     help = trait.get_metadata('help')
                     if help is not None:
                         help = '\n'.join(wrap_paragraphs(help, 76))
                     def c(s):
                         """return a commented, wrapped block."""
                         s = '\n\n'.join(wrap_paragraphs(s, 78))
                         return '# ' + s.replace('\n', '\n# ')
                     # section header
                     breaker = '#' + '-'*78
                     s = "# %s configuration"%cls.__name__
                     if desc:
                         lines.append(c(desc))
                         lines.append('')
                     parents = []
                     for parent in cls.mro():
                         # only include parents that are not base classes
                         if parent is not cls and issubclass(parent, Configurable) and \
                                 parent.class_traits(config=True):
                             parents.append(parent)
                     if parents:
                         pstr = ', '.join([ p.__name__ for p in parents ])
                         lines.append(c('%s will inherit config from: %s'%(cls.__name__, pstr)))
                         lines.append('')
                     for name,trait in cls.class_traits(config=True).iteritems():
                         help = trait.get_metadata('help') or ''
                         lines.append(c(help))
                         lines.append('# c.%s.%s = %r'%(cls.__name__, name, trait.get_default_value()))
                         lines.append('')
                     return '\n'.join(lines)
             class SingletonConfigurable(Configurable):
                 """A configurable that only allows one instance.
                 """
                 _instance = None
                 @classmethod
                 def _walk_mro(cls):
                     """Walk the cls.mro() for parent classes that are also singletons
                     For use in instance()
                     """
                     for subclass in cls.mro():
                         if issubclass(cls, subclass) and \
                                 issubclass(subclass, SingletonConfigurable) and \
                                 subclass != SingletonConfigurable:
                             yield subclass
                 @classmethod
                 def clear_instance(cls):
                     """unset _instance for this class and singleton parents.
                             # only clear instances that are instances
                             # of the calling class
                             subclass._instance = None
                 @classmethod
                 def instance(cls, *args, **kwargs):
                     """Returns a global instance of this class.
                         # parent classes' _instance attribute.
                         for subclass in cls._walk_mro():
                             subclass._instance = inst
                     if isinstance(cls._instance, cls):
                         return cls._instance
                     else:
             class LoggingConfigurable(Configurable):
                 """A parent class for Configurables that log.
                 Subclasses have a log trait, and the default behavior
                 is to get the logger from the currently running Application
                 via Application.instance().log.
                 """
                 log = Instance('logging.Logger')
                 def _log_default(self):
                     from IPython.config.application import Application
                     return Application.instance().log

IPython/config/loader.py +40 -40

             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
             #-----------------------------------------------------------------------------
                     # infinite recursion on top of PyPy. Instead, we manually fish the
                     # bound method.
                     is_section_key = self.__class__._is_section_key.__get__(self)
                     # 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_mod, key)
             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
                 def load_config(self):
                     """Load a config from somewhere, return a :class:`Config` instance.
                     Usually, this will cause self.config to be set and then returned.
                     However, in most cases, :meth:`ConfigLoader.clear` should be called
                     to erase any previous state.
             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.
                 """
                     # 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
                             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():
                         # it succeeds. If it still fails, we let it raise.
                         exec_str = u'self.config.' + lhs + '=' + repr(rhs)
                         exec exec_str in locals(), globals()
                 def _load_flag(self, cfg):
                     """update self.config from a flag, which can be a dict or Config"""
                     if isinstance(cfg, (dict, Config)):
                 """A config loader that loads key value pairs from the command line.
                 This allows command line options to be gives in the following form::
                     ipython --profile="foo" --InteractiveShell.autocall=False
                 """
                     self.argv = argv
                     self.aliases = aliases or {}
                     self.flags = flags or {}
                 def clear(self):
                     super(KeyValueConfigLoader, self).clear()
                     self.extra_args = []
                 def _decode_argv(self, argv, enc=None):
                     """decode argv if bytes, using stin.encoding, falling back on default enc"""
                     uargv = []
                             arg = arg.decode(enc)
                         uargv.append(arg)
                     return uargv
                 def load_config(self, argv=None, aliases=None, flags=None):
                     """Parse the configuration and generate the Config object.
                     After loading, any arguments that are not key-value or
                     flags will be stored in self.extra_args - a list of
                     unparsed command-line arguments.  This is used for
                     arguments such as input files or subcommands.
                     Parameters
                     ----------
                     argv : list, optional
                         Of the form: `{'alias' : 'Configurable.trait'}`
                     flags : dict
                         A dict of flags, keyed by str name. Values can be Config objects
                         or dicts.  When the flag is triggered, The config is loaded as
                         `self.config.update(cfg)`.
                     """
                     from IPython.config.configurable import Configurable
                         aliases = self.aliases
                     if flags is None:
                         flags = self.flags
                     # ensure argv is a list of unicode strings:
                     uargv = self._decode_argv(argv)
                     for idx,raw in enumerate(uargv):
                         # strip leading '-'
                         item = raw.lstrip('-')
                         if raw == '--':
                             # don't parse arguments after '--'
                             # this is useful for relaying arguments to scripts, e.g.
                             # ipython -i foo.py --pylab=qt -- args after '--' go-to-foo.py
                             self.extra_args.extend(uargv[idx+1:])
                             break
                         if kv_pattern.match(raw):
                             lhs,rhs = item.split('=',1)
                             # Substitute longnames for aliases.
                                 # probably a mistyped alias, but not technically illegal
                                 warn.warn("Unrecognized alias: '%s', it will probably have no effect."%lhs)
                             self._exec_config_str(lhs, rhs)
                         elif flag_pattern.match(raw):
                             if item in flags:
                                 cfg,help = flags[item]
                             else:
                                 raise ArgumentError("Invalid argument: '%s'"%raw)
                         else:
                             # keep all args that aren't valid in a list,
                             # in case our parent knows what to do with them.
                             self.extra_args.append(item)
                     return self.config
                     self.argv = argv
                     self.aliases = aliases or {}
                     self.flags = flags or {}
                     self.parser_args = parser_args
                     self.version = parser_kw.pop("version", None)
                     kwargs = dict(argument_default=argparse.SUPPRESS)
             class KVArgParseConfigLoader(ArgParseConfigLoader):
                 """A config loader that loads aliases and flags with argparse,
                 but will use KVLoader for the rest.  This allows better parsing
                 of common args, such as `ipython -c 'print 5'`, but still gets
                 arbitrary config with `ipython --InteractiveShell.use_readline=False`"""
                 def _convert_to_config(self):
                     """self.parsed_data->self.config"""
                     for k, v in vars(self.parsed_data).iteritems():
                             paa('--'+key, type=unicode, dest=value, nargs=nargs)
                     for key, (value, help) in flags.iteritems():
                         if key in self.aliases:
+                            #
                             self.alias_flags[self.aliases[key]] = value
                             continue
                         if len(key) is 1:
                             paa('-'+key, '--'+key, action='append_const', dest='_flags', const=value)
                         else:
                             paa('--'+key, action='append_const', dest='_flags', const=value)
                 def _convert_to_config(self):
                     """self.parsed_data->self.config, parse unrecognized extra args via KVLoader."""
                     # remove subconfigs list from namespace before transforming the Namespace
                         del self.parsed_data._flags
                     else:
                         subcs = []
                     for k, v in vars(self.parsed_data).iteritems():
                         if v is None:
                             # it was a flag that shares the name of an alias
                         else:
                             # eval the KV assignment
                             self._exec_config_str(k, v)
                     for subc in subcs:
                         self._load_flag(subc)
                     if self.extra_args:
                         sub_parser = KeyValueConfigLoader()
                         sub_parser.load_config(self.extra_args)