解析配置文件、环境和命令行参数,以获取单个选项集合

Posted

技术标签:

【中文标题】解析配置文件、环境和命令行参数,以获取单个选项集合【英文标题】:Parse config files, environment, and command-line arguments, to get a single collection of options 【发布时间】:2011-09-02 06:35:45 【问题描述】:

Python 的标准库具有用于配置文件解析 (configparser)、环境变量读取 (os.environ) 和命令行参数解析的模块 (argparse)。我想编写一个程序来完成所有这些,并且:

具有选项值的级联

默认选项值,被覆盖 配置文件选项,被覆盖 环境变量,被覆盖 命令行选项。

允许一个或多个在命令行中指定的配置文件位置,例如--config-file foo.conf,并读取它(代替或附加到通常的配置文件)。这仍然必须遵守上述级联。

允许在一个地方定义选项来确定配置文件和命令行的解析行为。

将已解析的选项统一为一个选项值的单一集合,以供程序的其余部分访问,而无需关心它们来自何处。

我需要的一切显然都在 Python 标准库中,但它们不能顺利协同工作。

如何在与 Python 标准库的偏差最小的情况下实现这一目标?

【问题讨论】:

我真的很喜欢这个问题。我一直在考虑做这样的事情......我很高兴jterrace 在这里给了我一个赏金,把我推到了边缘,足以让我尝试做这样的事情:) 优秀问题!令人惊讶的是,很久以前流行的包(或标准库本身)还没有解决这个问题。 【参考方案1】:

更新:我终于有时间把它放在 pypi 上。通过以下方式安装最新版本:

   pip install configargparser

Full help and instructions are here.

原帖

这是我一起破解的一些小东西。请随意在 cmets 中提出改进/错误报告:

import argparse
import ConfigParser
import os

def _identity(x):
    return x

_SENTINEL = object()


class AddConfigFile(argparse.Action):
    def __call__(self,parser,namespace,values,option_string=None):
        # I can never remember if `values` is a list all the time or if it
        # can be a scalar string; this takes care of both.
        if isinstance(values,basestring):
            parser.config_files.append(values)
        else:
            parser.config_files.extend(values)


class ArgumentConfigEnvParser(argparse.ArgumentParser):
    def __init__(self,*args,**kwargs):
        """
        Added 2 new keyword arguments to the ArgumentParser constructor:

           config --> List of filenames to parse for config goodness
           default_section --> name of the default section in the config file
        """
        self.config_files = kwargs.pop('config',[])  #Must be a list
        self.default_section = kwargs.pop('default_section','MAIN')
        self._action_defaults = 
        argparse.ArgumentParser.__init__(self,*args,**kwargs)


    def add_argument(self,*args,**kwargs):
        """
        Works like `ArgumentParser.add_argument`, except that we've added an action:

           config: add a config file to the parser

        This also adds the ability to specify which section of the config file to pull the 
        data from, via the `section` keyword.  This relies on the (undocumented) fact that
        `ArgumentParser.add_argument` actually returns the `Action` object that it creates.
        We need this to reliably get `dest` (although we could probably write a simple
        function to do this for us).
        """

        if 'action' in kwargs and kwargs['action'] == 'config':
            kwargs['action'] = AddConfigFile
            kwargs['default'] = argparse.SUPPRESS

        # argparse won't know what to do with the section, so 
        # we'll pop it out and add it back in later.
        #
        # We also have to prevent argparse from doing any type conversion,
        # which is done explicitly in parse_known_args.  
        #
        # This way, we can reliably check whether argparse has replaced the default.
        #
        section = kwargs.pop('section', self.default_section)
        type = kwargs.pop('type', _identity)
        default = kwargs.pop('default', _SENTINEL)

        if default is not argparse.SUPPRESS:
            kwargs.update(default=_SENTINEL)
        else:  
            kwargs.update(default=argparse.SUPPRESS)

        action = argparse.ArgumentParser.add_argument(self,*args,**kwargs)
        kwargs.update(section=section, type=type, default=default)
        self._action_defaults[action.dest] = (args,kwargs)
        return action

    def parse_known_args(self,args=None, namespace=None):
        # `parse_args` calls `parse_known_args`, so we should be okay with this...
        ns, argv = argparse.ArgumentParser.parse_known_args(self, args=args, namespace=namespace)
        config_parser = ConfigParser.SafeConfigParser()
        config_files = [os.path.expanduser(os.path.expandvars(x)) for x in self.config_files]
        config_parser.read(config_files)

        for dest,(args,init_dict) in self._action_defaults.items():
            type_converter = init_dict['type']
            default = init_dict['default']
            obj = default

            if getattr(ns,dest,_SENTINEL) is not _SENTINEL: # found on command line
                obj = getattr(ns,dest)
            else: # not found on commandline
                try:  # get from config file
                    obj = config_parser.get(init_dict['section'],dest)
                except (ConfigParser.NoSectionError, ConfigParser.NoOptionError): # Nope, not in config file
                    try: # get from environment
                        obj = os.environ[dest.upper()]
                    except KeyError:
                        pass

            if obj is _SENTINEL:
                setattr(ns,dest,None)
            elif obj is argparse.SUPPRESS:
                pass
            else:
                setattr(ns,dest,type_converter(obj))

        return ns, argv


