argparse-Unterbefehle, die mit verschachtelten namespaces

Ich bin mir nicht ganz sicher, was du fragst, aber ich denke, was Sie wollen, ist für eine argument-Gruppe oder sub-Befehl, um seine Argumente in einen sub-namespace.

Soweit ich weiß, argparse tut dies nicht aus der box. Aber es ist wirklich nicht schwer zu tun, durch die Nachbearbeitung das Ergebnis, so lange, wie Sie bereit sind, Graben sich unter der Decke ein bisschen. (Ich vermute, es ist noch einfacher, es zu tun, indem bilden von Unterklassen ArgumentParser haben, aber Sie ausdrücklich gesagt, Sie wollen nicht zu tun, also ich nicht versuchen.)

parser = argparse.ArgumentParser()
parser.add_argument('--foo')
breakfast = parser.add_argument_group('breakfast')
breakfast.add_argument('--spam')
breakfast.add_argument('--eggs')
args = parser.parse_args()

Nun, die Liste aller Reiseziele für breakfast Optionen:

[action.dest for action in breakfast._group_actions]

- Und Schlüssel-Wert-Paare in args ist:

args._get_kwargs()

So, alles, was wir haben, um zu bewegen, diejenigen, die übereinstimmen. Es wird ein wenig einfacher, wenn wir konstruieren, Wörterbücher zu erstellen, die namespaces von:

breakfast_options = [action.dest for action in breakfast._group_actions]
top_names = {name: value for (name, value) in args._get_kwargs()
             if name not in breakfast_options}
breakfast_names = {name: value for (name, value) in args._get_kwargs()
                   if name in breakfast_options}
top_names['breakfast'] = argparse.Namespace(**breakfast_names)
top_namespace = argparse.Namespace(**top_names)

... Und das ist es; top_namespace aussieht:

Namespace(breakfast=Namespace(eggs=None, spam='7'), foo='bar')

Natürlich in diesem Fall, wir haben eine statische Gruppe. Was, wenn Sie wollten, eine Allgemeine Lösung? Einfach. parser._action_groups ist eine Liste aller Gruppen, aber die ersten beiden sind die globalen positions-und Schlüsselwort-Gruppen. Also einfach nur Durchlaufen parser._action_groups[2:], und das gleiche tun für jeden, der Sie haben für breakfast oben.

Was über die sub-Befehle anstelle von Gruppen? Ähnlich, aber die details sind unterschiedlich. Wenn Sie gehalten habe, um jedes subparser Objekt, es ist nur ganz andere ArgumentParser. Wenn nicht, aber du hast das halten der subparsers Objekt, es ist eine spezielle Art von Action, deren choices ist ein dict dessen Schlüssel die subparser-Namen und deren Werte sind die subparsers selbst. Wenn Sie gehalten, weder... beginnen bei parser._subparsers und es herausfinden von dort.

Jedenfalls, sobald Sie wissen, wie zu finden, die Namen, die Sie verschieben möchten und wo Sie möchten, um Sie zu bewegen, es ist das gleiche wie mit Gruppen.

Wenn Sie haben, zusätzlich zu globalen args und/oder Gruppen und subparser-spezifische Argumente und/oder Gruppen, einige Gruppen, die gemeinsam von mehreren subparsers... dann konzeptionell an der es schwierig wird, weil jeder subparser endet mit Referenzen zu der gleichen Gruppe, und Sie können nicht verschieben Sie es an al von Ihnen. Aber zum Glück, du bist nur den Umgang mit genau einer subparser (oder keine), so können Sie einfach ignorieren die anderen subparsers und verschieben Sie alle Gruppen unter dem ausgewählten subparser (und jede Gruppe, die nicht existieren in der ausgewählten subparser, entweder oben verlassen, oder wegwerfen, oder wählen Sie eine subparser willkürlich).

Ab abarnert Antwort, ich habe die folgenden MWE++; -), mit der multiple Konfiguration von Gruppen mit ähnlichen option Namen.

#!/usr/bin/env python2
import argparse, re

