11 files changed, 123 insertions, 103 deletions
diff --git a/gnuradio-runtime/examples/mp-sched/affinity_set.py b/gnuradio-runtime/examples/mp-sched/affinity_set.py
index 4516b96f54..530742ef22 100644
--- a/gnuradio-runtime/examples/mp-sched/affinity_set.py
+++ b/gnuradio-runtime/examples/mp-sched/affinity_set.py
@@ -13,6 +13,7 @@ from gnuradio.filter import firdes
 from argparse import ArgumentParser
 import sys
 
+
 class affinity_set(gr.top_block):
 
     def __init__(self):
@@ -27,19 +28,23 @@ class affinity_set(gr.top_block):
         # Blocks
         ##################################################
         vec_len = 1
-        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*vec_len, samp_rate)
-        self.blocks_null_source_0 = blocks.null_source(gr.sizeof_gr_complex*vec_len)
-        self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex*vec_len)
-        self.filter_filt_0 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])
-        self.filter_filt_1 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])
+        self.blocks_throttle_0 = blocks.throttle(
+            gr.sizeof_gr_complex * vec_len, samp_rate)
+        self.blocks_null_source_0 = blocks.null_source(
+            gr.sizeof_gr_complex * vec_len)
+        self.blocks_null_sink_0 = blocks.null_sink(
+            gr.sizeof_gr_complex * vec_len)
+        self.filter_filt_0 = filter.fir_filter_ccc(1, 40000 * [0.2 + 0.3j, ])
+        self.filter_filt_1 = filter.fir_filter_ccc(1, 40000 * [0.2 + 0.3j, ])
 
-        self.filter_filt_0.set_processor_affinity([0,])
-        self.filter_filt_1.set_processor_affinity([0,1])
+        self.filter_filt_0.set_processor_affinity([0, ])
+        self.filter_filt_1.set_processor_affinity([0, 1])
 
         ##################################################
         # Connections
         ##################################################
-        self.connect((self.blocks_null_source_0, 0), (self.blocks_throttle_0, 0))
+        self.connect((self.blocks_null_source_0, 0),
+                     (self.blocks_throttle_0, 0))
         self.connect((self.blocks_throttle_0, 0), (self.filter_filt_0, 0))
         self.connect((self.filter_filt_0, 0), (self.filter_filt_1, 0))
         self.connect((self.filter_filt_1, 0), (self.blocks_null_sink_0, 0))
@@ -50,6 +55,7 @@ class affinity_set(gr.top_block):
     def set_samp_rate(self, samp_rate):
         self.samp_rate = samp_rate
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     args = parser.parse_args()
@@ -69,4 +75,4 @@ if __name__ == '__main__':
             except ValueError:
                 print("Invalid number")
             else:
-                tb.filter_filt_0.set_processor_affinity([n,])
+                tb.filter_filt_0.set_processor_affinity([n, ])
diff --git a/gnuradio-runtime/examples/mp-sched/plot_flops.py b/gnuradio-runtime/examples/mp-sched/plot_flops.py
index 918197f9f4..5b58e1ddcf 100644
--- a/gnuradio-runtime/examples/mp-sched/plot_flops.py
+++ b/gnuradio-runtime/examples/mp-sched/plot_flops.py
@@ -47,9 +47,11 @@ def parse_file(input_filename, output):
 
 
 def handle_file(input_filename):
-    cmd_file = tempfile.NamedTemporaryFile(mode='w+', prefix='pf', suffix='.cmd')
+    cmd_file = tempfile.NamedTemporaryFile(
+        mode='w+', prefix='pf', suffix='.cmd')
     cmd_file_name = cmd_file.name
-    data_file = tempfile.NamedTemporaryFile(mode='w+', prefix='pf', suffix='.dat')
+    data_file = tempfile.NamedTemporaryFile(
+        mode='w+', prefix='pf', suffix='.dat')
     data_file_name = data_file.name
     desc = parse_file(input_filename, data_file)
     if len(desc) > 0:
