loader.py
569 lines
| 19.7 KiB
| text/x-python
|
PythonLexer
Brian Granger
|
r2245 | """A simple configuration system. | ||
Fernando Perez
|
r2361 | Authors | ||
------- | ||||
Brian Granger
|
r2245 | * Brian Granger | ||
Fernando Perez
|
r2361 | * Fernando Perez | ||
MinRK
|
r4018 | * Min RK | ||
Brian Granger
|
r2157 | """ | ||
#----------------------------------------------------------------------------- | ||||
MinRK
|
r4018 | # Copyright (C) 2008-2011 The IPython Development Team | ||
Brian Granger
|
r2157 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
Brian Granger
|
r2245 | import __builtin__ | ||
MinRK
|
r3852 | import re | ||
Brian Granger
|
r2185 | import sys | ||
Brian Granger
|
r2157 | |||
Brian Granger
|
r2185 | from IPython.external import argparse | ||
MinRK
|
r4030 | from IPython.utils.path import filefind, get_ipython_dir | ||
Brian Granger
|
r2157 | |||
#----------------------------------------------------------------------------- | ||||
Brian Granger
|
r2245 | # Exceptions | ||
Brian Granger
|
r2157 | #----------------------------------------------------------------------------- | ||
Brian Granger
|
r2245 | class ConfigError(Exception): | ||
Brian Granger
|
r2157 | pass | ||
Brian Granger
|
r2245 | class ConfigLoaderError(ConfigError): | ||
pass | ||||
MinRK
|
r3951 | class ArgumentError(ConfigLoaderError): | ||
pass | ||||
Fernando Perez
|
r2361 | #----------------------------------------------------------------------------- | ||
# Argparse fix | ||||
#----------------------------------------------------------------------------- | ||||
Brian Granger
|
r2500 | |||
Fernando Perez
|
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.""" | ||||
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__ | ||||
Brian Granger
|
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 = {} | ||||
Thomas Kluyver
|
r3114 | for k, v in other.iteritems(): | ||
Brian Granger
|
r2245 | 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 | ||||
Thomas Kluyver
|
r3113 | def __contains__(self, key): | ||
Brian Granger
|
r2245 | if self._is_section_key(key): | ||
return True | ||||
else: | ||||
Thomas Kluyver
|
r3113 | return super(Config, self).__contains__(key) | ||
# .has_key is deprecated for dictionaries. | ||||
has_key = __contains__ | ||||
Brian Granger
|
r2245 | |||
def _has_section(self, key): | ||||
if self._is_section_key(key): | ||||
Thomas Kluyver
|
r3113 | if super(Config, self).__contains__(key): | ||
Brian Granger
|
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): | ||||
Antonio Cuni <antocuni>
|
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) | ||||
Brian Granger
|
r2245 | # 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 | ||||
Antonio Cuni <antocuni>
|
r3497 | if is_section_key(key): | ||
Brian Granger
|
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. | ||||
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 | ||||
#----------------------------------------------------------------------------- | ||||
Brian Granger
|
r2157 | class ConfigLoader(object): | ||
"""A object for loading configurations from just about anywhere. | ||||
The resulting configuration is packaged as a :class:`Struct`. | ||||
Brian Granger
|
r2185 | |||
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. | ||||
Brian Granger
|
r2157 | """ | ||
def __init__(self): | ||||
"""A base class for config loaders. | ||||
Examples | ||||
-------- | ||||
>>> cl = ConfigLoader() | ||||
>>> config = cl.load_config() | ||||
>>> config | ||||
{} | ||||
""" | ||||
self.clear() | ||||
def clear(self): | ||||
Brian Granger
|
r2245 | self.config = Config() | ||
Brian Granger
|
r2157 | |||
def load_config(self): | ||||
Brian Granger
|
r2500 | """Load a config from somewhere, return a :class:`Config` instance. | ||
Brian Granger
|
r2157 | |||
Usually, this will cause self.config to be set and then returned. | ||||
Brian Granger
|
r2500 | However, in most cases, :meth:`ConfigLoader.clear` should be called | ||
to erase any previous state. | ||||
Brian Granger
|
r2157 | """ | ||
Brian Granger
|
r2500 | self.clear() | ||
Brian Granger
|
r2157 | return self.config | ||
class FileConfigLoader(ConfigLoader): | ||||
Brian Granger
|
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): | ||||
Brian Granger
|
r2157 | """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. | ||||
""" | ||||
Brian Granger
|
r2200 | def __init__(self, filename, path=None): | ||
Brian Granger
|
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 | ||||
Brian Granger
|
r2185 | paths to try in order. | ||
Brian Granger
|
r2157 | """ | ||
Brian Granger
|
r2185 | super(PyFileConfigLoader, self).__init__() | ||
Brian Granger
|
r2157 | self.filename = filename | ||
self.path = path | ||||
self.full_filename = '' | ||||
self.data = None | ||||
Brian Granger
|
r2185 | def load_config(self): | ||
"""Load the config from a file and return it as a Struct.""" | ||||
Brian Granger
|
r2500 | self.clear() | ||
Brian Granger
|
r2185 | self._find_file() | ||
self._read_file_as_dict() | ||||
Brian Granger
|
r2245 | self._convert_to_config() | ||
Brian Granger
|
r2185 | return self.config | ||
Brian Granger
|
r2157 | |||
Brian Granger
|
r2185 | def _find_file(self): | ||
"""Try to find the file by searching the paths.""" | ||||
Brian Granger
|
r2200 | self.full_filename = filefind(self.filename, self.path) | ||
Brian Granger
|
r2185 | |||
def _read_file_as_dict(self): | ||||
Brian Granger
|
r2258 | """Load the config file into self.config, with recursive loading.""" | ||
# This closure is made available in the namespace that is used | ||||
MinRK
|
r4030 | # to exec the config file. It allows users to call | ||
Brian Granger
|
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. | ||||
MinRK
|
r4030 | |||
# If a profile is specified, the config file will be loaded | ||||
# from that profile | ||||
def load_subconfig(fname, profile=None): | ||||
# import here to prevent circular imports | ||||
from IPython.core.profiledir import ProfileDir, ProfileDirError | ||||
if profile is not None: | ||||
try: | ||||
profile_dir = ProfileDir.find_profile_dir_by_name( | ||||
get_ipython_dir(), | ||||
profile, | ||||
) | ||||
except ProfileDirError: | ||||
return | ||||
path = profile_dir.location | ||||
else: | ||||
path = self.path | ||||
loader = PyFileConfigLoader(fname, path) | ||||
Brian Granger
|
r2325 | try: | ||
sub_config = loader.load_config() | ||||
except IOError: | ||||
# Pass silently if the sub config is not there. This happens | ||||
MinRK
|
r4030 | # when a user s using a profile, but not the default config. | ||
Brian Granger
|
r2325 | pass | ||
else: | ||||
self.config._merge(sub_config) | ||||
MinRK
|
r4030 | |||
Brian Granger
|
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 | ||||
namespace = dict(load_subconfig=load_subconfig, get_config=get_config) | ||||
Thomas Kluyver
|
r3458 | fs_encoding = sys.getfilesystemencoding() or 'ascii' | ||
conf_filename = self.full_filename.encode(fs_encoding) | ||||
Thomas Kluyver
|
r3452 | execfile(conf_filename, namespace) | ||
Brian Granger
|
r2157 | |||
Brian Granger
|
r2245 | def _convert_to_config(self): | ||
Brian Granger
|
r2157 | if self.data is None: | ||
ConfigLoaderError('self.data does not exist') | ||||
class CommandLineConfigLoader(ConfigLoader): | ||||
Brian Granger
|
r2185 | """A config loader for command line arguments. | ||
Brian Granger
|
r2157 | |||
Brian Granger
|
r2185 | As we add more command line based loaders, the common logic should go | ||
here. | ||||
""" | ||||
Brian Granger
|
r2157 | |||
MinRK
|
r4197 | kv_pattern = re.compile(r'\-\-[A-Za-z]\w*(\.\w+)*\=.*') | ||
flag_pattern = re.compile(r'\-\-?\w+[\-\w]*$') | ||||
Brian Granger
|
r2157 | |||
Brian Granger
|
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:: | ||||
MinRK
|
r4197 | ipython --profile="foo" --InteractiveShell.autocall=False | ||
Brian Granger
|
r3786 | """ | ||
MinRK
|
r3861 | def __init__(self, argv=None, aliases=None, flags=None): | ||
Brian Granger
|
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. | ||||
MinRK
|
r3861 | aliases : dict | ||
MinRK
|
r3852 | A dict of aliases for configurable traits. | ||
Keys are the short aliases, Values are the resolved trait. | ||||
MinRK
|
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)`. | ||||
Brian Granger
|
r3786 | |||
Returns | ||||
------- | ||||
config : Config | ||||
The resulting Config object. | ||||
Examples | ||||
-------- | ||||
>>> from IPython.config.loader import KeyValueConfigLoader | ||||
>>> cl = KeyValueConfigLoader() | ||||
MinRK
|
r4197 | >>> cl.load_config(["--foo='bar'","--A.name='brian'","--B.number=0"]) | ||
Brian Granger
|
r3786 | {'A': {'name': 'brian'}, 'B': {'number': 0}, 'foo': 'bar'} | ||
""" | ||||
MinRK
|
r4021 | self.clear() | ||
Brian Granger
|
r3789 | if argv is None: | ||
Brian Granger
|
r3786 | argv = sys.argv[1:] | ||
self.argv = argv | ||||
MinRK
|
r3861 | self.aliases = aliases or {} | ||
self.flags = flags or {} | ||||
MinRK
|
r4021 | |||
def clear(self): | ||||
super(KeyValueConfigLoader, self).clear() | ||||
self.extra_args = [] | ||||
MinRK
|
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: | ||||
enc = sys.stdin.encoding or sys.getdefaultencoding() | ||||
for arg in argv: | ||||
if not isinstance(arg, unicode): | ||||
# only decode if not already decoded | ||||
arg = arg.decode(enc) | ||||
uargv.append(arg) | ||||
return uargv | ||||
MinRK
|
r3861 | def load_config(self, argv=None, aliases=None, flags=None): | ||
Brian Granger
|
r3786 | """Parse the configuration and generate the Config object. | ||
MinRK
|
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. | ||||
Brian Granger
|
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), | ||||
Brian Granger
|
r3789 | then self.argv will be used. | ||
MinRK
|
r3861 | aliases : dict | ||
MinRK
|
r3852 | A dict of aliases for configurable traits. | ||
Keys are the short aliases, Values are the resolved trait. | ||||
MinRK
|
r3861 | 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)`. | ||||
Brian Granger
|
r3786 | """ | ||
Brian Granger
|
r3791 | from IPython.config.configurable import Configurable | ||
Brian Granger
|
r3786 | self.clear() | ||
if argv is None: | ||||
argv = self.argv | ||||
MinRK
|
r3861 | if aliases is None: | ||
aliases = self.aliases | ||||
if flags is None: | ||||
flags = self.flags | ||||
MinRK
|
r3958 | |||
MinRK
|
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('-') | ||||
if raw == '--': | ||||
# don't parse arguments after '--' | ||||
self.extra_args.extend(uargv[idx+1:]) | ||||
break | ||||
MinRK
|
r4197 | if kv_pattern.match(raw): | ||
MinRK
|
r3852 | lhs,rhs = item.split('=',1) | ||
MinRK
|
r3861 | # Substitute longnames for aliases. | ||
if lhs in aliases: | ||||
lhs = aliases[lhs] | ||||
Brian Granger
|
r3789 | exec_str = 'self.config.' + lhs + '=' + rhs | ||
try: | ||||
Brian Granger
|
r3791 | # Try to see if regular Python syntax will work. This | ||
# won't handle strings as the quote marks are removed | ||||
# by the system shell. | ||||
Brian Granger
|
r3789 | exec exec_str in locals(), globals() | ||
except (NameError, SyntaxError): | ||||
Brian Granger
|
r3791 | # This case happens if the rhs is a string but without | ||
MinRK
|
r4162 | # the quote marks. Use repr, to get quote marks, and | ||
# 'u' prefix and see if | ||||
Brian Granger
|
r3791 | # it succeeds. If it still fails, we let it raise. | ||
MinRK
|
r4162 | exec_str = u'self.config.' + lhs + '=' + repr(rhs) | ||
Brian Granger
|
r3789 | exec exec_str in locals(), globals() | ||
MinRK
|
r4197 | elif flag_pattern.match(raw): | ||
if item in flags: | ||||
cfg,help = flags[item] | ||||
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: | ||||
raise ValueError("Invalid flag: '%s'"%raw) | ||||
MinRK
|
r3852 | else: | ||
MinRK
|
r4197 | raise ArgumentError("Unrecognized flag: '%s'"%raw) | ||
MinRK
|
r4189 | elif raw.startswith('-'): | ||
MinRK
|
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) | ||||
MinRK
|
r3958 | else: | ||
# keep all args that aren't valid in a list, | ||||
# in case our parent knows what to do with them. | ||||
MinRK
|
r4189 | # self.extra_args.append(item) | ||
self.extra_args.extend(uargv[idx:]) | ||||
break | ||||
Brian Granger
|
r3786 | return self.config | ||
Brian Granger
|
r2157 | class ArgParseConfigLoader(CommandLineConfigLoader): | ||
Brian Granger
|
r3786 | """A loader that uses the argparse module to load from the command line.""" | ||
Brian Granger
|
r2185 | |||
Brian Granger
|
r2501 | def __init__(self, argv=None, *parser_args, **parser_kw): | ||
Brian Granger
|
r2500 | """Create a config loader for use with argparse. | ||
Fernando Perez
|
r2391 | |||
Parameters | ||||
---------- | ||||
argv : optional, list | ||||
If given, used to read command-line arguments from, otherwise | ||||
sys.argv[1:] is used. | ||||
Fernando Perez
|
r2403 | |||
Brian Granger
|
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`. | ||||
Brian Granger
|
r3786 | |||
Returns | ||||
------- | ||||
config : Config | ||||
The resulting Config object. | ||||
Brian Granger
|
r2157 | """ | ||
Brian Granger
|
r2185 | super(CommandLineConfigLoader, self).__init__() | ||
Fernando Perez
|
r2391 | if argv == None: | ||
argv = sys.argv[1:] | ||||
self.argv = argv | ||||
Brian Granger
|
r2500 | self.parser_args = parser_args | ||
Thomas Kluyver
|
r3440 | self.version = parser_kw.pop("version", None) | ||
Brian Granger
|
r2500 | kwargs = dict(argument_default=argparse.SUPPRESS) | ||
kwargs.update(parser_kw) | ||||
self.parser_kw = kwargs | ||||
Brian Granger
|
r2157 | |||
Brian Granger
|
r3786 | def load_config(self, argv=None): | ||
"""Parse command line arguments and return as a Config object. | ||||
Fernando Perez
|
r2391 | |||
Parameters | ||||
---------- | ||||
args : optional, list | ||||
Brian Granger
|
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() | ||||
Brian Granger
|
r3786 | if argv is None: | ||
argv = self.argv | ||||
Brian Granger
|
r2185 | self._create_parser() | ||
Brian Granger
|
r3786 | self._parse_args(argv) | ||
Brian Granger
|
r2245 | self._convert_to_config() | ||
Brian Granger
|
r2185 | return self.config | ||
Brian Granger
|
r2253 | def get_extra_args(self): | ||
if hasattr(self, 'extra_args'): | ||||
return self.extra_args | ||||
else: | ||||
return [] | ||||
Brian Granger
|
r2185 | def _create_parser(self): | ||
Brian Granger
|
r2500 | self.parser = ArgumentParser(*self.parser_args, **self.parser_kw) | ||
Brian Granger
|
r2185 | self._add_arguments() | ||
Brian Granger
|
r2200 | |||
Brian Granger
|
r2185 | def _add_arguments(self): | ||
Brian Granger
|
r2501 | raise NotImplementedError("subclasses must implement _add_arguments") | ||
Fernando Perez
|
r2428 | |||
Fernando Perez
|
r2391 | def _parse_args(self, args): | ||
Thomas Kluyver
|
r3457 | """self.parser->self.parsed_data""" | ||
MinRK
|
r3464 | # decode sys.argv to support unicode command-line options | ||
uargs = [] | ||||
for a in args: | ||||
if isinstance(a, str): | ||||
# don't decode if we already got unicode | ||||
Thomas Kluyver
|
r3471 | a = a.decode(sys.stdin.encoding or | ||
sys.getdefaultencoding()) | ||||
MinRK
|
r3464 | uargs.append(a) | ||
self.parsed_data, self.extra_args = self.parser.parse_known_args(uargs) | ||||
Brian Granger
|
r2185 | |||
Brian Granger
|
r2245 | def _convert_to_config(self): | ||
Brian Granger
|
r2185 | """self.parsed_data->self.config""" | ||
Thomas Kluyver
|
r3114 | for k, v in vars(self.parsed_data).iteritems(): | ||
Brian Granger
|
r2500 | exec_str = 'self.config.' + k + '= v' | ||
exec exec_str in locals(), globals() | ||||