python - 使用 Python 将复杂的参数解析为 shell 脚本

Question

在编写 shell 脚本时，我经常发现自己大部分时间（尤其是在调试时）都在处理参数处理。我编写或维护的许多脚本很容易超过 80% 的输入解析和清理。我将其与我的 Python 脚本进行比较，其中argparse为我处理大部分繁重的工作，并让我轻松构建复杂的选项结构和清理/字符串解析行为。

因此，我希望能够让 Python 完成这项繁重的工作，然后在我的 shell 脚本中获取这些经过简化和清理的值，而无需再担心用户指定的参数。

举一个具体的例子，我工作的许多 shell 脚本都被定义为以特定顺序接受它们的参数。您可以调用start_server.sh --server myserver --port 80但start_server.sh --port 80 --server myserver失败You must specify a server to start.- 它使解析代码更简单，但它几乎不直观。

因此，第一次通过的解决方案可能很简单，比如让 Python 接受参数，对它们进行排序（将它们的参数放在旁边）并返回排序后的参数。因此，shell 脚本仍然会进行一些解析和清理，但用户可以输入比 shell 脚本本机接受的更多的任意内容，例如：

# script.sh -o -aR --dir /tmp/test --verbose

#!/bin/bash

args=$(order.py "$@")
# args is set to "-a --dir /tmp/test -o -R --verbose"

# simpler processing now that we can guarantee the order of parameters

这里有一些明显的限制，特别是parse.py无法区分带有参数的最终选项和索引参数的开始，但这似乎并不那么糟糕。

所以这是我的问题：1）是否有任何现有的（最好是 Python）实用程序可以通过比 bash 更强大的东西来启用 CLI 解析，然后可以在清理后由我的 bash 脚本的其余部分访问，或者2）以前有没有人这样做过? 是否有我不知道的问题、陷阱或更好的解决方案？愿意分享你的实现吗？

---

一个（非常不成熟的）想法：

#!/bin/bash

# Some sort of simple syntax to describe to Python what arguments to accept
opts='
"a", "append", boolean, help="Append to existing file"
"dir", str, help="Directory to run from"
"o", "overwrite", boolean, help="Overwrite duplicates"
"R", "recurse", boolean, help="Recurse into subdirectories"
"v", "verbose", boolean, help="Print additional information"
'

# Takes in CLI arguments and outputs a sanitized structure (JSON?) or fails
p=$(parse.py "Runs complex_function with nice argument parsing" "$opts" "$@")
if [ $? -ne 0 ]; exit 1; fi # while parse outputs usage to stderr

# Takes the sanitized structure and an argument to get
append=$(arg.py "$p" append)
overwrite=$(arg.py "$p" overwrite)
recurse=$(arg.py "$p" recurse)
verbose=$(arg.py "$p" verbose)

cd $(python arg.py "$p" dir)

complex_function $append $overwrite $recurse $verbose

两行代码，以及对预期参数的简明描述，我们将进入实际的脚本行为。也许我疯了，但这似乎比我现在必须做的要好得多。

---

我已经看到Parsing shell script arguments和类似这个 wiki page on easy CLI argument parsing的东西，但是其中许多模式感觉笨重且容易出错，我不喜欢每次编写 shell 脚本时都必须重新实现它们，尤其是当Python、Java 等都有很好的参数处理库。

Answer 1

Edit: I haven't used it (yet), but if I were posting this answer today I would probably recommend https://github.com/docopt/docopts instead of a custom approach like the one described below.

---

I've put together a short Python script that does most of what I want. I'm not convinced it's production quality yet (notably error handling is lacking), but it's better than nothing. I'd welcome any feedback.

It takes advantage of the set builtin to re-assign the positional arguments, allowing the remainder of the script to still handle them as desired.

bashparse.py

#!/usr/bin/env python

import optparse, sys
from pipes import quote

'''
Uses Python's optparse library to simplify command argument parsing.

Takes in a set of optparse arguments, separated by newlines, followed by command line arguments, as argv[2] and argv[3:]
and outputs a series of bash commands to populate associated variables.
'''

class _ThrowParser(optparse.OptionParser):
    def error(self, msg):
        """Overrides optparse's default error handling
        and instead raises an exception which will be caught upstream
        """
        raise optparse.OptParseError(msg)

