"optparse" --- Parser for command line options
**********************************************

**ソースコード:** Lib/optparse.py

バージョン 3.2 で非推奨: The "optparse" module is deprecated and will
not be developed further; development will continue with the
"argparse" module.

======================================================================

"optparse" モジュールは、昔からある "getopt" よりも簡便で、柔軟性に富
み、かつ強力なコマンドライン解析ライブラリです。 "optparse" では、より
宣言的なスタイルのコマンドライン解析手法、すなわち "OptionParser" のイ
ンスタンスを作成してオプションを追加してゆき、そのインスタンスでコマン
ドラインを解析するという手法をとっています。 "optparse" を使うと、
GNU/POSIX 構文でオプションを指定できるだけでなく、使用法やヘルプメッセ
ージの生成も行えます。

"optparse" を使った簡単なスクリプトの例を以下に示します:

   from optparse import OptionParser
   ...
   parser = OptionParser()
   parser.add_option("-f", "--file", dest="filename",
                     help="write report to FILE", metavar="FILE")
   parser.add_option("-q", "--quiet",
                     action="store_false", dest="verbose", default=True,
                     help="don't print status messages to stdout")

   (options, args) = parser.parse_args()

このようにわずかな行数のコードによって、スクリプトのユーザはコマンドラ
イン上で例えば以下のような「よくある使い方」を実行できるようになります
:

   <yourscript> --file=outfile -q

As it parses the command line, "optparse" sets attributes of the
"options" object returned by "parse_args()" based on user-supplied
command-line values.  When "parse_args()" returns from parsing this
command line, "options.filename" will be ""outfile"" and
"options.verbose" will be "False".  "optparse" supports both long and
short options, allows short options to be merged together, and allows
options to be associated with their arguments in a variety of ways.
Thus, the following command lines are all equivalent to the above
example:

   <yourscript> -f outfile --quiet
   <yourscript> --quiet --file outfile
   <yourscript> -q -foutfile
   <yourscript> -qfoutfile

さらに、ユーザが以下のいずれかを実行すると

   <yourscript> -h
   <yourscript> --help

"optparse" はスクリプトのオプションについて簡単にまとめた内容を出力し
ます:

   Usage: <yourscript> [options]

   Options:
     -h, --help            show this help message and exit
     -f FILE, --file=FILE  write report to FILE
     -q, --quiet           don't print status messages to stdout

*yourscript* の中身は実行時に決まります (通常は "sys.argv[0]" になりま
す)。


背景
====

"optparse" は、素直で慣習に則ったコマンドラインインターフェースを備え
たプログラムの作成を援助する目的で設計されました。その結果、Unix で慣
習的に使われているコマンドラインの構文や機能だけをサポートするに留まっ
ています。こうした慣習に詳しくなければ、よく知っておくためにもこの節を
読んでおきましょう。


用語集
------

引数 (argument)
   コマンドラインでユーザが入力するテキストの塊で、シェルが "execl" や
   "execv" に引き渡すものです。Python では、引数は "sys.argv[1:]" の要
   素となります。("sys.argv[0]" は実行しようとしているプログラムの名前
   です。引数解析に関しては、この要素はあまり重要ではありません。)
   Unix シェルでは、「語 (word)」という用語も使います。

   場合によっては "sys.argv[1:]" 以外の引数リストを代入する方が望まし
   いことがあるので、「引数」は「 "sys.argv[1:]" または "sys.argv[1:]"
   の代替として提供される別のリストの要素」と読むべきでしょう。

オプション (option)
   追加的な情報を与えるための引数で、プログラムの実行に対する教示やカ
   スタマイズを行います。オプションには多様な文法が存在します。伝統的
   な Unix における書法はハイフン ("-") の後ろに一文字が続くもので、例
   えば "-x" や "-F" です。また、伝統的な Unix における書法では、複数
   のオプションを一つの引数にまとめられます。例えば "-x -F" は "-xF"
   と等価です。 GNU プロジェクトでは "--" の後ろにハイフンで区切りの語
   を指定する方法、例えば "--file" や "--dry-run" も提供しています。
   "optparse" は、これら二種類のオプション書法だけをサポートしています
   。

   他に見られる他のオプション書法には以下のようなものがあります:

   * ハイフンの後ろに数個の文字が続くもので、例えば "-pf" (このオプシ
     ョンは複数のオプションを一つにまとめたものとは *違います*)

   * ハイフンの後ろに語が続くもので、例えば "-file" (これは技術的には
     上の書式と同じですが、通常同じプログラム上で一緒に使うことはあり
     ません)

   * プラス記号の後ろに一文字、数個の文字、または語を続けたもので、例
     えば "+f", "+rgb"

   * スラッシュ記号の後ろに一文字、数個の文字、または語を続けたもので
     、例えば "/f", "/file"

   上記のオプション書法は "optparse" ではサポートしておらず、今後もサ
   ポートする予定はありません。これは故意によるものです: 最初の三つは
   どの環境の標準でもなく、最後の一つは Windows や特定のレガシーなプラ
   ットフォーム (VMS や MS-DOS など) を対象にしているときにしか意味を
   なさないからです。

オプション引数 (option argument)
   あるオプションの後ろに続く引数で、そのオプションに密接な関連をもち
   、オプションと同時に引数リストから取り出されます。 "optparse" では
   、オプション引数は以下のように別々の引数にできます:

      -f foo
      --file foo

   また、一つの引数中にも入れられます:

      -ffoo
      --file=foo

   通常、オプションは引数をとることもとらないこともあります。あるオプ
   ションは引数をとることがなく、またあるオプションは常に引数をとりま
   す。多くの人々が「オプションのオプション引数」機能を欲しています。
   これは、あるオプションが引数が指定されている場合には引数をとり、そ
   うでない場合には引数をもたないようにするという機能です。この機能は
   引数解析をあいまいにするため、議論の的となっています: 例えば、もし
   "-a" がオプション引数をとり、 "-b" がまったく別のオプションだとした
   ら、 "-ab" をどうやって解析すればいいのでしょうか？こうした曖昧さが
   存在するため、 "optparse" は今のところこの機能をサポートしていませ
   ん。

位置引数 (positional argument)
   他のオプションが解析される、すなわち他のオプションとその引数が解析
   されて引数リストから除去された後に引数リストに置かれているものです
   。

必須のオプション (required option)
   コマンドラインで与えなければならないオプションです; 「必須のオプシ
   ョン (required option)」という語は、英語では矛盾した言葉です。
   "optparse" では必須オプションの実装を妨げてはいませんが、とりたてて
   実装上役立つこともしていません。

例えば、下記のような架空のコマンドラインを考えてみましょう:

   prog -v --report report.txt foo bar

"-v" と "--report" はどちらもオプションです。"--report" オプションが引
数をとるとすれば、"report.txt" はオプションの引数です。"foo" と "bar"
は位置引数になります。


オプションとは何か
------------------

オプションはプログラムの実行を調整したり、カスタマイズしたりするための
補助的な情報を与えるために使います。もっとはっきりいうと、オプションは
あくまでもオプション (省略可能)であるということです。本来、プログラム
はともかくもオプションなしでうまく実行できてしかるべきです。(Unix や
GNU ツールセットのプログラムをランダムにピックアップしてみてください。
オプションを全く指定しなくてもちゃんと動くでしょう？例外は "find",
"tar", "dd" くらいです---これらの例外は、オプション文法が標準的でなく
、インターフェースが混乱を招くと酷評されてきた変種のはみ出しものなので
す)

多くの人が自分のプログラムに「必須のオプション」を持たせたいと考えます
。しかしよく考えてください。必須なら、それは *オプション(省略可能) で
はないのです！* プログラムを正しく動作させるのに絶対的に必要な情報があ
るとすれば、そこには位置引数を割り当てるべきなのです。

良くできたコマンドライン インターフェース設計として、ファイルのコピー
に使われる "cp" ユーティリティのことを考えてみましょう。ファイルのコピ
ーでは、コピー先を指定せずにファイルをコピーするのは無意味な操作ですし
、少なくとも一つのコピー元が必要です。従って、"cp" は引数無しで実行す
ると失敗します。とはいえ、"cp" はオプションを全く必要としない柔軟で便
利なコマンドライン文法を備えています:

   cp SOURCE DEST
   cp SOURCE ... DEST-DIR

まだあります。ほとんどの "cp" の実装では、ファイルモードや変更時刻を変
えずにコピーする、シンボリックリンクの追跡を行わない、すでにあるファイ
ルを上書きする前にユーザに尋ねる、など、ファイルをコピーする方法をいじ
るための一連のオプションを実装しています。しかし、こうしたオプションは
、一つのファイルを別の場所にコピーする、または複数のファイルを別のディ
レクトリにコピーするという、"cp" の中心的な処理を乱すことはないのです
。


位置引数とは何か
----------------

位置引数とは、プログラムを動作させる上で絶対的に必要な情報となる引数で
す。

よいユーザインターフェースとは、絶対に必要だとされるものが可能な限り少
ないものです。プログラムを正しく動作させるために 17 個もの別個の情報が
必要だとしたら、その *方法* はさして問題にはなりません ---ユーザはプロ
グラムを正しく動作させられないうちに諦め、立ち去ってしまうからです。ユ
ーザインターフェースがコマンドラインでも、設定ファイルでも、GUI やその
他の何であっても同じです: 多くの要求をユーザに押し付ければ、ほとんどの
ユーザはただ音をあげてしまうだけなのです。

