पाइथन ने आपसी अनन्य समूह को विकसित किया

Question 1

मुझे क्या चाहिए:

pro [-a xxx | [-b yyy -c zzz]]

मैंने यह कोशिश की लेकिन काम नहीं करता। क्या कोई मेरी वहां मदद करेगा?

group= parser.add_argument_group('Model 2')
group_ex = group.add_mutually_exclusive_group()
group_ex.add_argument("-a", type=str, action = "store", default = "", help="test")
group_ex_2 = group_ex.add_argument_group("option 2")
group_ex_2.add_argument("-b", type=str, action = "store", default = "", help="test")
group_ex_2.add_argument("-c", type=str, action = "store", default = "", help="test")

धन्यवाद!

Question 2

add_mutually_exclusive_groupएक पूरे समूह को परस्पर अनन्य नहीं बनाता है। यह समूह के भीतर परस्पर अनन्य विकल्प बनाता है।

आप जो खोज रहे हैं, वह सब- वैंड है । प्रोग के बजाय [-a xxxx | [-b yyy -c zzz]], आपके पास होगा:

prog 
  command 1 
    -a: ...
  command 2
    -b: ...
    -c: ...

तर्कों के पहले सेट के साथ आह्वान करने के लिए:

prog command_1 -a xxxx

तर्क के दूसरे सेट के साथ आह्वान करने के लिए:

prog command_2 -b yyyy -c zzzz

आप उप कमांड तर्क को स्थिति के रूप में भी सेट कर सकते हैं।

prog command_1 xxxx

Git या svn की तरह:

git commit -am
git merge develop

काम करने का उदाहरण

# create the top-level parser
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--foo', action='store_true', help='help for foo arg.')
subparsers = parser.add_subparsers(help='help for subcommand')

# create the parser for the "command_1" command
parser_a = subparsers.add_parser('command_1', help='command_1 help')
parser_a.add_argument('a', type=str, help='help for bar, positional')

# create the parser for the "command_2" command
parser_b = subparsers.add_parser('command_2', help='help for command_2')
parser_b.add_argument('-b', type=str, help='help for b')
parser_b.add_argument('-c', type=str, action='store', default='', help='test')

झसे आज़माओ

>>> parser.print_help()
usage: PROG [-h] [--foo] {command_1,command_2} ...

positional arguments:
  {command_1,command_2}
                        help for subcommand
    command_1           command_1 help
    command_2           help for command_2

optional arguments:
  -h, --help            show this help message and exit
  --foo                 help for foo arg.
>>>

>>> parser.parse_args(['command_1', 'working'])
Namespace(a='working', foo=False)
>>> parser.parse_args(['command_1', 'wellness', '-b x'])
usage: PROG [-h] [--foo] {command_1,command_2} ...
PROG: error: unrecognized arguments: -b x

सौभाग्य।

Question 3

जबकि जोनाथन का जवाब जटिल विकल्पों के लिए पूरी तरह से ठीक है, एक बहुत ही सरल समाधान है जो सरल मामलों के लिए काम करेगा, जैसे 1 विकल्प में 2 अन्य विकल्प शामिल हैं जैसे

command [- a xxx | [ -b yyy | -c zzz ]]

या मूल प्रश्न के अनुसार भी:

pro [-a xxx | [-b yyy -c zzz]]

यहाँ है कि मैं यह कैसे करेंगे:

parser = argparse.ArgumentParser()

# group 1 
parser.add_argument("-q", "--query", help="query", required=False)
parser.add_argument("-f", "--fields", help="field names", required=False)

# group 2 
parser.add_argument("-a", "--aggregation", help="aggregation",
                    required=False)

मैं यहाँ एक मोंगोडब को क्वेरी करने के लिए कमांड लाइन रैपर को दिए गए विकल्पों का उपयोग कर रहा हूँ। collectionउदाहरण के किसी भी विधि कॉल कर सकते हैं aggregateया विधि findवैकल्पिक तर्क के साथ queryऔर fields, इसलिए आप देख क्यों पहले दो तर्क संगत कर रहे हैं और पिछले एक नहीं है।

तो अब मैं parser.parse_args()इसे चलाता हूँ और इसकी सामग्री देखता हूँ:

args = parser().parse_args()

print args.aggregation
if args.aggregation and (args.query or args.fields):
    print "-a and -q|-f are mutually exclusive ..."
    sys.exit(2)

बेशक, यह छोटी सी हैक केवल सरल मामलों के लिए काम कर रही है और यदि आपके पास कई पारस्परिक अनन्य विकल्प और समूह हैं, तो सभी संभावित विकल्पों की जांच करना एक दुःस्वप्न बन जाएगा। उस मामले में आपको जोनाथन जैसे सुझाए गए समूहों में अपने विकल्पों को तोड़ना चाहिए।

Question 4

एक अजगर पैच (विकास में) है जो आपको ऐसा करने की अनुमति देगा।
http://bugs.python.org/issue10984

विचार परस्पर अनन्य समूहों को ओवरलैप करने की अनुमति देना है। तो usageलग सकता है:

pro [-a xxx | -b yyy] [-a xxx | -c zzz]

इस तरह के दो समूह बना सकते हैं ताकि इस तरह के आसान भाग में परिवर्तन हो सके। usageएक कस्टम लिखने के लिए आवश्यक फ़ॉर्मेटिंग कोड को बदलना HelpFormatter।

में argparse, कार्रवाई समूहों पार्स प्रभावित नहीं करते। वे सिर्फ एक helpस्वरूपण उपकरण हैं। में help, परस्पर अनन्य समूह केवल प्रभावित कर usageलाइन। जब पार्स करने, parserसंभावित टकराव का एक शब्दकोश (निर्माण करने के लिए पारस्परिक रूप से विशिष्ट समूहों का उपयोग करता है aके साथ नहीं हो सकता है bया c, bके साथ नहीं हो सकता है a, आदि), और फिर अगर एक संघर्ष उठता है एक त्रुटि को जन्म देती है।

उस बगैर पैच के, मुझे लगता है कि आपकी सबसे अच्छी पसंद अपने द्वारा निर्मित नामस्थान का परीक्षण करना है parse_args(जैसे कि यदि दोनों aऔर bउनके पास नॉन्डफॉल्ट मान हैं), और अपनी खुद की त्रुटि उठाएं। तुम भी पार्सर की अपनी त्रुटि तंत्र का उपयोग कर सकते हैं।

parser.error('custom error message')