Wie sollte ich Sie umsetzen "nested" - Unterbefehle, die in Python?

Durchführung "nested" - Unterbefehle, die in Python mit cmdln.

Ich bin mir nicht sicher, ich verwende die richtige Terminologie hier. Ich versuche zu implementieren ist ein commandline-tool mit cmdln, der es ermöglicht, "nested" - Unterbefehle. Hier ist ein reales Beispiel:

git svn rebase

Was ist der beste Weg für die Umsetzung dieser? Ich habe die Suche nach mehr Informationen über dieses in der doc, hier und im web zu groß ist, aber haben gehen leer aus. (Vielleicht war ich Suche mit den falschen Begriffen.)

Kurzen der eine nicht dokumentierte Funktion, die dies automatisch erledigt, mein Erster Gedanke war, haben die früheren subcommand-handler bestimmen, dass es ein anderes subkommando und Versand der command dispatcher wieder. Ich habe schaute auf die Interna von cmdln aber und der dispatcher ist eine private Methode, _dispatch_cmd. Mein Nächster Gedanke ist, um meine eigene sub-sub-command dispatcher, aber das scheint weniger als ideal und chaotisch.

Jede mögliche Hilfe würde geschätzt.

InformationsquelleAutor tima | 2011-12-14
  1. 6

    argparse macht sub-Befehle sehr einfach.

    • Das Unternehmen arbeite ich für eine v2.6 baseline-so mit argparse ist ein Problem, es müsste einbezogen werden, die als externe Bibliothek, und nur dann geladen wenn Sie gebraucht werden. Durchaus nicht unmöglich, nur eben nicht ideal. Für die cmdln Bibliothek, gibt mir einen schönen bit des baseline-Funktionalität, die ich lieber nicht erstellen. Wie gesagt, ich bin nicht mit etwas anderes.
    InformationsquelleAutor Chris Lacasse
  2. 6

    Spät zur party hier, aber ich habe hierzu etwas gefunden haben argparse ziemlich klobig, dies zu tun mit. Dies motiviert mich, zu schreiben, eine Erweiterung argparse genannt arghandler, die explizit Unterstützung für diese Entscheidungen möglich umzusetzen-Unterbefehle, die mit im Grunde null Zeilen code.

    Hier ein Beispiel:

    from arghandler import *

@subcmd
def push(context,args):
    print 'command: push'

@subcmd
def pull(context,args):
    print 'command: pull'

# run the command - which will gather up all the subcommands
handler = ArgumentHandler()
handler.run()
    InformationsquelleAutor Derek Ruths
  3. 4

    Ich das Gefühl, es gibt eine leichte Einschränkung mit sub_parsers in argparse, wenn Sie sagen, Sie haben eine suite von tools, die möglicherweise haben ähnliche Optionen, die möglicherweise verteilt auf verschiedene Ebenen. Es könnte sein, selten zu dieser situation, aber wenn Sie schreiben, Steck - /modular-code, es könnte passieren.

    Habe ich Folgendes Beispiel. Es ist weit hergeholt und nicht gut erklärt im moment, weil es schon spät ist, aber hier geht es:

    Usage: tool [-y] {a, b}
  a [-x] {create, delete}
    create [-x]
    delete [-y]
  b [-y] {push, pull}
    push [-x]
    pull [-x]
    from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument('-x', action = 'store_true')
parser.add_argument('-y', action = 'store_true')

subparsers = parser.add_subparsers(dest = 'command')

parser_a = subparsers.add_parser('a')
parser_a.add_argument('-x', action = 'store_true')
subparsers_a = parser_a.add_subparsers(dest = 'sub_command')
parser_a_create = subparsers_a.add_parser('create')
parser_a_create.add_argument('-x', action = 'store_true')
parser_a_delete = subparsers_a.add_parser('delete')
parser_a_delete.add_argument('-y', action = 'store_true')

parser_b = subparsers.add_parser('b')
parser_b.add_argument('-y', action = 'store_true')
subparsers_b = parser_b.add_subparsers(dest = 'sub_command')
parser_b_create = subparsers_b.add_parser('push')
parser_b_create.add_argument('-x', action = 'store_true')
parser_b_delete = subparsers_b.add_parser('pull')
parser_b_delete.add_argument('-y', action = 'store_true')

print parser.parse_args(['-x', 'a', 'create'])
print parser.parse_args(['a', 'create', '-x'])
print parser.parse_args(['b', '-y', 'pull', '-y'])
print parser.parse_args(['-x', 'b', '-y', 'push', '-x'])

    Ausgabe

    Namespace(command='a', sub_command='create', x=True, y=False)
Namespace(command='a', sub_command='create', x=True, y=False)
Namespace(command='b', sub_command='pull', x=False, y=True)
Namespace(command='b', sub_command='push', x=True, y=True)

    Wie Sie sehen können, ist es schwer zu unterscheiden, wo entlang der Kette jedes argument gesetzt wurde.
    Man könnte dieses Problem lösen, indem Sie den Namen für jede variable. Sie könnten zum Beispiel festlegen, 'dest' zu 'x', 'a_x', 'a_create_x', 'b_push_x', etc., aber das wäre zu schmerzhaft und schwer zu trennen.

    Wäre eine alternative haben die ArgumentParser Stoppt, sobald es erreicht einen Unterbefehl, und übergeben Sie die restlichen Argumente aus zu einem anderen, unabhängigen parser, so könnte es erzeugt separate Objekte.
    Sie können versuchen, zu erreichen, dass durch die Verwendung von 'parse_known_args()' und nicht definieren Argumente für jedes subkommando. Das wäre aber nicht gut, weil alle un-analysiert die Argumente aus, bevor Sie würde immer noch dort sein und kann das Programm verwirren.

    Fühle ich mich etwas Billig, aber nützlich Abhilfe ist argparse interpretieren Sie die folgenden Argumente als strings in einer Liste. Dies kann durch die Einstellung des Präfix zu einem null-terminator '\0' (oder einige andere "hard-to-use' - Zeichen) - wenn der Präfix ist leer, und der code wirft einen Fehler, zumindest in Python-2.7.3.

    Beispiel:

    parser = ArgumentParser()
parser.add_argument('-x', action = 'store_true')
parser.add_argument('-y', action = 'store_true')
subparsers = parser.add_subparsers(dest = 'command')
parser_a = subparsers.add_parser('a' prefix_chars = '\0')
parser_a.add_argument('args', type = str, nargs = '*')

print parser.parse_args(['-xy', 'a', '-y', '12'])

    Ausgabe:

    Namespace(args=['-y', '12'], command='a', x=True, y=True)

    Beachten Sie, dass Sie nicht verbrauchen die zweite -y option.
    Sie können dann das Ergebnis "args" anderen ArgumentParser.

    Nachteile:

    • Helfen, vielleicht nicht richtg. Wäre um einige weitere Abhilfe mit diesem
    • Wenn Fehler auftreten, möglicherweise schwer zu verfolgen und erfordern einige zusätzlichen Aufwand, um sicherzustellen, Fehlermeldungen sind korrekt verkettet ist.
    • Ein wenig mehr Aufwand mit der mehrere ArgumentParsers.

    Wenn jemand mehr input auf dieser, lassen Sie es mich bitte wissen.

    InformationsquelleAutor eacousineau
Schreibe einen Kommentar