loader.py
705 lines
| 23.8 KiB
| text/x-python
|
PythonLexer
|
r2245 | """A simple configuration system. | ||
|
r8795 | Inheritance diagram: | ||
.. inheritance-diagram:: IPython.config.loader | ||||
:parts: 3 | ||||
|
r2361 | Authors | ||
------- | ||||
|
r2245 | * Brian Granger | ||
|
r2361 | * Fernando Perez | ||
|
r4018 | * Min RK | ||
|
r2157 | """ | ||
#----------------------------------------------------------------------------- | ||||
|
r4018 | # Copyright (C) 2008-2011 The IPython Development Team | ||
|
r2157 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r4731 | import __builtin__ as builtin_mod | ||
|
r5189 | import os | ||
|
r3852 | import re | ||
|
r2185 | import sys | ||
|
r2157 | |||
|
r2185 | from IPython.external import argparse | ||
|
r4030 | from IPython.utils.path import filefind, get_ipython_dir | ||
|
r4783 | from IPython.utils import py3compat, text, warn | ||
|
r6716 | from IPython.utils.encoding import DEFAULT_ENCODING | ||
|
r2157 | |||
#----------------------------------------------------------------------------- | ||||
|
r2245 | # Exceptions | ||
|
r2157 | #----------------------------------------------------------------------------- | ||
|
r2245 | class ConfigError(Exception): | ||
|
r2157 | pass | ||
|
r2245 | class ConfigLoaderError(ConfigError): | ||
pass | ||||
|
r4905 | class ConfigFileNotFound(ConfigError): | ||
pass | ||||
|
r3951 | class ArgumentError(ConfigLoaderError): | ||
pass | ||||
|
r2361 | #----------------------------------------------------------------------------- | ||
# Argparse fix | ||||
#----------------------------------------------------------------------------- | ||||
|
r2500 | |||
|
r2361 | # 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.""" | ||||
|
r4872 | |||
|
r2361 | def print_help(self, file=None): | ||
if file is None: | ||||
file = sys.stdout | ||||
return super(ArgumentParser, self).print_help(file) | ||||
|
r4872 | |||
|
r2361 | print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__ | ||
|
r4872 | |||
|
r2245 | #----------------------------------------------------------------------------- | ||
# 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 = {} | ||||
|
r3114 | for k, v in other.iteritems(): | ||
|
r7859 | if k not in self: | ||
|
r2245 | 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 | ||||
|
r3113 | def __contains__(self, key): | ||
|
r2245 | if self._is_section_key(key): | ||
return True | ||||
else: | ||||
|
r3113 | return super(Config, self).__contains__(key) | ||
# .has_key is deprecated for dictionaries. | ||||
has_key = __contains__ | ||||
|
r2245 | |||
def _has_section(self, key): | ||||
if self._is_section_key(key): | ||||
|
r3113 | if super(Config, self).__contains__(key): | ||
|
r2245 | 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): | ||||
|
r3497 | # We cannot use directly self._is_section_key, because it triggers | ||
# infinite recursion on top of PyPy. Instead, we manually fish the | ||||
# bound method. | ||||
is_section_key = self.__class__._is_section_key.__get__(self) | ||||
|
r4872 | |||
|
r2245 | # Because we use this for an exec namespace, we need to delegate | ||
# the lookup of names in __builtin__ to itself. This means | ||||
|
r4872 | # that you can't have section or attribute names that are | ||
|
r2245 | # builtins. | ||
try: | ||||
|
r4731 | return getattr(builtin_mod, key) | ||
|
r2245 | except AttributeError: | ||
pass | ||||
|
r3497 | if is_section_key(key): | ||
|
r2245 | 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. | ||||
|
r4731 | if hasattr(builtin_mod, key): | ||
|
r2245 | 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) | ||||
|
r7787 | except KeyError as e: | ||
|
r2245 | raise AttributeError(e) | ||
def __setattr__(self, key, value): | ||||
try: | ||||
self.__setitem__(key, value) | ||||
|
r7787 | except KeyError as e: | ||
|
r2245 | raise AttributeError(e) | ||
def __delattr__(self, key): | ||||
try: | ||||
dict.__delitem__(self, key) | ||||
|
r7787 | except KeyError as e: | ||
|
r2245 | raise AttributeError(e) | ||
#----------------------------------------------------------------------------- | ||||
# Config loading classes | ||||
#----------------------------------------------------------------------------- | ||||
|
r2157 | class ConfigLoader(object): | ||
"""A object for loading configurations from just about anywhere. | ||||
|
r4872 | |||
|
r2157 | The resulting configuration is packaged as a :class:`Struct`. | ||
|
r4872 | |||
|
r2185 | Notes | ||
----- | ||||
|
r4872 | A :class:`ConfigLoader` does one thing: load a config from a source | ||
|
r2185 | (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 | ||||
|
r4872 | default values or merge multiple configs. These things need to be | ||
|
r2185 | handled elsewhere. | ||
|
r2157 | """ | ||
def __init__(self): | ||||
"""A base class for config loaders. | ||||
|
r4872 | |||
|
r2157 | Examples | ||
-------- | ||||
|
r4872 | |||
|
r2157 | >>> cl = ConfigLoader() | ||
>>> config = cl.load_config() | ||||
>>> config | ||||
{} | ||||
""" | ||||
self.clear() | ||||
def clear(self): | ||||
|
r2245 | self.config = Config() | ||
|
r2157 | |||
def load_config(self): | ||||
|
r2500 | """Load a config from somewhere, return a :class:`Config` instance. | ||
|
r4872 | |||
|
r2157 | Usually, this will cause self.config to be set and then returned. | ||
|
r2500 | However, in most cases, :meth:`ConfigLoader.clear` should be called | ||
to erase any previous state. | ||||
|
r2157 | """ | ||
|
r2500 | self.clear() | ||
|
r2157 | return self.config | ||
class FileConfigLoader(ConfigLoader): | ||||
|
r2185 | """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): | ||||
|
r2157 | """A config loader for pure python files. | ||
|
r4872 | |||
|
r2157 | This calls execfile on a plain python file and looks for attributes | ||
that are all caps. These attribute are added to the config Struct. | ||||
""" | ||||
|
r2200 | def __init__(self, filename, path=None): | ||
|
r2157 | """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 | ||||
|
r2185 | paths to try in order. | ||
|
r2157 | """ | ||
|
r2185 | super(PyFileConfigLoader, self).__init__() | ||
|
r2157 | self.filename = filename | ||
self.path = path | ||||
self.full_filename = '' | ||||
self.data = None | ||||
|
r2185 | def load_config(self): | ||
"""Load the config from a file and return it as a Struct.""" | ||||
|
r2500 | self.clear() | ||
|
r4905 | try: | ||
self._find_file() | ||||
except IOError as e: | ||||
raise ConfigFileNotFound(str(e)) | ||||
|
r2185 | self._read_file_as_dict() | ||
|
r2245 | self._convert_to_config() | ||
|
r2185 | return self.config | ||
|
r2157 | |||
|
r2185 | def _find_file(self): | ||
"""Try to find the file by searching the paths.""" | ||||
|
r2200 | self.full_filename = filefind(self.filename, self.path) | ||
|
r2185 | |||
def _read_file_as_dict(self): | ||||
|
r2258 | """Load the config file into self.config, with recursive loading.""" | ||
# This closure is made available in the namespace that is used | ||||
|
r4030 | # to exec the config file. It allows users to call | ||
|
r2258 | # 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. | ||||
|
r4872 | |||
|
r4030 | # If a profile is specified, the config file will be loaded | ||
# from that profile | ||||
|
r4872 | |||
|
r4030 | 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) | ||||
|
r2325 | try: | ||
sub_config = loader.load_config() | ||||
|
r4905 | except ConfigFileNotFound: | ||
|
r2325 | # Pass silently if the sub config is not there. This happens | ||
|
r4030 | # when a user s using a profile, but not the default config. | ||
|
r2325 | pass | ||
else: | ||||
self.config._merge(sub_config) | ||||
|
r4872 | |||
|
r2261 | # 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 | ||||
|
r10646 | namespace = dict( | ||
load_subconfig=load_subconfig, | ||||
get_config=get_config, | ||||
__file__=self.full_filename, | ||||
) | ||||
|
r3458 | fs_encoding = sys.getfilesystemencoding() or 'ascii' | ||
conf_filename = self.full_filename.encode(fs_encoding) | ||||
|
r4731 | py3compat.execfile(conf_filename, namespace) | ||
|
r2157 | |||
|
r2245 | def _convert_to_config(self): | ||
|
r2157 | if self.data is None: | ||
ConfigLoaderError('self.data does not exist') | ||||
class CommandLineConfigLoader(ConfigLoader): | ||||
|
r2185 | """A config loader for command line arguments. | ||
|
r2157 | |||
|
r2185 | As we add more command line based loaders, the common logic should go | ||
here. | ||||
""" | ||||
|
r2157 | |||
|
r4471 | def _exec_config_str(self, lhs, rhs): | ||
|
r6757 | """execute self.config.<lhs> = <rhs> | ||
|
r5189 | |||
* expands ~ with expanduser | ||||
|
r6757 | * tries to assign with raw eval, otherwise assigns with just the string, | ||
|
r5189 | allowing `--C.a=foobar` and `--C.a="foobar"` to be equivalent. *Not* | ||
equivalent are `--C.a=4` and `--C.a='4'`. | ||||
""" | ||||
rhs = os.path.expanduser(rhs) | ||||
|
r4471 | try: | ||
# Try to see if regular Python syntax will work. This | ||||
# won't handle strings as the quote marks are removed | ||||
# by the system shell. | ||||
|
r6757 | value = eval(rhs) | ||
|
r4471 | except (NameError, SyntaxError): | ||
|
r6757 | # This case happens if the rhs is a string. | ||
value = rhs | ||||
exec u'self.config.%s = value' % lhs | ||||
|
r4872 | |||
|
r4471 | def _load_flag(self, cfg): | ||
"""update self.config from a flag, which can be a dict or Config""" | ||||
if isinstance(cfg, (dict, Config)): | ||||
# don't clobber whole config sections, update | ||||
# each section from config: | ||||
for sec,c in cfg.iteritems(): | ||||
self.config[sec].update(c) | ||||
else: | ||||
|
r6270 | raise TypeError("Invalid flag: %r" % cfg) | ||
|
r4471 | |||
|
r4214 | # raw --identifier=value pattern | ||
# but *also* accept '-' as wordsep, for aliases | ||||
# accepts: --foo=a | ||||
# --Class.trait=value | ||||
# --alias-name=value | ||||
# rejects: -foo=value | ||||
# --foo | ||||
# --Class.trait | ||||
kv_pattern = re.compile(r'\-\-[A-Za-z][\w\-]*(\.[\w\-]+)*\=.*') | ||||
# just flags, no assignments, with two *or one* leading '-' | ||||
# accepts: --foo | ||||
# -foo-bar-again | ||||
# rejects: --anything=anything | ||||
# --two.word | ||||
|
r4197 | flag_pattern = re.compile(r'\-\-?\w+[\-\w]*$') | ||
|
r2157 | |||
|
r3786 | class KeyValueConfigLoader(CommandLineConfigLoader): | ||
"""A config loader that loads key value pairs from the command line. | ||||
This allows command line options to be gives in the following form:: | ||||
|
r4872 | |||
|
r4197 | ipython --profile="foo" --InteractiveShell.autocall=False | ||
|
r3786 | """ | ||
|
r3861 | def __init__(self, argv=None, aliases=None, flags=None): | ||
|
r3786 | """Create a key value pair config loader. | ||
Parameters | ||||
---------- | ||||
argv : list | ||||
A list that has the form of sys.argv[1:] which has unicode | ||||
elements of the form u"key=value". If this is None (default), | ||||
then sys.argv[1:] will be used. | ||||
|
r3861 | aliases : dict | ||
|
r3852 | A dict of aliases for configurable traits. | ||
Keys are the short aliases, Values are the resolved trait. | ||||
|
r3861 | Of the form: `{'alias' : 'Configurable.trait'}` | ||
flags : dict | ||||
A dict of flags, keyed by str name. Vaues can be Config objects, | ||||
dicts, or "key=value" strings. If Config or dict, when the flag | ||||
is triggered, The flag is loaded as `self.config.update(m)`. | ||||
|
r3786 | |||
Returns | ||||
------- | ||||
config : Config | ||||
The resulting Config object. | ||||
Examples | ||||
-------- | ||||
>>> from IPython.config.loader import KeyValueConfigLoader | ||||
>>> cl = KeyValueConfigLoader() | ||||
|
r7015 | >>> d = cl.load_config(["--A.name='brian'","--B.number=0"]) | ||
>>> sorted(d.items()) | ||||
[('A', {'name': 'brian'}), ('B', {'number': 0})] | ||||
|
r3786 | """ | ||
|
r4021 | self.clear() | ||
|
r3789 | if argv is None: | ||
|
r3786 | argv = sys.argv[1:] | ||
self.argv = argv | ||||
|
r3861 | self.aliases = aliases or {} | ||
self.flags = flags or {} | ||||
|
r4872 | |||
|
r4021 | def clear(self): | ||
super(KeyValueConfigLoader, self).clear() | ||||
self.extra_args = [] | ||||
|
r4872 | |||
|
r4162 | def _decode_argv(self, argv, enc=None): | ||
"""decode argv if bytes, using stin.encoding, falling back on default enc""" | ||||
uargv = [] | ||||
if enc is None: | ||||
|
r6716 | enc = DEFAULT_ENCODING | ||
|
r4162 | for arg in argv: | ||
if not isinstance(arg, unicode): | ||||
# only decode if not already decoded | ||||
arg = arg.decode(enc) | ||||
uargv.append(arg) | ||||
return uargv | ||||
|
r4872 | |||
|
r3861 | def load_config(self, argv=None, aliases=None, flags=None): | ||
|
r3786 | """Parse the configuration and generate the Config object. | ||
|
r4872 | |||
|
r4021 | 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. | ||||
|
r4872 | |||
|
r3786 | Parameters | ||
---------- | ||||
argv : list, optional | ||||
A list that has the form of sys.argv[1:] which has unicode | ||||
elements of the form u"key=value". If this is None (default), | ||||
|
r3789 | then self.argv will be used. | ||
|
r3861 | aliases : dict | ||
|
r3852 | A dict of aliases for configurable traits. | ||
Keys are the short aliases, Values are the resolved trait. | ||||
|
r3861 | Of the form: `{'alias' : 'Configurable.trait'}` | ||
flags : dict | ||||
A dict of flags, keyed by str name. Values can be Config objects | ||||
|
r4872 | or dicts. When the flag is triggered, The config is loaded as | ||
|
r3861 | `self.config.update(cfg)`. | ||
|
r3786 | """ | ||
|
r3791 | from IPython.config.configurable import Configurable | ||
|
r3786 | self.clear() | ||
if argv is None: | ||||
argv = self.argv | ||||
|
r3861 | if aliases is None: | ||
aliases = self.aliases | ||||
if flags is None: | ||||
flags = self.flags | ||||
|
r4872 | |||
|
r4189 | # ensure argv is a list of unicode strings: | ||
uargv = self._decode_argv(argv) | ||||
for idx,raw in enumerate(uargv): | ||||
# strip leading '-' | ||||
item = raw.lstrip('-') | ||||
|
r4872 | |||
|
r4189 | if raw == '--': | ||
# don't parse arguments after '--' | ||||
|
r4211 | # this is useful for relaying arguments to scripts, e.g. | ||
# ipython -i foo.py --pylab=qt -- args after '--' go-to-foo.py | ||||
|
r4189 | self.extra_args.extend(uargv[idx+1:]) | ||
break | ||||
|
r4872 | |||
|
r4197 | if kv_pattern.match(raw): | ||
|
r3852 | lhs,rhs = item.split('=',1) | ||
|
r3861 | # Substitute longnames for aliases. | ||
if lhs in aliases: | ||||
lhs = aliases[lhs] | ||||
|
r4214 | if '.' not in lhs: | ||
# probably a mistyped alias, but not technically illegal | ||||
warn.warn("Unrecognized alias: '%s', it will probably have no effect."%lhs) | ||||
|
r5190 | try: | ||
self._exec_config_str(lhs, rhs) | ||||
except Exception: | ||||
raise ArgumentError("Invalid argument: '%s'" % raw) | ||||
|
r4872 | |||
|
r4197 | elif flag_pattern.match(raw): | ||
if item in flags: | ||||
cfg,help = flags[item] | ||||
|
r4471 | self._load_flag(cfg) | ||
|
r3852 | else: | ||
|
r4197 | raise ArgumentError("Unrecognized flag: '%s'"%raw) | ||
|
r4189 | elif raw.startswith('-'): | ||
|
r4197 | kv = '--'+item | ||
if kv_pattern.match(kv): | ||||
raise ArgumentError("Invalid argument: '%s', did you mean '%s'?"%(raw, kv)) | ||||
else: | ||||
raise ArgumentError("Invalid argument: '%s'"%raw) | ||||
|
r3958 | else: | ||
|
r4872 | # keep all args that aren't valid in a list, | ||
|
r3958 | # in case our parent knows what to do with them. | ||
|
r4211 | self.extra_args.append(item) | ||
|
r3786 | return self.config | ||
|
r2157 | class ArgParseConfigLoader(CommandLineConfigLoader): | ||
|
r3786 | """A loader that uses the argparse module to load from the command line.""" | ||
|
r2185 | |||
|
r4471 | def __init__(self, argv=None, aliases=None, flags=None, *parser_args, **parser_kw): | ||
|
r2500 | """Create a config loader for use with argparse. | ||
|
r2391 | |||
Parameters | ||||
---------- | ||||
argv : optional, list | ||||
If given, used to read command-line arguments from, otherwise | ||||
sys.argv[1:] is used. | ||||
|
r2403 | |||
|
r2500 | parser_args : tuple | ||
A tuple of positional arguments that will be passed to the | ||||
constructor of :class:`argparse.ArgumentParser`. | ||||
parser_kw : dict | ||||
A tuple of keyword arguments that will be passed to the | ||||
constructor of :class:`argparse.ArgumentParser`. | ||||
|
r3786 | |||
Returns | ||||
------- | ||||
config : Config | ||||
The resulting Config object. | ||||
|
r2157 | """ | ||
|
r2185 | super(CommandLineConfigLoader, self).__init__() | ||
|
r4471 | self.clear() | ||
if argv is None: | ||||
|
r2391 | argv = sys.argv[1:] | ||
self.argv = argv | ||||
|
r4471 | self.aliases = aliases or {} | ||
self.flags = flags or {} | ||||
|
r4872 | |||
|
r2500 | self.parser_args = parser_args | ||
|
r3440 | self.version = parser_kw.pop("version", None) | ||
|
r2500 | kwargs = dict(argument_default=argparse.SUPPRESS) | ||
kwargs.update(parser_kw) | ||||
self.parser_kw = kwargs | ||||
|
r2157 | |||
|
r4471 | def load_config(self, argv=None, aliases=None, flags=None): | ||
|
r3786 | """Parse command line arguments and return as a Config object. | ||
|
r2391 | |||
Parameters | ||||
---------- | ||||
args : optional, list | ||||
|
r2500 | 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.""" | ||||
self.clear() | ||||
|
r3786 | if argv is None: | ||
argv = self.argv | ||||
|
r4471 | if aliases is None: | ||
aliases = self.aliases | ||||
if flags is None: | ||||
flags = self.flags | ||||
self._create_parser(aliases, flags) | ||||
|
r3786 | self._parse_args(argv) | ||
|
r2245 | self._convert_to_config() | ||
|
r2185 | return self.config | ||
|
r2253 | def get_extra_args(self): | ||
if hasattr(self, 'extra_args'): | ||||
return self.extra_args | ||||
else: | ||||
return [] | ||||
|
r4471 | def _create_parser(self, aliases=None, flags=None): | ||
|
r2500 | self.parser = ArgumentParser(*self.parser_args, **self.parser_kw) | ||
|
r4471 | self._add_arguments(aliases, flags) | ||
|
r2200 | |||
|
r4471 | def _add_arguments(self, aliases=None, flags=None): | ||
|
r2501 | raise NotImplementedError("subclasses must implement _add_arguments") | ||
|
r2428 | |||
|
r2391 | def _parse_args(self, args): | ||
|
r3457 | """self.parser->self.parsed_data""" | ||
|
r3464 | # decode sys.argv to support unicode command-line options | ||
|
r6716 | enc = DEFAULT_ENCODING | ||
|
r4783 | uargs = [py3compat.cast_unicode(a, enc) for a in args] | ||
|
r3464 | self.parsed_data, self.extra_args = self.parser.parse_known_args(uargs) | ||
|
r2185 | |||
|
r2245 | def _convert_to_config(self): | ||
|
r2185 | """self.parsed_data->self.config""" | ||
|
r3114 | for k, v in vars(self.parsed_data).iteritems(): | ||
|
r4606 | exec "self.config.%s = v"%k in locals(), globals() | ||
|
r4471 | |||
class KVArgParseConfigLoader(ArgParseConfigLoader): | ||||
"""A config loader that loads aliases and flags with argparse, | ||||
|
r4872 | but will use KVLoader for the rest. This allows better parsing | ||
|
r4471 | of common args, such as `ipython -c 'print 5'`, but still gets | ||
arbitrary config with `ipython --InteractiveShell.use_readline=False`""" | ||||
|
r4872 | |||
|
r4471 | def _add_arguments(self, aliases=None, flags=None): | ||
self.alias_flags = {} | ||||
# print aliases, flags | ||||
if aliases is None: | ||||
aliases = self.aliases | ||||
if flags is None: | ||||
flags = self.flags | ||||
paa = self.parser.add_argument | ||||
for key,value in aliases.iteritems(): | ||||
if key in flags: | ||||
# flags | ||||
nargs = '?' | ||||
else: | ||||
nargs = None | ||||
if len(key) is 1: | ||||
|
r4830 | paa('-'+key, '--'+key, type=unicode, dest=value, nargs=nargs) | ||
|
r4471 | else: | ||
|
r4830 | paa('--'+key, type=unicode, dest=value, nargs=nargs) | ||
|
r4471 | for key, (value, help) in flags.iteritems(): | ||
if key in self.aliases: | ||||
|
r4872 | # | ||
|
r4471 | 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) | ||||
|
r4872 | |||
|
r4471 | 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 | ||||
if '_flags' in self.parsed_data: | ||||
subcs = self.parsed_data._flags | ||||
del self.parsed_data._flags | ||||
else: | ||||
subcs = [] | ||||
|
r4872 | |||
|
r4471 | for k, v in vars(self.parsed_data).iteritems(): | ||
if v is None: | ||||
# it was a flag that shares the name of an alias | ||||
subcs.append(self.alias_flags[k]) | ||||
else: | ||||
# eval the KV assignment | ||||
self._exec_config_str(k, v) | ||||
|
r4872 | |||
|
r4471 | for subc in subcs: | ||
|
r4606 | self._load_flag(subc) | ||
|
r4872 | |||
|
r4471 | if self.extra_args: | ||
sub_parser = KeyValueConfigLoader() | ||||
sub_parser.load_config(self.extra_args) | ||||
|
r4606 | self.config._merge(sub_parser.config) | ||
|
r4471 | self.extra_args = sub_parser.extra_args | ||
|
r6199 | |||
def load_pyconfig_files(config_files, path): | ||||
"""Load multiple Python config files, merging each of them in turn. | ||||
Parameters | ||||
========== | ||||
config_files : list of str | ||||
List of config files names to load and merge into the config. | ||||
path : unicode | ||||
The full path to the location of the config files. | ||||
""" | ||||
config = Config() | ||||
for cf in config_files: | ||||
loader = PyFileConfigLoader(cf, path=path) | ||||
try: | ||||
next_config = loader.load_config() | ||||
except ConfigFileNotFound: | ||||
pass | ||||
except: | ||||
raise | ||||
else: | ||||
config._merge(next_config) | ||||
return config | ||||