def gen_parser(usage, opts_ls):
    '''Takes a list of strings which can be used as the parameters to optparse's add_option function.
    Returns a parser object able to parse those options
    '''
    parser = _ThrowParser(usage=usage)
    for opts in opts_ls:
        if opts:
            # yes, I know it's evil, but it's easy
            eval('parser.add_option(%s)' % opts)
    return parser

def print_bash(opts, args):
    '''Takes the result of optparse and outputs commands to update a shell'''
    for opt, val in opts.items():
        if val:
            print('%s=%s' % (opt, quote(val)))
    print("set -- %s" % " ".join(quote(a) for a in args))

if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.stderr.write("Needs at least a usage string and a set of options to parse")
        sys.exit(2)
    parser = gen_parser(sys.argv[1], sys.argv[2].split('\n'))

    (opts, args) = parser.parse_args(sys.argv[3:])
    print_bash(opts.__dict__, args)

Example usage:

#!/bin/bash

usage="[-f FILENAME] [-t|--truncate] [ARGS...]"
opts='
"-f"
"-t", "--truncate",action="store_true"
'

echo "$(./bashparse.py "$usage" "$opts" "$@")"
eval "$(./bashparse.py "$usage" "$opts" "$@")"

echo
echo OUTPUT

echo $f
echo $@
echo $0 $2

Which, if run as: ./run.sh one -f 'a_filename.txt' "two' still two" three outputs the following (notice that the internal positional variables are still correct):

f=a_filename.txt
set -- one 'two'"'"' still two' three

OUTPUT
a_filename.txt
one two' still two three
./run.sh two' still two

Disregarding the debugging output, you're looking at approximately four lines to construct a powerful argument parser. Thoughts?

Answer 2

有同样的需求，我最终为 bash 编写了一个受 optparse 启发的解析器（实际上在内部使用了 python）；你可以在这里找到它：

https://github.com/carlobaldassi/bash_optparse

请参阅底部的 README 以获得快速解释。您可能想在以下位置查看一个简单的示例：

https://github.com/carlobaldassi/bash_optparse/blob/master/doc/example_script_simple

根据我的经验，它非常健壮（我是超级偏执狂）、功能丰富等，而且我在我的脚本中大量使用它。我希望它对其他人有用。欢迎反馈/贡献。

Answer 3

您可能会利用 bash 中的关联数组来帮助实现您的目标。

declare -A opts=($(getopts.py $@))
cd ${opts[dir]}
complex_function ${opts[append]}  ${opts[overwrite]} ${opts[recurse]} \
                 ${opts[verbose]} ${opts[args]}

为了使它工作，getopts.py应该是一个解析和清理你的参数的python脚本。它应该打印如下字符串：

[dir]=/tmp
[append]=foo
[overwrite]=bar
[recurse]=baz
[verbose]=fizzbuzz
[args]="a b c d"

您可以留出值来检查选项是否能够被正确解析和清理。

从返回getopts.py：

[__error__]=true

添加到 bash 脚本：

if ${opts[__error__]}; then
    exit 1
fi

如果您更愿意使用 的退出代码getopts.py，您可以使用eval：

getopts=$(getopts.py $@) || exit 1
eval declare -A opts=($getopts)

或者：

getopts=$(getopts.py $@)
if [[ $? -ne 0 ]]; then
    exit 1;
fi
eval declare -A opts=($getopts)

Answer 4

我的问题的原始前提假设委托给 Python 是简化参数解析的正确方法。如果我们放弃语言要求，我们实际上可以在 Bash 中做得不错*，使用getopts和一点eval魔法：

main() {
  local _usage='foo [-a] [-b] [-f val] [-v val] [args ...]'
  eval "$(parse_opts 'f:v:ab')"
  echo "f=$f v=$v a=$a b=$b -- $#: $*"
}

main "$@"

的实现parse_opts在这个 gist中，但基本方法是将选项转换为local变量，然后可以像平常一样处理。所有标准getopts样板都被隐藏起来，并且错误处理按预期工作。

因为它local在函数中使用变量，parse_opts不仅对命令行参数有用，它还可以与脚本中的任何函数一起使用。

---

_{* 我说“体面的工作”是因为 Bashgetopts是一个相当有限的解析器，并且只支持单字母选项。优雅、富有表现力的 CLI 仍然可以更好地用 Python 等其他语言实现。但是对于相当小的函数或脚本，这提供了一个很好的中间立场，而不会增加太多的复杂性或臃肿。}