18 files changed, 256 insertions, 306 deletions
diff --git a/gr-audio/examples/python/audio_play.py b/gr-audio/examples/python/audio_play.py
index 94ea72498d..367d7bd201 100755
--- a/gr-audio/examples/python/audio_play.py
+++ b/gr-audio/examples/python/audio_play.py
@@ -23,8 +23,8 @@
 from gnuradio import gr
 from gnuradio import audio
 from gnuradio import blocks
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 
 
 class my_top_block(gr.top_block):
@@ -32,22 +32,18 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-F", "--filename", type="string", default="audio.dat",
-                          help="read input from FILE")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-        parser.add_option("-R", "--repeat", action="store_true", default=False)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-F", "--filename", default="audio.dat",
+                          help="read input from FILENAME default=%(default)r")
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate (default=%(default)r)")
+        parser.add_argument("-R", "--repeat", action="store_true")
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        (options, args) = parser.parse_args()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
-        src = blocks.file_source (gr.sizeof_float, options.filename, options.repeat)
-        dst = audio.sink (sample_rate, options.audio_output)
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
+        src = blocks.file_source(gr.sizeof_float, args.filename, args.repeat)
+        dst = audio.sink(sample_rate, args.audio_output)
         self.connect(src, dst)
 
 
diff --git a/gr-audio/examples/python/audio_to_file.py b/gr-audio/examples/python/audio_to_file.py
index 6a2cbcb12e..b385abf925 100755
--- a/gr-audio/examples/python/audio_to_file.py
+++ b/gr-audio/examples/python/audio_to_file.py
@@ -23,37 +23,34 @@
 from gnuradio import gr
 from gnuradio import audio
 from gnuradio import blocks
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 
 class my_top_block(gr.top_block):
 
     def __init__(self):
         gr.top_block.__init__(self)
 
-        usage="%prog: [options] output_filename"
-        parser = OptionParser(option_class=eng_option, usage=usage)
-        parser.add_option("-I", "--audio-input", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-I", "--audio-input", default="",
                           help="pcm input device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-        parser.add_option("-N", "--nsamples", type="eng_float", default=None,
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate to RATE (%(default)r)")
+        parser.add_argument("-N", "--nsamples", type=eng_float,
                           help="number of samples to collect [default=+inf]")
+        parser.add_argument('file_name', metavar='FILE-NAME',
+                          help="Output file path")
 
-        (options, args) = parser.parse_args ()
-        if len(args) != 1:
-            parser.print_help()
-            raise SystemExit, 1
-        filename = args[0]
+        args = parser.parse_args()
 
-        sample_rate = int(options.sample_rate)
-        src = audio.source (sample_rate, options.audio_input)
-        dst = blocks.file_sink (gr.sizeof_float, filename)
+        sample_rate = int(args.sample_rate)
+        src = audio.source(sample_rate, args.audio_input)
+        dst = blocks.file_sink(gr.sizeof_float, args.file_name)
 
-        if options.nsamples is None:
+        if args.nsamples is None:
             self.connect((src, 0), dst)
         else:
-            head = blocks.head(gr.sizeof_float, int(options.nsamples))
+            head = blocks.head(gr.sizeof_float, int(args.nsamples))
             self.connect((src, 0), head, dst)
 
 
diff --git a/gr-audio/examples/python/dial_tone_daemon.py b/gr-audio/examples/python/dial_tone_daemon.py
index e4dbd95321..9919e367a6 100755
--- a/gr-audio/examples/python/dial_tone_daemon.py
+++ b/gr-audio/examples/python/dial_tone_daemon.py
@@ -22,8 +22,8 @@
 
 from gnuradio import gr, gru
 from gnuradio import audio
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 import os
 
 try:
@@ -37,22 +37,18 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-        (options, args) = parser.parse_args()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate to RATE (%(default)r)")
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
         ampl = 0.1
 
         src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl)
         src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl)
-        dst = audio.sink(sample_rate, options.audio_output)
+        dst = audio.sink(sample_rate, args.audio_output)
         self.connect(src0, (dst, 0))
         self.connect(src1, (dst, 1))
 
diff --git a/gr-audio/examples/python/dial_tone_wav.py b/gr-audio/examples/python/dial_tone_wav.py
index 82f8cf331d..351ca94e78 100755
--- a/gr-audio/examples/python/dial_tone_wav.py
+++ b/gr-audio/examples/python/dial_tone_wav.py
@@ -24,8 +24,8 @@
 
 from gnuradio import gr
 from gnuradio import blocks
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 
 try:
     from gnuradio import analog