@@ -68,8 +70,8 @@ def handle_file(input_filename):
 
     os.system("gnuplot " + cmd_file_name + " -")
 
-    #sys.stdout.write(open(cmd_file_name,'r').read())
-    #sys.stdout.write(open(data_file_name,'r').read())
+    # sys.stdout.write(open(cmd_file_name,'r').read())
+    # sys.stdout.write(open(data_file_name,'r').read())
 
 
 def main():
diff --git a/gnuradio-runtime/examples/mp-sched/run_synthetic.py b/gnuradio-runtime/examples/mp-sched/run_synthetic.py
index 35e7f1820d..db8378efe0 100644
--- a/gnuradio-runtime/examples/mp-sched/run_synthetic.py
+++ b/gnuradio-runtime/examples/mp-sched/run_synthetic.py
@@ -38,18 +38,20 @@ def write_shell_script(f, data_filename, description, ncores, gflops, max_pipes_
             # We'd like each run of synthetic to take ~10 seconds
             desired_time_per_run = 10
             est_gflops_avail = min(nstages * npipes, ncores) * gflops
-            nsamples = (est_gflops_avail * desired_time_per_run) / (512.0 * nstages * npipes)
+            nsamples = (est_gflops_avail * desired_time_per_run) / \
+                (512.0 * nstages * npipes)
             nsamples = int(nsamples * 1e9)
 
-            cmd = "./synthetic.py -m -s %d -p %d -N %d\n" % (nstages, npipes, nsamples)
+            cmd = "./synthetic.py -m -s %d -p %d -N %d\n" % (
+                nstages, npipes, nsamples)
             f.write(cmd)
             f.write('if test $? -ge 128; then exit 128; fi\n')
 
-    f.write(") 2>&1 | grep --line-buffered -v '^>>>' | tee %s\n" % (data_filename,))
+    f.write(") 2>&1 | grep --line-buffered -v '^>>>' | tee %s\n" %
+            (data_filename,))
     f.flush()
 
 
-
 def main():
     description = """%prog gathers multiprocessor scaling data using the ./synthetic.py benchmark.
 All combinations of npipes and nstages between 1 and --max-pipes-and-stages are tried.
@@ -61,14 +63,15 @@ plot_flops.py will make pretty graphs from the output data generated by %prog.
 """
     parser = ArgumentParser(description=description)
     parser.add_argument("-d", "--description", metavar="DESC",
-            help="machine description, e.g., \"Dual quad-core Xeon 3 GHz\"")
+                        help="machine description, e.g., \"Dual quad-core Xeon 3 GHz\"")
     parser.add_argument("-n", "--ncores", type=int, default=1,
-            help="number of processor cores [default=%(default)s]")
+                        help="number of processor cores [default=%(default)s]")
     parser.add_argument("-g", "--gflops", metavar="GFLOPS", type=float, default=3.0,
-            help="estimated GFLOPS per core [default=%(default)s]")
+                        help="estimated GFLOPS per core [default=%(default)s]")
     parser.add_argument("-m", "--max-pipes-and-stages", metavar="MAX", type=int, default=16,
-            help="maximum number of pipes and stages to use [default=%(default)s]")
-    parser.add_argument("output_file_name", metavar="FILE", help="output file name")
+                        help="maximum number of pipes and stages to use [default=%(default)s]")
+    parser.add_argument("output_file_name", metavar="FILE",
+                        help="output file name")
     args = parser.parse_args()
 
     shell = os.popen("/bin/sh", "w")
@@ -80,6 +83,6 @@ plot_flops.py will make pretty graphs from the output data generated by %prog.
                        args.gflops,
                        args.max_pipes_and_stages)
 
+
 if __name__ == '__main__':
     main()
-
diff --git a/gnuradio-runtime/examples/mp-sched/synthetic.py b/gnuradio-runtime/examples/mp-sched/synthetic.py
index 4d6f3b9a22..cff6fd970d 100644
--- a/gnuradio-runtime/examples/mp-sched/synthetic.py
+++ b/gnuradio-runtime/examples/mp-sched/synthetic.py
@@ -24,7 +24,7 @@ class pipeline(gr.hier_block2):
         gr.hier_block2.__init__(self, "pipeline",
                                 gr.io_signature(1, 1, gr.sizeof_float),
                                 gr.io_signature(0, 0, 0))
-        taps = ntaps*[1.0 / ntaps]
+        taps = ntaps * [1.0 / ntaps]
         upstream = self
         for i in range(nstages):
             op = filter.fir_filter_fff(1, taps)
@@ -41,14 +41,14 @@ class top(gr.top_block):
         default_nsamples = 10e6
         parser = ArgumentParser()
         parser.add_argument("-p", "--npipelines", type=intx, default=1,
-                          metavar="NPIPES", help="the number of pipelines to create (default=%(default)s)")
+                            metavar="NPIPES", help="the number of pipelines to create (default=%(default)s)")
         parser.add_argument("-s", "--nstages", type=intx, default=1, metavar="NSTAGES",
-                          help="the number of stages in each pipeline (default=%(default)s)")
+                            help="the number of stages in each pipeline (default=%(default)s)")
         parser.add_argument("-N", "--nsamples", type=eng_float, default=default_nsamples,
-                          help=("the number of samples to run through the graph (default=%s)" %
-                                (eng_notation.num_to_str(default_nsamples))))
+                            help=("the number of samples to run through the graph (default=%s)" %
+                                  (eng_notation.num_to_str(default_nsamples))))
         parser.add_argument("-m", "--machine-readable", action="store_true", default=False,
-                          help="enable machine readable output")
+                            help="enable machine readable output")
 
         args = parser.parse_args()
 
@@ -74,23 +74,24 @@ def time_it(tb):
     start = os.times()
     tb.run()
     stop = os.times()
-    delta = list(map((lambda a, b: a-b), stop, start))
+    delta = list(map((lambda a, b: a - b), stop, start))
     user, sys, childrens_user, childrens_sys, real = delta
     total_user = user + childrens_user
-    total_sys  = sys + childrens_sys
+    total_sys = sys + childrens_sys
     if tb.machine_readable:
         print("%3d %3d %.3e %7.3f %7.3f %7.3f %7.3f %.6e %.3e" % (
-            tb.npipes, tb.nstages, tb.nsamples, real, total_user, total_sys, (total_user+total_sys) / real, tb.flop, tb.flop / real))
+            tb.npipes, tb.nstages, tb.nsamples, real, total_user, total_sys, (total_user + total_sys) / real, tb.flop, tb.flop / real))
     else:
-        print("npipes           %7d"   % (tb.npipes,))
-        print("nstages          %7d"   % (tb.nstages,))
-        print("nsamples         %s"    % (eng_notation.num_to_str(tb.nsamples),))
+        print("npipes           %7d" % (tb.npipes,))
+        print("nstages          %7d" % (tb.nstages,))
+        print("nsamples         %s" % (eng_notation.num_to_str(tb.nsamples),))
         print("real             %7.3f" % (real,))
         print("user             %7.3f" % (total_user,))
         print("sys              %7.3f" % (total_sys,))
         print("(user+sys)/real  %7.3f" % ((total_user + total_sys) / real,))
-        print("pseudo_flop      %s"    % (eng_notation.num_to_str(tb.flop),))
-        print("pseudo_flop/real %s"    % (eng_notation.num_to_str(tb.flop / real),))
+        print("pseudo_flop      %s" % (eng_notation.num_to_str(tb.flop),))
+        print("pseudo_flop/real %s" %
+              (eng_notation.num_to_str(tb.flop / real),))
 
 
 if __name__ == "__main__":