要するに、ユーザが絶対に提供しなければならない情報だけに制限する ---
そして可能な限りよく練られたデフォルト設定を使うよう試みてください。も
ちろん、プログラムには適度な柔軟性を持たせたいとも望むはずですが、それ
こそがオプションの果たす役割です。繰り返しますが、設定ファイルのエント
リであろうが、GUI でできた「環境設定」ダイアログ上のウィジェットであろ
うが、コマンドラインオプションであろうが関係ありません --- より多くの
オプションを実装すればプログラムはより柔軟性を持ちますが、実装はより難
解になるのです。高すぎる柔軟性はユーザを閉口させ、コードの維持をより難
しくするのです。


チュートリアル
==============

"optparse" はとても柔軟で強力でありながら、ほとんどの場合には簡単に利
用できます。この節では、 "optparse" ベースのプログラムで広く使われてい
るコードパターンについて述べます。

まず、"OptionParser" クラスを import しておかなければなりません。次に
、プログラムの冒頭で "OptionParser" インスタンスを生成しておきます:

   from optparse import OptionParser
   ...
   parser = OptionParser()

これでオプションを定義できるようになりました。基本的な構文は以下の通り
です:

   parser.add_option(opt_str, ...,
                     attr=value, ...)

各オプションには、 "-f" や "--file" のような一つまたは複数のオプション
文字列と、パーザがコマンドライン上のオプションを見つけた際に、何を準備
し、何を行うべきかを "optparse" に教えるためのオプション属性 (option
attribute)がいくつか入ります。

通常、各オプションには短いオプション文字列と長いオプション文字列があり
ます。例えば:

   parser.add_option("-f", "--file", ...)

オプション文字列は、(ゼロ文字の場合も含め)いくらでも短く、またいくらで
も長くできます。ただしオプション文字列は少なくとも一つなければなりませ
ん。

"OptionParser.add_option()" に渡されたオプション文字列は、実際にはこの
関数で定義したオプションに対するラベルになります。簡単のため、以後では
コマンドライン上で *オプションを見つける* という表現をしばしば使います
が、これは実際には "optparse" がコマンドライン上の *オプション文字列*
を見つけ、対応づけされているオプションを探し出す、という処理に相当しま
す。

オプションを全て定義したら、 "optparse" にコマンドラインを解析するよう
に指示します:

   (options, args) = parser.parse_args()