if __name__ == '__main__':
    fake_config = """
[MAIN]
foo:bar
bar:1
"""
    with open('_config.file','w') as fout:
        fout.write(fake_config)

    parser = ArgumentConfigEnvParser()
    parser.add_argument('--config-file', action='config', help="location of config file")
    parser.add_argument('--foo', type=str, action='store', default="grape", help="don't know what foo does ...")
    parser.add_argument('--bar', type=int, default=7, action='store', help="This is an integer (I hope)")
    parser.add_argument('--baz', type=float, action='store', help="This is an float(I hope)")
    parser.add_argument('--qux', type=int, default='6', action='store', help="this is another int")
    ns = parser.parse_args([])

    parser_defaults = 'foo':"grape",'bar':7,'baz':None,'qux':6
    config_defaults = 'foo':'bar','bar':1
    env_defaults = "baz":3.14159

    # This should be the defaults we gave the parser
    print ns
    assert ns.__dict__ == parser_defaults

    # This should be the defaults we gave the parser + config defaults
    d = parser_defaults.copy()
    d.update(config_defaults)
    ns = parser.parse_args(['--config-file','_config.file'])
    print ns
    assert ns.__dict__ == d

    os.environ['BAZ'] = "3.14159"

    # This should be the parser defaults + config defaults + env_defaults
    d = parser_defaults.copy()
    d.update(config_defaults)
    d.update(env_defaults)
    ns = parser.parse_args(['--config-file','_config.file'])
    print ns
    assert ns.__dict__ == d

    # This should be the parser defaults + config defaults + env_defaults + commandline
    commandline = 'foo':'3','qux':4 
    d = parser_defaults.copy()
    d.update(config_defaults)
    d.update(env_defaults)
    d.update(commandline)
    ns = parser.parse_args(['--config-file','_config.file','--foo=3','--qux=4'])
    print ns
    assert ns.__dict__ == d

    os.remove('_config.file')

待办事项

这个实现仍然不完整。这是部分 TODO 列表:

(简单)与parser defaults的交互 (简单)如果类型转换不起作用,请检查argparse 如何处理error messages

符合记录的行为

(简单)编写一个函数,从add_argument 中的args 中找出dest,而不是依赖Action 对象 (平凡)编写一个使用parse_known_argsparse_args 函数。 (例如,从cpython 实现中复制parse_args 以保证它调用parse_known_args。)

不太容易的东西……

我还没有尝试过这些。不太可能——但仍然有可能!——它可以正常工作……

(很难?)Mutual Exclusion (难?)Argument Groups(如果实施,这些组应该在配置文件中获得section。) (难?)Sub Commands(子命令也应该在配置文件中获得section。)

【讨论】:

你介意把它扔进 github repo 以便每个人都可以改进吗? @brent.payne -- github.com/mgilson/configargparser -- 如果我要把它作为真正的代码发布,我决定今晚花点时间清理一下。 :-) FWIW,我终于有时间把它放在 pypi 上——你应该可以通过pip install configargparser安装它 @mgilson - 我更新了你的帖子。这个包值得更多使用!【参考方案2】:

