OptionParser - कमांड लाइन

Question

के अंत में किसी भी विकल्प का समर्थन करना मैं एक छोटा प्रोग्राम लिख रहा हूं जो रिमोट सर्वर पर कमांड निष्पादित करने वाला है (मान लें कि ssh [hostname] [command] के आसपास एक उचित गूंगा रैपर कहें)।

मैं इस तरह के रूप में यह निष्पादित करने के लिए करना चाहते हैं:

./floep [command]

हालांकि, मैं समय-समय पर कुछ कमांड लाइन पारित करने के लिए की जरूरत है:

./floep -v [command]

तो मैं इस बात के लिए optparse.OptionParser उपयोग करने का फैसला । समस्या है, मैं कभी-कभी आदेश भी तर्क है, जो ठीक काम करता है, तो मुझे क्या करना है:

./floep -v "uname -a"

लेकिन मैं यह भी यह है जब मैं का उपयोग काम करना चाहता हूँ:

./floep -v uname -a

विचार यह है कि जल्द ही मैं पहले गैर-विकल्प तर्क में आया हूं, उसके बाद सबकुछ मेरे आदेश का हिस्सा होना चाहिए।

लेकिन यह मुझे देता है:

Usage: floep [options] 

floep: error: no such option: -a

OptionParser इस वाक्य रचना का समर्थन करता है? यदि हां, तो कैसे? यदि नहीं: तो इसे ठीक करने का सबसे अच्छा तरीका क्या है?

Answer 1

disable_interspersed_args()

#!/usr/bin/env python 
from optparse import OptionParser 

parser = OptionParser() 
parser.disable_interspersed_args() 
parser.add_option("-v", action="store_true", dest="verbose") 
(options, args) = parser.parse_args() 

print "Options: %s args: %s" % (options, args) 

का उपयोग करते समय चलाने का प्रयास करें:

 
$ ./options.py foo -v bar 
Options: {'verbose': None} args: ['foo', '-v', 'bar'] 
$ ./options.py -v foo bar 
Options: {'verbose': True} args: ['foo', 'bar'] 
$ ./options.py foo -a bar 
Options: {'verbose': None} args: ['foo', '-a', 'bar'] 

Answer 2

आप इस प्रकार का बैश स्क्रिप्ट का उपयोग कर सकते हैं:

#!/bin/bash 
while [ "-" == "${1:0:1}" ] ; do 
    if [ "-v" == "${1}" ] ; then 
    # do something 
    echo "-v" 
    elif [ "-s" == "${1}" ] ; then 
    # do something 
    echo "-s" 
    fi 
    shift 
done 
${@} 

$ {@} आप आदेश पंक्ति है कि बदलाव कॉल से भस्म नहीं किया गया था के आराम देता है। ssh का उपयोग करने के लिए आप बस $ {@} को ssh $ {user} @ $ {मेजबान} $ {@}

test.sh bla
bla

परीक्षण गूंज से लाइन बदल जाते हैं। श -v गूंज bla
-v
bla

test.sh -v -s गूंज bla
-v
-s
ब्लै

Answer 3

विकल्प पार्सर उदाहरण वास्तव में जटिल मामलों के लिए पार्सिंग ऑपरेशन के दौरान छेड़छाड़ की जा सकती है। इस मामले में, मुझे विश्वास है कि आपके द्वारा वर्णित परिदृश्य को आउट ऑफ़ द बॉक्स (जो सच है तो अच्छी खबर होगी! यह कितनी बार होता है ??)। दस्तावेज़ में इस अनुभाग को देखें: Querying and manipulating your option parser।

disable_interspersed_args()

सेट पहली गैर विकल्प पर रोकने के लिए पार्स करने:

ऊपर के लिंक के शब्दों में। इसका उपयोग करें यदि आपके पास कमांड प्रोसेसर है जो एक और कमांड चलाता है जिसमें के विकल्प हैं और आप यह सुनिश्चित करना चाहते हैं कि ये विकल्प भ्रमित न हों। उदाहरण के लिए, प्रत्येक कमांड में विकल्पों का एक अलग सेट हो सकता है।

Answer 4

from optparse import OptionParser 
import subprocess 
import os 
import sys 

parser = OptionParser() 
parser.add_option("-q", "--quiet", 
        action="store_true", dest="quiet", default=False, 
        help="don't print output") 
parser.add_option("-s", "--signal", 
        action="store_true", dest="signal", default=False, 
        help="signal end of program and return code") 

parser.disable_interspersed_args() 
(options, command) = parser.parse_args() 

if not command: 
    parser.print_help() 
    sys.exit(1) 

if options.quiet: 
    ret = subprocess.call(command, stdout=open(os.devnull, 'w'), 
          stderr=subprocess.STDOUT) 
else: 
    ret = subprocess.call(command) 

if options.signal: 
    print "END OF PROGRAM!!! Code: %d" % ret