@@ -38,25 +38,23 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-	usage = "%prog: [options] filename"
-        parser = OptionParser(option_class=eng_option, usage=usage)
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-	parser.add_option("-N", "--samples", type="eng_float", default=None,
-			  help="number of samples to record")
-        (options, args) = parser.parse_args ()
-        if len(args) != 1 or options.samples is None:
-            parser.print_help()
-            raise SystemExit, 1
+        parser = ArgumentParser()
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate to RATE (%(default)r)")
+        parser.add_argument("-N", "--samples", type=eng_float, required=True,
+                          help="number of samples to record")
+        parser.add_argument('file_name', metavar='WAV-FILE',
+                          help='Output WAV file name', nargs=1)
+        args = parser.parse_args()
 
-        sample_rate = int(options.sample_rate)
+        sample_rate = int(args.sample_rate)
         ampl = 0.1
 
         src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, ampl)
         src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, ampl)
-	head0 = blocks.head(gr.sizeof_float, int(options.samples))
-	head1 = blocks.head(gr.sizeof_float, int(options.samples))
-	dst = blocks.wavfile_sink(args[0], 2, int(options.sample_rate), 16)
+        head0 = blocks.head(gr.sizeof_float, int(args.samples))
+        head1 = blocks.head(gr.sizeof_float, int(args.samples))
+        dst = blocks.wavfile_sink(args.file_name[0], 2, int(args.sample_rate), 16)
 
         self.connect(src0, head0, (dst, 0))
         self.connect(src1, head1, (dst, 1))
diff --git a/gr-audio/examples/python/mono_tone.py b/gr-audio/examples/python/mono_tone.py
index ad73d62327..653fd575fc 100755
--- a/gr-audio/examples/python/mono_tone.py
+++ b/gr-audio/examples/python/mono_tone.py
@@ -22,8 +22,8 @@
 
 from gnuradio import gr
 from gnuradio import audio
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 
 try:
     from gnuradio import analog
@@ -40,27 +40,23 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-        parser.add_option("-D", "--dont-block", action="store_false", default=True,
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate to RATE %(default)r)")
+        parser.add_argument("-D", "--dont-block", action="store_false", default=True,
                           dest="ok_to_block")
 
-        (options, args) = parser.parse_args ()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
-        ampl = 0.1
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
+        ampl = 0.5
 
         src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 650, ampl)
 
         dst = audio.sink(sample_rate,
-                         options.audio_output,
-                         options.ok_to_block)
+                         args.audio_output,
+                         args.ok_to_block)
 
         self.connect (src0, (dst, 0))
 
diff --git a/gr-audio/examples/python/multi_tone.py b/gr-audio/examples/python/multi_tone.py
index 6232cbef52..00c052794a 100755
--- a/gr-audio/examples/python/multi_tone.py
+++ b/gr-audio/examples/python/multi_tone.py
@@ -22,8 +22,8 @@
 
 from gnuradio import gr
 from gnuradio import audio
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 
 try:
     from gnuradio import analog
@@ -40,22 +40,18 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
-                          help="set sample rate to RATE (48000)")
-        parser.add_option ("-m", "--max-channels", type="int", default="16",
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
+                          help="set sample rate to RATE (%(default)r)")
+        parser.add_argument ("-m", "--max-channels", type=int, default=16,
                            help="set maximum channels to use")
-        parser.add_option("-D", "--dont-block", action="store_false", default=True,
+        parser.add_argument("-D", "--dont-block", action="store_false",
                           dest="ok_to_block")
-        (options, args) = parser.parse_args()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
-        limit_channels = options.max_channels
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
+        limit_channels = args.max_channels
 
         ampl = 0.1
 
@@ -76,8 +72,8 @@ class my_top_block(gr.top_block):
         progression = (7, 11, 1, 5, 9)
 
         dst = audio.sink(sample_rate,
-                         options.audio_output,
-                         options.ok_to_block)
+                         args.audio_output,
+                         args.ok_to_block)
 
         max_chan = dst.input_signature().max_streams()
         if (max_chan == -1) or (max_chan > limit_channels):
diff --git a/gr-audio/examples/python/noise.py b/gr-audio/examples/python/noise.py
index b15065cd4e..31fdb16fe5 100755
--- a/gr-audio/examples/python/noise.py
+++ b/gr-audio/examples/python/noise.py
@@ -23,30 +23,26 @@
 from gnuradio import gr
 from gnuradio import audio
 from gnuradio import digital
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float
+from argparse import ArgumentParser
 
 class my_top_block(gr.top_block):
 
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=48000,
                           help="set sample rate to RATE (48000)")