argparse 模块不会让这变得疯狂,只要您对看起来像命令行的配置文件感到满意。 (我认为这是一个优势,因为用户只需要学习一种语法。)例如,将fromfile_prefix_chars 设置为@,这样,

my_prog --foo=bar

等价于

my_prog @baz.conf

如果@baz.conf 是,

--foo
bar

您甚至可以通过修改 argv 让您的代码自动查找 foo.conf

if os.path.exists('foo.conf'):
    argv = ['@foo.conf'] + argv
args = argparser.parse_args(argv)

这些配置文件的格式可以通过创建ArgumentParser的子类并添加convert_arg_line_to_args方法来修改。

【讨论】:

直到有人提供更好的选择,这是正确的答案。我一直在使用 argparse,甚至没有看这个功能。不错! 但这没有环境变量的答案? @jterrace:这个 SO 答案可能对您有用:***.com/a/10551190/400793【参考方案3】:

有一个库可以做到这一点,称为configglue。

configglue 是一个将 python 的 optparse.OptionParser 和 ConfigParser.ConfigParser,这样你就不用 当您要将相同的选项导出到 配置文件和命令行界面。

它也是supports环境变量。

还有另一个名为 ConfigArgParse 的库

argparse 的替代品,允许设置选项 通过配置文件和/或环境变量。

您可能对 PyCon 感兴趣,讨论 Łukasz Langa 的配置 - Let Them Configure!

【讨论】:

我 asked 如果有任何计划支持 argparse 模块。【参考方案4】:

虽然我自己没有尝试过,但 ConfigArgParse 库表明它可以完成大部分您想要的事情:

argparse 的替代品,允许通过配置文件和/或环境变量设置选项。

【讨论】:

我试过了,ConfigArgParse 非常方便,确实是一个替代品。 ***.com/a/14743159/2506522 答案是一样的【参考方案5】:

标准库似乎没有解决这个问题,让每个程序员都以笨拙的方式拼凑configparserargparseos.environ

【讨论】:

【参考方案6】:

据我所知,Python 标准库不提供此功能。我自己解决了这个问题,编写代码使用optparseConfigParser 来解析命令行和配置文件,并在它们之上提供一个抽象层。但是,您需要将此作为单独的依赖项,从您之前的评论来看,这似乎令人不快。

如果您想查看我编写的代码,请查看http://liw.fi/cliapp/。它已集成到我的“命令行应用程序框架”库中,因为这是框架需要做的很大一部分。

【讨论】:

【参考方案7】:

要满足所有这些要求,我建议您编写自己的库,该库同时使用 [opt|arg]parse 和 configparser 来实现底层功能。

鉴于前两个和最后一个要求,我会说你想要:

第一步:执行只查找 --config-file 选项的命令行解析器传递。

第二步:解析配置文件。

第三步:使用配置文件传递的输出作为默认值设置第二个命令行解析器传递。

第三个要求可能意味着您必须设计自己的选项定义系统,以公开您关心的 optparse 和 configparser 的所有功能,并编写一些管道以在两者之间进行转换。

【讨论】:

这与我希望的“与 Python 标准库的最小偏差”相差甚远。【参考方案8】:

我最近尝试过类似的事情,使用“optparse”。

我将它设置为 OptonParser 的子类,带有“--Store”和“--Check”命令。

下面的代码应该已经涵盖了你。您只需要定义您自己的“加载”和“存储”方法来接受/返回字典,就可以了。


