qa: run autopep8 formatting on qa python files

find ./ -iname qa*.py | xargs autopep8 --in-place -a -a

mostly formats whitespace and gets rid of trailing semicolons

8 files changed, 134 insertions, 55 deletions

diff --git a/gr-zeromq/python/zeromq/qa_zeromq_pub.py b/gr-zeromq/python/zeromq/qa_zeromq_pub.py
index 5b40426f8..2c324b102 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_pub.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_pub.py
@@ -15,20 +15,22 @@ from gnuradio import blocks, zeromq
 from gnuradio import eng_notation
 import threading
 
+
 class qa_zeromq_pub (gr_unittest.TestCase):
 
-    def setUp (self):
-        self.tb = gr.top_block ()
+    def setUp(self):
+        self.tb = gr.top_block()
 
-    def tearDown (self):
+    def tearDown(self):
         self.tb = None
 
-    def test_001 (self):
+    def test_001(self):
         vlen = 10
         self.rx_data = None
-        src_data = list(range(vlen))*100
+        src_data = list(range(vlen)) * 100
         src = blocks.vector_source_f(src_data, False, vlen)
-        zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0")
+        zeromq_pub_sink = zeromq.pub_sink(
+            gr.sizeof_float, vlen, "tcp://127.0.0.1:0")
         address = zeromq_pub_sink.last_endpoint()
         self.tb.connect(src, zeromq_pub_sink)
         self.probe_manager = zeromq.probe_manager()
@@ -42,7 +44,7 @@ class qa_zeromq_pub (gr_unittest.TestCase):
         self.assertFalse(zmq_pull_t.is_alive())
         self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
 
-    def recv_data (self, data):
+    def recv_data(self, data):
         self.rx_data = data
 
 
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_pubsub.py b/gr-zeromq/python/zeromq/qa_zeromq_pubsub.py
index 44a936ec4..caacdbc5e 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_pubsub.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_pubsub.py
@@ -15,6 +15,7 @@ from gnuradio import blocks, zeromq
 import pmt
 import time
 
+
 def make_tag(key, value, offset, srcid=None):
     tag = gr.tag_t()
     tag.key = pmt.string_to_symbol(key)
@@ -24,27 +25,31 @@ def make_tag(key, value, offset, srcid=None):
         tag.srcid = pmt.to_pmt(srcid)
     return tag
 
+
 def compare_tags(a, b):
     return a.offset == b.offset and pmt.equal(a.key, b.key) and \
-           pmt.equal(a.value, b.value) and pmt.equal(a.srcid, b.srcid)
+        pmt.equal(a.value, b.value) and pmt.equal(a.srcid, b.srcid)
+
 
 class qa_zeromq_pubsub (gr_unittest.TestCase):
 
-    def setUp (self):
+    def setUp(self):
         self.send_tb = gr.top_block()
         self.recv_tb = gr.top_block()
 
-    def tearDown (self):
+    def tearDown(self):
         self.send_tb = None
         self.recv_tb = None
 
-    def test_001 (self):
+    def test_001(self):
         vlen = 10
-        src_data = list(range(vlen))*100
+        src_data = list(range(vlen)) * 100
         src = blocks.vector_source_f(src_data, False, vlen)
-        zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0)
+        zeromq_pub_sink = zeromq.pub_sink(
+            gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0)
         address = zeromq_pub_sink.last_endpoint()
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, address, 0)
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, address, 0)
         sink = blocks.vector_sink_f(vlen)
         self.send_tb.connect(src, zeromq_pub_sink)
         self.recv_tb.connect(zeromq_sub_source, sink)
@@ -58,17 +63,25 @@ class qa_zeromq_pubsub (gr_unittest.TestCase):
         self.send_tb.wait()
         self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
 
-    def test_002 (self):
+    def test_002(self):
         # same as test_001, but insert a tag and set key filter
         vlen = 10
-        src_data = list(range(vlen))*100
+        src_data = list(range(vlen)) * 100
 
-        src_tags = tuple([make_tag('key', 'val', 0, 'src'), make_tag('key', 'val', 1, 'src')])
+        src_tags = tuple([make_tag('key', 'val', 0, 'src'),
+                          make_tag('key', 'val', 1, 'src')])
 
         src = blocks.vector_source_f(src_data, False, vlen, tags=src_tags)
-        zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0, pass_tags=True, key="filter_key")
+        zeromq_pub_sink = zeromq.pub_sink(
+            gr.sizeof_float,
+            vlen,
+            "tcp://127.0.0.1:0",
+            0,
+            pass_tags=True,
+            key="filter_key")
         address = zeromq_pub_sink.last_endpoint()
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, address, 0, pass_tags=True, key="filter_key")
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, address, 0, pass_tags=True, key="filter_key")
         sink = blocks.vector_sink_f(vlen)
         self.send_tb.connect(src, zeromq_pub_sink)
         self.recv_tb.connect(zeromq_sub_source, sink)