-        (options, args) = parser.parse_args ()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
         ampl = 0.1
 
         src = digital.glfsr_source_b(32)     # Pseudorandom noise source
         b2f = digital.chunks_to_symbols_bf([ampl, -ampl], 1)
-        dst = audio.sink(sample_rate, options.audio_output)
+        dst = audio.sink(sample_rate, args.audio_output)
         self.connect(src, b2f, dst)
 
 if __name__ == '__main__':
diff --git a/gr-audio/examples/python/spectrum_inversion.py b/gr-audio/examples/python/spectrum_inversion.py
index a02d6c5821..163668e450 100755
--- a/gr-audio/examples/python/spectrum_inversion.py
+++ b/gr-audio/examples/python/spectrum_inversion.py
@@ -29,29 +29,25 @@
 from gnuradio import gr
 from gnuradio import audio
 from gnuradio import blocks
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 
 class my_top_block(gr.top_block):
 
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-I", "--audio-input", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-I", "--audio-input", default="",
                           help="pcm input device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-r", "--sample-rate", type="eng_float", default=8000,
-                          help="set sample rate to RATE (8000)")
-        (options, args) = parser.parse_args ()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        sample_rate = int(options.sample_rate)
-        src = audio.source (sample_rate, options.audio_input)
-        dst = audio.sink (sample_rate, options.audio_output)
+        parser.add_argument("-r", "--sample-rate", type=eng_float, default=8000,
+                          help="set sample rate to RATE (%(default)r)")
+        args = parser.parse_args()
+        sample_rate = int(args.sample_rate)
+        src = audio.source (sample_rate, args.audio_input)
+        dst = audio.sink (sample_rate, args.audio_output)
 
 	vec1 = [1, -1]
 	vsource = blocks.vector_source_f(vec1, True)
diff --git a/gr-audio/examples/python/test_resampler.py b/gr-audio/examples/python/test_resampler.py
index 94d95fecf3..4d8a9233e7 100755
--- a/gr-audio/examples/python/test_resampler.py
+++ b/gr-audio/examples/python/test_resampler.py
@@ -23,8 +23,8 @@
 from gnuradio import gr, gru
 from gnuradio import audio
 from gnuradio import filter
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 
 try:
     from gnuradio import analog