class SmartParse(optparse.OptionParser):
    def __init__(self,defaults,*args,**kwargs):
        self.smartDefaults=defaults
        optparse.OptionParser.__init__(self,*args,**kwargs)
        fileGroup = optparse.OptionGroup(self,'handle stored defaults')
        fileGroup.add_option(
            '-S','--Store',
            dest='Action',
            action='store_const',const='Store',
            help='store command line settings'
        )
        fileGroup.add_option(
            '-C','--Check',
            dest='Action',
            action='store_const',const='Check',
            help ='check stored settings'
        )
        self.add_option_group(fileGroup)
    def parse_args(self,*args,**kwargs):
        (options,arguments) = optparse.OptionParser.parse_args(self,*args,**kwargs)
        action = options.__dict__.pop('Action')
        if action == 'Check':
            assert all(
                value is None 
                for (key,value) in options.__dict__.iteritems() 
            )
            print 'defaults:',self.smartDefaults
            print 'config:',self.load()
            sys.exit()
        elif action == 'Store':
            self.store(options.__dict__)
            sys.exit()
        else:
            config=self.load()
            commandline=dict(
                [key,val] 
                for (key,val) in options.__dict__.iteritems() 
                if val is not None
            )
            result = 
            result.update(self.defaults)
            result.update(config)
            result.update(commandline)
            return result,arguments
    def load(self):
        return 
    def store(self,optionDict):
        print 'Storing:',optionDict

【讨论】:

但如果您想与旧版本的 Python 保持兼容仍然很有用【参考方案9】:

这是我一起编写的一个模块,它还可以读取命令行参数、环境设置、ini 文件和密钥环值。它也可以通过gist 获得。

"""
Configuration Parser

Configurable parser that will parse config files, environment variables,
keyring, and command-line arguments.



Example test.ini file:

    [defaults]
    gini=10

    [app]
    xini = 50

Example test.arg file:

    --xfarg=30

Example test.py file:

    import os
    import sys

    import config


    def main(argv):
        '''Test.'''
        options = [
            config.Option("xpos",
                          help="positional argument",
                          nargs='?',
                          default="all",
                          env="APP_XPOS"),
            config.Option("--xarg",
                          help="optional argument",
                          default=1,
                          type=int,
                          env="APP_XARG"),
            config.Option("--xenv",
                          help="environment argument",
                          default=1,
                          type=int,
                          env="APP_XENV"),
            config.Option("--xfarg",
                          help="@file argument",
                          default=1,
                          type=int,
                          env="APP_XFARG"),
            config.Option("--xini",
                          help="ini argument",
                          default=1,
                          type=int,
                          ini_section="app",
                          env="APP_XINI"),
            config.Option("--gini",
                          help="global ini argument",
                          default=1,
                          type=int,
                          env="APP_GINI"),
            config.Option("--karg",
                          help="secret keyring arg",
                          default=-1,
                          type=int),
        ]
        ini_file_paths = [
            '/etc/default/app.ini',
            os.path.join(os.path.dirname(os.path.abspath(__file__)),
                         'test.ini')
        ]

        # default usage
        conf = config.Config(prog='app', options=options,
                             ini_paths=ini_file_paths)
        conf.parse()
        print conf

        # advanced usage
        cli_args = conf.parse_cli(argv=argv)
        env = conf.parse_env()
        secrets = conf.parse_keyring(namespace="app")
        ini = conf.parse_ini(ini_file_paths)
        sources = 
        if ini:
            for key, value in ini.iteritems():
                conf[key] = value
                sources[key] = "ini-file"
        if secrets:
            for key, value in secrets.iteritems():
                conf[key] = value
                sources[key] = "keyring"
        if env:
            for key, value in env.iteritems():
                conf[key] = value
                sources[key] = "environment"
        if cli_args:
            for key, value in cli_args.iteritems():
                conf[key] = value
                sources[key] = "command-line"
        print '\n'.join(['%s:\t%s' % (k, v) for k, v in sources.items()])


    if __name__ == "__main__":
        if config.keyring:
            config.keyring.set_password("app", "karg", "13")
        main(sys.argv)

Example results:

    $APP_XENV=10 python test.py api --xarg=2 @test.arg
    <Config xpos=api, gini=1, xenv=10, xini=50, karg=13, xarg=2, xfarg=30>
    xpos:   command-line
    xenv:   environment
    xini:   ini-file
    karg:   keyring
    xarg:   command-line
    xfarg:  command-line


"""
import argparse
import ConfigParser
import copy
import os
import sys

try:
    import keyring
except ImportError:
    keyring = None