@@ -93,5 +106,6 @@ class qa_zeromq_pubsub (gr_unittest.TestCase):
         for in_tag, out_tag in zip(src_tags, rx_tags):
             self.assertTrue(compare_tags(in_tag, out_tag))
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_pubsub)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_pull_msg_source.py b/gr-zeromq/python/zeromq/qa_zeromq_pull_msg_source.py
index 4ffc90800..0a2e541ac 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_pull_msg_source.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_pull_msg_source.py
@@ -15,6 +15,7 @@ import zmq
 from gnuradio import gr, gr_unittest, blocks, zeromq
 import pmt
 
+
 class qa_zeromq_pull_msg_source(gr_unittest.TestCase):
     """Unit tests for ZMQ PULL Message Source block"""
 
@@ -24,10 +25,12 @@ class qa_zeromq_pull_msg_source(gr_unittest.TestCase):
         self.zmq_sock = self.context.socket(zmq.PUSH)
         port = self.zmq_sock.bind_to_random_port(addr)
 
-        self.zeromq_pull_msg_source = zeromq.pull_msg_source(('%s:%s' % (addr, port)), 100)
+        self.zeromq_pull_msg_source = zeromq.pull_msg_source(
+            ('%s:%s' % (addr, port)), 100)
         self.message_debug = blocks.message_debug()
         self.tb = gr.top_block()
-        self.tb.msg_connect((self.zeromq_pull_msg_source, 'out'), (self.message_debug, 'store'))
+        self.tb.msg_connect(
+            (self.zeromq_pull_msg_source, 'out'), (self.message_debug, 'store'))
 
         self.tb.start()
         time.sleep(0.1)
@@ -57,5 +60,6 @@ class qa_zeromq_pull_msg_source(gr_unittest.TestCase):
         time.sleep(0.1)
         self.assertEqual(0, self.message_debug.num_messages())
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_pull_msg_source)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_pushpull.py b/gr-zeromq/python/zeromq/qa_zeromq_pushpull.py
index e99a06e1a..9ffc8cdfa 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_pushpull.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_pushpull.py
@@ -12,23 +12,26 @@
 from gnuradio import gr, gr_unittest, blocks, zeromq
 import time
 
+
 class qa_zeromq_pushpull (gr_unittest.TestCase):
 
-    def setUp (self):
+    def setUp(self):
         self.send_tb = gr.top_block()
         self.recv_tb = gr.top_block()
 
-    def tearDown (self):
+    def tearDown(self):
         self.send_tb = None
         self.recv_tb = None
 
-    def test_001 (self):
+    def test_001(self):
         vlen = 10
-        src_data = list(range(vlen))*100
+        src_data = list(range(vlen)) * 100
         src = blocks.vector_source_f(src_data, False, vlen)
-        zeromq_push_sink = zeromq.push_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0")
+        zeromq_push_sink = zeromq.push_sink(
+            gr.sizeof_float, vlen, "tcp://127.0.0.1:0")
         address = zeromq_push_sink.last_endpoint()
-        zeromq_pull_source = zeromq.pull_source(gr.sizeof_float, vlen, address, 0)
+        zeromq_pull_source = zeromq.pull_source(
+            gr.sizeof_float, vlen, address, 0)
         sink = blocks.vector_sink_f(vlen)
         self.send_tb.connect(src, zeromq_push_sink)
         self.recv_tb.connect(zeromq_pull_source, sink)
@@ -42,5 +45,6 @@ class qa_zeromq_pushpull (gr_unittest.TestCase):
         self.send_tb.wait()
         self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_pushpull)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_req_msg_source.py b/gr-zeromq/python/zeromq/qa_zeromq_req_msg_source.py
index af075e6b3..61759c289 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_req_msg_source.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_req_msg_source.py
@@ -16,6 +16,7 @@ import zmq
 from gnuradio import gr, gr_unittest, blocks, zeromq
 import pmt
 
+
 class qa_zeromq_req_msg_source(gr_unittest.TestCase):
     """Unit tests for ZMQ REQ Message Source block"""
 
@@ -25,10 +26,12 @@ class qa_zeromq_req_msg_source(gr_unittest.TestCase):
         self.zmq_sock = self.context.socket(zmq.REP)
         port = self.zmq_sock.bind_to_random_port(addr)
 
-        self.zeromq_req_msg_source = zeromq.req_msg_source(('%s:%s' % (addr, port)), 100)
+        self.zeromq_req_msg_source = zeromq.req_msg_source(
+            ('%s:%s' % (addr, port)), 100)
         self.message_debug = blocks.message_debug()
         self.tb = gr.top_block()