@@ -99,7 +100,3 @@ if __name__ == "__main__":
         time_it(tb)
     except KeyboardInterrupt:
         raise SystemExit(128)
-
-
-
-
diff --git a/gnuradio-runtime/examples/mp-sched/wfm_rcv_pll_to_wav.py b/gnuradio-runtime/examples/mp-sched/wfm_rcv_pll_to_wav.py
index f78404a66a..d2fa94b8ad 100644
--- a/gnuradio-runtime/examples/mp-sched/wfm_rcv_pll_to_wav.py
+++ b/gnuradio-runtime/examples/mp-sched/wfm_rcv_pll_to_wav.py
@@ -17,14 +17,15 @@ from argparse import ArgumentParser
 import sys
 import math
 
+
 class wfm_rx_block (gr.top_block):
     def __init__(self):
         gr.top_block.__init__(self)
 
         parser = ArgumentParser(description="Decode WFM signal into WAV file.")
         parser.add_argument("-V", "--volume", type=eng_float,
-                help="Volume (dB) <%r, %r> (default is midpoint)" % \
-                        self.volume_range()[:2])
+                            help="Volume (dB) <%r, %r> (default is midpoint)" %
+                            self.volume_range()[:2])
         parser.add_argument("input_file", help="Input file (complex samples)")
         parser.add_argument("output_file", help="Output WAV file")
 
@@ -34,7 +35,8 @@ class wfm_rx_block (gr.top_block):
 
         # build graph
 
-        self.src = blocks.file_source(gr.sizeof_gr_complex, args.input_file, False)
+        self.src = blocks.file_source(
+            gr.sizeof_gr_complex, args.input_file, False)
 
         adc_rate = 64e6                             # 64 MS/s
         usrp_decim = 200
@@ -44,19 +46,17 @@ class wfm_rx_block (gr.top_block):
         audio_decimation = 10
         audio_rate = demod_rate / audio_decimation  # 32 kHz
 
-
-        chan_filt_coeffs = filter.optfir.low_pass (1,    # gain
-                                            usrp_rate,   # sampling rate
-                                            80e3,        # passband cutoff
-                                            115e3,       # stopband cutoff
-                                            0.1,         # passband ripple
-                                            60)          # stopband attenuation
-        #print len(chan_filt_coeffs)
-        chan_filt = filter.fir_filter_ccf (chanfilt_decim, chan_filt_coeffs)
-
+        chan_filt_coeffs = filter.optfir.low_pass(1,    # gain
+                                                  usrp_rate,   # sampling rate
+                                                  80e3,        # passband cutoff
+                                                  115e3,       # stopband cutoff
+                                                  0.1,         # passband ripple
+                                                  60)          # stopband attenuation
+        # print len(chan_filt_coeffs)
+        chan_filt = filter.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs)
 
         #self.guts = analog.wfm_rcv (demod_rate, audio_decimation)
-        self.guts = analog.wfm_rcv_pll (demod_rate, audio_decimation)
+        self.guts = analog.wfm_rcv_pll(demod_rate, audio_decimation)
 
         # FIXME rework {add,multiply}_const_* to handle multiple streams
         self.volume_control_l = blocks.multiply_const_ff(self.vol)
@@ -67,24 +67,24 @@ class wfm_rx_block (gr.top_block):
             sink = blocks.wavfile_sink(args.output_file, 2, int(audio_rate),
                                        blocks.FORMAT_WAV, blocks.FORMAT_PCM_16)
         else:
-            sink = audio.sink (int (audio_rate),
-                               args.audio_output,
-                               False)   # ok_to_block
+            sink = audio.sink(int(audio_rate),
+                              args.audio_output,
+                              False)   # ok_to_block
 
         # now wire it all together