class Option(object):
    """Holds a configuration option and the names and locations for it.

    Instantiate options using the same arguments as you would for an
    add_arguments call in argparse. However, you have two additional kwargs
    available:

        env: the name of the environment variable to use for this option
        ini_section: the ini file section to look this value up from
    """

    def __init__(self, *args, **kwargs):
        self.args = args or []
        self.kwargs = kwargs or 

    def add_argument(self, parser, **override_kwargs):
        """Add an option to a an argparse parser."""
        kwargs = 
        if self.kwargs:
            kwargs = copy.copy(self.kwargs)
            try:
                del kwargs['env']
            except KeyError:
                pass
            try:
                del kwargs['ini_section']
            except KeyError:
                pass
        kwargs.update(override_kwargs)
        parser.add_argument(*self.args, **kwargs)

    @property
    def type(self):
        """The type of the option.

        Should be a callable to parse options.
        """
        return self.kwargs.get("type", str)

    @property
    def name(self):
        """The name of the option as determined from the args."""
        for arg in self.args:
            if arg.startswith("--"):
                return arg[2:].replace("-", "_")
            elif arg.startswith("-"):
                continue
            else:
                return arg.replace("-", "_")

    @property
    def default(self):
        """The default for the option."""
        return self.kwargs.get("default")


class Config(object):
    """Parses configuration sources."""

    def __init__(self, options=None, ini_paths=None, **parser_kwargs):
        """Initialize with list of options.

        :param ini_paths: optional paths to ini files to look up values from
        :param parser_kwargs: kwargs used to init argparse parsers.
        """
        self._parser_kwargs = parser_kwargs or 
        self._ini_paths = ini_paths or []
        self._options = copy.copy(options) or []
        self._values = option.name: option.default
                        for option in self._options
        self._parser = argparse.ArgumentParser(**parser_kwargs)
        self.pass_thru_args = []

    @property
    def prog(self):
        """Program name."""
        return self._parser.prog

    def __getitem__(self, key):
        return self._values[key]

    def __setitem__(self, key, value):
        self._values[key] = value

    def __delitem__(self, key):
        del self._values[key]

    def __contains__(self, key):
        return key in self._values

    def __iter__(self):
        return iter(self._values)

    def __len__(self):
        return len(self._values)

    def get(self, key, *args):
        """
        Return the value for key if it exists otherwise the default.
        """
        return self._values.get(key, *args)

    def __getattr__(self, attr):
        if attr in self._values:
            return self._values[attr]
        else:
            raise AttributeError("'config' object has no attribute '%s'"
                                 % attr)

    def build_parser(self, options, **override_kwargs):
        """."""
        kwargs = copy.copy(self._parser_kwargs)
        kwargs.update(override_kwargs)
        if 'fromfile_prefix_chars' not in kwargs:
            kwargs['fromfile_prefix_chars'] = '@'
        parser = argparse.ArgumentParser(**kwargs)
        if options:
            for option in options:
                option.add_argument(parser)
        return parser

    def parse_cli(self, argv=None):
        """Parse command-line arguments into values."""
        if not argv:
            argv = sys.argv
        options = []
        for option in self._options:
            temp = Option(*option.args, **option.kwargs)
            temp.kwargs['default'] = argparse.SUPPRESS
            options.append(temp)
        parser = self.build_parser(options=options)
        parsed, extras = parser.parse_known_args(argv[1:])
        if extras:
            valid, pass_thru = self.parse_passthru_args(argv[1:])
            parsed, extras = parser.parse_known_args(valid)
            if extras:
                raise AttributeError("Unrecognized arguments: %s" %
                                     ' ,'.join(extras))
            self.pass_thru_args = pass_thru + extras
        return vars(parsed)

    def parse_env(self):
        results = 
        for option in self._options:
            env_var = option.kwargs.get('env')
            if env_var and env_var in os.environ:
                value = os.environ[env_var]
                results[option.name] = option.type(value)
        return results

    def get_defaults(self):
        """Use argparse to determine and return dict of defaults."""
        parser = self.build_parser(options=self._options)
        parsed, _ = parser.parse_known_args([])
        return vars(parsed)

    def parse_ini(self, paths=None):
        """Parse config files and return configuration options.

        Expects array of files that are in ini format.
        :param paths: list of paths to files to parse (uses ConfigParse logic).
                      If not supplied, uses the ini_paths value supplied on
                      initialization.
        """
        results = 
        config = ConfigParser.SafeConfigParser()
        config.read(paths or self._ini_paths)
        for option in self._options:
            ini_section = option.kwargs.get('ini_section')
            if ini_section:
                try:
                    value = config.get(ini_section, option.name)
                    results[option.name] = option.type(value)
                except ConfigParser.NoSectionError:
                    pass
        return results

    def parse_keyring(self, namespace=None):
        """."""
        results = 
        if not keyring:
            return results
        if not namespace:
            namespace = self.prog
        for option in self._options:
            secret = keyring.get_password(namespace, option.name)
            if secret:
                results[option.name] = option.type(secret)
        return results

    def parse(self, argv=None):
        """."""
        defaults = self.get_defaults()
        args = self.parse_cli(argv=argv)
        env = self.parse_env()
        secrets = self.parse_keyring()
        ini = self.parse_ini()

        results = defaults
        results.update(ini)
        results.update(secrets)
        results.update(env)
        results.update(args)

        self._values = results
        return self

    @staticmethod
    def parse_passthru_args(argv):
        """Handles arguments to be passed thru to a subprocess using '--'.

        :returns: tuple of two lists; args and pass-thru-args
        """
        if '--' in argv:
            dashdash = argv.index("--")
            if dashdash == 0:
                return argv[1:], []
            elif dashdash > 0:
                return argv[0:dashdash], argv[dashdash + 1:]
        return argv, []

    def __repr__(self):
        return "<Config %s>" % ', '.join([
            '%s=%s' % (k, v) for k, v in self._values.iteritems()])