(If you like, you can pass a custom argument list to "parse_args()",
but that's rarely necessary: by default it uses "sys.argv[1:]".)

"parse_args()" returns two values:

* 全てのオプションに対する値の入ったオブジェクト "options" --- 例えば
  、"--file" が単一の文字列引数をとる場合、"options.file" はユーザが指
  定したファイル名になります。オプションを指定しなかった場合には
  "None" になります

* オプションの解析後に残った位置引数からなるリスト "args"

このチュートリアルの節では、最も重要な四つのオプション属性: "action",
"type", "dest" (destination), "help" についてしか触れません。このうち
最も重要なのは "action" です。


オプション・アクションを理解する
--------------------------------

アクション(action)は "optparse" がコマンドライン上にあるオプションを見
つけたときに何をすべきかを指示します。 "optparse" には押し着せのアクシ
ョンのセットがハードコードされています。新たなアクションの追加は上級者
向けの話題であり、 optparse の拡張 で触れます。ほとんどのアクションは
、値を何らかの変数に記憶するよう "optparse" に指示します --- 例えば、
文字列をコマンドラインから取り出して、 "options" の属性の中に入れる、
といった具合にです。

オプション・アクションを指定しない場合、 "optparse" のデフォルトの動作
は "store" になります。


store アクション
----------------

もっとも良く使われるアクションは "store" です。このアクションは次の引
数 (あるいは現在の引数の残りの部分) を取り出し、正しい型の値か確かめ、
指定した保存先に保存するよう "optparse" に指示します。

例えば:

   parser.add_option("-f", "--file",
                     action="store", type="string", dest="filename")

例えば、以下のように指定しておき、偽のコマンドラインを作成して
"optparse" に解析させてみましょう:

   args = ["-f", "foo.txt"]
   (options, args) = parser.parse_args(args)

When "optparse" sees the option string "-f", it consumes the next
argument, "foo.txt", and stores it in "options.filename".  So, after
this call to "parse_args()", "options.filename" is ""foo.txt"".

オプションの型として、 "optparse" は他にも "int" や "float" をサポート
しています:

   parser.add_option("-n", type="int", dest="num")

このオプションには長い形式のオプション文字列がないため、設定に問題がな
いということに注意してください。また、デフォルトのアクションは "store"
なので、ここでは action を明示的に指定していません。

架空のコマンドラインをもう一つ解析してみましょう。今度は、オプション引
数をオプションの右側にぴったりくっつけて一緒くたにします: "-n42" (一つ
の引数のみ) は "-n 42" (二つの引数からなる) と等価になるので

   (options, args) = parser.parse_args(["-n42"])
   print(options.num)

は "42" を出力します。

型を指定しない場合、 "optparse" は引数を "string" であると仮定します。
デフォルトのアクションが "store" であることも併せて考えると、最初の例
はもっと短くなります:

   parser.add_option("-f", "--file", dest="filename")

保存先 (destination) を指定しない場合、 "optparse" はデフォルト値とし
てオプション文字列から気のきいた名前を設定します: 最初に指定した長い形
式のオプション文字列が "--foo-bar" であれば、デフォルトの保存先は
"foo_bar" になります。長い形式のオプション文字列がなければ、
"optparse" は最初に指定した短い形式のオプション文字列を探します: 例え
ば、 "-f" に対する保存先は "f" になります。

"optparse" にはビルトインの "complex" 型も含まれています。型の追加につ
いては optparse の拡張 で触れています。


ブール値 (フラグ) オプションの処理
----------------------------------

フラグオプション---特定のオプションに対して真または偽の値の値を設定す
るオプション--- はよく使われます。 "optparse" では、二つのアクション、
"store_true" および "store_false" をサポートしています。例えば、
"verbose" というフラグを "-v" で有効にして、 "-q" で無効にしたいとしま
す:

   parser.add_option("-v", action="store_true", dest="verbose")
   parser.add_option("-q", action="store_false", dest="verbose")

ここでは二つのオプションに同じ保存先を指定していますが、全く問題ありま
せん。(下記のように、デフォルト値の設定を少し注意深く行わなければなら
ないだけです。)

"-v" をコマンドライン上に見つけると、 "optparse" は "options.verbose"
を "True" に設定します。 "-q" を見つければ、 "options.verbose" は
"False" にセットされます。


その他のアクション
------------------

この他にも、 "optparse" は以下のようなアクションをサポートしています:

""store_const""
   store a constant value, pre-set via "Option.const"

""append""
   オプションの引数を指定のリストに追加します

""count""
   指定のカウンタを 1 増やします

""callback""
   指定の関数を呼び出します

これらのアクションについては、 リファレンスガイド 節および オプション
処理コールバック 節で触れます。


デフォルト値
------------

上記の例は全て、何らかのコマンドラインオプションが見つかった時に何らか
の変数 (保存先: destination) に値を設定していました。では、該当するオ
プションが見つからなかった場合には何が起きるのでしょうか？デフォルトは
全く与えていないため、これらの値は全て "None" になります。たいていはこ
れで十分ですが、もっときちんと制御したい場合もあります。 "optparse" で
は各保存先に対してデフォルト値を指定し、コマンドラインの解析前にデフォ
ルト値が設定されるようにできます。

まず、 verbose/quiet の例について考えてみましょう。 "optparse" に対し
て、 "-q" がない限り "verbose" を "True" に設定させたいなら、以下のよ
うにします:

   parser.add_option("-v", action="store_true", dest="verbose", default=True)
   parser.add_option("-q", action="store_false", dest="verbose")

デフォルトの値は特定のオプションではなく *保存先* に対して適用されます
。また、これら二つのオプションはたまたま同じ保存先を持っているにすぎな
いため、上のコードは下のコードと全く等価になります:

   parser.add_option("-v", action="store_true", dest="verbose")
   parser.add_option("-q", action="store_false", dest="verbose", default=True)

下のような場合を考えてみましょう:

   parser.add_option("-v", action="store_true", dest="verbose", default=False)
   parser.add_option("-q", action="store_false", dest="verbose", default=True)

やはり "verbose" のデフォルト値は "True" になります; 特定の目的変数に
対するデフォルト値として有効なのは、最後に指定した値だからです。

A clearer way to specify default values is the "set_defaults()" method
of OptionParser, which you can call at any time before calling
"parse_args()":

   parser.set_defaults(verbose=True)
   parser.add_option(...)
   (options, args) = parser.parse_args()

前の例と同様、あるオプションの値の保存先に対するデフォルトの値は最後に
指定した値になります。コードを読みやすくするため、デフォルト値を設定す
るときには両方のやり方を混ぜるのではなく、片方だけを使うようにしましょ
う。


ヘルプの生成
------------

"optparse" にはヘルプと使い方の説明 (usage text) を生成する機能があり
、ユーザに優しいコマンドライン インターフェースを作成する上で役立ちま
す。やらなければならないのは、各オプションに対する "help" の値と、必要
ならプログラム全体の使用法を説明する短いメッセージを与えることだけです
。ユーザフレンドリな (ドキュメント付きの) オプションを追加した
"OptionParser" を以下に示します:

   usage = "usage: %prog [options] arg1 arg2"
   parser = OptionParser(usage=usage)
   parser.add_option("-v", "--verbose",
                     action="store_true", dest="verbose", default=True,
                     help="make lots of noise [default]")
   parser.add_option("-q", "--quiet",
                     action="store_false", dest="verbose",
                     help="be vewwy quiet (I'm hunting wabbits)")
   parser.add_option("-f", "--filename",
                     metavar="FILE", help="write output to FILE")
   parser.add_option("-m", "--mode",
                     default="intermediate",
                     help="interaction mode: novice, intermediate, "
                          "or expert [default: %default]")

"optparse" がコマンドライン上で "-h" や "--help" を見つけた場合や、
"parser.print_help()" を呼び出した場合、この "OptionParser" は以下のよ
うなメッセージを標準出力に出力します:

   Usage: <yourscript> [options] arg1 arg2

   Options:
     -h, --help            show this help message and exit
     -v, --verbose         make lots of noise [default]
     -q, --quiet           be vewwy quiet (I'm hunting wabbits)
     -f FILE, --filename=FILE
                           write output to FILE
     -m MODE, --mode=MODE  interaction mode: novice, intermediate, or
                           expert [default: intermediate]

(help オプションでヘルプを出力した場合、 "optparse" は出力後にプログラ
ムを終了します。)

"optparse" ができるだけうまくメッセージを生成するよう手助けするには、
他にもまだまだやるべきことがあります:

* スクリプト自体の利用法を表すメッセージを定義します:

     usage = "usage: %prog [options] arg1 arg2"

  "optparse" は "%prog" を現在のプログラム名、すなわち
  "os.path.basename(sys.argv[0])" と置き換えます。この文字列は詳細なオ
  プションヘルプの前に展開され出力されます。

  usage の文字列を指定しない場合、 "optparse" は型どおりとはいえ気の利
  いたデフォルト値、 ""Usage: %prog [options]"" を使います。位置引数を
  とらないスクリプトの場合はこれで十分でしょう。

* 全てのオプションにヘルプ文字列を定義します。行の折り返しは気にしなく
  てかまいません ---"optparse" は行の折り返しに気を配り、見栄えのよい
  ヘルプ出力を生成します。

* オプションが値をとるということは自動的に生成されるヘルプメッセージの
  中で分かります。例えば、"mode" option の場合にはこのようになります:

     -m MODE, --mode=MODE

  ここで "MODE" はメタ変数 (meta-variable) と呼ばれます: メタ変数は、
  ユーザが "-m"/"--mode" に対して指定するはずの引数を表します。デフォ
  ルトでは、 "optparse" は保存先の変数名を大文字だけにしたものをメタ変
  数に使います。これは時として期待通りの結果になりません --- 例えば、
  上の例の "--filename" オプションでは明示的に "metavar="FILE"" を設定
  しており、その結果自動生成されたオプション説明テキストは:

     -f FILE, --filename=FILE

  この機能の重要さは、単に表示スペースを節約するといった理由にとどまり
  ません: 上の例では、手作業で書いたヘルプテキストの中でメタ変数として
  "FILE" を使っています。その結果、ユーザに対してやや堅苦しい表現の書
  法 "-f FILE" と、より平易に意味付けを説明した "write output to FILE"
  との間に対応があるというヒントを与えています。これは、エンドユーザに
  とってより明解で便利なヘルプテキストを作成する単純でありながら効果的
  な手法なのです。

* デフォルト値を持つオプションはヘルプ文字列に "%default" を含むことが
  できます---"optparse" はそれをオプションのデフォルト値に "str()" を
  適用したもので置き換えます。オプションがデフォルト値を持たない (もし
  くはデフォルト値が "None" である) 場合、 "%default" は "none" に展開
  されます。


オプションをグループ化する
~~~~~~~~~~~~~~~~~~~~~~~~~~

たくさんのオプションを扱う場合、オプションをグループ分けするとヘルプ出
力が見やすくなります。 "OptionParser" は、複数のオプションをまとめたオ
プショングループを複数持つことができます。

オプションのグループは、 "OptionGroup" を使って作成します:

class optparse.OptionGroup(parser, title, description=None)

   ここでは:

   * *parser* は、このグループが属する "OptionParser" のインスタンスで
     す

   * *title* はグループのタイトルです

   * *description* はオプションで、グループの長い説明です

"OptionGroup" は ("OptionParser" のように) "OptionContainer" を継承し
ていて、オプションをグループに追加するために "add_option()" メソッドを
利用できます。

全てのオプションを定義したら、 "OptionParser" の "add_option_group()"
メソッドを使ってグループを定義済みのパーサーに追加します。

前のセクションで定義したパーサーに、続けて "OptionGroup" を追加します:

   group = OptionGroup(parser, "Dangerous Options",
                       "Caution: use these options at your own risk.  "
                       "It is believed that some of them bite.")
   group.add_option("-g", action="store_true", help="Group option.")
   parser.add_option_group(group)

この結果のヘルプ出力は次のようになります:

   Usage: <yourscript> [options] arg1 arg2

   Options:
     -h, --help            show this help message and exit
     -v, --verbose         make lots of noise [default]
     -q, --quiet           be vewwy quiet (I'm hunting wabbits)
     -f FILE, --filename=FILE
                           write output to FILE
     -m MODE, --mode=MODE  interaction mode: novice, intermediate, or
                           expert [default: intermediate]

     Dangerous Options:
       Caution: use these options at your own risk.  It is believed that some
       of them bite.

       -g                  Group option.

さらにサンプルを拡張して、複数のグループを使うようにしてみます:

   group = OptionGroup(parser, "Dangerous Options",
                       "Caution: use these options at your own risk.  "
                       "It is believed that some of them bite.")
   group.add_option("-g", action="store_true", help="Group option.")
   parser.add_option_group(group)

   group = OptionGroup(parser, "Debug Options")
   group.add_option("-d", "--debug", action="store_true",
                    help="Print debug information")
   group.add_option("-s", "--sql", action="store_true",
                    help="Print all SQL statements executed")
   group.add_option("-e", action="store_true", help="Print every action done")
   parser.add_option_group(group)

出力結果は次のようになります:

   Usage: <yourscript> [options] arg1 arg2

   Options:
     -h, --help            show this help message and exit
     -v, --verbose         make lots of noise [default]
     -q, --quiet           be vewwy quiet (I'm hunting wabbits)
     -f FILE, --filename=FILE
                           write output to FILE
     -m MODE, --mode=MODE  interaction mode: novice, intermediate, or expert
                           [default: intermediate]

     Dangerous Options:
       Caution: use these options at your own risk.  It is believed that some
       of them bite.

       -g                  Group option.

     Debug Options:
       -d, --debug         Print debug information
       -s, --sql           Print all SQL statements executed
       -e                  Print every action done

もう1つの、特にオプショングループをプログラムから操作するときに利用で
きるメソッドがあります:

OptionParser.get_option_group(opt_str)

   短いオプション文字列もしくは長いオプション文字列 *opt_str* (例。
   "'-o'" 、 "'--option'") が属する "OptionGroup" を返します。そのよう
   な "OptionGroup" が無い場合は、 "None" を返します。


バージョン番号の出力
--------------------

"optparse" では、使用法メッセージと同様にプログラムのバージョン文字列
を出力できます。 "OptionParser" の "version" 引数に文字列を渡します:

   parser = OptionParser(usage="%prog [-f] [-q]", version="%prog 1.0")

"%prog" は "usage" と同じような展開を受けます。その他にも "version" に
は何でも好きな内容を入れられます。 "version" を指定した場合、
"optparse" は自動的に "--version" オプションをパーザに渡します。コマン
ドライン中に "--version" が見つかると、 "optparse" は "version" 文字列
を展開して ("%prog" を置き換えて) 標準出力に出力し、プログラムを終了し
ます。

例えば、"/usr/bin/foo" という名前のスクリプトなら:

   $ /usr/bin/foo --version
   foo 1.0

以下の2つのメソッドを、"version" 文字列を表示するために利用できます:

OptionParser.print_version(file=None)

   現在のプログラムのバージョン ("self.version") を *file* (デフォルト
   : stdout) へ表示します。 "print_usage()" と同じく、 "self.version"
   の中の全ての "%prog" が現在のプログラム名に置き換えられます。
   "self.version" が空文字列だだったり未定義だったときは何もしません。

OptionParser.get_version()

   "print_version()" と同じですが、バージョン文字列を表示する代わりに
   返します。


"optparse" のエラー処理法
-------------------------

"optparse" を使う場合に気を付けなければならないエラーには、大きく分け
てプログラマ側のエラーとユーザ側のエラーという二つの種類があります。プ
ログラマ側のエラーの多くは、例えば不正なオプション文字列や定義されてい
ないオプション属性の指定、あるいはオプション属性を指定し忘れるといった
、誤った "OptionParser.add_option()", 呼び出しによるものです。こうした
誤りは通常通りに処理されます。すなわち、例外("optparse.OptionError" や
"TypeError") を送出して、プログラムをクラッシュさせます。

もっと重要なのはユーザ側のエラーの処理です。というのも、ユーザの操作エ
ラーというものはコードの安定性に関係なく起こるからです。 "optparse" は
、誤ったオプション引数の指定 (整数を引数にとるオプション "-n" に対して
"-n 4x" と指定してしまうなど) や、引数を指定し忘れた場合 ("-n" が何ら
かの引数をとるオプションであるのに、 "-n" が引数の末尾に来ている場合)
といった、ユーザによるエラーを自動的に検出します。また、アプリケーショ
ン側で定義されたエラー条件が起きた場合、 "OptionParser.error()" を呼び
出してエラーを通知できます:

   (options, args) = parser.parse_args()
   ...
   if options.a and options.b:
       parser.error("options -a and -b are mutually exclusive")

いずれの場合にも "optparse" はエラーを同じやり方で処理します。すなわち
、プログラムの使用法メッセージとエラーメッセージを標準エラー出力に出力
して、終了ステータス 2 でプログラムを終了させます。

上に挙げた最初の例、すなわち整数を引数にとるオプションにユーザが "4x"
を指定した場合を考えてみましょう:

   $ /usr/bin/foo -n 4x
   Usage: foo [options]

   foo: error: option -n: invalid integer value: '4x'

値を全く指定しない場合には、以下のようになります:

   $ /usr/bin/foo -n
   Usage: foo [options]

   foo: error: -n option requires an argument

"optparse" は、常にエラーを引き起こしたオプションについて説明の入った
エラーメッセージを生成するよう気を配ります; 従って、
"OptionParser.error()" をアプリケーションコードから呼び出す場合にも、
同じようなメッセージになるようにしてください。

"optparse" のデフォルトのエラー処理動作が気に入らないのなら、
"OptionParser" をサブクラス化して、 "exit()" かつ/または "error()" を
オーバライドする必要があります。


全てをつなぎ合わせる
--------------------

"optparse" を使ったスクリプトは、通常以下のようになります:

   from optparse import OptionParser
   ...
   def main():
       usage = "usage: %prog [options] arg"
       parser = OptionParser(usage)
       parser.add_option("-f", "--file", dest="filename",
                         help="read data from FILENAME")
       parser.add_option("-v", "--verbose",
                         action="store_true", dest="verbose")
       parser.add_option("-q", "--quiet",
                         action="store_false", dest="verbose")
       ...
       (options, args) = parser.parse_args()
       if len(args) != 1:
           parser.error("incorrect number of arguments")
       if options.verbose:
           print("reading %s..." % options.filename)
       ...

   if __name__ == "__main__":
       main()


リファレンスガイド
==================


parserを作る
------------

"optparse" を使う最初の一歩は OptionParser インスタンスを作ることです
。

class optparse.OptionParser(...)

   OptionParser のコンストラクタの引数はどれも必須ではありませんが、い
   くつものキーワード引数がオプションとして使えます。これらはキーワー
   ド引数として渡さなければなりません。すなわち、引数が宣言されている
   順番に頼ってはいけません。

   "usage" (デフォルト: ""%prog [options]"")
      The usage summary to print when your program is run incorrectly
      or with a help option.  When "optparse" prints the usage string,
      it expands "%prog" to "os.path.basename(sys.argv[0])" (or to
      "prog" if you passed that keyword argument).  To suppress a
      usage message, pass the special value "optparse.SUPPRESS_USAGE".

   "option_list" (デフォルト: "[]")
      パーザに追加する Option オブジェクトのリストです。 "option_list"
      の中のオプションは "standard_option_list" (OptionParser のサブク
      ラスでセットされる可能性のあるクラス属性) の後に追加されますが、
      バージョンやヘルプのオプションよりは前になります。このオプション
      の使用は推奨されません。パーザを作成した後で、 "add_option()" を
      使って追加してください。

   "option_class" (デフォルト: optparse.Option)
      "add_option()" でパーザにオプションを追加するときに使用されるク
      ラス。

   "version" (デフォルト: "None")
      ユーザがバージョンオプションを与えたときに表示されるバージョン文
      字列です。 "version" に真の値を与えると、 "optparse" は自動的に
      単独のオプション文字列 "--version" とともにバージョンオプション
      を追加します。部分文字列 "%prog" は "usage" と同様に展開されます
      。

   "conflict_handler" (デフォルト: ""error"")
      オプション文字列が衝突するようなオプションがパーザに追加されたと
      きにどうするかを指定します。 オプション間の衝突 節を参照して下さ
      い。

   "description" (デフォルト: "None")
      プログラムの概要を表す一段落のテキストです。 "optparse" はユーザ
      がヘルプを要求したときにこの概要を現在のターミナルの幅に合わせて
      整形し直して表示します ("usage" の後、オプションリストの前に表示
      されます)。

   "formatter" (デフォルト: 新しい "IndentedHelpFormatter")
      ヘルプテキストを表示する際に使われる optparse.HelpFormatter のイ
      ンスタンスです。 "optparse" はこの目的のためにすぐ使えるクラスを
      二つ提供しています。 IndentedHelpFormatter と
      TitledHelpFormatter がそれです。

   "add_help_option" (デフォルト: "True")
      もし真ならば、 "optparse" はパーザにヘルプオプションを (オプショ
      ン文字列 "-h" と "--help" とともに)追加します。

   "prog"
      "usage" や "version" の中の "%prog" を展開するときに
      "os.path.basename(sys.argv[0])" の代わりに使われる文字列です。

   "epilog" (デフォルト: "None")
      オプションのヘルプの後に表示されるヘルプテキスト.


パーザへのオプション追加
------------------------

パーザにオプションを加えていくにはいくつか方法があります。推奨するのは
チュートリアル 節で示したような "OptionParser.add_option()" を使う方法
です。 "add_option()" は以下の二つのうちいずれかの方法で呼び出せます:

* ("make_option()" などが返す) "Option" インスタンスを渡します

* "make_option()" に (すなわち "Option" のコンストラクタに) 位置引数と
  キーワード引数の組み合わせを渡して、 "Option" インスタンスを生成させ
  ます

もう一つの方法は、あらかじめ作成しておいた "Option" インスタンスからな
るリストを、以下のようにして "OptionParser" のコンストラクタに渡すとい
うものです:

   option_list = [
       make_option("-f", "--filename",
                   action="store", type="string", dest="filename"),
       make_option("-q", "--quiet",
                   action="store_false", dest="verbose"),
       ]
   parser = OptionParser(option_list=option_list)

("make_option()" は "Option" インスタンスを生成するファクトリ関数です;
現在のところ、この関数は "Option" のコンストラクタの別名にすぎません。
"optparse" の将来のバージョンでは、 "Option" を複数のクラスに分割し、
"make_option()" は適切なクラスを選んでインスタンスを生成するようになる
予定です。従って、 "Option" を直接インスタンス化しないでください。)


オプションの定義
----------------

各々の "Option" インスタンス、は "-f" や "--file" といった同義のコマン
ドラインオプションからなる集合を表現しています。一つの "Option" には任
意の数のオプションを短い形式でも長い形式でも指定できます。ただし、少な
くとも一つは指定しなければなりません。

正しい方法で "Option" インスタンスを生成するには、 "OptionParser" の
"add_option()" を使います。

OptionParser.add_option(option)
OptionParser.add_option(*opt_str, attr=value, ...)

   短い形式のオプション文字列を一つだけ持つようなオプションを生成する
   には次のようにします:

      parser.add_option("-f", attr=value, ...)

   また、長い形式のオプション文字列を一つだけ持つようなオプションの定
   義は次のようになります:

      parser.add_option("--foo", attr=value, ...)

   キーワード引数は新しい "Option" オブジェクトの属性を定義します。オ
   プションの属性のうちでもっとも重要なのは "action" です。この属性は
   、他のどの属性と関連があるか、そしてどの属性が必要かに大きく作用し
   ます。関係のないオプション属性を指定したり、必要な属性を指定し忘れ
   たりすると、 "optparse" は誤りを解説した "OptionError" 例外を送出し
   ます。

   コマンドライン上にあるオプションが見つかったときの "optparse" の振
   舞いを決定しているのは *アクション(action)* です。 "optparse" でハ
   ードコードされている標準的なアクションには以下のようなものがありま
   す:

   ""store""
      オプションの引数を保存します (デフォルトの動作です)

   ""store_const""
      store a constant value, pre-set via "Option.const"

   ""store_true""
      store "True"

   ""store_false""
      store "False"

   ""append""
      オプションの引数を指定のリストに追加します

   ""append_const""
      append a constant value to a list, pre-set via "Option.const"

   ""count""
      指定のカウンタを 1 増やします

   ""callback""
      指定の関数を呼び出します

   ""help""
      全てのオプションとそのドキュメントの入った使用法メッセージを出力
      します

   (アクションを指定しない場合、デフォルトは ""store"" になります。こ
   のアクションでは、 "type" および "dest" オプション属性を指定できま
   す。 標準的なオプション・アクション を参照してください。)

As you can see, most actions involve storing or updating a value
somewhere. "optparse" always creates a special object for this,
conventionally called "options", which is an instance of
"optparse.Values".

class optparse.Values

   An object holding parsed argument names and values as attributes.
   Normally created by calling when calling
   "OptionParser.parse_args()", and can be overridden by a custom
   subclass passed to the *values* argument of
   "OptionParser.parse_args()" (as described in 引数を解析する).

Option arguments (and various other values) are stored as attributes
of this object, according to the "dest" (destination) option
attribute.

例えばこれを呼び出した場合

   parser.parse_args()

"optparse" はまず "options" オブジェクトを生成します:

   options = Values()

パーザ中で以下のようなオプションが定義されていて

   parser.add_option("-f", "--file", action="store", type="string", dest="filename")

パーズしたコマンドラインに以下のいずれかが入っていた場合:

   -ffoo
   -f foo
   --file=foo
   --file foo

"optparse" はこのオプションを見つけて、以下と同等の処理を行います

   options.filename = "foo"

"type" および "dest" オプション属性は "action" と同じくらい重要ですが
、 *全ての* オプションで意味をなすのは "action" だけなのです。


オプション属性
--------------

class optparse.Option

   A single command line argument, with various attributes passed by
   keyword to the constructor. Normally created with
   "OptionParser.add_option()" rather than directly, and can be
   overridden by a custom class via the *option_class* argument to
   "OptionParser".

以下のオプション属性は "OptionParser.add_option()" へのキーワード引数
として渡すことができます。特定のオプションに無関係なオプション属性を渡
した場合、または必須のオプションを渡しそこなった場合、 "optparse" は
"OptionError" を送出します。

Option.action

   (デフォルト: ""store"")

   このオプションがコマンドラインにあった場合に "optparse" に何をさせ
   るかを決めます。取りうるオプションについては こちら を参照してくだ
   さい。

Option.type

   (デフォルト: ""string"")

   このオプションに与えられる引数の型 (たとえば ""string"" や ""int"")
   です。取りうるオプションについては こちら を参照してください。

Option.dest

   (デフォルト: オプション文字列を使う)

   このオプションのアクションがある値をどこかに書いたり書き換えたりを
   意味する場合、これは "optparse" にその書く場所を教えます。詳しく言
   えば "dest" には "optparse" がコマンドラインを解析しながら組み立て
   る "options" オブジェクトの属性の名前を指定します。

Option.default

   コマンドラインに指定がなかったときにこのオプションの対象に使われる
   値です。 "OptionParser.set_defaults()" も参照してください。

Option.nargs

   (デフォルト: 1)

   このオプションがあったときに幾つの "type" 型の引数が消費されるべき
   かを指定します。 1 より大きい場合、 "optparse" は "dest" に値のタプ
   ルを格納します。

Option.const

   定数を格納する動作のための、その定数です。

Option.choices

   ""choice"" 型オプションに対してユーザが選べる選択肢となる文字列のリ
   ストです。

Option.callback

   アクションが ""callback"" であるオプションに対し、このオプションが
   あったときに呼ばれる呼び出し可能オブジェクトです。呼び出し時に渡さ
   れる引数の詳細については、 オプション処理コールバック を参照してく
   ださい。

Option.callback_args
Option.callback_kwargs

   "callback" に渡される標準的な4つのコールバック引数の後ろに追加する
   、位置引数とキーワード引数。

Option.help

   Help text to print for this option when listing all available
   options after the user supplies a "help" option (such as "--help").
   If no help text is supplied, the option will be listed without help
   text.  To hide this option, use the special value
   "optparse.SUPPRESS_HELP".

Option.metavar

   (デフォルト: オプション文字列を使う)

   説明文を表示する際にオプションの引数の身代わりになるものです。例は
   チュートリアル 節を参照してください。


標準的なオプション・アクション
------------------------------

様々なオプション・アクションにはどれも互いに少しづつ異なった条件と作用
があります。ほとんどのアクションに関連するオプション属性がいくつかあり
、値を指定して "optparse" の挙動を操作できます。いくつかのアクションに
は必須の属性があり、必ず値を指定しなければなりません。

* ""store"" [関連: "type", "dest", "nargs", "choices"]

  オプションの後には必ず引数が続きます。引数は "type" に従って値に変換
  されて "dest" に保存されます。 "nargs" > 1 の場合、複数の引数をコマ
  ンドラインから取り出します。引数は全て "type" に従って変換され、
  "dest" にタプルとして保存されます。 標準のオプション型 節を参照して
  ください。

  "choices" を(文字列のリストかタプルで) 指定した場合、型のデフォルト
  値は ""choice"" になります。

  "type" を指定しない場合、デフォルトの値は ""string"" です。

  "dest" を指定しない場合、 "optparse" は保存先を最初の長い形式のオプ
  ション文字列から導出します (例えば、 "--foo-bar" は "foo_bar" になり
  ます)。長い形式のオプション文字列がない場合、 "optparse" は最初の短
  い形式のオプションから保存先の変数名を導出します ("-f" は "f" になり
  ます)。

  以下はプログラム例です:

     parser.add_option("-f")
     parser.add_option("-p", type="float", nargs=3, dest="point")

  とすると、以下のようなコマンドライン

     -f foo.txt -p 1 -3.5 4 -fbar.txt

  を解析した場合、 "optparse" は以下のように設定を行います

     options.f = "foo.txt"
     options.point = (1.0, -3.5, 4.0)
     options.f = "bar.txt"

* ""store_const"" [関連: "const"; 関連: "dest"]

  値 "const" を "dest" に保存します。

  以下はプログラム例です:

     parser.add_option("-q", "--quiet",
                       action="store_const", const=0, dest="verbose")
     parser.add_option("-v", "--verbose",
                       action="store_const", const=1, dest="verbose")
     parser.add_option("--noisy",
                       action="store_const", const=2, dest="verbose")

  とします。 "--noisy" が見つかると、 "optparse" は

     options.verbose = 2

* ""store_true"" [関連: "dest"]

  A special case of ""store_const"" that stores "True" to "dest".

* ""store_false"" [関連: "dest"]

  Like ""store_true"", but stores "False".

  以下はプログラム例です:

     parser.add_option("--clobber", action="store_true", dest="clobber")
     parser.add_option("--no-clobber", action="store_false", dest="clobber")

* ""append"" [関連: "type", "dest", "nargs", "choices"]

  このオプションの後ろには必ず引数が続きます。引数は "dest" のリストに
  追加されます。 "dest" のデフォルト値を指定しなかった場合、
  "optparse" がこのオプションを最初にみつけた時点で空のリストを自動的
  に生成します。 "nargs" > 1 の場合、複数の引数をコマンドラインから取
  り出し、長さ "nargs" のタプルを生成して "dest" に追加します。

  "type" および "dest" のデフォルト値は ""store"" アクションと同じです
  。

  以下はプログラム例です:

     parser.add_option("-t", "--tracks", action="append", type="int")

  "-t3" がコマンドライン上で見つかると、 "optparse" は:

     options.tracks = []
     options.tracks.append(int("3"))

  その後、"--tracks=4" が見つかると以下を実行します:

     options.tracks.append(int("4"))

  "append" アクションは、オプションの現在の値の "append" メソッドを呼
  び出します。これは、どのデフォルト値も "append" メソッドを持っていな
  ければならないことを意味します。また、デフォルト値が空でない場合、オ
  プションの解析結果は、そのデフォルトの要素の後ろにコマンドラインから
  の値が追加されたものになる、ということも意味します:

     >>> parser.add_option("--files", action="append", default=['~/.mypkg/defaults'])
     >>> opts, args = parser.parse_args(['--files', 'overrides.mypkg'])
     >>> opts.files
     ['~/.mypkg/defaults', 'overrides.mypkg']

* ""append_const"" [関連: "const"; 関連: "dest"]

  ""store_const"" と同様ですが、 "const" の値は "dest" に追加(append)
  されます。 ""append"" の場合と同じように "dest" のデフォルトは
  "None" ですがこのオプションを最初にみつけた時点で空のリストを自動的
  に生成します。

* ""count"" [関連: "dest"]

  "dest" に保存されている整数値をインクリメントします。 "dest" は (デ
  フォルトの値を指定しない限り) 最初にインクリメントを行う前にゼロに設
  定されます。

  以下はプログラム例です:

     parser.add_option("-v", action="count", dest="verbosity")

  コマンドライン上で最初に "-v" が見つかると、 "optparse" は:

     options.verbosity = 0
     options.verbosity += 1

  以後、"-v" が見つかるたびに

     options.verbosity += 1

* ""callback"" [必須: "callback"; 関連: "type", "nargs",
  "callback_args", "callback_kwargs"]

  "callback" に指定された関数を次のように呼び出します

     func(option, opt_str, value, parser, *args, **kwargs)

  詳細は、 オプション処理コールバック 節を参照してください。

* ""help""

  現在のオプションパーザ内の全てのオプションに対する完全なヘルプメッセ
  ージを出力します。ヘルプメッセージは "OptionParser" のコンストラクタ
  に渡した "usage"  文字列と、各オプションに渡した "help" 文字列から生
  成します。

  If no "help" string is supplied for an option, it will still be
  listed in the help message.  To omit an option entirely, use the
  special value "optparse.SUPPRESS_HELP".

  "optparse" は全ての "OptionParser" に自動的に "help" オプションを追
  加するので、通常自分で生成する必要はありません。

  以下はプログラム例です:

     from optparse import OptionParser, SUPPRESS_HELP

     # usually, a help option is added automatically, but that can
     # be suppressed using the add_help_option argument
     parser = OptionParser(add_help_option=False)

     parser.add_option("-h", "--help", action="help")
     parser.add_option("-v", action="store_true", dest="verbose",
                       help="Be moderately verbose")
     parser.add_option("--file", dest="filename",
                       help="Input file to read data from")
     parser.add_option("--secret", help=SUPPRESS_HELP)

  "optparse" がコマンドライン上に "-h" または "--help" を見つけると、
  以下のようなヘルプメッセージを標準出力に出力します ("sys.argv[0]" は
  ""foo.py"" だとします):

     Usage: foo.py [options]

     Options:
       -h, --help        Show this help message and exit
       -v                Be moderately verbose
       --file=FILENAME   Input file to read data from

  ヘルプメッセージの出力後、 "optparse" は "sys.exit(0)" でプロセスを
  終了します。

* ""version""

  "OptionParser" に指定されているバージョン番号を標準出力に出力して終
  了します。バージョン番号は、実際には "OptionParser" の
  "print_version()" メソッドで書式化されてから出力されます。通常、
  "OptionParser" のコンストラクタに "version" 引数が指定されたときのみ
  関係のあるアクションです。 "help" オプションと同様、 "optparse" はこ
  のオプションを必要に応じて自動的に追加するので、 "version" オプショ
  ンを作成することはほとんどないでしょう。


標準のオプション型
------------------

"optparse" には、 ""string"", ""int"", ""choice"", ""float"",
""complex"" の 5 種類のビルトインのオプション型があります。 新たなオプ
ションの型を追加したければ、 optparse の拡張 節を参照してください。

文字列オプションの引数はチェックや変換を一切受けません: コマンドライン
上のテキストは保存先にそのまま保存されます (またはコールバックに渡され
ます)。

整数引数 (""int"" 型) は次のように解析されます:

* 数が "0x" から始まるならば、16進数として読み取られます

* 数が "0" から始まるならば、8進数として読み取られます

* 数が "0b" から始まるならば、2進数として読み取られます

* それ以外の場合、数は10進数として読み取られます

変換は適切な底 (2, 8, 10, 16 のどれか) とともに "int()" を呼び出すこと
で行なわれます。この変換が失敗した場合 "optparse" の処理も失敗に終わり
ますが、 より役に立つエラーメッセージを出力します。

""float"" および ""complex"" のオプション引数は直接 "float()" や
"complex()" で変換されます。エラーは同様の扱いです。

""choice"" オプションは ""string"" オプションのサブタイプです。
"choices" オプションの属性 (文字列からなるシーケンス) には、利用できる
オプション引数のセットを指定します。 "optparse.check_choice()" はユー
ザの指定したオプション引数とマスタリストを比較して、無効な文字列が指定
された場合には "OptionValueError" を送出します。


引数を解析する
--------------

The whole point of creating and populating an OptionParser is to call
its "parse_args()" method.

OptionParser.parse_args(args=None, values=None)

   Parse the command-line options found in *args*.

   The input parameters are

   "args"
      処理する引数のリスト (デフォルト: "sys.argv[1:]")

   "values"
      a "Values" object to store option arguments in (default: a new
      instance of "Values") -- if you give an existing object, the
      option defaults will not be initialized on it

   and the return value is a pair "(options, args)" where

   "options"
      the same object that was passed in as *values*, or the
      "optparse.Values" instance created by "optparse"

   "args"
      全てのオプションの処理が終わった後で残った位置引数

The most common usage is to supply neither keyword argument.  If you
supply "values", it will be modified with repeated "setattr()" calls
(roughly one for every option argument stored to an option
destination) and returned by "parse_args()".

If "parse_args()" encounters any errors in the argument list, it calls
the OptionParser's "error()" method with an appropriate end-user error
message. This ultimately terminates your process with an exit status
of 2 (the traditional Unix exit status for command-line errors).


オプション解析器への問い合わせと操作
------------------------------------

オプションパーザのデフォルトの振る舞いは、ある程度カスタマイズすること
ができます。また、オプションパーザの中を調べることもできます。
"OptionParser" は幾つかのヘルパーメソッドを提供しています:

OptionParser.disable_interspersed_args()

   オプションで無い最初の引数を見つけた時点でパースを止めるように設定
   します。例えば、 "-a" と "-b" が両方とも引数を取らないシンプルなオ
   プションだったとすると、 "optparse" は通常次の構文を受け付け:

      prog -a arg1 -b arg2

   それを次と同じように扱います

      prog -a -b arg1 arg2

   この機能を無効にしたいときは、 "disable_interspersed_args()" メソッ
   ドを呼び出してください。古典的な Unix システムのように、最初のオプ
   ションでない引数を見つけたときにオプションの解析を止めるようになり
   ます。

   別のコマンドを実行するコマンドをプロセッサを作成する際、別のコマン
   ドのオプションと自身のオプションが混ざるのを防ぐために利用すること
   ができます。例えば、各コマンドがそれぞれ異なるオプションのセットを
   持つ場合などに有効です。

OptionParser.enable_interspersed_args()

   オプションで無い最初の引数を見つけてもパースを止めないように設定し
   ます。オプションとコマンド引数の順序が混ざっても良いようになります
   。これはデフォルトの動作です。

OptionParser.get_option(opt_str)

   オプション文字列 *opt_str* に対する "Option" インスタンスを返します
   。該当するオプションがなければ "None" を返します。

OptionParser.has_option(opt_str)

   "OptionParser" に("-q" や "--verbose" のような) オプション
   *opt_str* がある場合、"True" を返します。

OptionParser.remove_option(opt_str)

   "OptionParser" に *opt_str* に対応するオプションがある場合、そのオ
   プションを削除します。該当するオプションに他のオプション文字列が指
   定されていた場合、それらのオプション文字列は全て無効になります。
   *opt_str* がこの "OptionParser" オブジェクトのどのオプションにも属
   さない場合、 "ValueError" を送出します。


オプション間の衝突
------------------

注意が足りないと、衝突するオプションを定義してしまうことがあります:

   parser.add_option("-n", "--dry-run", ...)
   ...
   parser.add_option("-n", "--noisy", ...)

(とりわけ、"OptionParser" から標準的なオプションを備えた自前のサブクラ
スを定義してしまった場合にはよく起きます。)

ユーザがオプションを追加するたびに、 "optparse" は既存のオプションとの
衝突がないかチェックします。何らかの衝突が見付かると、現在設定されてい
る衝突処理メカニズムを呼び出します。衝突処理メカニズムはコンストラクタ
中で呼び出せます:

   parser = OptionParser(..., conflict_handler=handler)

個別にも呼び出せます:

   parser.set_conflict_handler(handler)

衝突時の処理をおこなうハンドラ(handler)には、以下のものが利用できます:

   ""error"" (デフォルト)
      オプション間の衝突をプログラム上のエラーとみなし、
      "OptionConflictError" を送出します

   ""resolve""
      オプション間の衝突をインテリジェントに解決します (下記参照)

一例として、衝突をインテリジェントに解決する "OptionParser" を定義し、
衝突を起こすようなオプションを追加してみましょう:

   parser = OptionParser(conflict_handler="resolve")
   parser.add_option("-n", "--dry-run", ..., help="do no harm")
   parser.add_option("-n", "--noisy", ..., help="be noisy")

この時点で、 "optparse" はすでに追加済のオプションがオプション文字列
"-n" を使っていることを検出します。 "conflict_handler" が ""resolve""
なので、 "optparse" は既に追加済のオプションリストの方から "-n" を除去
して問題を解決します。従って、 "-n" の除去されたオプションは "--dry-
run" だけでしか有効にできなくなります。ユーザがヘルプ文字列を要求した
場合、問題解決の結果を反映したメッセージが出力されます:

   Options:
     --dry-run     do no harm
     ...
     -n, --noisy   be noisy

これまでに追加したオプション文字列を跡形もなく削り去り、ユーザがそのオ
プションをコマンドラインから起動する手段をなくせます。この場合、
"optparse" はオプションを完全に除去してしまうので、こうしたオプション
はヘルプテキストやその他のどこにも表示されなくなります。例えば、現在の
"OptionParser" の場合、以下の操作:

   parser.add_option("--dry-run", ..., help="new dry-run option")

を行った時点で、最初の "-n"/"--dry-run" オプションはもはやアクセスでき
なくなります。このため、 "optparse" はオプションを消去してしまい、ヘル
プテキストだけが残ります:

   Options:
     ...
     -n, --noisy   be noisy
     --dry-run     new dry-run option


クリーンアップ
--------------

OptionParser インスタンスはいくつかの循環参照を抱えています。このこと
は Python のガーベジコレクタにとって問題になるわけではありませんが、使
い終わった OptionParser に対して "destroy()" を呼び出すことでこの循環
参照を意図的に断ち切るという方法を選ぶこともできます。この方法は特に長
時間実行するアプリケーションで OptionParser から大きなオブジェクトグラ
フが到達可能になっているような場合に有用です。


その他のメソッド
----------------

OptionParser にはその他にも幾つかの公開されたメソッドがあります:

OptionParser.set_usage(usage)

   Set the usage string according to the rules described above for the
   "usage" constructor keyword argument.  Passing "None" sets the
   default usage string; use "optparse.SUPPRESS_USAGE" to suppress a
   usage message.

OptionParser.print_usage(file=None)

   現在のプログラムの使用法メッセージ ("self.usage") を *file* (デフォ
   ルト: stdout) に表示します。"self.usage" 内にある全ての "%prog" と
   いう文字列は現在のプログラム名に置換されます。"self.usage" が空もし
   くは未定義の時は何もしません。

OptionParser.get_usage()

   "print_usage()" と同じですが、使用法メッセージを表示する代わりに文
   字列として返します。

OptionParser.set_defaults(dest=value, ...)

   幾つかの保存先に対してデフォルト値をまとめてセットします。
   "set_defaults()" を使うのは複数のオプションにデフォルト値をセットす
   る好ましいやり方です。複数のオプションが同じ保存先を共有することが
   あり得るからです。たとえば幾つかの "mode" オプションが全て同じ保存
   先をセットするものだったとすると、どのオプションもデフォルトをセッ
   トすることができ、しかし最後に指定したものだけが有効になります:

      parser.add_option("--advanced", action="store_const",
                        dest="mode", const="advanced",
                        default="novice")    # overridden below
      parser.add_option("--novice", action="store_const",
                        dest="mode", const="novice",
                        default="advanced")  # overrides above setting

   こうした混乱を避けるために "set_defaults()" を使います:

      parser.set_defaults(mode="advanced")
      parser.add_option("--advanced", action="store_const",
                        dest="mode", const="advanced")
      parser.add_option("--novice", action="store_const",
                        dest="mode", const="novice")


オプション処理コールバック
==========================

"optparse" の組み込みのアクションや型が望みにかなったものでない場合、
二つの選択肢があります: 一つは "optparse" の拡張、もう一つは callback
オプションの定義です。 "optparse" の拡張は汎用性に富んでいますが、単純
なケースに対していささか大げさでもあります。大体は簡単なコールバックで
事足りるでしょう。

"callback" オプションの定義は二つのステップからなります:

* ""callback"" アクションを使ってオプション自体を定義する

* コールバックを書く。コールバックは少なくとも後で説明する 4 つの引数
  をとる関数 (またはメソッド) でなければなりません


callbackオプションの定義
------------------------

callback オプションを最も簡単に定義するには、
"OptionParser.add_option()" メソッドを使います。 "action" の他に指定し
なければならない属性は "callback" すなわちコールバックする関数自体です
:

   parser.add_option("-c", action="callback", callback=my_callback)

"callback" は関数 (または呼び出し可能オブジェクト)なので、callback オ
プションを定義する時にはあらかじめ "my_callback()" を定義しておかなけ
ればなりません。この単純なケースでは、 "optparse" は "-c" が何らかの引
数をとるかどうか判別できず、通常は "-c" が引数を伴わないことを意味しま
す --- 知りたいことはただ単に "-c" がコマンドライン上に現れたどうかだ
けです。とはいえ、場合によっては、自分のコールバック関数に任意の個数の
コマンドライン引数を消費させたいこともあるでしょう。これがコールバック
関数をトリッキーなものにしています; これについてはこの節の後の方で説明
します。

"optparse" は常に四つの引数をコールバックに渡し、その他には
"callback_args" および "callback_kwargs" で指定した追加引数しか渡しま
せん。従って、最小のコールバック関数シグネチャは:

   def my_callback(option, opt, value, parser):

コールバックの四つの引数については後で説明します。

callback オプションを定義する場合には、他にもいくつかオプション属性を
指定できます:

"type"
   他で使われているのと同じ意味です: ""store"" や ""append"" アクショ
   ンの時と同じく、この属性は "optparse" に引数を一つ消費して "type"
   で指定した型に変換させます。 "optparse" は変換後の値をどこかに保存
   する代わりにコールバック関数に渡します。

"nargs"
   これも他で使われているのと同じ意味です: このオプションが指定されて
   いて、かつ "nargs" > 1 である場合、 "optparse" は "nargs" 個の引数
   を消費します。このとき各引数は "type" 型に変換できなければなりませ
   ん。変換後の値はタプルとしてコールバックに渡されます。

"callback_args"
   その他の位置引数からなるタプルで、コールバックに渡されます

"callback_kwargs"
   その他のキーワード引数からなる辞書で、コールバックに渡されます


コールバック関数はどのように呼び出されるか
------------------------------------------

コールバックは全て以下の形式で呼び出されます:

   func(option, opt_str, value, parser, *args, **kwargs)

ここでは:

"option"
   コールバックを呼び出している "Option" のインスタンスです

"opt_str"
   は、コールバック呼び出しのきっかけとなったコマンドライン上のオプシ
   ョン文字列です。(長い形式のオプションに対する省略形が使われている場
   合、"opt_str" は完全な、正式な形のオプション文字列となります --- 例
   えば、ユーザが "--foobar" の短縮形として "--foo" をコマンドラインに
   入力した時には、"opt_str" は ""--foobar"" となります。)

"value"
   オプションの引数で、コマンドライン上に見つかったものです。
   "optparse" は、 "type" が設定されている場合、単一の引数しかとりませ
   ん。 "value" の型はオプションの型として指定された型になります。この
   オプションに対する "type" が "None" である(引数なしの) 場合、
   "value" は "None" になります。 "nargs" > 1 であれば、 "value" は適
   切な型をもつ値のタプルになります。

"parser"
   現在のオプション解析の全てを駆動している "OptionParser" インスタン
   スです。この変数が有用なのは、この値を介してインスタンス属性として
   いくつかの興味深いデータにアクセスできるからです:

   "parser.largs"
      the current list of leftover arguments, ie. arguments that have
      been consumed but are neither options nor option arguments. Feel
      free to modify "parser.largs", e.g. by adding more arguments to
      it.  (This list will become "args", the second return value of
      "parse_args()".)

   "parser.rargs"
      現在残っている引数、すなわち、"opt_str" および "value" があれば
      除き、それ以外の引数が残っているリストです。"parser.rargs" は自
      由に変更でき、例えばさらに引数を消費したりできます。

   "parser.values"
      オプションの値がデフォルトで保存されるオブジェクト
      ("optparse.OptionValues" のインスタンス) です。この値を使うと、
      コールバック関数がオプションの値を記憶するために、他の
      "optparse" と同じ機構を使えるようにするため、グローバル変数や閉
      包 (closure) を台無しにしないので便利です。コマンドライン上にす
      でに現れているオプションの値にもアクセスできます。

"args"
   "callback_args" オプション属性で与えられた任意の位置引数からなるタ
   プルです。

"kwargs"
   "callback_kwargs" オプション属性で与えられた任意のキーワード引数か
   らなるタプルです。


コールバック中で例外を送出する
------------------------------

オプション自体か、あるいはその引数に問題がある場合、コールバック関数は
"OptionValueError" を送出しなければなりません。 "optparse" はこの例外
をとらえてプログラムを終了させ、ユーザが指定しておいたエラーメッセージ
を標準エラー出力に出力します。エラーメッセージは明確、簡潔かつ正確で、
どのオプションに誤りがあるかを示さなければなりません。さもなければ、ユ
ーザは自分の操作のどこに問題があるかを解決するのに苦労することになりま
す。


コールバックの例 1: ありふれたコールバック
------------------------------------------

引数をとらず、発見したオプションを単に記録するだけのコールバックオプシ
ョンの例を以下に示します:

   def record_foo_seen(option, opt_str, value, parser):
       parser.values.saw_foo = True

   parser.add_option("--foo", action="callback", callback=record_foo_seen)

もちろん、""store_true"" アクションを使っても実現できます。


コールバックの例 2: オプションの順番をチェックする
--------------------------------------------------

もう少し面白みのある例を示します: この例では、"-b" を発見して、その後
で "-a" がコマンドライン中に現れた場合にはエラーになります。

   def check_order(option, opt_str, value, parser):
       if parser.values.b:
           raise OptionValueError("can't use -a after -b")
       parser.values.a = 1
   ...
   parser.add_option("-a", action="callback", callback=check_order)
   parser.add_option("-b", action="store_true", dest="b")


コールバックの例 3: オプションの順番をチェックする (汎用的)
-----------------------------------------------------------

If you want to reuse this callback for several similar options (set a
flag, but blow up if "-b" has already been seen), it needs a bit of
work: the error message and the flag that it sets must be generalized.

   def check_order(option, opt_str, value, parser):
       if parser.values.b:
           raise OptionValueError("can't use %s after -b" % opt_str)
       setattr(parser.values, option.dest, 1)
   ...
   parser.add_option("-a", action="callback", callback=check_order, dest='a')
   parser.add_option("-b", action="store_true", dest="b")
   parser.add_option("-c", action="callback", callback=check_order, dest='c')


コールバックの例 4: 任意の条件をチェックする
--------------------------------------------

もちろん、単に定義済みのオプションの値を調べるだけにとどまらず、コール
バックには任意の条件を入れられます。例えば、満月でなければ呼び出しては
ならないオプションがあるとしましょう。やらなければならないことはこれだ
けです:

   def check_moon(option, opt_str, value, parser):
       if is_moon_full():
           raise OptionValueError("%s option invalid when moon is full"
                                  % opt_str)
       setattr(parser.values, option.dest, 1)
   ...
   parser.add_option("--foo",
                     action="callback", callback=check_moon, dest="foo")

("is_moon_full()" の定義は読者への課題としましょう。)


コールバックの例5: 固定引数
---------------------------

決まった数の引数をとるようなコールパックオプションを定義するなら、問題
はやや興味深くなってきます。引数をとるようコールバックに指定するのは、
""store"" や ""append"" オプションの定義に似ています。 "type" を定義し
ていれば、そのオプションは引数を受け取ったときに該当する型に変換できな
ければなりません。さらに "nargs" を指定すれば、オプションは "nargs" 個
の引数を受け取ります。

標準の ""store"" アクションをエミュレートする例を以下に示します:

   def store_value(option, opt_str, value, parser):
       setattr(parser.values, option.dest, value)
   ...
   parser.add_option("--foo",
                     action="callback", callback=store_value,
                     type="int", nargs=3, dest="foo")

"optparse" は 3 個の引数を受け取り、それらを整数に変換するところまで面
倒をみてくれます。ユーザは単にそれを保存するだけです。 (他の処理もでき
ます; いうまでもなく、この例にはコールバックは必要ありません)


コールバックの例6: 可変個の引数
-------------------------------

あるオプションに可変個の引数を持たせたいと考えているなら、問題はいささ
か手強くなってきます。この場合、 "optparse" では該当する組み込みのオプ
ション解析機能を提供していないので、自分でコールバックを書かなければな
りません。さらに、 "optparse" が普段処理している、伝統的な Unix コマン
ドライン解析における難題を自分で解決しなければなりません。とりわけ、コ
ールバック関数では引数が裸の "--" や "-" の場合における慣習的な処理規
則:

* either "--" or "-" can be option arguments

* 裸の "--" (何らかのオプションの引数でない場合): コマンドライン処理を
  停止し、"--" を無視します

* 裸の "-" (何らかのオプションの引数でない場合): コマンドライン処理を
  停止しますが、"-" は残します ("parser.largs" に追加します)

オプションが可変個の引数をとるようにさせたいなら、いくつかの巧妙で厄介
な問題に配慮しなければなりません。どういう実装をとるかは、アプリケーシ
ョンでどのようなトレードオフを考慮するかによります (このため、
"optparse" では可変個の引数に関する問題を直接的に取り扱わないのです)。

とはいえ、可変個の引数をもつオプションに対するスタブ (stub、仲介インタ
ーフェース) を以下に示しておきます:

   def vararg_callback(option, opt_str, value, parser):
       assert value is None
       value = []

       def floatable(str):
           try:
               float(str)
               return True
           except ValueError:
               return False

       for arg in parser.rargs:
           # stop on --foo like options
           if arg[:2] == "--" and len(arg) > 2:
               break
           # stop on -a, but not on -3 or -3.0
           if arg[:1] == "-" and len(arg) > 1 and not floatable(arg):
               break
           value.append(arg)

       del parser.rargs[:len(value)]
       setattr(parser.values, option.dest, value)

   ...
   parser.add_option("-c", "--callback", dest="vararg_attr",
                     action="callback", callback=vararg_callback)


"optparse" の拡張
=================

"optparse" がコマンドラインオプションをどのように解釈するかを決める二
つの重要な要素はそれぞれのオプションのアクションと型なので、拡張の方向
は新しいアクションと型を追加することになると思います。


新しい型の追加
--------------

新しい型を追加するためには、 "optparse" の "Option" クラスのサブクラス
を自身で定義する必要があります。このクラスには "optparse" における型を
定義する一対の属性があります。それは "TYPES" と "TYPE_CHECKER" です。

Option.TYPES

   "TYPES" は型名のタプルです。新しく作るサブクラスでは、タプル
   "TYPES" を単純に標準のものを利用して新しく定義すると良いでしょう。

Option.TYPE_CHECKER

   "TYPE_CHECKER" は辞書で型名を型チェック関数に対応付けるものです。型
   チェック関数は以下のようなシグネチャを持ちます:

      def check_mytype(option, opt, value)

   ここで "option" は "Option" のインスタンスであり、 "opt" はオプショ
   ン文字列(たとえば "-f")で、 "value" は望みの型としてチェックされ変
   換されるべくコマンドラインで与えられる文字列です。 "check_mytype()"
   は想定されている型 "mytype" のオブジェクトを返さなければなりません
   。型チェック関数から返される値は "OptionParser.parse_args()" で返さ
   れるOptionValues インスタンスに収められるか、またはコールバックに
   "value" パラメータとして渡されます。

   型チェック関数は何か問題に遭遇したら "OptionValueError" を送出しな
   ければなりません。 "OptionValueError" は文字列一つを引数に取り、そ
   れはそのまま "OptionParser" の "error()" メソッドに渡され、そこでプ
   ログラム名と文字列 ""error:"" が前置されてプロセスが終了する前に
   stderr に出力されます。

馬鹿馬鹿しい例ですが、Python スタイルの複素数を解析する ""complex"" オ
プション型を作ってみせることにします。("optparse" 1.3 が複素数のサポー
トを組み込んでしまったため以前にも増して馬鹿らしくなりましたが、気にし
ないでください。)

最初に必要な import 文を書きます:

   from copy import copy
   from optparse import Option, OptionValueError

まずは型チェック関数を定義しなければなりません。これは後で(これから定
義する Option のサブクラスの "TYPE_CHECKER" クラス属性の中で) 参照され
ることになります:

   def check_complex(option, opt, value):
       try:
           return complex(value)
       except ValueError:
           raise OptionValueError(
               "option %s: invalid complex value: %r" % (opt, value))

最後に Option のサブクラスです:

   class MyOption (Option):
       TYPES = Option.TYPES + ("complex",)
       TYPE_CHECKER = copy(Option.TYPE_CHECKER)
       TYPE_CHECKER["complex"] = check_complex

(もしここで "Option.TYPE_CHECKER" に "copy()" を適用しなければ、
"optparse" の Option クラスの "TYPE_CHECKER" 属性をいじってしまうこと
になります。 Python の常として、良いマナーと常識以外にそうすることを止
めるものはありません。)

これだけです! もう新しいオプション型を使うスクリプトを他の "optparse"
に基づいたスクリプトとまるで同じように書くことができます。ただし、
OptionParser に Option でなく MyOption を使うように指示しなければなけ
ればなりません:

   parser = OptionParser(option_class=MyOption)
   parser.add_option("-c", type="complex")

別のやり方として、オプションリストを構築して OptionParser に渡すという
方法もあります。 "add_option()" を上でやったように使わないならば、
OptionParser にどのクラスを使うのか教える必要はありません:

   option_list = [MyOption("-c", action="store", type="complex", dest="c")]
   parser = OptionParser(option_list=option_list)


新しいアクションの追加
----------------------

新しいアクションの追加はもう少しトリッキーです。というのも "optparse"
が使っている二つのアクションの分類を理解する必要があるからです:

"store" アクション
   "optparse" が値を現在の OptionValues の属性に格納することになるアク
   ションです。この種類のオプションは Option のコンストラクタに "dest"
   属性を与えることが要求されます。

"typed" アクション
   コマンドラインから引数を受け取り、それがある型であることが期待され
   ているアクションです。もう少しはっきり言えば、その型に変換される文
   字列を受け取るものです。この種類のオプションは Option のコンストラ
   クタに "type" 属性を与えることが要求されます。

この分類には重複する部分があります。デフォルトの "store" アクションに
は ""store"", ""store_const"", ""append"", ""count"" などがありますが
、デフォルトの "typed" オプションは ""store"", ""append"",
""callback"" の三つです。

アクションを追加する際に、以下の Option のクラス属性(全て文字列のリス
トです) の中の少なくとも一つに付け加えることでそのアクションを分類する
必要があります:

Option.ACTIONS

   全てのアクションは ACTIONS にリストされていなければなりません。

Option.STORE_ACTIONS

   "store" アクションはここにもリストされます。

Option.TYPED_ACTIONS

   "typed" アクションはここにもリストされます。

Option.ALWAYS_TYPED_ACTIONS

   型を取るアクション (つまりそのオプションが値を取る) はここにもリス
   トされます。このことの唯一の効果は "optparse" が、型の指定が無くア
   クションが "ALWAYS_TYPED_ACTIONS" のリストにあるオプションに、デフ
   ォルト型 ""string"" を割り当てるということだけです。

実際に新しいアクションを実装するには、Option の "take_action()" メソッ
ドをオーバライドしてそのアクションを認識する場合分けを追加しなければな
りません。

例えば、""extend"" アクションというのを追加してみましょう。このアクシ
ョンは標準的な ""append"" アクションと似ていますが、コマンドラインから
一つだけ値を読み取って既存のリストに追加するのではなく、複数の値をコン
マ区切りの文字列として読み取ってそれらで既存のリストを拡張します。すな
わち、もし "--names" が ""string"" 型の ""extend"" オプションだとする
と、次のコマンドライン

   --names=foo,bar --names blah --names ding,dong

の結果は次のリストになります

   ["foo", "bar", "blah", "ding", "dong"]

再び Option のサブクラスを定義します:

   class MyOption(Option):

       ACTIONS = Option.ACTIONS + ("extend",)
       STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
       TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
       ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)

       def take_action(self, action, dest, opt, value, values, parser):
           if action == "extend":
               lvalue = value.split(",")
               values.ensure_value(dest, []).extend(lvalue)
           else:
               Option.take_action(
                   self, action, dest, opt, value, values, parser)

注意すべきは次のようなところです:

* ""extend"" はコマンドラインの値を予期していると同時にその値をどこか
  に格納しますので、 "STORE_ACTIONS" と "TYPED_ACTIONS" の両方に入りま
  す。

* "optparse" が ""extend"" アクションに ""string"" 型を割り当てるよう
  に ""extend"" アクションは "ALWAYS_TYPED_ACTIONS" にも入れてあります
  。

* "MyOption.take_action()" にはこの新しいアクション一つの扱いだけを実
  装してあり、他の標準的な "optparse" のアクションについては
  "Option.take_action()" に制御を戻すようにしてあります。

* "values" は optparse_parser.Values クラスのインスタンスであり、非常
  に有用な "ensure_value()" メソッドを提供しています。
  "ensure_value()" は本質的に安全弁付きの "getattr()" です。次のように
  呼び出します

     values.ensure_value(attr, value)

  If the "attr" attribute of "values" doesn't exist or is "None", then
  ensure_value() first sets it to "value", and then returns "value".
  This is very handy for actions like ""extend"", ""append"", and
  ""count"", all of which accumulate data in a variable and expect
  that variable to be of a certain type (a list for the first two, an
  integer for the latter).  Using "ensure_value()" means that scripts
  using your action don't have to worry about setting a default value
  for the option destinations in question; they can just leave the
  default as "None" and "ensure_value()" will take care of getting it
  right when it's needed.


例外
====

exception optparse.OptionError

   Raised if an "Option" instance is created with invalid or
   inconsistent arguments.

exception optparse.OptionConflictError

   Raised if conflicting options are added to an "OptionParser".

exception optparse.OptionValueError

   Raised if an invalid option value is encountered on the command
   line.

exception optparse.BadOptionError

   Raised if an invalid option is passed on the command line.

exception optparse.AmbiguousOptionError

   Raised if an ambiguous option is passed on the command line.