-        self.tb.msg_connect((self.zeromq_req_msg_source, 'out'), (self.message_debug, 'store'))
+        self.tb.msg_connect(
+            (self.zeromq_req_msg_source, 'out'), (self.message_debug, 'store'))
 
         self.tb.start()
 
@@ -72,17 +75,22 @@ class qa_zeromq_req_msg_source(gr_unittest.TestCase):
         time.sleep(0.1)
         self.assertEqual(len(msgs), self.message_debug.num_messages())
         for index, msg in enumerate(msgs):
-            self.assertTrue(pmt.equal(msg, self.message_debug.get_message(index)))
+            self.assertTrue(
+                pmt.equal(
+                    msg,
+                    self.message_debug.get_message(index)))
 
     def test_invalid_pmt(self):
         """Test receiving of invalid PMT messages"""
         self.recv_request()
 
-        #Do not use pmt.serialize_str here as we don't want a valid PMT message
+        # Do not use pmt.serialize_str here as we don't want a valid PMT
+        # message
         self.zmq_sock.send_string('test_invalid_pmt')
 
         time.sleep(0.1)
         self.assertEqual(0, self.message_debug.num_messages())
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_req_msg_source)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_reqrep.py b/gr-zeromq/python/zeromq/qa_zeromq_reqrep.py
index 8e5e8b5f9..703102e12 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_reqrep.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_reqrep.py
@@ -15,23 +15,26 @@ from gnuradio import blocks, zeromq
 from gnuradio import eng_notation
 import time
 
+
 class qa_zeromq_reqrep (gr_unittest.TestCase):
 
-    def setUp (self):
+    def setUp(self):
         self.send_tb = gr.top_block()
         self.recv_tb = gr.top_block()
 
-    def tearDown (self):
+    def tearDown(self):
         self.send_tb = None
         self.recv_tb = None
 
-    def test_001 (self):
+    def test_001(self):
         vlen = 10
-        src_data = list(range(vlen))*100
+        src_data = list(range(vlen)) * 100
         src = blocks.vector_source_f(src_data, False, vlen)
-        zeromq_rep_sink = zeromq.rep_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0)
+        zeromq_rep_sink = zeromq.rep_sink(
+            gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0)
         address = zeromq_rep_sink.last_endpoint()
-        zeromq_req_source = zeromq.req_source(gr.sizeof_float, vlen, address, 0)
+        zeromq_req_source = zeromq.req_source(
+            gr.sizeof_float, vlen, address, 0)
         sink = blocks.vector_sink_f(vlen)
         self.send_tb.connect(src, zeromq_rep_sink)
         self.recv_tb.connect(zeromq_req_source, sink)
@@ -45,5 +48,6 @@ class qa_zeromq_reqrep (gr_unittest.TestCase):
         self.send_tb.wait()
         self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_reqrep)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_sub.py b/gr-zeromq/python/zeromq/qa_zeromq_sub.py
index 9e82420c2..ba08c9246 100755
--- a/gr-zeromq/python/zeromq/qa_zeromq_sub.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_sub.py
@@ -17,24 +17,26 @@ import numpy
 import time
 import zmq
 
+
 class qa_zeromq_sub (gr_unittest.TestCase):
 
-    def setUp (self):
-        self.tb = gr.top_block ()
+    def setUp(self):
+        self.tb = gr.top_block()
         self.zmq_context = zmq.Context()
         self.pub_socket = self.zmq_context.socket(zmq.PUB)
         self.pub_socket.bind("tcp://127.0.0.1:0")
         self._address = self.pub_socket.getsockopt(zmq.LAST_ENDPOINT).decode()
 
-    def tearDown (self):
+    def tearDown(self):
         self.pub_socket.close()
         self.zmq_context.term()
         self.tb = None
 
-    def test_001 (self):
+    def test_001(self):
         vlen = 10
-        src_data = numpy.array(list(range(vlen))*100, 'float32')
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, self._address)
+        src_data = numpy.array(list(range(vlen)) * 100, 'float32')
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, self._address)
         sink = blocks.vector_sink_f(vlen)
         self.tb.connect(zeromq_sub_source, sink)
 
@@ -46,12 +48,24 @@ class qa_zeromq_sub (gr_unittest.TestCase):
         self.tb.wait()
         self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
 
-    def test_002 (self):
+    def test_002(self):
         vlen = 10
         # Construct multipart source data to publish