cmdl_skel = {
    'description'       : 'An example of multi-level argparse usage.',
    'opts'              : {
        '--foo' : {
            'type'    : int,
            'default' : 0,
            'help'    : 'foo help main',
        },
        '--bar' : {
            'type'    : str,
            'default' : 'quux',
            'help'    : 'bar help main',
        },
    },
    # Assume your program uses sub-programs with their options. Argparse will
    # first digest *all* defs, so opts with the same name across groups are
    # forbidden. The trick is to use the module name (=> group.title) as
    # pseudo namespace which is stripped off at group parsing
    'groups' : [
        {   'module'        : 'mod1',
            'description'   : 'mod1 description',
            'opts'          : {
                '--mod1-foo, --mod1.foo'  : {
                    'type'    : int,
                    'default' : 0,
                    'help'    : 'foo help for mod1'
                },
            },
        },
        {   'module'        : 'mod2',
            'description'   : 'mod2 description',
            'opts'          : {
                '--mod2-foo, --mod2.foo'  : {
                    'type'    : int,
                    'default' : 1,
                    'help'    : 'foo help for mod2'
                },
            },
        },
    ],
    'args'              : {
        'arg1'  : {
            'type'    : str,
            'help'    : 'arg1 help',
        },
        'arg2'  : {
            'type'    : str,
            'help'    : 'arg2 help',
        },
    }
}


def parse_args ():
    def _parse_group (parser, opt, **optd):
        # digest variants
        optv = re.split('\s*,\s*', opt)
        # this may rise exceptions...
        parser.add_argument(*optv, **optd)

    errors = {}
    parser = argparse.ArgumentParser(description=cmdl_skel['description'],
                formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    # it'd be nice to loop in a single run over zipped lists, but they have
    # different lenghts...
    for opt in cmdl_skel['opts'].keys():
        _parse_group(parser, opt, **cmdl_skel['opts'][opt])

    for arg in cmdl_skel['args'].keys():
        _parse_group(parser, arg, **cmdl_skel['args'][arg])

    for grp in cmdl_skel['groups']:
        group = parser.add_argument_group(grp['module'], grp['description'])
        for mopt in grp['opts'].keys():
            _parse_group(group, mopt, **grp['opts'][mopt])

    args = parser.parse_args()

    all_group_opts = []
    all_group_names = {}
    for group in parser._action_groups[2:]:
        gtitle = group.title
        group_opts = [action.dest for action in group._group_actions]
        all_group_opts += group_opts
        group_names = {
            # remove the leading pseudo-namespace
            re.sub("^%s_" % gtitle, '', name) : value
                for (name, value) in args._get_kwargs()
                    if name in group_opts
        }
        # build group namespace
        all_group_names[gtitle] = argparse.Namespace(**group_names)

    # rebuild top namespace
    top_names = {
        name: value for (name, value) in args._get_kwargs()
            if name not in all_group_opts
    }
    top_names.update(**all_group_names)
    top_namespace = argparse.Namespace(**top_names)

    return top_namespace


def main():
    args = parse_args()

    print(str(args))
    print(args.bar)
    print(args.mod1.foo)


if __name__ == '__main__':
    main()

Dann können Sie es so nennen (Eselsbrücke: --mod1-... sind die Optionen für "mod1", usw.):

$ ./argparse_example.py one two --bar=three --mod1-foo=11231 --mod2.foo=46546
Namespace(arg1='one', arg2='two', bar='three', foo=0, mod1=Namespace(foo=11231), mod2=Namespace(foo=46546))
three
11231

Basiert auf der Antwort von @abarnert, schrieb ich eine einfache Funktion, die tut, was der OP will:

from argparse import Namespace, ArgumentParser


def parse_args(parser):
    assert isinstance(parser, ArgumentParser)
    args = parser.parse_args()

    # the first two argument groups are 'positional_arguments' and 'optional_arguments'
    pos_group, optional_group = parser._action_groups[0], parser._action_groups[1]
    args_dict = args._get_kwargs()
    pos_optional_arg_names = [arg.dest for arg in pos_group._group_actions] + [arg.dest for arg in optional_group._group_actions]
    pos_optional_args = {name: value for name, value in args_dict if name in pos_optional_arg_names}
    other_group_args = dict()

    # If there are additional argument groups, add them as nested namespaces
    if len(parser._action_groups) > 2:
        for group in parser._action_groups[2:]:
            group_arg_names = [arg.dest for arg in group._group_actions]
            other_group_args[group.title] = Namespace(**{name: value for name, value in args_dict if name in group_arg_names})

    # combine the positiona/optional args and the group args
    combined_args = pos_optional_args
    combined_args.update(other_group_args)
    return Namespace(**combined_args)

Sie nur geben es die ArgumentParser Instanz und es gibt eine verschachtelte NameSpace nach der Struktur der Gruppe der Argumente.