-        self.connect (self.src, chan_filt, self.guts)
-        self.connect ((self.guts, 0), self.volume_control_l, (sink, 0))
-        self.connect ((self.guts, 1), self.volume_control_r, (sink, 1))
+        self.connect(self.src, chan_filt, self.guts)
+        self.connect((self.guts, 0), self.volume_control_l, (sink, 0))
+        self.connect((self.guts, 1), self.volume_control_r, (sink, 1))
 
         if args.volume is None:
             g = self.volume_range()
-            args.volume = float(g[0]+g[1]) / 2
+            args.volume = float(g[0] + g[1]) / 2
 
         # set initial values
 
         self.set_vol(args.volume)
 
-    def set_vol (self, vol):
+    def set_vol(self, vol):
         g = self.volume_range()
         self.vol = max(g[0], min(g[1], vol))
         self.volume_control_l.set_k(10**(self.vol / 10))
diff --git a/gnuradio-runtime/examples/network/audio_sink.py b/gnuradio-runtime/examples/network/audio_sink.py
index 68cc2ae95d..d38b30d34c 100644
--- a/gnuradio-runtime/examples/network/audio_sink.py
+++ b/gnuradio-runtime/examples/network/audio_sink.py
@@ -16,9 +16,11 @@ import sys
 try:
     from gnuradio import audio
 except ImportError:
-    sys.stderr.write("Failed to import gnuradio.audio. Make sure gr-audio component is installed.\n")
+    sys.stderr.write(
+        "Failed to import gnuradio.audio. Make sure gr-audio component is installed.\n")
     sys.exit(1)
 
+
 class audio_sink(gr.top_block):
     def __init__(self, host, port, pkt_size, sample_rate, eof):
         gr.top_block.__init__(self, "audio_sink")
@@ -26,18 +28,19 @@ class audio_sink(gr.top_block):
         dst = audio.sink(sample_rate)
         self.connect(src, dst)
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument("--host", default="0.0.0.0",
-                      help="local host name (domain name or IP address)")
+                        help="local host name (domain name or IP address)")
     parser.add_argument("--port", type=int, default=65500,
-                      help="port value to listen to for connection")
+                        help="port value to listen to for connection")
     parser.add_argument("--packet-size", type=int, default=1472,
-                      help="packet size.")
+                        help="packet size.")
     parser.add_argument("-r", "--sample-rate", type=int, default=32000,
-                      help="audio signal sample rate [default=%(default)r]")
+                        help="audio signal sample rate [default=%(default)r]")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
     # Create an instance of a hierarchical block
     top_block = audio_sink(args.host, args.port,
@@ -50,4 +53,3 @@ if __name__ == '__main__':
     except KeyboardInterrupt:
         # Ctrl-C exits
         pass
-
diff --git a/gnuradio-runtime/examples/network/audio_source.py b/gnuradio-runtime/examples/network/audio_source.py
index 70430025f2..6cffc3aedf 100644
--- a/gnuradio-runtime/examples/network/audio_source.py
+++ b/gnuradio-runtime/examples/network/audio_source.py
@@ -16,28 +16,32 @@ import sys
 try:
     from gnuradio import audio
 except ImportError:
-    sys.stderr.write("Failed to import gnuradio.audio. Make sure gr-audio component is installed.\n")
+    sys.stderr.write(
+        "Failed to import gnuradio.audio. Make sure gr-audio component is installed.\n")
     sys.exit(1)
 
+
 class audio_source(gr.top_block):
     def __init__(self, host, port, pkt_size, sample_rate, eof):
         gr.top_block.__init__(self, "audio_source")
         self.audio = audio.source(sample_rate)
-        self.sink = blocks.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof)
+        self.sink = blocks.udp_sink(
+            gr.sizeof_float, host, port, pkt_size, eof=eof)
         self.connect(self.audio, self.sink)
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument("--host", default="127.0.0.1",
-                      help="Remote host name (domain name or IP address")
+                        help="Remote host name (domain name or IP address")
     parser.add_argument("--port", type=int, default=65500,
-                      help="port number to connect to")
+                        help="port number to connect to")
     parser.add_argument("--packet-size", type=int, default=1472,
-                      help="packet size.")
-    parser.add_argument("-r", "--sample-rate", type=int, default=32000 ,
-                      help="audio signal sample rate [default=%(default)r]")
+                        help="packet size.")
+    parser.add_argument("-r", "--sample-rate", type=int, default=32000,
+                        help="audio signal sample rate [default=%(default)r]")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
     # Create an instance of a hierarchical block
     top_block = audio_source(args.host, args.port,
@@ -50,4 +54,3 @@ if __name__ == '__main__':
     except KeyboardInterrupt:
         # Ctrl-C exits
         pass
-
diff --git a/gnuradio-runtime/examples/network/dial_tone_sink.py b/gnuradio-runtime/examples/network/dial_tone_sink.py
index 8fff674d23..d0702a5539 100644
--- a/gnuradio-runtime/examples/network/dial_tone_sink.py
+++ b/gnuradio-runtime/examples/network/dial_tone_sink.py
@@ -12,6 +12,7 @@ from gnuradio import gr, audio
 from gnuradio import blocks
 from argparse import ArgumentParser
 
+
 class dial_tone_sink(gr.top_block):
     def __init__(self, host, port, pkt_size, sample_rate, eof):
         gr.top_block.__init__(self, "dial_tone_sink")
@@ -19,18 +20,19 @@ class dial_tone_sink(gr.top_block):
         sink = audio.sink(sample_rate)
         self.connect(udp, sink)
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument("--host", default="0.0.0.0",
-                      help="local host name (domain name or IP address)")
+                        help="local host name (domain name or IP address)")
     parser.add_argument("--port", type=int, default=65500,
-                      help="port value to listen to for connection")
+                        help="port value to listen to for connection")
     parser.add_argument("--packet-size", type=int, default=1472,
-                      help="packet size.")
+                        help="packet size.")
     parser.add_argument("-r", "--sample-rate", type=int, default=8000,
-                      help="audio signal sample rate [default=%(default)r]")
+                        help="audio signal sample rate [default=%(default)r]")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
     # Create an instance of a hierarchical block
     top_block = dial_tone_sink(args.host, args.port,
@@ -43,4 +45,3 @@ if __name__ == '__main__':
     except KeyboardInterrupt:
         # Ctrl-C exits
         pass
-
diff --git a/gnuradio-runtime/examples/network/dial_tone_source.py b/gnuradio-runtime/examples/network/dial_tone_source.py
index 16e5fa34a8..abddf0f96e 100644
--- a/gnuradio-runtime/examples/network/dial_tone_source.py
+++ b/gnuradio-runtime/examples/network/dial_tone_source.py
@@ -22,13 +22,16 @@ try:
 except ImportError:
     sys.stderr.write("This example requires gr-blocks.\n")
 
+
 class dial_tone_source(gr.top_block):
     def __init__(self, host, port, pkt_size, sample_rate, eof):
         gr.top_block.__init__(self, "dial_tone_source")
 
         amplitude = 0.3
-        src0 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 350, amplitude)
-        src1 = analog.sig_source_f(sample_rate, analog.GR_SIN_WAVE, 440, amplitude)
+        src0 = analog.sig_source_f(
+            sample_rate, analog.GR_SIN_WAVE, 350, amplitude)
+        src1 = analog.sig_source_f(
+            sample_rate, analog.GR_SIN_WAVE, 440, amplitude)
         add = blocks.add_ff()
 
         # Throttle needed here to account for the other side's audio card sampling rate