def comma_separated_strings(value):
    """Handles comma-separated arguments passed in command-line."""
    return map(str, value.split(","))


def comma_separated_pairs(value):
    """Handles comma-separated key/values passed in command-line."""
    pairs = value.split(",")
    results = 
    for pair in pairs:
        key, pair_value = pair.split('=')
        results[key] = pair_value
    return results

【讨论】:

【参考方案10】:

您可以为此使用 ChainMap。 Take a look at my example that I provided for 在“在 Python 的命令行中允许覆盖配置选项的最佳方法是什么?”所以问题。

【讨论】:

【参考方案11】:

我建立的库confect正是为了满足您的大部分需求。

它可以通过给定的文件路径或模块名称多次加载配置文件。 它从具有给定前缀的环境变量中加载配置。

它可以将命令行选项附加到一些click 命令

(抱歉,它不是 argparse,但 click 更好,更高级。confect 可能会在未来的版本中支持 argparse)。

最重要的是,confect 加载 Python 配置文件而不是 JSON/YMAL/TOML/INI。与 IPython 配置文件或 DJANGO 设置文件一样,Python 配置文件灵活且易于维护。

如需更多信息,请查看project repository 中的README.rst。注意它只支持Python3.6以上。

示例

附加命令行选项

import click
from proj_X.core import conf

@click.command()
@conf.click_options
def cli():
    click.echo(f'cache_expire = conf.api.cache_expire')

if __name__ == '__main__':
    cli()

它会自动创建一个全面的帮助消息,其中声明了所有属性和默认值。

$ python -m proj_X.cli --help
Usage: cli.py [OPTIONS]

Options:
  --api-cache_expire INTEGER  [default: 86400]
  --api-cache_prefix TEXT     [default: proj_X_cache]
  --api-url_base_path TEXT    [default: api/v2/]
  --db-db_name TEXT           [default: proj_x]
  --db-username TEXT          [default: proj_x_admin]
  --db-password TEXT          [default: your_password]
  --db-host TEXT              [default: 127.0.0.1]
  --help                      Show this message and exit.

加载环境变量

加载环境变量只需要一行

conf.load_envvars('proj_X')

【讨论】:

> 抱歉,它不是 argparse,但 click 更好,更高级 [...] 不管第三方库的优点如何,这都不是问题的答案。

以上是关于解析配置文件、环境和命令行参数,以获取单个选项集合的主要内容,如果未能解决你的问题,请参考以下文章

ETCD:配置参数

使用多个参数解析命令行选项 [getopt?]

Python技法:用argparse模块解析命令行选项

go的解析命令行库flag

go的解析命令行库flag

go的解析命令行库flag