-        raw_data = [numpy.array(range(vlen), 'float32')*100, numpy.array(range(vlen, 2*vlen), 'float32')*100]
+        raw_data = [
+            numpy.array(
+                range(vlen),
+                'float32') *
+            100,
+            numpy.array(
+                range(
+                    vlen,
+                    2 *
+                    vlen),
+                'float32') *
+            100]
         src_data = [a.tostring() for a in raw_data]
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, self._address)
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, self._address)
         sink = blocks.vector_sink_f(vlen)
         self.tb.connect(zeromq_sub_source, sink)
 
@@ -66,16 +80,28 @@ class qa_zeromq_sub (gr_unittest.TestCase):
         expected_data = numpy.concatenate(raw_data)
         self.assertFloatTuplesAlmostEqual(sink.data(), expected_data)
 
-    def test_003 (self):
+    def test_003(self):
         # Check that message is received when correct key is used
         # Construct multipart source data to publish
         vlen = 10
-        raw_data = [numpy.array(range(vlen), 'float32')*100, numpy.array(range(vlen, 2*vlen), 'float32')*100]
+        raw_data = [
+            numpy.array(
+                range(vlen),
+                'float32') *
+            100,
+            numpy.array(
+                range(
+                    vlen,
+                    2 *
+                    vlen),
+                'float32') *
+            100]
         src_data = [a.tostring() for a in raw_data]
 
         src_data = [b"filter_key"] + src_data
 
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, self._address, key="filter_key")
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, self._address, key="filter_key")
         sink = blocks.vector_sink_f(vlen)
         self.tb.connect(zeromq_sub_source, sink)
 
@@ -90,15 +116,27 @@ class qa_zeromq_sub (gr_unittest.TestCase):
         expected_data = numpy.concatenate(raw_data)
         self.assertFloatTuplesAlmostEqual(sink.data(), expected_data)
 
-    def test_004 (self):
+    def test_004(self):
         # Test that no message is received when wrong key is used
         vlen = 10
-        raw_data = [numpy.array(range(vlen), 'float32')*100, numpy.array(range(vlen, 2*vlen), 'float32')*100]
+        raw_data = [
+            numpy.array(
+                range(vlen),
+                'float32') *
+            100,
+            numpy.array(
+                range(
+                    vlen,
+                    2 *
+                    vlen),
+                'float32') *
+            100]
         src_data = [a.tostring() for a in raw_data]
 
         src_data = [b"filter_key"] + src_data
 
-        zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, self._address, key="wrong_filter_key")
+        zeromq_sub_source = zeromq.sub_source(
+            gr.sizeof_float, vlen, self._address, key="wrong_filter_key")
         sink = blocks.vector_sink_f(vlen)
         self.tb.connect(zeromq_sub_source, sink)
 
@@ -109,7 +147,8 @@ class qa_zeromq_sub (gr_unittest.TestCase):
         self.tb.stop()
         self.tb.wait()
 
-        assert( len(sink.data()) == 0 )
+        assert(len(sink.data()) == 0)
+
 
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_sub)
diff --git a/gr-zeromq/python/zeromq/qa_zeromq_sub_msg_source.py b/gr-zeromq/python/zeromq/qa_zeromq_sub_msg_source.py
index 145483f6a..3c9839608 100644
--- a/gr-zeromq/python/zeromq/qa_zeromq_sub_msg_source.py
+++ b/gr-zeromq/python/zeromq/qa_zeromq_sub_msg_source.py
@@ -15,6 +15,7 @@ import zmq
 from gnuradio import gr, gr_unittest, blocks, zeromq
 import pmt
 
+
 class qa_zeromq_sub_msg_source(gr_unittest.TestCase):
     """Unit tests for ZMQ SUB Message Source block"""
 
@@ -24,10 +25,12 @@ class qa_zeromq_sub_msg_source(gr_unittest.TestCase):
         self.zmq_sock = self.context.socket(zmq.PUB)
         port = self.zmq_sock.bind_to_random_port(addr)
 
-        self.zeromq_sub_msg_source = zeromq.sub_msg_source(('%s:%s' % (addr, port)), 100)
+        self.zeromq_sub_msg_source = zeromq.sub_msg_source(
+            ('%s:%s' % (addr, port)), 100)
         self.message_debug = blocks.message_debug()
         self.tb = gr.top_block()
-        self.tb.msg_connect((self.zeromq_sub_msg_source, 'out'), (self.message_debug, 'store'))
+        self.tb.msg_connect(
+            (self.zeromq_sub_msg_source, 'out'), (self.message_debug, 'store'))
 
         self.tb.start()
         time.sleep(0.1)
@@ -57,5 +60,6 @@ class qa_zeromq_sub_msg_source(gr_unittest.TestCase):
         time.sleep(0.1)
         self.assertEqual(0, self.message_debug.num_messages())
 
+
 if __name__ == '__main__':
     gr_unittest.run(qa_zeromq_sub_msg_source)