@@ -38,18 +41,19 @@ class dial_tone_source(gr.top_block):
         self.connect(src1, (add, 1))
         self.connect(add, thr, sink)
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument("--host", default="127.0.0.1",
-                      help="Remote host name (domain name or IP address")
+                        help="Remote host name (domain name or IP address")
     parser.add_argument("--port", type=int, default=65500,
-                      help="port number to connect to")
+                        help="port number to connect to")
     parser.add_argument("--packet-size", type=int, default=1472,
-                      help="packet size.")
+                        help="packet size.")
     parser.add_argument("-r", "--sample-rate", type=int, default=8000,
-                      help="audio signal sample rate [default=%(default)r]")
+                        help="audio signal sample rate [default=%(default)r]")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
     # Create an instance of a hierarchical block
     top_block = dial_tone_source(args.host, args.port,
diff --git a/gnuradio-runtime/examples/network/vector_sink.py b/gnuradio-runtime/examples/network/vector_sink.py
index 619303d7ec..06d0519b85 100644
--- a/gnuradio-runtime/examples/network/vector_sink.py
+++ b/gnuradio-runtime/examples/network/vector_sink.py
@@ -13,6 +13,7 @@ from gnuradio import blocks
 from gnuradio.eng_arg import eng_float, intx
 from argparse import ArgumentParser
 
+
 class vector_sink(gr.top_block):
     def __init__(self, host, port, pkt_size, eof):
         gr.top_block.__init__(self, "vector_sink")
@@ -21,16 +22,17 @@ class vector_sink(gr.top_block):
         sink = blocks.file_sink(gr.sizeof_float, "received.dat")
         self.connect(udp, sink)
 
+
 if __name__ == "__main__":
     parser = ArgumentParser()
     parser.add_argument("-H", "--host", default="0.0.0.0",
-                      help="local host name (domain name or IP address)")
+                        help="local host name (domain name or IP address)")
     parser.add_argument("-p", "--port", type=int, default=65500,
-                      help="port value to listen to for connection")
+                        help="port value to listen to for connection")
     parser.add_argument("-s", "--packet-size", type=int, default=1471,
-                      help="packet size.")
+                        help="packet size.")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
     # Create an instance of a hierarchical block
     top_block = vector_sink(args.host, args.port,
@@ -43,4 +45,3 @@ if __name__ == "__main__":
     except KeyboardInterrupt:
         # Ctrl-C exits
         pass
-
diff --git a/gnuradio-runtime/examples/network/vector_source.py b/gnuradio-runtime/examples/network/vector_source.py
index 0a43b4978b..7ab6a66df1 100644
--- a/gnuradio-runtime/examples/network/vector_source.py
+++ b/gnuradio-runtime/examples/network/vector_source.py
@@ -12,24 +12,26 @@ from gnuradio import gr
 from gnuradio import blocks
 from argparse import ArgumentParser
 
+
 class vector_source(gr.top_block):
     def __init__(self, host, port, pkt_size, eof):
         gr.top_block.__init__(self, "vector_source")
-        data = [i*0.01 for i in range(1000)]
+        data = [i * 0.01 for i in range(1000)]
         vec = blocks.vector_source_f(data, True)
         udp = blocks.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof)
         self.connect(vec, udp)
 
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument("--host", default="127.0.0.1",
-                      help="Remote host name (domain name or IP address")
+                        help="Remote host name (domain name or IP address")
     parser.add_argument("--port", type=int, default=65500,
-                      help="port number to connect to")
+                        help="port number to connect to")
     parser.add_argument("--packet-size", type=int, default=1471,
-                      help="packet size.")
+                        help="packet size.")
     parser.add_argument("--no-eof", action="store_true", default=False,
-                      help="don't send EOF on disconnect")
+                        help="don't send EOF on disconnect")
     args = parser.parse_args()
 # Create an instance of a hierarchical block
     top_block = vector_source(args.host, args.port, args.packet_size,
@@ -41,4 +43,3 @@ if __name__ == '__main__':
     except KeyboardInterrupt:
         # Ctrl-C exits
         pass
-