@@ -43,20 +43,16 @@ class my_top_block(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        parser.add_option("-O", "--audio-output", type="string", default="",
+        parser = ArgumentParser()
+        parser.add_argument("-O", "--audio-output", default="",
                           help="pcm output device name.  E.g., hw:0,0 or /dev/dsp")
-        parser.add_option("-i", "--input-rate", type="eng_float", default=8000,
-                          help="set input sample rate to RATE (%default)")
-        parser.add_option("-o", "--output-rate", type="eng_float", default=48000,
-                          help="set output sample rate to RATE (%default)")
-        (options, args) = parser.parse_args()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
-        input_rate = int(options.input_rate)
-        output_rate = int(options.output_rate)
+        parser.add_argument("-i", "--input-rate", type=eng_float, default=8000,
+                          help="set input sample rate to RATE %(default)r")
+        parser.add_argument("-o", "--output-rate", type=eng_float, default=48000,
+                          help="set output sample rate to RATE %(default)r")
+        args = parser.parse_args()
+        input_rate = int(args.input_rate)
+        output_rate = int(args.output_rate)
 
         interp = gru.lcm(input_rate, output_rate) / input_rate
         decim = gru.lcm(input_rate, output_rate) / output_rate
@@ -67,7 +63,7 @@ class my_top_block(gr.top_block):
         ampl = 0.1
         src0 = analog.sig_source_f(input_rate, analog.GR_SIN_WAVE, 650, ampl)
         rr = filter.rational_resampler_fff(interp, decim)
-        dst = audio.sink(output_rate, options.audio_output)
+        dst = audio.sink(output_rate, args.audio_output)
         self.connect(src0, rr, (dst, 0))
 
 if __name__ == '__main__':
diff --git a/gr-blocks/examples/ctrlport/usrp_sink_controller.py b/gr-blocks/examples/ctrlport/usrp_sink_controller.py
index d8c38e36f2..ec687d80e1 100755
--- a/gr-blocks/examples/ctrlport/usrp_sink_controller.py
+++ b/gr-blocks/examples/ctrlport/usrp_sink_controller.py
@@ -3,28 +3,22 @@
 import sys
 import pmt
 from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient
-from optparse import OptionParser
+from argparse import ArgumentParser
 
-parser = OptionParser(usage="%prog: [options]")
-parser.add_option("-H", "--host", type="string", default="localhost",
-                  help="Hostname to connect to (default=%default)")
-parser.add_option("-p", "--port", type="int", default=9090,
-                  help="Port of Controlport instance on host (default=%default)")
-parser.add_option("-a", "--alias", type="string", default="gr uhd usrp sink0",
-                  help="The UHD block's alias to control (default=%default)")
-options, args = parser.parse_args()
-
-if(len(args) < 2):
-    sys.stderr.write('Not enough arguments: usrp_source_controller.py [options] <command> <value>\n')
-    sys.stderr.write('See the "UHD Interface" section of the manual for available commands.\n\n')
-    sys.exit(1)
+parser = ArgumentParser()
+parser.add_argument("-H", "--host", default="localhost",
+                  help="Hostname to connect to (default=%(default)r)")
+parser.add_argument("-p", "--port", type=int, default=9090,
+                  help="Port of Controlport instance on host (default=%(default)r)")
+parser.add_argument("-a", "--alias", default="gr uhd usrp sink0",
+                  help="The UHD block's alias to control (default=%(default)r)")
+parser.add_argument("command", metavar="COMMAND")
+parser.add_argument("value", metavar="VALUE")
+args = parser.parse_args()
 
 port = 'command'
-alias = options.alias
-hostname = options.host
-portnum = options.port
-cmd = args[0]
-val = args[1]
+cmd = args.command
+val = args.value
 
 if(cmd == "tune" or cmd == "time"):
     sys.stderr.write("This application currently does not support the 'tune' or 'time' UHD "
@@ -35,8 +29,8 @@ elif(cmd == "antenna"):
 else:
     val = pmt.from_double(float(val))
 
-argv = [None, hostname, portnum]
+argv = [None, args.host, args.port]
 radiosys = GNURadioControlPortClient(argv=argv, rpcmethod='thrift')
 radio = radiosys.client
 
-radio.postMessage(alias, port, pmt.cons(pmt.intern(cmd), val))
+radio.postMessage(args.alias, port, pmt.cons(pmt.intern(cmd), val))
diff --git a/gr-blocks/examples/ctrlport/usrp_source_controller.py b/gr-blocks/examples/ctrlport/usrp_source_controller.py
index 02d30a9d37..78c5ae66aa 100755
--- a/gr-blocks/examples/ctrlport/usrp_source_controller.py
+++ b/gr-blocks/examples/ctrlport/usrp_source_controller.py
@@ -3,28 +3,22 @@
 import sys
 import pmt
 from gnuradio.ctrlport.GNURadioControlPortClient import GNURadioControlPortClient
-from optparse import OptionParser
+from argparse import ArgumentParser
 
-parser = OptionParser(usage="%prog: [options]")
-parser.add_option("-H", "--host", type="string", default="localhost",
-                  help="Hostname to connect to (default=%default)")
-parser.add_option("-p", "--port", type="int", default=9090,
-                  help="Port of Controlport instance on host (default=%default)")
-parser.add_option("-a", "--alias", type="string", default="gr uhd usrp source0",
-                  help="The UHD block's alias to control (default=%default)")
-options, args = parser.parse_args()
-
-if(len(args) < 2):
-    sys.stderr.write('Not enough arguments: usrp_source_controller.py [options] <command> <value>\n')
-    sys.stderr.write('See the "UHD Interface" section of the manual for available commands.\n\n')
-    sys.exit(1)
+parser = ArgumentParser()
+parser.add_argument("-H", "--host", default="localhost",
+                  help="Hostname to connect to (default=%(default)r)")
+parser.add_argument("-p", "--port", type=int, default=9090,
+                  help="Port of Controlport instance on host (default=%(default)r)")
+parser.add_argument("-a", "--alias", default="gr uhd usrp source0",
+                  help="The UHD block's alias to control (default=%(default)r)")
+parser.add_argument("command", metavar="COMMAND")
+parser.add_argument("value", metavar="VALUE")
+args = parser.parse_args()
 
 port = 'command'
-alias = options.alias
-hostname = options.host
-portnum = options.port
-cmd = args[0]
-val = args[1]
+cmd = args.command
+val = args.value
 
 if(cmd == "tune" or cmd == "time"):
     sys.stderr.write("This application currently does not support the 'tune' or 'time' UHD "
@@ -35,8 +29,8 @@ if(cmd == "antenna"):
 else:
     val = pmt.from_double(float(val))
 
-argv = [None, hostname, portnum]
+argv = [None, args.host, args.port]
 radiosys = GNURadioControlPortClient(argv=argv, rpcmethod='thrift')
 radio = radiosys.client
 
-radio.postMessage(alias, port, pmt.cons(pmt.intern(cmd), val))
+radio.postMessage(args.alias, port, pmt.cons(pmt.intern(cmd), val))
diff --git a/gr-digital/examples/example_costas.py b/gr-digital/examples/example_costas.py
index 9a65691ff6..77495d944c 100755
--- a/gr-digital/examples/example_costas.py
+++ b/gr-digital/examples/example_costas.py
@@ -24,8 +24,8 @@ from gnuradio import gr, digital, filter
 from gnuradio import blocks
 from gnuradio import channels
 from gnuradio import eng_notation
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import sys
 
 try:
@@ -64,34 +64,34 @@ class example_costas(gr.top_block):
         self.connect((self.cst,1), self.vsnk_frq)
 
 def main():
-    parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
-    parser.add_option("-N", "--nsamples", type="int", default=2000,
-                      help="Set the number of samples to process [default=%default]")
-    parser.add_option("-S", "--sps", type="int", default=4,
-                      help="Set the samples per symbol [default=%default]")
-    parser.add_option("-r", "--rolloff", type="eng_float", default=0.35,
-                      help="Set the rolloff factor [default=%default]")
-    parser.add_option("-W", "--bandwidth", type="eng_float", default=2*scipy.pi/100.0,
-                      help="Set the loop bandwidth [default=%default]")
-    parser.add_option("-n", "--ntaps", type="int", default=45,
-                      help="Set the number of taps in the filters [default=%default]")
-    parser.add_option("", "--noise", type="eng_float", default=0.0,
-                      help="Set the simulation noise voltage [default=%default]")
-    parser.add_option("-f", "--foffset", type="eng_float", default=0.0,
-                      help="Set the simulation's normalized frequency offset (in Hz) [default=%default]")
-    parser.add_option("-t", "--toffset", type="eng_float", default=1.0,
-                      help="Set the simulation's timing offset [default=%default]")
-    parser.add_option("-p", "--poffset", type="eng_float", default=0.707,
-                      help="Set the simulation's phase offset [default=%default]")
-    (options, args) = parser.parse_args ()
+    parser = ArgumentParser(conflict_handler="resolve")
+    parser.add_argument("-N", "--nsamples", type=int, default=2000,
+                      help="Set the number of samples to process [default=%(default)r]")
+    parser.add_argument("-S", "--sps", type=int, default=4,
+                      help="Set the samples per symbol [default=%(default)r]")
+    parser.add_argument("-r", "--rolloff", type=eng_float, default=0.35,
+                      help="Set the rolloff factor [default=%(default)r]")
+    parser.add_argument("-W", "--bandwidth", type=eng_float, default=2*scipy.pi/100.0,
+                      help="Set the loop bandwidth [default=%(default)r]")
+    parser.add_argument("-n", "--ntaps", type=int, default=45,
+                      help="Set the number of taps in the filters [default=%(default)r]")
+    parser.add_argument("--noise", type=eng_float, default=0.0,
+                      help="Set the simulation noise voltage [default=%(default)r]")
+    parser.add_argument("-f", "--foffset", type=eng_float, default=0.0,
+                      help="Set the simulation's normalized frequency offset (in Hz) [default=%(default)r]")
+    parser.add_argument("-t", "--toffset", type=eng_float, default=1.0,
+                      help="Set the simulation's timing offset [default=%(default)r]")
+    parser.add_argument("-p", "--poffset", type=eng_float, default=0.707,
+                      help="Set the simulation's phase offset [default=%(default)r]")
+    args = parser.parse_args()
 
     # Adjust N for the interpolation by sps
-    options.nsamples = options.nsamples // options.sps
+    args.nsamples = args.nsamples // args.sps
 
     # Set up the program-under-test
-    put = example_costas(options.nsamples, options.sps, options.rolloff,
-                         options.ntaps, options.bandwidth, options.noise,
-                         options.foffset, options.toffset, options.poffset)
+    put = example_costas(args.nsamples, args.sps, args.rolloff,
+                         args.ntaps, args.bandwidth, args.noise,
+                         args.foffset, args.toffset, args.poffset)
     put.run()
 
     data_src = scipy.array(put.vsnk_src.data())
diff --git a/gr-digital/examples/example_fll.py b/gr-digital/examples/example_fll.py
index 1c8234c786..cda92eaa78 100755
--- a/gr-digital/examples/example_fll.py
+++ b/gr-digital/examples/example_fll.py
@@ -24,8 +24,8 @@ from gnuradio import gr, digital, filter
 from gnuradio import blocks
 from gnuradio import channels
 from gnuradio import eng_notation
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import sys
 
 try:
@@ -68,34 +68,34 @@ class example_fll(gr.top_block):
         self.connect((self.fll,3), self.vsnk_err)
 
 def main():
-    parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
-    parser.add_option("-N", "--nsamples", type="int", default=2000,
-                      help="Set the number of samples to process [default=%default]")
-    parser.add_option("-S", "--sps", type="int", default=4,
-                      help="Set the samples per symbol [default=%default]")
-    parser.add_option("-r", "--rolloff", type="eng_float", default=0.35,
-                      help="Set the rolloff factor [default=%default]")
-    parser.add_option("-W", "--bandwidth", type="eng_float", default=2*scipy.pi/100.0,
-                      help="Set the loop bandwidth [default=%default]")
-    parser.add_option("-n", "--ntaps", type="int", default=45,
-                      help="Set the number of taps in the filters [default=%default]")
-    parser.add_option("", "--noise", type="eng_float", default=0.0,
-                      help="Set the simulation noise voltage [default=%default]")
-    parser.add_option("-f", "--foffset", type="eng_float", default=0.2,
-                      help="Set the simulation's normalized frequency offset (in Hz) [default=%default]")
-    parser.add_option("-t", "--toffset", type="eng_float", default=1.0,
-                      help="Set the simulation's timing offset [default=%default]")
-    parser.add_option("-p", "--poffset", type="eng_float", default=0.0,
-                      help="Set the simulation's phase offset [default=%default]")
-    (options, args) = parser.parse_args ()
+    parser = ArgumentParser(conflict_handler="resolve")
+    parser.add_argument("-N", "--nsamples", type=int, default=2000,
+                      help="Set the number of samples to process [default=%(default)r]")
+    parser.add_argument("-S", "--sps", type=int, default=4,
+                      help="Set the samples per symbol [default=%(default)r]")
+    parser.add_argument("-r", "--rolloff", type=eng_float, default=0.35,
+                      help="Set the rolloff factor [default=%(default)r]")
+    parser.add_argument("-W", "--bandwidth", type=eng_float, default=2*scipy.pi/100.0,
+                      help="Set the loop bandwidth [default=%(default)r]")
+    parser.add_argument("-n", "--ntaps", type=int, default=45,
+                      help="Set the number of taps in the filters [default=%(default)r]")
+    parser.add_argument("--noise", type=eng_float, default=0.0,
+                      help="Set the simulation noise voltage [default=%(default)r]")
+    parser.add_argument("-f", "--foffset", type=eng_float, default=0.2,
+                      help="Set the simulation's normalized frequency offset (in Hz) [default=%(default)r]")
+    parser.add_argument("-t", "--toffset", type=eng_float, default=1.0,
+                      help="Set the simulation's timing offset [default=%(default)r]")
+    parser.add_argument("-p", "--poffset", type=eng_float, default=0.0,
+                      help="Set the simulation's phase offset [default=%(default)r]")
+    args = parser.parse_args()
 
     # Adjust N for the interpolation by sps
-    options.nsamples = options.nsamples // options.sps
+    args.nsamples = args.nsamples // args.sps
 
     # Set up the program-under-test
-    put = example_fll(options.nsamples, options.sps, options.rolloff,
-                      options.ntaps, options.bandwidth, options.noise,
-                      options.foffset, options.toffset, options.poffset)
+    put = example_fll(args.nsamples, args.sps, args.rolloff,
+                      args.ntaps, args.bandwidth, args.noise,
+                      args.foffset, args.toffset, args.poffset)
     put.run()
 
     data_src = scipy.array(put.vsnk_src.data())
@@ -106,7 +106,7 @@ def main():
 
     # adjust this to align with the data. There are 2 filters of
     # ntaps long and the channel introduces another 4 sample delay.
-    data_fll = scipy.array(put.vsnk_fll.data()[2*options.ntaps-4:])
+    data_fll = scipy.array(put.vsnk_fll.data()[2*args.ntaps-4:])
 
     # Plot the FLL's LO frequency
     f1 = pylab.figure(1, figsize=(12,10))
diff --git a/gr-digital/examples/example_timing.py b/gr-digital/examples/example_timing.py
index 94a4938f80..9e8e3e07b4 100755
--- a/gr-digital/examples/example_timing.py
+++ b/gr-digital/examples/example_timing.py
@@ -24,8 +24,8 @@ from gnuradio import gr, digital, filter
 from gnuradio import blocks
 from gnuradio import channels
 from gnuradio import eng_notation
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import sys
 
 try:
@@ -102,40 +102,40 @@ class example_timing(gr.top_block):
 
 
 def main():
-    parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
-    parser.add_option("-N", "--nsamples", type="int", default=2000,
-                      help="Set the number of samples to process [default=%default]")
-    parser.add_option("-S", "--sps", type="int", default=4,
-                      help="Set the samples per symbol [default=%default]")
-    parser.add_option("-r", "--rolloff", type="eng_float", default=0.35,
-                      help="Set the rolloff factor [default=%default]")
-    parser.add_option("-W", "--bandwidth", type="eng_float", default=2*scipy.pi/100.0,
-                      help="Set the loop bandwidth (PFB) or gain (M&M) [default=%default]")
-    parser.add_option("-n", "--ntaps", type="int", default=45,
-                      help="Set the number of taps in the filters [default=%default]")
-    parser.add_option("", "--noise", type="eng_float", default=0.0,
-                      help="Set the simulation noise voltage [default=%default]")
-    parser.add_option("-f", "--foffset", type="eng_float", default=0.0,
-                      help="Set the simulation's normalized frequency offset (in Hz) [default=%default]")
-    parser.add_option("-t", "--toffset", type="eng_float", default=1.0,
-                      help="Set the simulation's timing offset [default=%default]")
-    parser.add_option("-p", "--poffset", type="eng_float", default=0.0,
-                      help="Set the simulation's phase offset [default=%default]")
-    parser.add_option("-M", "--mode", type="int", default=0,
-                      help="Set the recovery mode (0: polyphase, 1: M&M) [default=%default]")
-    (options, args) = parser.parse_args ()
+    parser = ArgumentParser(conflict_handler="resolve")
+    parser.add_argument("-N", "--nsamples", type=int, default=2000,
+                      help="Set the number of samples to process [default=%(default)r]")
+    parser.add_argument("-S", "--sps", type=int, default=4,
+                      help="Set the samples per symbol [default=%(default)r]")
+    parser.add_argument("-r", "--rolloff", type=eng_float, default=0.35,
+                      help="Set the rolloff factor [default=%(default)r]")
+    parser.add_argument("-W", "--bandwidth", type=eng_float, default=2*scipy.pi/100.0,
+                      help="Set the loop bandwidth (PFB) or gain (M&M) [default=%(default)r]")
+    parser.add_argument("-n", "--ntaps", type=int, default=45,
+                      help="Set the number of taps in the filters [default=%(default)r]")
+    parser.add_argument("--noise", type=eng_float, default=0.0,
+                      help="Set the simulation noise voltage [default=%(default)r]")
+    parser.add_argument("-f", "--foffset", type=eng_float, default=0.0,
+                      help="Set the simulation's normalized frequency offset (in Hz) [default=%(default)r]")
+    parser.add_argument("-t", "--toffset", type=eng_float, default=1.0,
+                      help="Set the simulation's timing offset [default=%(default)r]")
+    parser.add_argument("-p", "--poffset", type=eng_float, default=0.0,
+                      help="Set the simulation's phase offset [default=%(default)r]")
+    parser.add_argument("-M", "--mode", type=int, default=0,
+                      help="Set the recovery mode (0: polyphase, 1: M&M) [default=%(default)r]")
+    args = parser.parse_args()
 
     # Adjust N for the interpolation by sps
-    options.nsamples = options.nsamples // options.sps
+    args.nsamples = args.nsamples // args.sps
 
     # Set up the program-under-test
-    put = example_timing(options.nsamples, options.sps, options.rolloff,
-                         options.ntaps, options.bandwidth, options.noise,
-                         options.foffset, options.toffset, options.poffset,
-                         options.mode)
+    put = example_timing(args.nsamples, args.sps, args.rolloff,
+                         args.ntaps, args.bandwidth, args.noise,
+                         args.foffset, args.toffset, args.poffset,
+                         args.mode)
     put.run()
 
-    if options.mode == 0:
+    if args.mode == 0:
         data_src = scipy.array(put.vsnk_src.data()[20:])
         data_clk = scipy.array(put.vsnk_clk.data()[20:])
 
diff --git a/gr-digital/examples/gen_whitener.py b/gr-digital/examples/gen_whitener.py
index 63616605ba..62345cee5d 100755
--- a/gr-digital/examples/gen_whitener.py
+++ b/gr-digital/examples/gen_whitener.py
@@ -22,8 +22,8 @@
 
 from gnuradio import gr, gru
 from gnuradio import blocks
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import sys
 
 class my_graph(gr.top_block):
@@ -31,12 +31,8 @@ class my_graph(gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
-        parser = OptionParser(option_class=eng_option)
-        (options, args) = parser.parse_args ()
-        if len(args) != 0:
-            parser.print_help()
-            raise SystemExit, 1
-
+        parser = ArgumentParser()
+        args = parser.parse_args()
         src = blocks.lfsr_32k_source_s()
         head = blocks.head(gr.sizeof_short, 2048)
         self.dst = blocks.vector_sink_s()
@@ -54,8 +50,7 @@ if __name__ == '__main__':
             i = i+2
             if i % 16 == 0:
                 f.write('\n')
-                    
+
     except KeyboardInterrupt:
         pass
-    
-    
+
diff --git a/gr-zeromq/examples/python/client.py b/gr-zeromq/examples/python/client.py
index a63a77aa0d..ca7ad1830a 100755
--- a/gr-zeromq/examples/python/client.py
+++ b/gr-zeromq/examples/python/client.py
@@ -28,8 +28,8 @@ from gnuradio import gr
 from gnuradio import blocks
 from gnuradio import analog
 from gnuradio import eng_notation
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import numpy
 import sys
 from threading import Thread
@@ -81,13 +81,13 @@ class top_block(gr.top_block):
 ###############################################################################
 # Options Parser
 ###############################################################################
-def parse_options():
-    """ Options parser. """
-    parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
-    parser.add_option("-s", "--servername", type="string", default="localhost",
+def parse_args():
+    """Argument parser."""
+    parser = ArgumentParser()
+    parser.add_argument("-s", "--servername", default="localhost",
                       help="Server hostname")
-    (options, args) = parser.parse_args()
-    return options
+    args = parser.parse_args()
+    return args
 
 ###############################################################################
 # Waiter Thread
@@ -102,8 +102,8 @@ class waiter(Thread):
 # Main
 ###############################################################################
 if __name__ == "__main__":
-    options = parse_options()
-    tb = top_block(options)
+    args = parse_args()
+    tb = top_block(args)
     try:
         # keep the program running when flowgraph is stopped
         while True:
diff --git a/gr-zeromq/examples/python/gui.py b/gr-zeromq/examples/python/gui.py
index ffdfdc2a75..c932549408 100755
--- a/gr-zeromq/examples/python/gui.py
+++ b/gr-zeromq/examples/python/gui.py
@@ -22,8 +22,8 @@
 ###############################################################################
 # Imports
 ###############################################################################
-from optparse import OptionParser
-from gnuradio.eng_option import eng_option
+from argparse import ArgumentParser
+from gnuradio.eng_arg import eng_float, intx
 import gui
 import sys
 import os
@@ -141,24 +141,24 @@ class gui(QtGui.QMainWindow):
 ###############################################################################
 # Options Parser
 ###############################################################################
-def parse_options():
-    """ Options parser. """
-    parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
-    parser.add_option("-s", "--servername", type="string", default="localhost",
+def parse_args():
+    """Options parser."""
+    parser = ArgumentParser()
+    parser.add_argument("-s", "--servername", default="localhost",
                       help="Server hostname")
-    parser.add_option("-c", "--clientname", type="string", default="localhost",
+    parser.add_argument("-c", "--clientname", default="localhost",
                       help="Server hostname")
-    (options, args) = parser.parse_args()
-    return options
+    args = parser.parse_args()
+    return args
 
 
 ###############################################################################
 # Main
 ###############################################################################
 if __name__ == "__main__":
-    options = parse_options()
+    args = parse_args()
     qapp = Qt.QApplication(sys.argv)
-    qapp.main_window = gui("Remote GNU Radio GUI",options)
+    qapp.main_window = gui("Remote GNU Radio GUI", args)
     qapp.main_window.show()
     qapp.exec_()
 
diff --git a/gr-zeromq/examples/python/server.py b/gr-zeromq/examples/python/server.py
index e3b7c9b928..23951664c1 100755
--- a/gr-zeromq/examples/python/server.py
+++ b/gr-zeromq/examples/python/server.py
@@ -27,8 +27,8 @@ from gnuradio import gr
 from gnuradio import blocks
 from gnuradio import analog
 from gnuradio import eng_notation
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
+from gnuradio.eng_arg import eng_float, intx
+from argparse import ArgumentParser
 import numpy
 import sys
 from threading import Thread
@@ -101,18 +101,18 @@ class top_block(gr.top_block):
 ###############################################################################
 # Options Parser
 ###############################################################################
-def parse_options():
-    """ Options parser. """
-    parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
-    (options, args) = parser.parse_args()
-    return options
+def parse_args():
+    """Argument parser."""
+    parser = ArgumentParser()
+    args = parser.parse_args()
+    return args
 
 ###############################################################################
 # Main
 ###############################################################################
 if __name__ == "__main__":
-    options = parse_options()
-    tb = top_block(options)
+    args = parse_args()
+    tb = top_block(args)
     try:
         # keep the program running when flowgraph is stopped
         while True: