diff options
| author | Marcus Müller <marcus@hostalia.de> | 2018-08-31 23:02:22 +0200 |
|---|---|---|
| committer | Marcus Müller <marcus@hostalia.de> | 2018-08-31 23:02:22 +0200 |
| commit | 254fe5e89403d4de1fa6663d09efdf946996aff3 (patch) | |
| tree | 62877d7ac7fdedf6c397c51e22ac6f97eba97ddf /gr-blocks/python | |
| parent | 896d1c9da31963ecf5b0d90942c2af51ca998a69 (diff) | |
| parent | 5ad935c3a3dd46ce2860b13e2b774e4841784616 (diff) | |
Merge remote-tracking branch 'origin/next' into merge_next
Diffstat (limited to 'gr-blocks/python')
88 files changed, 1091 insertions, 1282 deletions
diff --git a/gr-blocks/python/blocks/CMakeLists.txt b/gr-blocks/python/blocks/CMakeLists.txt index ffd7d81c4e..2f9c94f9f2 100644 --- a/gr-blocks/python/blocks/CMakeLists.txt +++ b/gr-blocks/python/blocks/CMakeLists.txt @@ -26,7 +26,6 @@ GR_PYTHON_INSTALL( parse_file_metadata.py stream_to_vector_decimator.py DESTINATION ${GR_PYTHON_DIR}/gnuradio/blocks - COMPONENT "blocks_python" ) ######################################################################## @@ -56,7 +55,7 @@ if(ENABLE_TESTING) foreach(py_qa_test_file ${py_qa_test_files}) get_filename_component(py_qa_test_name ${py_qa_test_file} NAME_WE) - GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} ${PYTHON_DASH_B} ${py_qa_test_file}) + GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} -B ${py_qa_test_file}) endforeach(py_qa_test_file) endif(ENABLE_TESTING) diff --git a/gr-blocks/python/blocks/__init__.py b/gr-blocks/python/blocks/__init__.py index fc4cc7ab66..148479a21e 100644 --- a/gr-blocks/python/blocks/__init__.py +++ b/gr-blocks/python/blocks/__init__.py @@ -22,16 +22,20 @@ ''' Processing blocks common to many flowgraphs. ''' + +from __future__ import absolute_import +from __future__ import unicode_literals + import os try: - from blocks_swig import * + from .blocks_swig import * except ImportError: dirname, filename = os.path.split(os.path.abspath(__file__)) __path__.append(os.path.join(dirname, "..", "..", "swig")) - from blocks_swig import * + from .blocks_swig import * -from stream_to_vector_decimator import * +from .stream_to_vector_decimator import * #alias old add_vXX and multiply_vXX add_vcc = add_cc diff --git a/gr-blocks/python/blocks/parse_file_metadata.py b/gr-blocks/python/blocks/parse_file_metadata.py index 7d8d41d166..39092d8abd 100644 --- a/gr-blocks/python/blocks/parse_file_metadata.py +++ b/gr-blocks/python/blocks/parse_file_metadata.py @@ -20,6 +20,10 @@ # Boston, MA 02110-1301, USA. # +from __future__ import print_function +from __future__ import division +from __future__ import unicode_literals + import sys from gnuradio import gr, blocks import pmt @@ -65,7 +69,7 @@ def parse_header(p, VERBOSE=False): r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump) version = pmt.to_long(r) if(VERBOSE): - print "Version Number: {0}".format(version) + print("Version Number: {0}".format(version)) else: sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n") sys.exit(1) @@ -76,7 +80,7 @@ def parse_header(p, VERBOSE=False): samp_rate = pmt.to_double(r) info["rx_rate"] = samp_rate if(VERBOSE): - print "Sample Rate: {0:.2f} sps".format(samp_rate) + print("Sample Rate: {0:.2f} sps".format(samp_rate)) else: sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n") sys.exit(1) @@ -91,7 +95,7 @@ def parse_header(p, VERBOSE=False): t = secs + fracs info["rx_time"] = t if(VERBOSE): - print "Seconds: {0:.6f}".format(t) + print("Seconds: {0:.6f}".format(t)) else: sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n") sys.exit(1) @@ -102,7 +106,7 @@ def parse_header(p, VERBOSE=False): dsize = pmt.to_long(r) info["size"] = dsize if(VERBOSE): - print "Item size: {0}".format(dsize) + print("Item size: {0}".format(dsize)) else: sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n") sys.exit(1) @@ -114,7 +118,7 @@ def parse_header(p, VERBOSE=False): stype = ftype_to_string[dtype] info["type"] = stype if(VERBOSE): - print "Data Type: {0} ({1})".format(stype, dtype) + print("Data Type: {0} ({1})".format(stype, dtype)) else: sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n") sys.exit(1) @@ -125,7 +129,7 @@ def parse_header(p, VERBOSE=False): cplx = pmt.to_bool(r) info["cplx"] = cplx if(VERBOSE): - print "Complex? {0}".format(cplx) + print("Complex? {0}".format(cplx)) else: sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n") sys.exit(1) @@ -138,9 +142,9 @@ def parse_header(p, VERBOSE=False): info["extra_len"] = seg_start - HEADER_LENGTH info["has_extra"] = info["extra_len"] > 0 if(VERBOSE): - print "Header Length: {0} bytes".format(info["hdr_len"]) - print "Extra Length: {0}".format((info["extra_len"])) - print "Extra Header? {0}".format(info["has_extra"]) + print("Header Length: {0} bytes".format(info["hdr_len"])) + print("Extra Length: {0}".format((info["extra_len"]))) + print("Extra Header? {0}".format(info["has_extra"])) else: sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n") sys.exit(1) @@ -150,13 +154,13 @@ def parse_header(p, VERBOSE=False): r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump) nbytes = pmt.to_uint64(r) - nitems = nbytes/dsize + nitems = nbytes / dsize info["nitems"] = nitems info["nbytes"] = nbytes if(VERBOSE): - print "Size of Data: {0} bytes".format(nbytes) - print " {0} items".format(nitems) + print("Size of Data: {0} bytes".format(nbytes)) + print(" {0} items".format(nitems)) else: sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n") sys.exit(1) @@ -171,12 +175,12 @@ def parse_extra_dict(p, info, VERBOSE=False): items = pmt.dict_items(p) nitems = pmt.length(items) - for i in xrange(nitems): + for i in range(nitems): item = pmt.nth(i, items) key = pmt.symbol_to_string(pmt.car(item)) val = pmt.cdr(item) info[key] = val if(VERBOSE): - print "{0}: {1}".format(key, val) + print("{0}: {1}".format(key, val)) return info diff --git a/gr-blocks/python/blocks/qa_add_mult_div_sub.py b/gr-blocks/python/blocks/qa_add_mult_div_sub.py index 8699b3a085..f90609f9e0 100755..100644 --- a/gr-blocks/python/blocks/qa_add_mult_div_sub.py +++ b/gr-blocks/python/blocks/qa_add_mult_div_sub.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_add_mult_div_sub(gr_unittest.TestCase): @@ -31,7 +32,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): self.tb = None def help_ii(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_i() @@ -41,7 +42,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_ss(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_s(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_s() @@ -51,7 +52,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_ff(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_f(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_f() @@ -61,7 +62,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_cc(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_c(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_c() diff --git a/gr-blocks/python/blocks/qa_add_mult_v.py b/gr-blocks/python/blocks/qa_add_mult_v.py index 721ee4eca6..eaa33755b7 100755..100644 --- a/gr-blocks/python/blocks/qa_add_mult_v.py +++ b/gr-blocks/python/blocks/qa_add_mult_v.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_add_mult_v(gr_unittest.TestCase): @@ -31,12 +32,13 @@ class test_add_mult_v(gr_unittest.TestCase): self.tb = None def help_ss(self, size, src_data, exp_data, op): - for s in zip(range (len (src_data)), src_data): + for s in zip(list(range(len (src_data))), src_data): src = blocks.vector_source_s(s[1]) - srcv = blocks.stream_to_vector(gr.sizeof_short, size) - self.tb.connect(src, srcv) + srcv = blocks.stream_to_vector(gr.sizeof_short, size) + self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = blocks.vector_to_stream(gr.sizeof_short, size) + + rhs = blocks.vector_to_stream(gr.sizeof_short, size) dst = blocks.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() @@ -44,12 +46,13 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_ii(self, size, src_data, exp_data, op): - for s in zip(range (len (src_data)), src_data): + for s in zip(list(range(len (src_data))), src_data): src = blocks.vector_source_i(s[1]) - srcv = blocks.stream_to_vector(gr.sizeof_int, size) - self.tb.connect(src, srcv) + srcv = blocks.stream_to_vector(gr.sizeof_int, size) + self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = blocks.vector_to_stream(gr.sizeof_int, size) + + rhs = blocks.vector_to_stream(gr.sizeof_int, size) dst = blocks.vector_sink_i() self.tb.connect(op, rhs, dst) self.tb.run() @@ -57,12 +60,13 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_ff(self, size, src_data, exp_data, op): - for s in zip(range (len (src_data)), src_data): + for s in zip(list(range(len (src_data))), src_data): src = blocks.vector_source_f(s[1]) - srcv = blocks.stream_to_vector(gr.sizeof_float, size) - self.tb.connect(src, srcv) + srcv = blocks.stream_to_vector(gr.sizeof_float, size) + self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = blocks.vector_to_stream(gr.sizeof_float, size) + + rhs = blocks.vector_to_stream(gr.sizeof_float, size) dst = blocks.vector_sink_f() self.tb.connect(op, rhs, dst) self.tb.run() @@ -70,12 +74,13 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_cc(self, size, src_data, exp_data, op): - for s in zip(range (len (src_data)), src_data): + for s in zip(list(range(len (src_data))), src_data): src = blocks.vector_source_c(s[1]) - srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size) - self.tb.connect(src, srcv) + srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size) + self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) - rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size) + + rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size) dst = blocks.vector_sink_c() self.tb.connect(op, rhs, dst) self.tb.run() @@ -83,9 +88,9 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_const_ss(self, src_data, exp_data, op): - src = blocks.vector_source_s(src_data) - srcv = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) - rhs = blocks.vector_to_stream(gr.sizeof_short, len(src_data)) + src = blocks.vector_source_s(src_data) + srcv = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_short, len(src_data)) dst = blocks.vector_sink_s() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -93,9 +98,9 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_const_ii(self, src_data, exp_data, op): - src = blocks.vector_source_i(src_data) - srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data)) - rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data)) + src = blocks.vector_source_i(src_data) + srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data)) dst = blocks.vector_sink_i() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -103,9 +108,9 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_const_ff(self, src_data, exp_data, op): - src = blocks.vector_source_f(src_data) - srcv = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) - rhs = blocks.vector_to_stream(gr.sizeof_float, len(src_data)) + src = blocks.vector_source_f(src_data) + srcv = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_float, len(src_data)) dst = blocks.vector_sink_f() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -113,9 +118,9 @@ class test_add_mult_v(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_const_cc(self, src_data, exp_data, op): - src = blocks.vector_source_c(src_data) - srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, len(src_data)) - rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, len(src_data)) + src = blocks.vector_source_c(src_data) + srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, len(src_data)) + rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, len(src_data)) dst = blocks.vector_sink_c() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() @@ -125,234 +130,234 @@ class test_add_mult_v(gr_unittest.TestCase): # add_vXX def test_add_vss_one(self): - src1_data = (1,) - src2_data = (2,) - src3_data = (3,) - expected_result = (6,) - op = blocks.add_ss(1) - self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1,) + src2_data = (2,) + src3_data = (3,) + expected_result = (6,) + op = blocks.add_ss(1) + self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vss_five(self): - src1_data = (1, 2, 3, 4, 5) - src2_data = (6, 7, 8, 9, 10) - src3_data = (11, 12, 13, 14, 15) - expected_result = (18, 21, 24, 27, 30) - op = blocks.add_ss(5) - self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1, 2, 3, 4, 5) + src2_data = (6, 7, 8, 9, 10) + src3_data = (11, 12, 13, 14, 15) + expected_result = (18, 21, 24, 27, 30) + op = blocks.add_ss(5) + self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vii_one(self): - src1_data = (1,) - src2_data = (2,) - src3_data = (3,) - expected_result = (6,) - op = blocks.add_ii(1) - self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1,) + src2_data = (2,) + src3_data = (3,) + expected_result = (6,) + op = blocks.add_ii(1) + self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vii_five(self): - src1_data = (1, 2, 3, 4, 5) - src2_data = (6, 7, 8, 9, 10) - src3_data = (11, 12, 13, 14, 15) - expected_result = (18, 21, 24, 27, 30) - op = blocks.add_ii(5) - self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1, 2, 3, 4, 5) + src2_data = (6, 7, 8, 9, 10) + src3_data = (11, 12, 13, 14, 15) + expected_result = (18, 21, 24, 27, 30) + op = blocks.add_ii(5) + self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vff_one(self): - src1_data = (1.0,) - src2_data = (2.0,) - src3_data = (3.0,) - expected_result = (6.0,) - op = blocks.add_ff(1) - self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0,) + src2_data = (2.0,) + src3_data = (3.0,) + expected_result = (6.0,) + op = blocks.add_ff(1) + self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vff_five(self): - src1_data = (1.0, 2.0, 3.0, 4.0, 5.0) - src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) - src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) - expected_result = (18.0, 21.0, 24.0, 27.0, 30.0) - op = blocks.add_ff(5) - self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0, 2.0, 3.0, 4.0, 5.0) + src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) + src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) + expected_result = (18.0, 21.0, 24.0, 27.0, 30.0) + op = blocks.add_ff(5) + self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vcc_one(self): - src1_data = (1.0+2.0j,) - src2_data = (3.0+4.0j,) - src3_data = (5.0+6.0j,) - expected_result = (9.0+12j,) - op = blocks.add_cc(1) - self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0+2.0j,) + src2_data = (3.0+4.0j,) + src3_data = (5.0+6.0j,) + expected_result = (9.0+12j,) + op = blocks.add_cc(1) + self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) def test_add_vcc_five(self): - src1_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) - src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) - expected_result = (33.0+36.0j, 39.0+42.0j, 45.0+48.0j, 51.0+54.0j, 57.0+60.0j) - op = blocks.add_cc(5) - self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) + src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) + src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) + expected_result = (33.0+36.0j, 39.0+42.0j, 45.0+48.0j, 51.0+54.0j, 57.0+60.0j) + op = blocks.add_cc(5) + self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) # add_const_vXX def test_add_const_vss_one(self): - src_data = (1,) - op = blocks.add_const_vss((2,)) - exp_data = (3,) - self.help_const_ss(src_data, exp_data, op) + src_data = (1,) + op = blocks.add_const_vss((2,)) + exp_data = (3,) + self.help_const_ss(src_data, exp_data, op) def test_add_const_vss_five(self): - src_data = (1, 2, 3, 4, 5) - op = blocks.add_const_vss((6, 7, 8, 9, 10)) - exp_data = (7, 9, 11, 13, 15) - self.help_const_ss(src_data, exp_data, op) + src_data = (1, 2, 3, 4, 5) + op = blocks.add_const_vss((6, 7, 8, 9, 10)) + exp_data = (7, 9, 11, 13, 15) + self.help_const_ss(src_data, exp_data, op) def test_add_const_vii_one(self): - src_data = (1,) - op = blocks.add_const_vii((2,)) - exp_data = (3,) - self.help_const_ii(src_data, exp_data, op) + src_data = (1,) + op = blocks.add_const_vii((2,)) + exp_data = (3,) + self.help_const_ii(src_data, exp_data, op) def test_add_const_vii_five(self): - src_data = (1, 2, 3, 4, 5) - op = blocks.add_const_vii((6, 7, 8, 9, 10)) - exp_data = (7, 9, 11, 13, 15) - self.help_const_ii(src_data, exp_data, op) + src_data = (1, 2, 3, 4, 5) + op = blocks.add_const_vii((6, 7, 8, 9, 10)) + exp_data = (7, 9, 11, 13, 15) + self.help_const_ii(src_data, exp_data, op) def test_add_const_vff_one(self): - src_data = (1.0,) - op = blocks.add_const_vff((2.0,)) - exp_data = (3.0,) - self.help_const_ff(src_data, exp_data, op) + src_data = (1.0,) + op = blocks.add_const_vff((2.0,)) + exp_data = (3.0,) + self.help_const_ff(src_data, exp_data, op) def test_add_const_vff_five(self): - src_data = (1.0, 2.0, 3.0, 4.0, 5.0) - op = blocks.add_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) - exp_data = (7.0, 9.0, 11.0, 13.0, 15.0) - self.help_const_ff(src_data, exp_data, op) + src_data = (1.0, 2.0, 3.0, 4.0, 5.0) + op = blocks.add_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) + exp_data = (7.0, 9.0, 11.0, 13.0, 15.0) + self.help_const_ff(src_data, exp_data, op) def test_add_const_vcc_one(self): - src_data = (1.0+2.0j,) - op = blocks.add_const_vcc((2.0+3.0j,)) - exp_data = (3.0+5.0j,) - self.help_const_cc(src_data, exp_data, op) + src_data = (1.0+2.0j,) + op = blocks.add_const_vcc((2.0+3.0j,)) + exp_data = (3.0+5.0j,) + self.help_const_cc(src_data, exp_data, op) def test_add_const_vcc_five(self): - src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - op = blocks.add_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) - exp_data = (12.0+14.0j, 16.0+18.0j, 20.0+22.0j, 24.0+26.0j, 28.0+30.0j) - self.help_const_cc(src_data, exp_data, op) + src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) + op = blocks.add_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) + exp_data = (12.0+14.0j, 16.0+18.0j, 20.0+22.0j, 24.0+26.0j, 28.0+30.0j) + self.help_const_cc(src_data, exp_data, op) # multiply_vXX def test_multiply_vss_one(self): - src1_data = (1,) - src2_data = (2,) - src3_data = (3,) - expected_result = (6,) - op = blocks.multiply_ss(1) - self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1,) + src2_data = (2,) + src3_data = (3,) + expected_result = (6,) + op = blocks.multiply_ss(1) + self.help_ss(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vss_five(self): - src1_data = (1, 2, 3, 4, 5) - src2_data = (6, 7, 8, 9, 10) - src3_data = (11, 12, 13, 14, 15) - expected_result = (66, 168, 312, 504, 750) - op = blocks.multiply_ss(5) - self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1, 2, 3, 4, 5) + src2_data = (6, 7, 8, 9, 10) + src3_data = (11, 12, 13, 14, 15) + expected_result = (66, 168, 312, 504, 750) + op = blocks.multiply_ss(5) + self.help_ss(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vii_one(self): - src1_data = (1,) - src2_data = (2,) - src3_data = (3,) - expected_result = (6,) - op = blocks.multiply_ii(1) - self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1,) + src2_data = (2,) + src3_data = (3,) + expected_result = (6,) + op = blocks.multiply_ii(1) + self.help_ii(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vii_five(self): - src1_data = (1, 2, 3, 4, 5) - src2_data = (6, 7, 8, 9, 10) - src3_data = (11, 12, 13, 14, 15) - expected_result = (66, 168, 312, 504, 750) - op = blocks.multiply_ii(5) - self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1, 2, 3, 4, 5) + src2_data = (6, 7, 8, 9, 10) + src3_data = (11, 12, 13, 14, 15) + expected_result = (66, 168, 312, 504, 750) + op = blocks.multiply_ii(5) + self.help_ii(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vff_one(self): - src1_data = (1.0,) - src2_data = (2.0,) - src3_data = (3.0,) - expected_result = (6.0,) - op = blocks.multiply_ff(1) - self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0,) + src2_data = (2.0,) + src3_data = (3.0,) + expected_result = (6.0,) + op = blocks.multiply_ff(1) + self.help_ff(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vff_five(self): - src1_data = (1.0, 2.0, 3.0, 4.0, 5.0) - src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) - src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) - expected_result = (66.0, 168.0, 312.0, 504.0, 750.0) - op = blocks.multiply_ff(5) - self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0, 2.0, 3.0, 4.0, 5.0) + src2_data = (6.0, 7.0, 8.0, 9.0, 10.0) + src3_data = (11.0, 12.0, 13.0, 14.0, 15.0) + expected_result = (66.0, 168.0, 312.0, 504.0, 750.0) + op = blocks.multiply_ff(5) + self.help_ff(5, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vcc_one(self): - src1_data = (1.0+2.0j,) - src2_data = (3.0+4.0j,) - src3_data = (5.0+6.0j,) - expected_result = (-85+20j,) - op = blocks.multiply_cc(1) - self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0+2.0j,) + src2_data = (3.0+4.0j,) + src3_data = (5.0+6.0j,) + expected_result = (-85+20j,) + op = blocks.multiply_cc(1) + self.help_cc(1, (src1_data, src2_data, src3_data), expected_result, op) def test_multiply_vcc_five(self): - src1_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) - src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) - expected_result = (-1021.0+428.0j, -2647.0+1754.0j, -4945.0+3704.0j, -8011.0+6374.0j, -11941.0+9860.0j) - op = blocks.multiply_cc(5) - self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) + src1_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) + src2_data = (11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j) + src3_data = (21.0+22.0j, 23.0+24.0j, 25.0+26.0j, 27.0+28.0j, 29.0+30.0j) + expected_result = (-1021.0+428.0j, -2647.0+1754.0j, -4945.0+3704.0j, -8011.0+6374.0j, -11941.0+9860.0j) + op = blocks.multiply_cc(5) + self.help_cc(5, (src1_data, src2_data, src3_data), expected_result, op) # multiply_const_vXX def test_multiply_const_vss_one(self): - src_data = (2,) - op = blocks.multiply_const_vss((3,)) - exp_data = (6,) - self.help_const_ss(src_data, exp_data, op) + src_data = (2,) + op = blocks.multiply_const_vss((3,)) + exp_data = (6,) + self.help_const_ss(src_data, exp_data, op) def test_multiply_const_vss_five(self): - src_data = (1, 2, 3, 4, 5) - op = blocks.multiply_const_vss((6, 7, 8, 9, 10)) - exp_data = (6, 14, 24, 36, 50) - self.help_const_ss(src_data, exp_data, op) + src_data = (1, 2, 3, 4, 5) + op = blocks.multiply_const_vss((6, 7, 8, 9, 10)) + exp_data = (6, 14, 24, 36, 50) + self.help_const_ss(src_data, exp_data, op) def test_multiply_const_vii_one(self): - src_data = (2,) - op = blocks.multiply_const_vii((3,)) - exp_data = (6,) - self.help_const_ii(src_data, exp_data, op) + src_data = (2,) + op = blocks.multiply_const_vii((3,)) + exp_data = (6,) + self.help_const_ii(src_data, exp_data, op) def test_multiply_const_vii_five(self): - src_data = (1, 2, 3, 4, 5) - op = blocks.multiply_const_vii((6, 7, 8, 9, 10)) - exp_data = (6, 14, 24, 36, 50) - self.help_const_ii(src_data, exp_data, op) + src_data = (1, 2, 3, 4, 5) + op = blocks.multiply_const_vii((6, 7, 8, 9, 10)) + exp_data = (6, 14, 24, 36, 50) + self.help_const_ii(src_data, exp_data, op) def test_multiply_const_vff_one(self): - src_data = (2.0,) - op = blocks.multiply_const_vff((3.0,)) - exp_data = (6.0,) - self.help_const_ff(src_data, exp_data, op) + src_data = (2.0,) + op = blocks.multiply_const_vff((3.0,)) + exp_data = (6.0,) + self.help_const_ff(src_data, exp_data, op) def test_multiply_const_vff_five(self): - src_data = (1.0, 2.0, 3.0, 4.0, 5.0) - op = blocks.multiply_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) - exp_data = (6.0, 14.0, 24.0, 36.0, 50.0) - self.help_const_ff(src_data, exp_data, op) + src_data = (1.0, 2.0, 3.0, 4.0, 5.0) + op = blocks.multiply_const_vff((6.0, 7.0, 8.0, 9.0, 10.0)) + exp_data = (6.0, 14.0, 24.0, 36.0, 50.0) + self.help_const_ff(src_data, exp_data, op) def test_multiply_const_vcc_one(self): - src_data = (1.0+2.0j,) - op = blocks.multiply_const_vcc((2.0+3.0j,)) - exp_data = (-4.0+7.0j,) - self.help_const_cc(src_data, exp_data, op) + src_data = (1.0+2.0j,) + op = blocks.multiply_const_vcc((2.0+3.0j,)) + exp_data = (-4.0+7.0j,) + self.help_const_cc(src_data, exp_data, op) def test_multiply_const_vcc_five(self): - src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) - op = blocks.multiply_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) - exp_data = (-13.0+34.0j, -17.0+94.0j, -21.0+170.0j, -25.0+262.0j, -29.0+370.0j) - self.help_const_cc(src_data, exp_data, op) + src_data = (1.0+2.0j, 3.0+4.0j, 5.0+6.0j, 7.0+8.0j, 9.0+10.0j) + op = blocks.multiply_const_vcc((11.0+12.0j, 13.0+14.0j, 15.0+16.0j, 17.0+18.0j, 19.0+20.0j)) + exp_data = (-13.0+34.0j, -17.0+94.0j, -21.0+170.0j, -25.0+262.0j, -29.0+370.0j) + self.help_const_cc(src_data, exp_data, op) if __name__ == '__main__': diff --git a/gr-blocks/python/blocks/qa_affinity.py b/gr-blocks/python/blocks/qa_affinity.py index 98b5c44862..d80e50bc40 100644 --- a/gr-blocks/python/blocks/qa_affinity.py +++ b/gr-blocks/python/blocks/qa_affinity.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_affinity(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_argmax.py b/gr-blocks/python/blocks/qa_argmax.py index fead481c0f..9dea186fea 100644 --- a/gr-blocks/python/blocks/qa_argmax.py +++ b/gr-blocks/python/blocks/qa_argmax.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math diff --git a/gr-blocks/python/blocks/qa_bin_statistics.py b/gr-blocks/python/blocks/qa_bin_statistics.py index 52b8585721..b3a8c3de81 100755..100644 --- a/gr-blocks/python/blocks/qa_bin_statistics.py +++ b/gr-blocks/python/blocks/qa_bin_statistics.py @@ -20,17 +20,19 @@ # Boston, MA 02110-1301, USA. # -from gnuradio import gr, gr_unittest, blocks - -import random -import struct - """ Note: There has been an issue with this block in the past, see Issue #199. This test is being enabled only on the 'next' branch for version v3.7 for now. TWR """ +from __future__ import print_function + +import struct + +from gnuradio import gr, gr_unittest, blocks + + class counter(gr.feval_dd): def __init__(self, step_size=1): gr.feval_dd.__init__(self) @@ -57,8 +59,8 @@ class counter3(gr.feval_dd): t = self.count self.count = self.count + self.step_size self.f(self.count) - except Exception, e: - print "Exception: ", e + except Exception as e: + print("Exception: ", e) return t def foobar3(new_t): @@ -79,8 +81,8 @@ class counter4(gr.feval_dd): t = self.count self.count = self.count + self.step_size self.obj_instance.foobar4(self.count) - except Exception, e: - print "Exception: ", e + except Exception as e: + print("Exception: ", e) return t @@ -89,7 +91,8 @@ class parse_msg(object): self.center_freq = msg.arg1() self.vlen = int(msg.arg2()) assert(msg.length() == self.vlen * gr.sizeof_float) - self.data = struct.unpack('%df' % (self.vlen,), msg.to_string()) + self.data = struct.unpack(b'%df' % self.vlen, msg.to_string()) + class test_bin_statistics(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_block_behavior.py b/gr-blocks/python/blocks/qa_block_behavior.py index a21e423b21..482e88a316 100644 --- a/gr-blocks/python/blocks/qa_block_behavior.py +++ b/gr-blocks/python/blocks/qa_block_behavior.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_block_behavior(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_block_gateway.py b/gr-blocks/python/blocks/qa_block_gateway.py index 6fdb0090ae..23036eec57 100644 --- a/gr-blocks/python/blocks/qa_block_gateway.py +++ b/gr-blocks/python/blocks/qa_block_gateway.py @@ -1,3 +1,5 @@ +from __future__ import division + # # Copyright 2011-2013 Free Software Foundation, Inc. # @@ -126,7 +128,7 @@ class tag_source(gr.sync_block): #put code here to fill the output items... #make a new tag on the middle element every time work is called - count = self.nitems_written(0) + num_output_items/2 + count = self.nitems_written(0) + num_output_items // 2 key = pmt.string_to_symbol("example_key") value = pmt.string_to_symbol("example_value") self.add_item_tag(0, count, key, value) @@ -200,8 +202,8 @@ class vector_to_stream(gr.interp_block): def work(self, input_items, output_items): n = 0 - for i in xrange(len(input_items[0])): - for j in xrange(self.block_size): + for i in range(len(input_items[0])): + for j in range(self.block_size): output_items[0][n] = input_items[0][i][j] n += 1 diff --git a/gr-blocks/python/blocks/qa_boolean_operators.py b/gr-blocks/python/blocks/qa_boolean_operators.py index cbcd5688a1..e364aaaa04 100755..100644 --- a/gr-blocks/python/blocks/qa_boolean_operators.py +++ b/gr-blocks/python/blocks/qa_boolean_operators.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_boolean_operators (gr_unittest.TestCase): @@ -31,7 +32,7 @@ class test_boolean_operators (gr_unittest.TestCase): self.tb = None def help_ss (self, src_data, exp_data, op): - for s in zip (range (len (src_data)), src_data): + for s in zip (list(range(len (src_data))), src_data): src = blocks.vector_source_s (s[1]) self.tb.connect (src, (op, s[0])) dst = blocks.vector_sink_s () @@ -41,7 +42,7 @@ class test_boolean_operators (gr_unittest.TestCase): self.assertEqual (exp_data, result_data) def help_bb (self, src_data, exp_data, op): - for s in zip (range (len (src_data)), src_data): + for s in zip (list(range(len (src_data))), src_data): src = blocks.vector_source_b (s[1]) self.tb.connect (src, (op, s[0])) dst = blocks.vector_sink_b () @@ -51,7 +52,7 @@ class test_boolean_operators (gr_unittest.TestCase): self.assertEqual (exp_data, result_data) def help_ii (self, src_data, exp_data, op): - for s in zip (range (len (src_data)), src_data): + for s in zip (list(range(len (src_data))), src_data): src = blocks.vector_source_i (s[1]) self.tb.connect (src, (op, s[0])) dst = blocks.vector_sink_i () diff --git a/gr-blocks/python/blocks/qa_burst_tagger.py b/gr-blocks/python/blocks/qa_burst_tagger.py index b1a4f942f1..a2b7b402ec 100644 --- a/gr-blocks/python/blocks/qa_burst_tagger.py +++ b/gr-blocks/python/blocks/qa_burst_tagger.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt diff --git a/gr-blocks/python/blocks/qa_conjugate.py b/gr-blocks/python/blocks/qa_conjugate.py index 36172e30a0..d672c453c5 100644 --- a/gr-blocks/python/blocks/qa_conjugate.py +++ b/gr-blocks/python/blocks/qa_conjugate.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_conjugate (gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_copy.py b/gr-blocks/python/blocks/qa_copy.py index 20914b51e3..c832c0ef04 100755..100644 --- a/gr-blocks/python/blocks/qa_copy.py +++ b/gr-blocks/python/blocks/qa_copy.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_copy(gr_unittest.TestCase): @@ -46,7 +47,7 @@ class test_copy(gr_unittest.TestCase): expected_result = () src = blocks.vector_source_b(src_data) op = blocks.copy(gr.sizeof_char) - op.set_enabled(False) + op.set_enabled(False) dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() diff --git a/gr-blocks/python/blocks/qa_cpp_py_binding.py b/gr-blocks/python/blocks/qa_cpp_py_binding.py index 23a5c9b826..f15bfddb29 100644 --- a/gr-blocks/python/blocks/qa_cpp_py_binding.py +++ b/gr-blocks/python/blocks/qa_cpp_py_binding.py @@ -24,6 +24,7 @@ # This program tests mixed python and c++ ctrlport exports in a single app # + import sys, time, random, numpy, re from gnuradio import gr, gr_unittest, blocks @@ -37,7 +38,7 @@ def get1(): def get2(): return "failure" -class inc_class: +class inc_class(object): def __init__(self): self.val = 1 def pp(self): @@ -131,7 +132,7 @@ class test_cpp_py_binding(gr_unittest.TestCase): self.assertComplexTuplesAlmostEqual(val, rval, 5) def test_002(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_c(data) self.p1 = blocks.ctrlport_probe_c("aaa","C++ exported variable") @@ -163,7 +164,7 @@ class test_cpp_py_binding(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::bbb"]) - for name in ret.keys(): + for name in list(ret.keys()): result = ret[name].value self.assertEqual(result, expected_result) diff --git a/gr-blocks/python/blocks/qa_cpp_py_binding_set.py b/gr-blocks/python/blocks/qa_cpp_py_binding_set.py index 5b81de08f9..641f588faf 100644 --- a/gr-blocks/python/blocks/qa_cpp_py_binding_set.py +++ b/gr-blocks/python/blocks/qa_cpp_py_binding_set.py @@ -24,6 +24,7 @@ # This program tests mixed python and c++ GRCP sets in a single app # + import sys, time, random, numpy, re from gnuradio import gr, gr_unittest, blocks @@ -31,7 +32,7 @@ from gnuradio.ctrlport import GNURadio from gnuradio import ctrlport import os -class inc_class: +class inc_class(object): def __init__(self,val): self.val = val; @@ -108,7 +109,7 @@ class test_cpp_py_binding_set(gr_unittest.TestCase): def test_002(self): - data = range(1, 10) + data = list(range(1, 10)) self.src = blocks.vector_source_c(data, True) self.p = blocks.nop(gr.sizeof_gr_complex) diff --git a/gr-blocks/python/blocks/qa_ctrlport_probes.py b/gr-blocks/python/blocks/qa_ctrlport_probes.py index c678846df0..d373bb9fff 100644 --- a/gr-blocks/python/blocks/qa_ctrlport_probes.py +++ b/gr-blocks/python/blocks/qa_ctrlport_probes.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import sys, time, random, numpy from gnuradio import gr, gr_unittest, blocks import os, struct, re @@ -36,7 +37,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): self.tb = None def test_001(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_c(data, True) self.probe = blocks.ctrlport_probe2_c("samples","Complex", @@ -68,7 +69,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::samples"]) - for name in ret.keys(): + for name in list(ret.keys()): # Get data in probe, which might be offset; find the # beginning and unwrap. result = ret[name].value @@ -81,7 +82,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): def test_002(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_f(data, True) self.probe = blocks.ctrlport_probe2_f("samples","Floats", @@ -109,7 +110,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::samples"]) - for name in ret.keys(): + for name in list(ret.keys()): # Get data in probe, which might be offset; find the # beginning and unwrap. result = ret[name].value @@ -121,7 +122,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): self.tb.wait() def test_003(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_i(data, True) self.probe = blocks.ctrlport_probe2_i("samples","Integers", @@ -149,7 +150,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::samples"]) - for name in ret.keys(): + for name in list(ret.keys()): # Get data in probe, which might be offset; find the # beginning and unwrap. result = ret[name].value @@ -162,7 +163,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): def test_004(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_s(data, True) self.probe = blocks.ctrlport_probe2_s("samples","Shorts", @@ -190,7 +191,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::samples"]) - for name in ret.keys(): + for name in list(ret.keys()): # Get data in probe, which might be offset; find the # beginning and unwrap. result = ret[name].value @@ -202,7 +203,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): self.tb.wait() def test_005(self): - data = range(1,9) + data = list(range(1,9)) self.src = blocks.vector_source_b(data, True) self.probe = blocks.ctrlport_probe2_b("samples","Bytes", @@ -230,7 +231,7 @@ class test_ctrlport_probes(gr_unittest.TestCase): # Get all exported knobs ret = radio.getKnobs([probe_name + "::samples"]) - for name in ret.keys(): + for name in list(ret.keys()): # Get data in probe, which might be offset; find the # beginning and unwrap. result = ret[name].value diff --git a/gr-blocks/python/blocks/qa_delay.py b/gr-blocks/python/blocks/qa_delay.py index 09200862bd..2fd3691424 100755..100644 --- a/gr-blocks/python/blocks/qa_delay.py +++ b/gr-blocks/python/blocks/qa_delay.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt diff --git a/gr-blocks/python/blocks/qa_endian_swap.py b/gr-blocks/python/blocks/qa_endian_swap.py index dd6ee349b2..3e1e059608 100644 --- a/gr-blocks/python/blocks/qa_endian_swap.py +++ b/gr-blocks/python/blocks/qa_endian_swap.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import ctypes diff --git a/gr-blocks/python/blocks/qa_file_descriptor_source_sink.py b/gr-blocks/python/blocks/qa_file_descriptor_source_sink.py new file mode 100644 index 0000000000..c84a82d59f --- /dev/null +++ b/gr-blocks/python/blocks/qa_file_descriptor_source_sink.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python +# +# Copyright 2018 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +from gnuradio import gr, gr_unittest, blocks +import os +import tempfile +import pmt + +class test_file_descriptor_source_sink(gr_unittest.TestCase): + + def setUp (self): + os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' + self.tb = gr.top_block () + + def tearDown (self): + self.tb = None + + def test_file_descriptor(self): + src_data = range(1000) + expected_result = range(1000) + + snk2 = blocks.vector_sink_f() + + with tempfile.NamedTemporaryFile() as temp: + fhandle0 = open(temp.name, "wb") + fd0 = fhandle0.fileno() + + src = blocks.vector_source_f(src_data) + snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0) + + self.tb.connect(src, snk) + self.tb.run() + os.fsync(fd0) + fhandle0.close() + + fhandle1 = open(temp.name, "rb") + fd1 = fhandle1.fileno() + src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False) + + self.tb.disconnect(src, snk) + self.tb.connect(src2, snk2) + self.tb.run() + os.fsync(fd1) + fhandle1.close() + + result_data = snk2.data() + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + self.assertEqual(len(snk2.tags()), 0) + +if __name__ == '__main__': + gr_unittest.run(test_file_descriptor_source_sink, "test_file_descriptor_source_sink.xml") diff --git a/gr-blocks/python/blocks/qa_file_metadata.py b/gr-blocks/python/blocks/qa_file_metadata.py index 886207f108..cdc0b94520 100644 --- a/gr-blocks/python/blocks/qa_file_metadata.py +++ b/gr-blocks/python/blocks/qa_file_metadata.py @@ -20,6 +20,9 @@ # Boston, MA 02110-1301, USA. # +from __future__ import absolute_import +from __future__ import division + import os, math from gnuradio import gr, gr_unittest, blocks @@ -28,9 +31,9 @@ import pmt import parse_file_metadata def sig_source_c(samp_rate, freq, amp, N): - t = map(lambda x: float(x)/samp_rate, xrange(N)) - y = map(lambda x: amp*math.cos(2.*math.pi*freq*x) + \ - 1j*amp*math.sin(2.*math.pi*freq*x), t) + t = [float(x) / samp_rate for x in range(N)] + y = [amp*math.cos(2.*math.pi*freq*x) + \ + 1j*amp*math.sin(2.*math.pi*freq*x) for x in t] return y class test_file_metadata(gr_unittest.TestCase): @@ -44,7 +47,7 @@ class test_file_metadata(gr_unittest.TestCase): def test_001(self): N = 1000 - outfile = "test_out.dat" + outfile = "test_out.dat" detached = False samp_rate = 200000 @@ -52,18 +55,17 @@ class test_file_metadata(gr_unittest.TestCase): val = pmt.from_double(samp_rate) extras = pmt.make_dict() extras = pmt.dict_add(extras, key, val) - extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) src = blocks.vector_source_c(data) fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile, samp_rate, 1, blocks.GR_FILE_FLOAT, True, - 1000000, extras_str, detached) + 1000000, extras, detached) fsnk.set_unbuffered(True) - self.tb.connect(src, fsnk) - self.tb.run() + self.tb.connect(src, fsnk) + self.tb.run() fsnk.close() handle = open(outfile, "rb") @@ -119,12 +121,12 @@ class test_file_metadata(gr_unittest.TestCase): # Test that the data portion was extracted and received correctly. self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5) - os.remove(outfile) + os.remove(outfile) def test_002(self): N = 1000 - outfile = "test_out.dat" - outfile_hdr = "test_out.dat.hdr" + outfile = "test_out.dat" + outfile_hdr = "test_out.dat.hdr" detached = True samp_rate = 200000 @@ -132,18 +134,17 @@ class test_file_metadata(gr_unittest.TestCase): val = pmt.from_double(samp_rate) extras = pmt.make_dict() extras = pmt.dict_add(extras, key, val) - extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) src = blocks.vector_source_c(data) fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile, samp_rate, 1, blocks.GR_FILE_FLOAT, True, - 1000000, extras_str, detached) + 1000000, extras, detached) fsnk.set_unbuffered(True) - self.tb.connect(src, fsnk) - self.tb.run() + self.tb.connect(src, fsnk) + self.tb.run() fsnk.close() # Open detached header for reading @@ -201,8 +202,8 @@ class test_file_metadata(gr_unittest.TestCase): # Test that the data portion was extracted and received correctly. self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5) - os.remove(outfile) - os.remove(outfile_hdr) + os.remove(outfile) + os.remove(outfile_hdr) if __name__ == '__main__': gr_unittest.run(test_file_metadata, "test_file_metadata.xml") diff --git a/gr-blocks/python/blocks/qa_file_sink.py b/gr-blocks/python/blocks/qa_file_sink.py new file mode 100644 index 0000000000..36d24bb74b --- /dev/null +++ b/gr-blocks/python/blocks/qa_file_sink.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# +# Copyright 2018 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +import os +import tempfile +import array +from gnuradio import gr, gr_unittest, blocks + +class test_file_sink(gr_unittest.TestCase): + + def setUp (self): + os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' + self.tb = gr.top_block () + + def tearDown (self): + self.tb = None + + def test_file_sink(self): + data = range(1000) + expected_result = data + + with tempfile.NamedTemporaryFile() as temp: + src = blocks.vector_source_f(data) + snk = blocks.file_sink(gr.sizeof_float, temp.name) + snk.set_unbuffered(True) + self.tb.connect(src, snk) + self.tb.run() + + # Check file length (float: 4 * nsamples) + file_size = os.stat(temp.name).st_size + self.assertEqual(file_size, 4 * len(data)) + + # Check file contents + datafile = open(temp.name, 'rb') + result_data = array.array('f') + result_data.fromfile(datafile, len(data)) + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + +if __name__ == '__main__': + gr_unittest.run(test_file_sink, "test_file_sink.xml") diff --git a/gr-blocks/python/blocks/qa_file_source.py b/gr-blocks/python/blocks/qa_file_source.py new file mode 100644 index 0000000000..3829386e30 --- /dev/null +++ b/gr-blocks/python/blocks/qa_file_source.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python +# +# Copyright 2018 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +import os +import tempfile +import array +import pmt +from gnuradio import gr, gr_unittest, blocks + +class test_file_source(gr_unittest.TestCase): + + @classmethod + def setUpClass(cls): + os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' + cls._datafile = tempfile.NamedTemporaryFile() + cls._datafilename = cls._datafile.name + cls._vector = [x for x in range(1000)] + with open(cls._datafilename, 'wb') as f: + array.array('f', cls._vector).tofile(f) + + @classmethod + def tearDownClass(cls): + del cls._vector + del cls._datafilename + del cls._datafile + + def setUp (self): + self.tb = gr.top_block() + + def tearDown (self): + self.tb = None + + def test_file_source(self): + src = blocks.file_source(gr.sizeof_float, self._datafilename) + snk = blocks.vector_sink_f() + self.tb.connect(src, snk) + self.tb.run() + + result_data = snk.data() + self.assertFloatTuplesAlmostEqual(self._vector, result_data) + self.assertEqual(len(snk.tags()), 0) + + def test_file_source_no_such_file(self): + """ + Try to open a non-existant file and verify exception is thrown. + """ + try: + _ = blocks.file_source(gr.sizeof_float, "___no_such_file___") + self.assertTrue(False) + except RuntimeError: + self.assertTrue(True) + + def test_file_source_with_offset(self): + expected_result = self._vector[100:] + + src = blocks.file_source(gr.sizeof_float, self._datafilename, offset=100) + snk = blocks.vector_sink_f() + + self.tb.connect(src, snk) + self.tb.run() + + result_data = snk.data() + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + self.assertEqual(len(snk.tags()), 0) + + def test_source_with_offset_and_len(self): + expected_result = self._vector[100:100+600] + + src = blocks.file_source(gr.sizeof_float, self._datafilename, offset=100, len=600) + snk = blocks.vector_sink_f() + self.tb.connect(src, snk) + self.tb.run() + + result_data = snk.data() + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + self.assertEqual(len(snk.tags()), 0) + + def test_file_source_can_seek_after_open(self): + + src = blocks.file_source(gr.sizeof_float, self._datafilename) + self.assertTrue(src.seek(0, os.SEEK_SET)) + self.assertTrue(src.seek(len(self._vector)-1, os.SEEK_SET)) + # Seek past end of file - this will also log a warning + self.assertFalse(src.seek(len(self._vector), os.SEEK_SET)) + # Negative seek - this will also log a warning + self.assertFalse(src.seek(-1, os.SEEK_SET)) + + self.assertTrue(src.seek(1, os.SEEK_END)) + self.assertTrue(src.seek(len(self._vector), os.SEEK_END)) + # Seek past end of file - this will also log a warning + self.assertFalse(src.seek(0, os.SEEK_END)) + + self.assertTrue(src.seek(0, os.SEEK_SET)) + self.assertTrue(src.seek(1, os.SEEK_CUR)) + # Seek past end of file - this will also log a warning + self.assertFalse(src.seek(len(self._vector), os.SEEK_CUR)) + + + def test_begin_tag(self): + expected_result = self._vector + + src = blocks.file_source(gr.sizeof_float, self._datafilename) + src.set_begin_tag(pmt.string_to_symbol("file_begin")) + snk = blocks.vector_sink_f() + self.tb.connect(src, snk) + self.tb.run() + + result_data = snk.data() + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + self.assertEqual(len(snk.tags()), 1) + + def test_begin_tag_repeat(self): + expected_result = self._vector + self._vector + + src = blocks.file_source(gr.sizeof_float, self._datafilename, True) + src.set_begin_tag(pmt.string_to_symbol("file_begin")) + head = blocks.head(gr.sizeof_float, 2 * len(self._vector)) + snk = blocks.vector_sink_f() + self.tb.connect(src, head, snk) + self.tb.run() + + result_data = snk.data() + self.assertFloatTuplesAlmostEqual(expected_result, result_data) + tags = snk.tags() + self.assertEqual(len(tags), 2) + self.assertEqual(str(tags[0].key), "file_begin") + self.assertEqual(str(tags[0].value), "0") + self.assertEqual(tags[0].offset, 0) + self.assertEqual(str(tags[1].key), "file_begin") + self.assertEqual(str(tags[1].value), "1") + self.assertEqual(tags[1].offset, 1000) + +if __name__ == '__main__': + gr_unittest.run(test_file_source, "test_file_source.xml") diff --git a/gr-blocks/python/blocks/qa_file_source_sink.py b/gr-blocks/python/blocks/qa_file_source_sink.py deleted file mode 100644 index 32910cb4bc..0000000000 --- a/gr-blocks/python/blocks/qa_file_source_sink.py +++ /dev/null @@ -1,168 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2013 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -from gnuradio import gr, gr_unittest, blocks -import os -import tempfile -import pmt - -class test_file_source_sink(gr_unittest.TestCase): - - def setUp (self): - os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' - self.tb = gr.top_block () - - def tearDown (self): - self.tb = None - - def test_001(self): - src_data = range(1000) - expected_result = range(1000) - - snk2 = blocks.vector_sink_f() - - with tempfile.NamedTemporaryFile() as temp: - src = blocks.vector_source_f(src_data) - snk = blocks.file_sink(gr.sizeof_float, temp.name) - snk.set_unbuffered(True) - - src2 = blocks.file_source(gr.sizeof_float, temp.name) - - self.tb.connect(src, snk) - self.tb.run() - - self.tb.disconnect(src, snk) - self.tb.connect(src2, snk2) - self.tb.run() - - result_data = snk2.data() - self.assertFloatTuplesAlmostEqual(expected_result, result_data) - self.assertEqual(len(snk2.tags()), 0) - - def test_descriptor_001(self): - src_data = range(1000) - expected_result = range(1000) - - snk2 = blocks.vector_sink_f() - - with tempfile.NamedTemporaryFile() as temp: - fhandle0 = open(temp.name, "wb") - fd0 = fhandle0.fileno() - - src = blocks.vector_source_f(src_data) - snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0) - - self.tb.connect(src, snk) - self.tb.run() - os.fsync(fd0) - fhandle0.close() - - fhandle1 = open(temp.name, "rb") - fd1 = fhandle1.fileno() - src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False) - - self.tb.disconnect(src, snk) - self.tb.connect(src2, snk2) - self.tb.run() - os.fsync(fd1) - fhandle1.close() - - result_data = snk2.data() - self.assertFloatTuplesAlmostEqual(expected_result, result_data) - self.assertEqual(len(snk2.tags()), 0) - - def test_file_source_can_seek_after_open(self): - src_data = range(1000) - - with tempfile.NamedTemporaryFile() as temp: - src = blocks.vector_source_f(src_data) - snk = blocks.file_sink(gr.sizeof_float, temp.name) - snk.set_unbuffered(True) - - self.tb.connect(src, snk) - self.tb.run() - - source = blocks.file_source(gr.sizeof_float, temp.name) - self.assertTrue(source.seek(0, os.SEEK_SET)) - - def test_begin_tag(self): - src_data = range(1000) - expected_result = range(1000) - - snk2 = blocks.vector_sink_f() - - with tempfile.NamedTemporaryFile() as temp: - src = blocks.vector_source_f(src_data) - snk = blocks.file_sink(gr.sizeof_float, temp.name) - snk.set_unbuffered(True) - - src2 = blocks.file_source(gr.sizeof_float, temp.name) - src2.set_begin_tag(pmt.string_to_symbol("file_begin")) - - self.tb.connect(src, snk) - self.tb.run() - - self.tb.disconnect(src, snk) - self.tb.connect(src2, snk2) - self.tb.run() - - result_data = snk2.data() - self.assertFloatTuplesAlmostEqual(expected_result, result_data) - self.assertEqual(len(snk2.tags()), 1) - - def test_begin_tag_repeat(self): - src_data = range(1000) - expected_result = range(1000) - expected_result.extend(range(1000)) - - snk2 = blocks.vector_sink_f() - - with tempfile.NamedTemporaryFile() as temp: - src = blocks.vector_source_f(src_data) - snk = blocks.file_sink(gr.sizeof_float, temp.name) - snk.set_unbuffered(True) - - src2 = blocks.file_source(gr.sizeof_float, temp.name, True) - src2.set_begin_tag(pmt.string_to_symbol("file_begin")) - hd = blocks.head(gr.sizeof_float, 2000) - - self.tb.connect(src, snk) - self.tb.run() - - self.tb.disconnect(src, snk) - self.tb.connect(src2, hd, snk2) - self.tb.run() - - result_data = snk2.data() - self.assertFloatTuplesAlmostEqual(expected_result, result_data) - tags = snk2.tags() - self.assertEqual(len(tags), 2) - self.assertEqual(str(tags[0].key), "file_begin") - self.assertEqual(str(tags[0].value), "0") - self.assertEqual(tags[0].offset, 0) - self.assertEqual(str(tags[1].key), "file_begin") - self.assertEqual(str(tags[1].value), "1") - self.assertEqual(tags[1].offset, 1000) - -if __name__ == '__main__': - gr_unittest.run(test_file_source_sink, "test_file_source_sink.xml") - diff --git a/gr-blocks/python/blocks/qa_head.py b/gr-blocks/python/blocks/qa_head.py index 9b5bca221b..b6167f9379 100755..100644 --- a/gr-blocks/python/blocks/qa_head.py +++ b/gr-blocks/python/blocks/qa_head.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_head(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_hier_block2.py b/gr-blocks/python/blocks/qa_hier_block2.py index 3e780806bc..74533ad84b 100755..100644 --- a/gr-blocks/python/blocks/qa_hier_block2.py +++ b/gr-blocks/python/blocks/qa_hier_block2.py @@ -1,10 +1,13 @@ #!/usr/bin/env python -from gnuradio import gr, gr_unittest, blocks -import numpy import threading import time +import numpy + +from gnuradio import gr, gr_unittest, blocks + + class add_ff(gr.sync_block): def __init__(self): gr.sync_block.__init__( @@ -29,88 +32,88 @@ class multiply_const_ff(gr.sync_block): self.k = k def work(self, input_items, output_items): - output_items[0][:] = map(lambda x: self.k*x, input_items[0]) + output_items[0][:] = [self.k*x for x in input_items[0]] return len(output_items[0]) class test_hier_block2(gr_unittest.TestCase): def setUp(self): - pass + pass def tearDown(self): - pass + pass def test_001_make(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - self.assertEqual("test_block", hblock.name()) - self.assertEqual(1, hblock.input_signature().max_streams()) - self.assertEqual(1, hblock.output_signature().min_streams()) - self.assertEqual(1, hblock.output_signature().max_streams()) - self.assertEqual(gr.sizeof_int, hblock.output_signature().sizeof_stream_item(0)) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + self.assertEqual("test_block", hblock.name()) + self.assertEqual(1, hblock.input_signature().max_streams()) + self.assertEqual(1, hblock.output_signature().min_streams()) + self.assertEqual(1, hblock.output_signature().max_streams()) + self.assertEqual(gr.sizeof_int, hblock.output_signature().sizeof_stream_item(0)) def test_002_connect_input(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) def test_004_connect_output(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(nop1, hblock) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) def test_005_connect_output_in_use(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - nop2 = blocks.nop(gr.sizeof_int) - hblock.connect(nop1, hblock) - self.assertRaises(ValueError, - lambda: hblock.connect(nop2, hblock)) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + self.assertRaises(RuntimeError, + lambda: hblock.connect(nop2, hblock)) def test_006_connect_invalid_src_port_neg(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - self.assertRaises(ValueError, - lambda: hblock.connect((hblock, -1), nop1)) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + self.assertRaises(RuntimeError, + lambda: hblock.connect((hblock, -1), nop1)) def test_005_connect_invalid_src_port_exceeds(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - self.assertRaises(ValueError, - lambda: hblock.connect((hblock, 1), nop1)) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + self.assertRaises(RuntimeError, + lambda: hblock.connect((hblock, 1), nop1)) def test_007_connect_invalid_dst_port_neg(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - nop2 = blocks.nop(gr.sizeof_int) - self.assertRaises(ValueError, - lambda: hblock.connect(nop1, (nop2, -1))) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + self.assertRaises(RuntimeError, + lambda: hblock.connect(nop1, (nop2, -1))) def test_008_connect_invalid_dst_port_exceeds(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.null_sink(gr.sizeof_int) - nop2 = blocks.null_sink(gr.sizeof_int) - self.assertRaises(ValueError, - lambda: hblock.connect(nop1, (nop2, 1))) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.null_sink(gr.sizeof_int) + nop2 = blocks.null_sink(gr.sizeof_int) + self.assertRaises(RuntimeError, + lambda: hblock.connect(nop1, (nop2, 1))) def test_009_check_topology(self): - hblock = gr.top_block("test_block") - hblock.check_topology(0, 0) + hblock = gr.top_block("test_block") + hblock.check_topology(0, 0) def test_010_run(self): expected = (1.0, 2.0, 3.0, 4.0) @@ -123,89 +126,89 @@ class test_hier_block2(gr_unittest.TestCase): hblock.run() actual1 = sink1.data() actual2 = sink2.data() - self.assertEquals(expected, actual1) - self.assertEquals(expected, actual2) + self.assertEqual(expected, actual1) + self.assertEqual(expected, actual2) def test_012_disconnect_input(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) hblock.disconnect(hblock, nop1) def test_013_disconnect_input_not_connected(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) nop2 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) - self.assertRaises(ValueError, + hblock.connect(hblock, nop1) + self.assertRaises(RuntimeError, lambda: hblock.disconnect(hblock, nop2)) def test_014_disconnect_input_neg(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) - self.assertRaises(ValueError, + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(RuntimeError, lambda: hblock.disconnect((hblock, -1), nop1)) def test_015_disconnect_input_exceeds(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) - self.assertRaises(ValueError, + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(RuntimeError, lambda: hblock.disconnect((hblock, 1), nop1)) def test_016_disconnect_output(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(nop1, hblock) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) hblock.disconnect(nop1, hblock) def test_017_disconnect_output_not_connected(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) nop2 = blocks.nop(gr.sizeof_int) - hblock.connect(nop1, hblock) - self.assertRaises(ValueError, + hblock.connect(nop1, hblock) + self.assertRaises(RuntimeError, lambda: hblock.disconnect(nop2, hblock)) def test_018_disconnect_output_neg(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(hblock, nop1) - self.assertRaises(ValueError, + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(RuntimeError, lambda: hblock.disconnect(nop1, (hblock, -1))) def test_019_disconnect_output_exceeds(self): - hblock = gr.hier_block2("test_block", - gr.io_signature(1,1,gr.sizeof_int), - gr.io_signature(1,1,gr.sizeof_int)) - nop1 = blocks.nop(gr.sizeof_int) - hblock.connect(nop1, hblock) - self.assertRaises(ValueError, + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + self.assertRaises(RuntimeError, lambda: hblock.disconnect(nop1, (hblock, 1))) def test_020_run(self): - hblock = gr.top_block("test_block") - data = (1.0, 2.0, 3.0, 4.0) - src = blocks.vector_source_f(data, False) - dst = blocks.vector_sink_f() - hblock.connect(src, dst) - hblock.run() - self.assertEquals(data, dst.data()) + hblock = gr.top_block("test_block") + data = (1.0, 2.0, 3.0, 4.0) + src = blocks.vector_source_f(data, False) + dst = blocks.vector_sink_f() + hblock.connect(src, dst) + hblock.run() + self.assertEqual(data, dst.data()) def test_021_connect_single(self): hblock = gr.top_block("test_block") @@ -219,7 +222,7 @@ class test_hier_block2(gr_unittest.TestCase): blk = gr.hier_block2("block", gr.io_signature(1, 1, 1), gr.io_signature(1, 1, 1)) - self.assertRaises(ValueError, + self.assertRaises(RuntimeError, lambda: hblock.connect(blk)) def test_023_connect_single_twice(self): @@ -228,7 +231,7 @@ class test_hier_block2(gr_unittest.TestCase): gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) hblock.connect(blk) - self.assertRaises(ValueError, + self.assertRaises(RuntimeError, lambda: hblock.connect(blk)) def test_024_disconnect_single(self): @@ -244,7 +247,7 @@ class test_hier_block2(gr_unittest.TestCase): blk = gr.hier_block2("block", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) - self.assertRaises(ValueError, + self.assertRaises(RuntimeError, lambda: hblock.disconnect(blk)) def test_026_run_single(self): @@ -258,7 +261,7 @@ class test_hier_block2(gr_unittest.TestCase): hb.connect(src, dst) tb.connect(hb) tb.run() - self.assertEquals(expected_data, dst.data()) + self.assertEqual(expected_data, dst.data()) def test_027a_internally_unconnected_input(self): tb = gr.top_block() @@ -333,7 +336,7 @@ class test_hier_block2(gr_unittest.TestCase): tb.disconnect(src) # Singleton disconnect tb.connect(src, dst) tb.run() - self.assertEquals(dst.data(), (1,)) + self.assertEqual(dst.data(), (1,)) def test_030_nested_input(self): tb = gr.top_block() @@ -349,7 +352,7 @@ class test_hier_block2(gr_unittest.TestCase): hb1.connect(hb1, hb2) hb2.connect(hb2, blocks.copy(gr.sizeof_char), dst) tb.run() - self.assertEquals(dst.data(), (1,)) + self.assertEqual(dst.data(), (1,)) def test_031_multiple_internal_inputs(self): tb = gr.top_block() @@ -368,7 +371,7 @@ class test_hier_block2(gr_unittest.TestCase): dst = blocks.vector_sink_f() tb.connect(src, hb, dst) tb.run() - self.assertEquals(dst.data(), (3.0,)) + self.assertEqual(dst.data(), (3.0,)) def test_032_nested_multiple_internal_inputs(self): tb = gr.top_block() @@ -392,7 +395,7 @@ class test_hier_block2(gr_unittest.TestCase): dst = blocks.vector_sink_f() tb.connect(src, hb, dst) tb.run() - self.assertEquals(dst.data(), (3.0,)) + self.assertEqual(dst.data(), (3.0,)) def test_033a_set_affinity(self): @@ -404,7 +407,7 @@ class test_hier_block2(gr_unittest.TestCase): hblock.set_processor_affinity([0,]) hblock.run() actual = snk.data() - self.assertEquals(expected, actual) + self.assertEqual(expected, actual) def test_033b_unset_affinity(self): expected = (1.0, 2.0, 3.0, 4.0) @@ -416,7 +419,7 @@ class test_hier_block2(gr_unittest.TestCase): hblock.unset_processor_affinity() hblock.run() actual = snk.data() - self.assertEquals(expected, actual) + self.assertEqual(expected, actual) def test_033c_get_affinity(self): expected = (1.0, 2.0, 3.0, 4.0) @@ -426,7 +429,7 @@ class test_hier_block2(gr_unittest.TestCase): hblock.connect(src, snk) hblock.set_processor_affinity([0,]) procs = hblock.processor_affinity() - self.assertEquals((0,), procs) + self.assertEqual((0,), procs) def test_34a_lock_unlock(self): hblock = gr.top_block("test_block") diff --git a/gr-blocks/python/blocks/qa_hier_block2_message_connections.py b/gr-blocks/python/blocks/qa_hier_block2_message_connections.py index 4283f537e8..e66a0dbdc8 100644 --- a/gr-blocks/python/blocks/qa_hier_block2_message_connections.py +++ b/gr-blocks/python/blocks/qa_hier_block2_message_connections.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import weakref from gnuradio import blocks, gr, gr_unittest diff --git a/gr-blocks/python/blocks/qa_integrate.py b/gr-blocks/python/blocks/qa_integrate.py index be4285ce95..4ecfbb5171 100755..100644 --- a/gr-blocks/python/blocks/qa_integrate.py +++ b/gr-blocks/python/blocks/qa_integrate.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_integrate (gr_unittest.TestCase): @@ -31,66 +32,66 @@ class test_integrate (gr_unittest.TestCase): self.tb = None def test_000_ss(self): - src_data = (1, 2, 3, 4, 5, 6) - dst_data = (6, 15) - src = blocks.vector_source_s(src_data) - itg = blocks.integrate_ss(3) - dst = blocks.vector_sink_s() - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertEqual(dst_data, dst.data()) + src_data = (1, 2, 3, 4, 5, 6) + dst_data = (6, 15) + src = blocks.vector_source_s(src_data) + itg = blocks.integrate_ss(3) + dst = blocks.vector_sink_s() + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertEqual(dst_data, dst.data()) def test_001_ii(self): - src_data = (1, 2, 3, 4, 5, 6) - dst_data = (6, 15) - src = blocks.vector_source_i(src_data) - itg = blocks.integrate_ii(3) - dst = blocks.vector_sink_i() - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertEqual(dst_data, dst.data()) + src_data = (1, 2, 3, 4, 5, 6) + dst_data = (6, 15) + src = blocks.vector_source_i(src_data) + itg = blocks.integrate_ii(3) + dst = blocks.vector_sink_i() + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertEqual(dst_data, dst.data()) def test_002_ff(self): - src_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] - dst_data = [6.0, 15.0] - src = blocks.vector_source_f(src_data) - itg = blocks.integrate_ff(3) - dst = blocks.vector_sink_f() - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) + src_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] + dst_data = [6.0, 15.0] + src = blocks.vector_source_f(src_data) + itg = blocks.integrate_ff(3) + dst = blocks.vector_sink_f() + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) def test_003_cc(self): - src_data = [1.0+1.0j, 2.0+2.0j, 3.0+3.0j, 4.0+4.0j, 5.0+5.0j, 6.0+6.0j] - dst_data = [6.0+6.0j, 15.0+15.0j] - src = blocks.vector_source_c(src_data) - itg = blocks.integrate_cc(3) - dst = blocks.vector_sink_c() - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertComplexTuplesAlmostEqual(dst_data, dst.data(), 6) + src_data = [1.0+1.0j, 2.0+2.0j, 3.0+3.0j, 4.0+4.0j, 5.0+5.0j, 6.0+6.0j] + dst_data = [6.0+6.0j, 15.0+15.0j] + src = blocks.vector_source_c(src_data) + itg = blocks.integrate_cc(3) + dst = blocks.vector_sink_c() + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertComplexTuplesAlmostEqual(dst_data, dst.data(), 6) def test_004_ss_vec(self): - src_data = (1, 2, 3, 4, 5, 6) - dst_data = (9, 12) - vlen = 2 - src = blocks.vector_source_s(src_data, False, vlen) - itg = blocks.integrate_ss(3, vlen) - dst = blocks.vector_sink_s(vlen) - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertEqual(dst_data, dst.data()) + src_data = (1, 2, 3, 4, 5, 6) + dst_data = (9, 12) + vlen = 2 + src = blocks.vector_source_s(src_data, False, vlen) + itg = blocks.integrate_ss(3, vlen) + dst = blocks.vector_sink_s(vlen) + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertEqual(dst_data, dst.data()) def test_003_cc_vec(self): - src_data = [1.0+1.0j, 2.0+2.0j, 3.0+3.0j, 4.0+4.0j, 5.0+5.0j, 6.0+6.0j] - dst_data = [9.0+9.0j, 12.0+12.0j] - vlen = 2 - src = blocks.vector_source_c(src_data, False, vlen) - itg = blocks.integrate_cc(3, vlen) - dst = blocks.vector_sink_c(vlen) - self.tb.connect(src, itg, dst) - self.tb.run() - self.assertComplexTuplesAlmostEqual(dst_data, dst.data(), 6) + src_data = [1.0+1.0j, 2.0+2.0j, 3.0+3.0j, 4.0+4.0j, 5.0+5.0j, 6.0+6.0j] + dst_data = [9.0+9.0j, 12.0+12.0j] + vlen = 2 + src = blocks.vector_source_c(src_data, False, vlen) + itg = blocks.integrate_cc(3, vlen) + dst = blocks.vector_sink_c(vlen) + self.tb.connect(src, itg, dst) + self.tb.run() + self.assertComplexTuplesAlmostEqual(dst_data, dst.data(), 6) if __name__ == '__main__': gr_unittest.run(test_integrate, "test_integrate.xml") diff --git a/gr-blocks/python/blocks/qa_interleave.py b/gr-blocks/python/blocks/qa_interleave.py index 526e4a4e6f..9d334a465f 100755..100644 --- a/gr-blocks/python/blocks/qa_interleave.py +++ b/gr-blocks/python/blocks/qa_interleave.py @@ -20,6 +20,8 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks class test_interleave (gr_unittest.TestCase): @@ -32,10 +34,10 @@ class test_interleave (gr_unittest.TestCase): def test_int_001 (self): lenx = 64 - src0 = blocks.vector_source_f (range (0, lenx, 4)) - src1 = blocks.vector_source_f (range (1, lenx, 4)) - src2 = blocks.vector_source_f (range (2, lenx, 4)) - src3 = blocks.vector_source_f (range (3, lenx, 4)) + src0 = blocks.vector_source_f (list(range(0, lenx, 4))) + src1 = blocks.vector_source_f (list(range(1, lenx, 4))) + src2 = blocks.vector_source_f (list(range(2, lenx, 4))) + src3 = blocks.vector_source_f (list(range(3, lenx, 4))) op = blocks.interleave (gr.sizeof_float) dst = blocks.vector_sink_f () @@ -54,13 +56,13 @@ class test_interleave (gr_unittest.TestCase): lenx = 64 plusup_big = lambda a: a + (blksize * 4) plusup_little = lambda a: a + blksize - a_vec = range(0,blksize) - for i in range(0,(lenx/(4 * blksize)) - 1): - a_vec += map(plusup_big, a_vec[len(a_vec) - blksize:]) + a_vec = list(range(0,blksize)) + for i in range(0,(lenx // (4 * blksize)) - 1): + a_vec += list(map(plusup_big, a_vec[len(a_vec) - blksize:])) - b_vec = map(plusup_little, a_vec) - c_vec = map(plusup_little, b_vec) - d_vec = map(plusup_little, c_vec) + b_vec = list(map(plusup_little, a_vec)) + c_vec = list(map(plusup_little, b_vec)) + d_vec = list(map(plusup_little, c_vec)) src0 = blocks.vector_source_f (a_vec) src1 = blocks.vector_source_f (b_vec) @@ -82,7 +84,7 @@ class test_interleave (gr_unittest.TestCase): def test_deint_001 (self): lenx = 64 - src = blocks.vector_source_f (range (lenx)) + src = blocks.vector_source_f (list(range(lenx))) op = blocks.deinterleave (gr.sizeof_float) dst0 = blocks.vector_sink_f () dst1 = blocks.vector_sink_f () @@ -109,7 +111,7 @@ class test_interleave (gr_unittest.TestCase): def test_deint_002 (self): blksize = 4 lenx = 64 - src = blocks.vector_source_f (range (lenx)) + src = blocks.vector_source_f (list(range(lenx))) op = blocks.deinterleave (gr.sizeof_float, blksize) dst0 = blocks.vector_sink_f () dst1 = blocks.vector_sink_f () @@ -125,13 +127,13 @@ class test_interleave (gr_unittest.TestCase): plusup_big = lambda a: a + (blksize * 4) plusup_little = lambda a: a + blksize - a_vec = range(0,blksize) - for i in range(0,(lenx/(4 * blksize)) - 1): - a_vec += map(plusup_big, a_vec[len(a_vec) - blksize:]) + a_vec = list(range(0,blksize)) + for i in range(0,(lenx // (4 * blksize)) - 1): + a_vec += list(map(plusup_big, a_vec[len(a_vec) - blksize:])) - b_vec = map(plusup_little, a_vec) - c_vec = map(plusup_little, b_vec) - d_vec = map(plusup_little, c_vec) + b_vec = list(map(plusup_little, a_vec)) + c_vec = list(map(plusup_little, b_vec)) + d_vec = list(map(plusup_little, c_vec)) expected_result0 = tuple (a_vec) expected_result1 = tuple (b_vec) diff --git a/gr-blocks/python/blocks/qa_keep_m_in_n.py b/gr-blocks/python/blocks/qa_keep_m_in_n.py index 4db48335b2..30a15d9ded 100755..100644 --- a/gr-blocks/python/blocks/qa_keep_m_in_n.py +++ b/gr-blocks/python/blocks/qa_keep_m_in_n.py @@ -19,6 +19,7 @@ # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # + from gnuradio import gr, gr_unittest, blocks import sys @@ -27,15 +28,15 @@ import random class test_keep_m_in_n(gr_unittest.TestCase): def setUp(self): - pass + pass def tearDown(self): - pass + pass def test_001(self): self.maxDiff = None; tb = gr.top_block() - src = blocks.vector_source_b( range(0,100) ) + src = blocks.vector_source_b( list(range(0,100)) ) # itemsize, M, N, offset km2 = blocks.keep_m_in_n( 1, 1, 2, 0 ); @@ -49,11 +50,10 @@ class test_keep_m_in_n(gr_unittest.TestCase): tb.connect(src,km7,snk7); tb.run(); - self.assertEqual(range(0,100,2), list(snk2.data())); - self.assertEqual(range(1,100,3), list(snk3.data())); - self.assertEqual(range(2,100,7), list(snk7.data())); + self.assertEqual(list(range(0,100,2)), list(snk2.data())); + self.assertEqual(list(range(1,100,3)), list(snk3.data())); + self.assertEqual(list(range(2,100,7)), list(snk7.data())); if __name__ == '__main__': gr_unittest.run(test_keep_m_in_n, "test_keep_m_in_n.xml") - diff --git a/gr-blocks/python/blocks/qa_keep_one_in_n.py b/gr-blocks/python/blocks/qa_keep_one_in_n.py index d8251fe611..fd7c122c62 100755..100644 --- a/gr-blocks/python/blocks/qa_keep_one_in_n.py +++ b/gr-blocks/python/blocks/qa_keep_one_in_n.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_keep_one_in_n(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_logger.py b/gr-blocks/python/blocks/qa_logger.py new file mode 100644 index 0000000000..bdcd24cf0e --- /dev/null +++ b/gr-blocks/python/blocks/qa_logger.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python +# +# Copyright 2016 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + + +from gnuradio import gr, gr_unittest, blocks + +class test_logger (gr_unittest.TestCase): + + def setUp(self): + pass + + def tearDown(self): + pass + + def set_and_assert_log_level(self, block, level): + block.set_log_level(level) + self.assertEqual(block.log_level(), level) + + def test_log_level_for_block(self): + # Test the python API for getting and setting log levels of individual block + # go through all of the documented log_levels + ns = blocks.null_source(1) + self.set_and_assert_log_level(ns, "notset") + self.set_and_assert_log_level(ns, "debug") + self.set_and_assert_log_level(ns, "info") + self.set_and_assert_log_level(ns, "notice") + self.set_and_assert_log_level(ns, "warn") + self.set_and_assert_log_level(ns, "error") + self.set_and_assert_log_level(ns, "crit") + self.set_and_assert_log_level(ns, "alert") + self.set_and_assert_log_level(ns, "emerg") + # There's a couple of special cases. "off" == "notset" (specific to gr) + # and "fatal" == "emerg" (built in to log4cpp) + ns.set_log_level("off") + self.assertEqual(ns.log_level(), "notset") + ns.set_log_level("fatal") + self.assertEqual(ns.log_level(), "emerg") + # Make sure exception is throw on bogus data + self.assertRaises(RuntimeError, ns.set_log_level, "11") + + + def test_log_level_for_tb(self): + # Test the python API for getting and setting log levels for a top_block + nsrc = blocks.null_source(4) + nsnk = blocks.null_sink(4) + # Set all log levels to a known state + nsrc.set_log_level("debug") + nsnk.set_log_level("debug") + tb = gr.top_block() + tb.connect(nsrc, nsnk) + # confirm that the tb has log_level of first block + self.assertEqual(tb.log_level(), "debug") + # confirm that changing tb log_level propagates to connected blocks + tb.set_log_level("alert") + self.assertEqual(tb.log_level(), "alert") + self.assertEqual(nsrc.log_level(), "alert") + self.assertEqual(nsnk.log_level(), "alert") + + def test_log_level_for_hier_block(self): + # Test the python API for getting and setting log levels for hier blocks + nsrc = blocks.null_source(4) + nsnk = blocks.null_sink(4) + b = blocks.stream_to_vector_decimator(4, 1, 1, 1) # just a random hier block that exists + tb = gr.top_block() + tb.connect(nsrc, b, nsnk) + tb.set_log_level("debug") + self.assertEqual(tb.log_level(), "debug") + self.assertEqual(nsrc.log_level(), "debug") + self.assertEqual(nsnk.log_level(), "debug") + self.assertEqual(b.one_in_n.log_level(), "debug") + tb.set_log_level("alert") + self.assertEqual(tb.log_level(), "alert") + self.assertEqual(nsrc.log_level(), "alert") + self.assertEqual(nsnk.log_level(), "alert") + self.assertEqual(b.one_in_n.log_level(), "alert") + +if __name__ == '__main__': + gr_unittest.run(test_logger, "test_logger.xml") diff --git a/gr-blocks/python/blocks/qa_max.py b/gr-blocks/python/blocks/qa_max.py index 709dbee72e..45c2261ded 100755..100644 --- a/gr-blocks/python/blocks/qa_max.py +++ b/gr-blocks/python/blocks/qa_max.py @@ -20,6 +20,8 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks import math @@ -47,18 +49,18 @@ class test_max(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def stest_002(self): - src_data=(-100,-99,-98,-97,-96,-1) - expected_result = (float(max(src_data)),) + src_data=(-100,-99,-98,-97,-96,-1) + expected_result = (float(max(src_data)),) - src = blocks.vector_source_f(src_data) - s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) - op = blocks.max_ff(len(src_data)) - dst = blocks.vector_sink_f() + src = blocks.vector_source_f(src_data) + s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) + op = blocks.max_ff(len(src_data)) + dst = blocks.vector_sink_f() - self.tb.connect(src, s2v, op, dst) - self.tb.run() - result_data = dst.data() - self.assertEqual(expected_result, result_data) + self.tb.connect(src, s2v, op, dst) + self.tb.run() + result_data = dst.data() + self.assertEqual(expected_result, result_data) def stest_003(self): src_data0 = (0, 2, -3, 0, 12, 0) @@ -85,7 +87,7 @@ class test_max(gr_unittest.TestCase): expected_data = [] tmp = [float(max(x,y)) for x,y in zip(src_data0, src_data1)] - for i in xrange(len(tmp)/dim): + for i in range(len(tmp) / dim): expected_data.append(float(max(tmp[i*dim:(i+1)*dim]))) src0 = blocks.vector_source_f(src_data0) @@ -118,18 +120,18 @@ class test_max(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def stest_s002(self): - src_data=(-100,-99,-98,-97,-96,-1) - expected_result = (max(src_data),) + src_data=(-100,-99,-98,-97,-96,-1) + expected_result = (max(src_data),) - src = blocks.vector_source_s(src_data) - s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) - op = blocks.max_ss(len(src_data)) - dst = blocks.vector_sink_s() + src = blocks.vector_source_s(src_data) + s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) + op = blocks.max_ss(len(src_data)) + dst = blocks.vector_sink_s() - self.tb.connect(src, s2v, op, dst) - self.tb.run() - result_data = dst.data() - self.assertEqual(expected_result, result_data) + self.tb.connect(src, s2v, op, dst) + self.tb.run() + result_data = dst.data() + self.assertEqual(expected_result, result_data) def stest_s003(self): @@ -157,7 +159,7 @@ class test_max(gr_unittest.TestCase): expected_data = [] tmp = [max(x,y) for x,y in zip(src_data0, src_data1)] - for i in xrange(len(tmp)/dim): + for i in range(len(tmp) / dim): expected_data.append(max(tmp[i*dim:(i+1)*dim])) src0 = blocks.vector_source_s(src_data0) diff --git a/gr-blocks/python/blocks/qa_message.py b/gr-blocks/python/blocks/qa_message.py index 1d677007b4..3ee5102519 100755..100644 --- a/gr-blocks/python/blocks/qa_message.py +++ b/gr-blocks/python/blocks/qa_message.py @@ -1,6 +1,7 @@ #!/usr/bin/env python +# -*- coding: utf-8 -*- # -# Copyright 2004,2010,2013 Free Software Foundation, Inc. +# Copyright 2004,2010,2013,2016 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -25,6 +26,7 @@ import time from gnuradio import gr, gr_unittest, blocks import pmt + def all_counts(): return (gr.block_ncurrently_allocated(), gr.block_detail_ncurrently_allocated(), @@ -57,10 +59,15 @@ class test_message(gr_unittest.TestCase): self.assertEquals(0, msg.length()) def test_101(self): - s = 'This is a test' - msg = gr.message_from_string(s) + s = b'This is a test' + msg = gr.message_from_string(s.decode('utf8')) self.assertEquals(s, msg.to_string()) + def test_102_unicodechars(self): + s = u"(╯°□°)╯︵ ┻━┻" + msg = gr.message_from_string(s) + self.assertEquals(s.encode('utf8'), msg.to_string()) + def test_200(self): self.leak_check(self.body_200) @@ -95,46 +102,17 @@ class test_message(gr_unittest.TestCase): input_data = (0,1,2,3,4,5,6,7,8,9) src = blocks.vector_source_b(input_data) dst = blocks.vector_sink_b() - tb = gr.top_block() + tb = gr.top_block() tb.connect(src, dst) tb.run() self.assertEquals(input_data, dst.data()) - def test_301(self): - # Use itemsize, limit constructor - src = blocks.message_source(gr.sizeof_char) - dst = blocks.vector_sink_b() - tb = gr.top_block() - tb.connect(src, dst) - src.msgq().insert_tail(gr.message_from_string('01234')) - src.msgq().insert_tail(gr.message_from_string('5')) - src.msgq().insert_tail(gr.message_from_string('')) - src.msgq().insert_tail(gr.message_from_string('6789')) - src.msgq().insert_tail(gr.message(1)) # send EOF - tb.run() - self.assertEquals(tuple(map(ord, '0123456789')), dst.data()) - - def test_302(self): - # Use itemsize, msgq constructor - msgq = gr.msg_queue() - src = blocks.message_source(gr.sizeof_char, msgq) - dst = blocks.vector_sink_b() - tb = gr.top_block() - tb.connect(src, dst) - src.msgq().insert_tail(gr.message_from_string('01234')) - src.msgq().insert_tail(gr.message_from_string('5')) - src.msgq().insert_tail(gr.message_from_string('')) - src.msgq().insert_tail(gr.message_from_string('6789')) - src.msgq().insert_tail(gr.message(1)) # send EOF - tb.run() - self.assertEquals(tuple(map(ord, '0123456789')), dst.data()) - def test_debug_401(self): msg = pmt.intern("TESTING") src = blocks.message_strobe(msg, 500) snk = blocks.message_debug() - tb = gr.top_block() + tb = gr.top_block() tb.msg_connect(src, "strobe", snk, "store") tb.start() time.sleep(1) diff --git a/gr-blocks/python/blocks/qa_message_tags.py b/gr-blocks/python/blocks/qa_message_tags.py deleted file mode 100644 index 0d4f77bf9f..0000000000 --- a/gr-blocks/python/blocks/qa_message_tags.py +++ /dev/null @@ -1,27 +0,0 @@ -import time - -from gnuradio import gr, gr_unittest, blocks - -class test_message_tags (gr_unittest.TestCase): - - def test_1 (self): - data = ('hello', 'you', 'there') - tx_msgq = gr.msg_queue() - rx_msgq = gr.msg_queue() - for d in data: - tx_msgq.insert_tail(gr.message_from_string(d)) - tx_msgq.insert_tail(gr.message(1)) # send EOF - tb = gr.top_block() - src = blocks.message_source(gr.sizeof_char, tx_msgq, "packet_length") - snk = blocks.message_sink(gr.sizeof_char, rx_msgq, False, "packet_length") - tb.connect(src, snk) - tb.start() - time.sleep(1) - tb.stop() - for d in data: - msg = rx_msgq.delete_head() - contents = msg.to_string() - self.assertEqual(d, contents) - -if __name__ == '__main__': - gr_unittest.run(test_message_tags, "test_message_tags.xml") diff --git a/gr-blocks/python/blocks/qa_min.py b/gr-blocks/python/blocks/qa_min.py index 642782a1a1..374c15e319 100644 --- a/gr-blocks/python/blocks/qa_min.py +++ b/gr-blocks/python/blocks/qa_min.py @@ -20,6 +20,8 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks import math @@ -47,18 +49,18 @@ class test_min(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def stest_002(self): - src_data=(-100,-99,-98,-97,-96,-1) - expected_result = (float(min(src_data)),) + src_data=(-100,-99,-98,-97,-96,-1) + expected_result = (float(min(src_data)),) - src = blocks.vector_source_f(src_data) - s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) - op = blocks.min_ff(len(src_data)) - dst = blocks.vector_sink_f() + src = blocks.vector_source_f(src_data) + s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) + op = blocks.min_ff(len(src_data)) + dst = blocks.vector_sink_f() - self.tb.connect(src, s2v, op, dst) - self.tb.run() - result_data = dst.data() - self.assertEqual(expected_result, result_data) + self.tb.connect(src, s2v, op, dst) + self.tb.run() + result_data = dst.data() + self.assertEqual(expected_result, result_data) def stest_003(self): src_data0 = (0, 2, -3, 0, 12, 0) @@ -85,7 +87,7 @@ class test_min(gr_unittest.TestCase): expected_data = [] tmp = [float(min(x,y)) for x,y in zip(src_data0, src_data1)] - for i in xrange(len(tmp)/dim): + for i in range(len(tmp) / dim): expected_data.append(float(min(tmp[i*dim:(i+1)*dim]))) src0 = blocks.vector_source_f(src_data0) @@ -118,18 +120,18 @@ class test_min(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def stest_s002(self): - src_data=(-100,-99,-98,-97,-96,-1) - expected_result = (min(src_data),) + src_data=(-100,-99,-98,-97,-96,-1) + expected_result = (min(src_data),) - src = blocks.vector_source_s(src_data) - s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) - op = blocks.min_ss(len(src_data)) - dst = blocks.vector_sink_s() + src = blocks.vector_source_s(src_data) + s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) + op = blocks.min_ss(len(src_data)) + dst = blocks.vector_sink_s() - self.tb.connect(src, s2v, op, dst) - self.tb.run() - result_data = dst.data() - self.assertEqual(expected_result, result_data) + self.tb.connect(src, s2v, op, dst) + self.tb.run() + result_data = dst.data() + self.assertEqual(expected_result, result_data) def stest_s003(self): @@ -157,7 +159,7 @@ class test_min(gr_unittest.TestCase): expected_data = [] tmp = [min(x,y) for x,y in zip(src_data0, src_data1)] - for i in xrange(len(tmp)/dim): + for i in range(len(tmp) / dim): expected_data.append(min(tmp[i*dim:(i+1)*dim])) src0 = blocks.vector_source_s(src_data0) diff --git a/gr-blocks/python/blocks/qa_moving_average.py b/gr-blocks/python/blocks/qa_moving_average.py index b76f81392d..87f8d3015f 100644 --- a/gr-blocks/python/blocks/qa_moving_average.py +++ b/gr-blocks/python/blocks/qa_moving_average.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math, random diff --git a/gr-blocks/python/blocks/qa_multiply_conjugate.py b/gr-blocks/python/blocks/qa_multiply_conjugate.py index c2391f1410..dadea69ba2 100644 --- a/gr-blocks/python/blocks/qa_multiply_conjugate.py +++ b/gr-blocks/python/blocks/qa_multiply_conjugate.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_multiply_conjugate (gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_multiply_matrix_xx.py b/gr-blocks/python/blocks/qa_multiply_matrix_xx.py index feee53d510..eb10535565 100755..100644 --- a/gr-blocks/python/blocks/qa_multiply_matrix_xx.py +++ b/gr-blocks/python/blocks/qa_multiply_matrix_xx.py @@ -21,6 +21,7 @@ # Boston, MA 02110-1301, USA. # + import time import numpy import os @@ -73,7 +74,7 @@ class test_multiply_matrix_xx (gr_unittest.TestCase): self.multiplier.set_A(A2) A = A2 A_matrix = numpy.matrix(A) - for i in xrange(N): + for i in range(N): if tags is None: these_tags = () else: @@ -83,17 +84,17 @@ class test_multiply_matrix_xx (gr_unittest.TestCase): (self.multiplier, i) ) sinks = [] - for i in xrange(M): + for i in range(M): sinks.append(BLOCK_LOOKUP[datatype]['sink']()) self.tb.connect((self.multiplier, i), sinks[i]) # Run and check self.tb.run() - for i in xrange(X_in.shape[1]): + for i in range(X_in.shape[1]): Y_out_exp[:,i] = A_matrix * X_in[:,i] Y_out = [list(x.data()) for x in sinks] if tags is not None: self.the_tags = [] - for i in xrange(M): + for i in range(M): self.the_tags.append(sinks[i].tags()) self.assertEqual(list(Y_out), Y_out_exp.tolist()) diff --git a/gr-blocks/python/blocks/qa_mute.py b/gr-blocks/python/blocks/qa_mute.py index 97ee5bd821..d061954ef8 100755..100644 --- a/gr-blocks/python/blocks/qa_mute.py +++ b/gr-blocks/python/blocks/qa_mute.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_mute(gr_unittest.TestCase): @@ -31,7 +32,7 @@ class test_mute(gr_unittest.TestCase): self.tb = None def help_ii(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_i() @@ -41,7 +42,7 @@ class test_mute(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_ff(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_f(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_f() @@ -51,7 +52,7 @@ class test_mute(gr_unittest.TestCase): self.assertEqual(exp_data, result_data) def help_cc(self, src_data, exp_data, op): - for s in zip(range(len(src_data)), src_data): + for s in zip(list(range(len(src_data))), src_data): src = blocks.vector_source_c(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_c() diff --git a/gr-blocks/python/blocks/qa_nlog10.py b/gr-blocks/python/blocks/qa_nlog10.py index 0194e85d48..94269c34f0 100755..100644 --- a/gr-blocks/python/blocks/qa_nlog10.py +++ b/gr-blocks/python/blocks/qa_nlog10.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_nlog10(gr_unittest.TestCase): @@ -31,15 +32,15 @@ class test_nlog10(gr_unittest.TestCase): self.tb = None def test_001(self): - src_data = (-10, 0, 10, 100, 1000, 10000, 100000) - expected_result = (-180, -180, 10, 20, 30, 40, 50) + src_data = (1, 10, 100, 1000, 10000, 100000) + expected_result = (0, 10, 20, 30, 40, 50) src = blocks.vector_source_f(src_data) op = blocks.nlog10_ff(10) dst = blocks.vector_sink_f() self.tb.connect (src, op, dst) self.tb.run() result_data = dst.data() - self.assertFloatTuplesAlmostEqual (expected_result, result_data) + self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5) if __name__ == '__main__': diff --git a/gr-blocks/python/blocks/qa_null_sink_source.py b/gr-blocks/python/blocks/qa_null_sink_source.py index 03d6ab14c1..8ddd8db6fc 100644 --- a/gr-blocks/python/blocks/qa_null_sink_source.py +++ b/gr-blocks/python/blocks/qa_null_sink_source.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math diff --git a/gr-blocks/python/blocks/qa_pack_k_bits.py b/gr-blocks/python/blocks/qa_pack_k_bits.py index ab0b638a09..28285845b3 100755..100644 --- a/gr-blocks/python/blocks/qa_pack_k_bits.py +++ b/gr-blocks/python/blocks/qa_pack_k_bits.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import random from gnuradio import gr, gr_unittest, blocks @@ -54,7 +55,7 @@ class test_pack(gr_unittest.TestCase): self.assertEqual(expected_results, dst.data()) def test_003(self): - src_data = expected_results = map(lambda x: random.randint(0,3), range(10)); + src_data = expected_results = [random.randint(0,3) for x in range(10)]; src = blocks.vector_source_b( src_data ); pack = blocks.pack_k_bits_bb(2); unpack = blocks.unpack_k_bits_bb(2); diff --git a/gr-blocks/python/blocks/qa_packed_to_unpacked.py b/gr-blocks/python/blocks/qa_packed_to_unpacked.py index 02dc872490..13e93a7136 100755..100644 --- a/gr-blocks/python/blocks/qa_packed_to_unpacked.py +++ b/gr-blocks/python/blocks/qa_packed_to_unpacked.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import random @@ -139,7 +140,7 @@ class test_packing(gr_unittest.TestCase): def test_009(self): random.seed(0) src_data = [] - for i in xrange(202): + for i in range(202): src_data.append((random.randint(0,255))) src_data = tuple(src_data) expected_results = src_data @@ -158,7 +159,7 @@ class test_packing(gr_unittest.TestCase): def test_010(self): random.seed(0) src_data = [] - for i in xrange(56): + for i in range(56): src_data.append((random.randint(0,255))) src_data = tuple(src_data) expected_results = src_data @@ -176,7 +177,7 @@ class test_packing(gr_unittest.TestCase): def test_011(self): random.seed(0) src_data = [] - for i in xrange(56): + for i in range(56): src_data.append((random.randint(0,255))) src_data = tuple(src_data) expected_results = src_data @@ -196,7 +197,7 @@ class test_packing(gr_unittest.TestCase): def test_100a(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data @@ -214,7 +215,7 @@ class test_packing(gr_unittest.TestCase): def test_100b(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data @@ -232,7 +233,7 @@ class test_packing(gr_unittest.TestCase): def test_101a(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data @@ -250,7 +251,7 @@ class test_packing(gr_unittest.TestCase): def test_101b(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data @@ -270,7 +271,7 @@ class test_packing(gr_unittest.TestCase): def test_200a(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**31,2**31-1))) src_data = tuple(src_data) expected_results = src_data @@ -288,7 +289,7 @@ class test_packing(gr_unittest.TestCase): def test_200b(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**31,2**31-1))) src_data = tuple(src_data) expected_results = src_data @@ -306,7 +307,7 @@ class test_packing(gr_unittest.TestCase): def test_201a(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**31,2**31-1))) src_data = tuple(src_data) expected_results = src_data @@ -324,7 +325,7 @@ class test_packing(gr_unittest.TestCase): def test_201b(self): random.seed(0) src_data = [] - for i in xrange(100): + for i in range(100): src_data.append((random.randint(-2**31,2**31-1))) src_data = tuple(src_data) expected_results = src_data diff --git a/gr-blocks/python/blocks/qa_patterned_interleaver.py b/gr-blocks/python/blocks/qa_patterned_interleaver.py index 2d3168db40..300565210e 100755..100644 --- a/gr-blocks/python/blocks/qa_patterned_interleaver.py +++ b/gr-blocks/python/blocks/qa_patterned_interleaver.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math diff --git a/gr-blocks/python/blocks/qa_pdu.py b/gr-blocks/python/blocks/qa_pdu.py index bbee3605ba..3ee5e576ea 100755..100644 --- a/gr-blocks/python/blocks/qa_pdu.py +++ b/gr-blocks/python/blocks/qa_pdu.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import time from gnuradio import gr, gr_unittest, blocks @@ -55,18 +56,17 @@ class test_pdu(gr_unittest.TestCase): self.tb.connect(src, snk2) self.tb.connect(src, snk3) self.tb.msg_connect(snk3, "pdus", dbg, "store") - self.tb.start() # make our reference and message pmts port = pmt.intern("pdus") msg = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message - src.to_basic_block()._post(port, msg) # eww, what's that smell? + src.to_basic_block()._post(port, msg) + src.to_basic_block()._post(pmt.intern("system"), + pmt.cons(pmt.intern("done"), pmt.PMT_T)) - while dbg.num_messages() < 1: - time.sleep(0.1) - self.tb.stop() + self.tb.start() self.tb.wait() # Get the vector of data from the vector sink @@ -80,7 +80,7 @@ class test_pdu(gr_unittest.TestCase): # Convert the PMT vector into a Python list msg_data = [] - for i in xrange(16): + for i in range(16): msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16*[0xFF,] @@ -98,18 +98,18 @@ class test_pdu(gr_unittest.TestCase): msg = pmt.cons( pmt.PMT_NIL, pmt.init_f32vector(10, src_data)) src.to_basic_block()._post(port, msg) + src.to_basic_block()._post(pmt.intern("system"), + pmt.cons(pmt.intern("done"), pmt.PMT_T)) self.tb.start() - #ideally, would wait until we get ten samples - time.sleep(0.2) - self.tb.stop() + self.tb.wait() self.assertEqual(src_data, list(snk.data()) ) def test_002_tags_plus_data(self): packet_len = 16 - src_data = range(packet_len) + src_data = list(range(packet_len)) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol('spam') @@ -125,9 +125,6 @@ class test_pdu(gr_unittest.TestCase): self.tb.connect(src, s2ts, ts2pdu) self.tb.msg_connect(ts2pdu, "pdus", dbg, "store") self.tb.start() - while dbg.num_messages() < 1: - time.sleep(0.1) - self.tb.stop() self.tb.wait() result_msg = dbg.get_message(0) metadata = pmt.to_python(pmt.car(result_msg)) @@ -138,4 +135,3 @@ class test_pdu(gr_unittest.TestCase): if __name__ == '__main__': gr_unittest.run(test_pdu, "test_pdu.xml") - diff --git a/gr-blocks/python/blocks/qa_peak_detector.py b/gr-blocks/python/blocks/qa_peak_detector.py index c855e92530..cb253a5db6 100644 --- a/gr-blocks/python/blocks/qa_peak_detector.py +++ b/gr-blocks/python/blocks/qa_peak_detector.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_peak_detector(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_peak_detector2.py b/gr-blocks/python/blocks/qa_peak_detector2.py index d6fd4fe95f..a7de40200e 100644 --- a/gr-blocks/python/blocks/qa_peak_detector2.py +++ b/gr-blocks/python/blocks/qa_peak_detector2.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_peak_detector2(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_pipe_fittings.py b/gr-blocks/python/blocks/qa_pipe_fittings.py index bc29cc750e..b569157582 100755..100644 --- a/gr-blocks/python/blocks/qa_pipe_fittings.py +++ b/gr-blocks/python/blocks/qa_pipe_fittings.py @@ -20,13 +20,14 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks def calc_expected_result(src_data, n): assert (len(src_data) % n) == 0 result = [list() for x in range(n)] #print "len(result) =", len(result) - for i in xrange(len(src_data)): + for i in range(len(src_data)): (result[i % n]).append(src_data[i]) return [tuple(x) for x in result] @@ -45,7 +46,7 @@ class test_pipe_fittings(gr_unittest.TestCase): """ n = 8 src_len = n * 8 - src_data = range(src_len) + src_data = list(range(src_len)) expected_results = calc_expected_result(src_data, n) #print "expected results: ", expected_results diff --git a/gr-blocks/python/blocks/qa_plateau_detector_fb.py b/gr-blocks/python/blocks/qa_plateau_detector_fb.py index 003c4ea74d..6a41a249e9 100755..100644 --- a/gr-blocks/python/blocks/qa_plateau_detector_fb.py +++ b/gr-blocks/python/blocks/qa_plateau_detector_fb.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class qa_plateau_detector_fb (gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_probe_signal.py b/gr-blocks/python/blocks/qa_probe_signal.py index 8194cafdb0..b7fd6b061c 100644 --- a/gr-blocks/python/blocks/qa_probe_signal.py +++ b/gr-blocks/python/blocks/qa_probe_signal.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_probe_signal(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_python_message_passing.py b/gr-blocks/python/blocks/qa_python_message_passing.py index 7bb5fbe10e..49e2e5e481 100644 --- a/gr-blocks/python/blocks/qa_python_message_passing.py +++ b/gr-blocks/python/blocks/qa_python_message_passing.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt import numpy diff --git a/gr-blocks/python/blocks/qa_regenerate.py b/gr-blocks/python/blocks/qa_regenerate.py index 52b6bdb515..65d76cfe16 100755..100644 --- a/gr-blocks/python/blocks/qa_regenerate.py +++ b/gr-blocks/python/blocks/qa_regenerate.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_regenerate(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_repack_bits_bb.py b/gr-blocks/python/blocks/qa_repack_bits_bb.py index 50e1506196..fa86c0ccac 100755..100644 --- a/gr-blocks/python/blocks/qa_repack_bits_bb.py +++ b/gr-blocks/python/blocks/qa_repack_bits_bb.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import random from gnuradio import gr, gr_unittest, blocks import pmt diff --git a/gr-blocks/python/blocks/qa_repeat.py b/gr-blocks/python/blocks/qa_repeat.py index eaf20d4e27..0054f8ce5e 100755..100644 --- a/gr-blocks/python/blocks/qa_repeat.py +++ b/gr-blocks/python/blocks/qa_repeat.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_repeat (gr_unittest.TestCase): @@ -31,17 +32,17 @@ class test_repeat (gr_unittest.TestCase): self.tb = None def test_001_float(self): - src_data = [n*1.0 for n in range(100)]; - dst_data = [] - for n in range(100): - dst_data += [1.0*n, 1.0*n, 1.0*n] - - src = blocks.vector_source_f(src_data) - rpt = blocks.repeat(gr.sizeof_float, 3) - dst = blocks.vector_sink_f() - self.tb.connect(src, rpt, dst) - self.tb.run() - self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) + src_data = [n*1.0 for n in range(100)]; + dst_data = [] + for n in range(100): + dst_data += [1.0*n, 1.0*n, 1.0*n] + + src = blocks.vector_source_f(src_data) + rpt = blocks.repeat(gr.sizeof_float, 3) + dst = blocks.vector_sink_f() + self.tb.connect(src, rpt, dst) + self.tb.run() + self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) if __name__ == '__main__': gr_unittest.run(test_repeat, "test_repeat.xml") diff --git a/gr-blocks/python/blocks/qa_rms.py b/gr-blocks/python/blocks/qa_rms.py index 0b07c37bdc..53c13b54d1 100644 --- a/gr-blocks/python/blocks/qa_rms.py +++ b/gr-blocks/python/blocks/qa_rms.py @@ -20,19 +20,21 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks import math def sig_source_f(samp_rate, freq, amp, N): - t = map(lambda x: float(x)/samp_rate, xrange(N)) - y = map(lambda x: amp*math.cos(2.*math.pi*freq*x), t) + t = [float(x) / samp_rate for x in range(N)] + y = [amp*math.cos(2.*math.pi*freq*x) for x in t] return y def sig_source_c(samp_rate, freq, amp, N): - t = map(lambda x: float(x)/samp_rate, xrange(N)) - y = map(lambda x: amp*math.cos(2.*math.pi*freq*x) + \ - 1j*amp*math.sin(2.*math.pi*freq*x), t) + t = [float(x) / samp_rate for x in range(N)] + y = [amp*math.cos(2.*math.pi*freq*x) + \ + 1j*amp*math.sin(2.*math.pi*freq*x) for x in t] return y class test_rms(gr_unittest.TestCase): @@ -48,7 +50,7 @@ class test_rms(gr_unittest.TestCase): src_data = sig_source_f(1, 0.01, amp, 200) N = 750000 - expected_data = amp/math.sqrt(2.0) + expected_data = amp / math.sqrt(2.0) src = blocks.vector_source_f(src_data, True) head = blocks.head(gr.sizeof_float, N) diff --git a/gr-blocks/python/blocks/qa_sample_and_hold.py b/gr-blocks/python/blocks/qa_sample_and_hold.py index f645148695..306151600a 100644 --- a/gr-blocks/python/blocks/qa_sample_and_hold.py +++ b/gr-blocks/python/blocks/qa_sample_and_hold.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import time from gnuradio import gr, gr_unittest, blocks diff --git a/gr-blocks/python/blocks/qa_skiphead.py b/gr-blocks/python/blocks/qa_skiphead.py index 16a4ba13b4..36f3f3e797 100755..100644 --- a/gr-blocks/python/blocks/qa_skiphead.py +++ b/gr-blocks/python/blocks/qa_skiphead.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt import numpy diff --git a/gr-blocks/python/blocks/qa_socket_pdu.py b/gr-blocks/python/blocks/qa_socket_pdu.py index 5285585340..961dc914ea 100755..100644 --- a/gr-blocks/python/blocks/qa_socket_pdu.py +++ b/gr-blocks/python/blocks/qa_socket_pdu.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import random import pmt @@ -67,7 +68,7 @@ class qa_socket_pdu (gr_unittest.TestCase): received = self.dbg.get_message(0) received_data = pmt.cdr(received) msg_data = [] - for i in xrange(4): + for i in range(4): msg_data.append(pmt.u8vector_ref(received_data, i)) self.assertEqual(srcdata, tuple(msg_data)) @@ -104,7 +105,7 @@ class qa_socket_pdu (gr_unittest.TestCase): # Test that the TCP server can stream PDUs <= the MTU size. port = str(random.Random().randint(0, 30000) + 10000) mtu = 10000 - srcdata = tuple([x % 256 for x in xrange(mtu)]) + srcdata = tuple(x % 256 for x in range(mtu)) data = pmt.init_u8vector(srcdata.__len__(), srcdata) pdu_msg = pmt.cons(pmt.PMT_NIL, data) @@ -124,7 +125,7 @@ class qa_socket_pdu (gr_unittest.TestCase): received = self.pdu_sink.get_message(0) received_data = pmt.cdr(received) msg_data = [] - for i in xrange(mtu): + for i in range(mtu): msg_data.append(pmt.u8vector_ref(received_data, i)) self.assertEqual(srcdata, tuple(msg_data)) diff --git a/gr-blocks/python/blocks/qa_stream_mux.py b/gr-blocks/python/blocks/qa_stream_mux.py index 3b470afa4c..b09e6db762 100755..100644 --- a/gr-blocks/python/blocks/qa_stream_mux.py +++ b/gr-blocks/python/blocks/qa_stream_mux.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt import os @@ -49,8 +50,8 @@ class test_stream_mux (gr_unittest.TestCase): return dst.data () def help_stream_ramp_2ff(self, N, stream_sizes): - r1 = range(N) - r2 = range(N) + r1 = list(range(N)) + r2 = list(range(N)) r2.reverse() v0 = blocks.vector_source_f(r1, False) diff --git a/gr-blocks/python/blocks/qa_stream_to_tagged_stream.py b/gr-blocks/python/blocks/qa_stream_to_tagged_stream.py index 0d3f503abd..27904ede01 100755..100644 --- a/gr-blocks/python/blocks/qa_stream_to_tagged_stream.py +++ b/gr-blocks/python/blocks/qa_stream_to_tagged_stream.py @@ -21,6 +21,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest from gnuradio import blocks @@ -34,7 +35,7 @@ class qa_stream_to_tagged_stream (gr_unittest.TestCase): def test_001_t (self): src_data = (1, ) * 50 - packet_len = 10L + packet_len = 10 len_tag_key = 'packet_len' src = blocks.vector_source_f(src_data, False, 1) tagger = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len, len_tag_key) @@ -44,7 +45,7 @@ class qa_stream_to_tagged_stream (gr_unittest.TestCase): self.assertEqual(sink.data(), src_data) tags = [gr.tag_to_python(x) for x in sink.tags()] tags = sorted([(x.offset, x.key, x.value) for x in tags]) - expected_tags = [(long(pos), 'packet_len', packet_len) for pos in range(0, 50, 10) ] + expected_tags = [(int(pos), 'packet_len', packet_len) for pos in range(0, 50, 10) ] self.assertEqual(tags, expected_tags) diff --git a/gr-blocks/python/blocks/qa_stretch.py b/gr-blocks/python/blocks/qa_stretch.py index e91a375abf..540d89c0c4 100755..100644 --- a/gr-blocks/python/blocks/qa_stretch.py +++ b/gr-blocks/python/blocks/qa_stretch.py @@ -20,6 +20,8 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks class test_stretch(gr_unittest.TestCase): @@ -34,8 +36,8 @@ class test_stretch(gr_unittest.TestCase): tb = self.tb data = 10*[1,] - data0 = map(lambda x: x/20.0, data) - data1 = map(lambda x: x/10.0, data) + data0 = [x / 20.0 for x in data] + data1 = [x / 10.0 for x in data] expected_result0 = 10*[0.05,] expected_result1 = 10*[0.1,] diff --git a/gr-blocks/python/blocks/qa_tag_debug.py b/gr-blocks/python/blocks/qa_tag_debug.py index 5ccb285a5d..68d131ac0b 100755..100644 --- a/gr-blocks/python/blocks/qa_tag_debug.py +++ b/gr-blocks/python/blocks/qa_tag_debug.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_tag_debug(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_tag_file_sink.py b/gr-blocks/python/blocks/qa_tag_file_sink.py index 250ad1addf..bd4ee54380 100644 --- a/gr-blocks/python/blocks/qa_tag_file_sink.py +++ b/gr-blocks/python/blocks/qa_tag_file_sink.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import os, struct @@ -51,14 +52,14 @@ class test_tag_file_sink(gr_unittest.TestCase): # Open the files and read in the data, then remove the files # to clean up the directory. - outfile0 = file(file0, 'rb') - outfile1 = file(file1, 'rb') - data0 = outfile0.read(8) - data1 = outfile1.read(8) + outfile0 = open(file0, 'rb') + outfile1 = open(file1, 'rb') + data0 = outfile0.read(8) + data1 = outfile1.read(8) outfile0.close() outfile1.close() - os.remove(file0) - os.remove(file1) + os.remove(file0) + os.remove(file1) # Convert the 8 bytes from the files into a tuple of 2 ints. idata0 = struct.unpack('ii', data0) diff --git a/gr-blocks/python/blocks/qa_tag_gate.py b/gr-blocks/python/blocks/qa_tag_gate.py index 7ae676562e..085abf3377 100755..100644 --- a/gr-blocks/python/blocks/qa_tag_gate.py +++ b/gr-blocks/python/blocks/qa_tag_gate.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt @@ -37,7 +38,7 @@ class qa_tag_gate (gr_unittest.TestCase): tag.key = pmt.string_to_symbol('key') tag.value = pmt.from_long(42) tag.offset = 0 - src = blocks.vector_source_f(range(20), False, 1, (tag,)) + src = blocks.vector_source_f(list(range(20)), False, 1, (tag,)) gate = blocks.tag_gate(gr.sizeof_float, False) sink = blocks.vector_sink_f() self.tb.connect(src, gate, sink) diff --git a/gr-blocks/python/blocks/qa_tagged_stream_mux.py b/gr-blocks/python/blocks/qa_tagged_stream_mux.py index 6f1c1c538a..aeedd16c4d 100755..100644 --- a/gr-blocks/python/blocks/qa_tagged_stream_mux.py +++ b/gr-blocks/python/blocks/qa_tagged_stream_mux.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + import numpy import pmt from gnuradio import gr, gr_unittest, blocks @@ -84,9 +85,9 @@ class qa_tagged_stream_mux (gr_unittest.TestCase): This will add a 'special' tag to item 0 on stream 1. It should be on item 0 of the output stream. """ packet_len_0 = 5 - data0 = range(packet_len_0) + data0 = list(range(packet_len_0)) packet_len_1 = 3 - data1 = range(packet_len_1) + data1 = list(range(packet_len_1)) mux = blocks.tagged_stream_mux( gr.sizeof_float, self.tsb_key, @@ -99,7 +100,7 @@ class qa_tagged_stream_mux (gr_unittest.TestCase): (mux, 0) ) self.tb.connect( - blocks.vector_source_f(range(packet_len_1), tags=(make_tag('spam', 'eggs', 0),)), + blocks.vector_source_f(list(range(packet_len_1)), tags=(make_tag('spam', 'eggs', 0),)), blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, self.tsb_key), (mux, 1) ) diff --git a/gr-blocks/python/blocks/qa_tags_strobe.py b/gr-blocks/python/blocks/qa_tags_strobe.py index c4e1b5d8bc..e347e30c8e 100644 --- a/gr-blocks/python/blocks/qa_tags_strobe.py +++ b/gr-blocks/python/blocks/qa_tags_strobe.py @@ -20,6 +20,8 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks import pmt import math @@ -55,7 +57,7 @@ class test_tags_strobe(gr_unittest.TestCase): def test_002(self): N = 10000 nsamps = 123 - ntags = N / nsamps + ntags = N // nsamps src = blocks.tags_strobe(gr.sizeof_float, pmt.intern("TEST"), nsamps) diff --git a/gr-blocks/python/blocks/qa_tcp_server_sink.py b/gr-blocks/python/blocks/qa_tcp_server_sink.py index f7d3a0af92..96c6fcbe32 100644 --- a/gr-blocks/python/blocks/qa_tcp_server_sink.py +++ b/gr-blocks/python/blocks/qa_tcp_server_sink.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import os import socket diff --git a/gr-blocks/python/blocks/qa_threshold.py b/gr-blocks/python/blocks/qa_threshold.py index 49798426f3..5b92ca1a7e 100644 --- a/gr-blocks/python/blocks/qa_threshold.py +++ b/gr-blocks/python/blocks/qa_threshold.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_threshold(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_throttle.py b/gr-blocks/python/blocks/qa_throttle.py index 7d18e87ade..dae489fec8 100755..100644 --- a/gr-blocks/python/blocks/qa_throttle.py +++ b/gr-blocks/python/blocks/qa_throttle.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks class test_throttle(gr_unittest.TestCase): diff --git a/gr-blocks/python/blocks/qa_transcendental.py b/gr-blocks/python/blocks/qa_transcendental.py index 1da56381f4..ba30a62e3d 100644 --- a/gr-blocks/python/blocks/qa_transcendental.py +++ b/gr-blocks/python/blocks/qa_transcendental.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math diff --git a/gr-blocks/python/blocks/qa_tsb_vector_sink_X.py b/gr-blocks/python/blocks/qa_tsb_vector_sink_X.py index ac3cd38d45..dca47b321e 100755..100644 --- a/gr-blocks/python/blocks/qa_tsb_vector_sink_X.py +++ b/gr-blocks/python/blocks/qa_tsb_vector_sink_X.py @@ -21,6 +21,7 @@ # Boston, MA 02110-1301, USA. # + import pmt from gnuradio import gr, gr_unittest from gnuradio import blocks @@ -36,7 +37,7 @@ class qa_tsb_vector_sink (gr_unittest.TestCase): def test_001_t (self): packet_len = 4 - data = range(2 * packet_len) + data = list(range(2 * packet_len)) tag = gr.tag_t() tag.key = pmt.intern("foo") tag.offset = 5 diff --git a/gr-blocks/python/blocks/qa_type_conversions.py b/gr-blocks/python/blocks/qa_type_conversions.py index cd600de2be..6206542edb 100755..100644 --- a/gr-blocks/python/blocks/qa_type_conversions.py +++ b/gr-blocks/python/blocks/qa_type_conversions.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks from math import sqrt, atan2 diff --git a/gr-blocks/python/blocks/qa_udp_source_sink.py b/gr-blocks/python/blocks/qa_udp_source_sink.py index 905b9e08a0..f0418357fd 100644 --- a/gr-blocks/python/blocks/qa_udp_source_sink.py +++ b/gr-blocks/python/blocks/qa_udp_source_sink.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import os diff --git a/gr-blocks/python/blocks/qa_unpack_k_bits.py b/gr-blocks/python/blocks/qa_unpack_k_bits.py index 765c459dfa..f351e75d30 100755..100644 --- a/gr-blocks/python/blocks/qa_unpack_k_bits.py +++ b/gr-blocks/python/blocks/qa_unpack_k_bits.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import random diff --git a/gr-blocks/python/blocks/qa_vco.py b/gr-blocks/python/blocks/qa_vco.py index fdd1eb1001..a67fe36d62 100644 --- a/gr-blocks/python/blocks/qa_vco.py +++ b/gr-blocks/python/blocks/qa_vco.py @@ -20,18 +20,20 @@ # Boston, MA 02110-1301, USA. # +from __future__ import division + from gnuradio import gr, gr_unittest, blocks import math def sig_source_f(samp_rate, freq, amp, N): - t = map(lambda x: float(x)/samp_rate, xrange(N)) - y = map(lambda x: amp*math.cos(2.*math.pi*freq*x), t) + t = [float(x) / samp_rate for x in range(N)] + y = [amp*math.cos(2.*math.pi*freq*x) for x in t] return y def sig_source_c(samp_rate, freq, amp, N): - t = map(lambda x: float(x)/samp_rate, xrange(N)) - y = map(lambda x: math.cos(2.*math.pi*freq*x) + \ - 1j*math.sin(2.*math.pi*freq*x), t) + t = [float(x) / samp_rate for x in range(N)] + y = [math.cos(2.*math.pi*freq*x) + \ + 1j*math.sin(2.*math.pi*freq*x) for x in t] return y class test_vco(gr_unittest.TestCase): @@ -49,7 +51,7 @@ class test_vco(gr_unittest.TestCase): sig_source_f(1, 0.25, 1, 200) src = blocks.vector_source_f(src_data) - op = blocks.vco_f(1, math.pi/2.0, 1) + op = blocks.vco_f(1, math.pi / 2.0, 1) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) @@ -66,7 +68,7 @@ class test_vco(gr_unittest.TestCase): sig_source_c(1, 0.25, 1, 200) src = blocks.vector_source_f(src_data) - op = blocks.vco_c(1, math.pi/2.0, 1) + op = blocks.vco_c(1, math.pi / 2.0, 1) dst = blocks.vector_sink_c() self.tb.connect(src, op, dst) diff --git a/gr-blocks/python/blocks/qa_vector_insert.py b/gr-blocks/python/blocks/qa_vector_insert.py index b916e3d528..5913fee68a 100755..100644 --- a/gr-blocks/python/blocks/qa_vector_insert.py +++ b/gr-blocks/python/blocks/qa_vector_insert.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math diff --git a/gr-blocks/python/blocks/qa_vector_map.py b/gr-blocks/python/blocks/qa_vector_map.py index 1c07de826f..1e7545c2f3 100644 --- a/gr-blocks/python/blocks/qa_vector_map.py +++ b/gr-blocks/python/blocks/qa_vector_map.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import math @@ -34,7 +35,7 @@ class test_vector_map(gr_unittest.TestCase): def test_reversing(self): # Chunk data in blocks of N and reverse the block contents. N = 5 - src_data = range(0, 20) + src_data = list(range(0, 20)) expected_result = [] for i in range(N-1, len(src_data), N): for j in range(0, N): @@ -52,10 +53,10 @@ class test_vector_map(gr_unittest.TestCase): # Split an input vector into N streams. N = 5 M = 20 - src_data = range(0, M) + src_data = list(range(0, M)) expected_results = [] for n in range(0, N): - expected_results.append(range(n, M, N)) + expected_results.append(list(range(n, M, N))) mapping = [[(0, n)] for n in range(0, N)] src = blocks.vector_source_f(src_data, False, N) vmap = blocks.vector_map(gr.sizeof_float, (N, ), mapping) diff --git a/gr-blocks/python/blocks/qa_vector_sink_source.py b/gr-blocks/python/blocks/qa_vector_sink_source.py index 026713f5f4..c9bdfb4b5b 100755..100644 --- a/gr-blocks/python/blocks/qa_vector_sink_source.py +++ b/gr-blocks/python/blocks/qa_vector_sink_source.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import pmt import math diff --git a/gr-blocks/python/blocks/qa_wavfile.py b/gr-blocks/python/blocks/qa_wavfile.py index 97978c936d..761b0be9c5 100755..100644 --- a/gr-blocks/python/blocks/qa_wavfile.py +++ b/gr-blocks/python/blocks/qa_wavfile.py @@ -20,6 +20,7 @@ # Boston, MA 02110-1301, USA. # + from gnuradio import gr, gr_unittest, blocks import os @@ -38,35 +39,35 @@ class test_wavefile(gr_unittest.TestCase): self.tb = None def test_001_checkwavread(self): - wf = blocks.wavfile_source(g_in_file) - self.assertEqual(wf.sample_rate(), 8000) + wf = blocks.wavfile_source(g_in_file) + self.assertEqual(wf.sample_rate(), 8000) def test_002_checkwavcopy(self): - infile = g_in_file - outfile = "test_out.wav" + infile = g_in_file + outfile = "test_out.wav" - wf_in = blocks.wavfile_source(infile) - wf_out = blocks.wavfile_sink(outfile, + wf_in = blocks.wavfile_source(infile) + wf_out = blocks.wavfile_sink(outfile, wf_in.channels(), wf_in.sample_rate(), wf_in.bits_per_sample()) - self.tb.connect(wf_in, wf_out) - self.tb.run() - wf_out.close() + self.tb.connect(wf_in, wf_out) + self.tb.run() + wf_out.close() - # we're losing all extra header chunks - self.assertEqual(getsize(infile) - g_extra_header_len, getsize(outfile)) + # we're losing all extra header chunks + self.assertEqual(getsize(infile) - g_extra_header_len, getsize(outfile)) - in_f = file(infile, 'rb') - out_f = file(outfile, 'rb') + in_f = open(infile, 'rb') + out_f = open(outfile, 'rb') - in_data = in_f.read() - out_data = out_f.read() + in_data = in_f.read() + out_data = out_f.read() out_f.close() - os.remove(outfile) - # cut extra header chunks input file - self.assertEqual(in_data[:g_extra_header_offset] + \ - in_data[g_extra_header_offset + g_extra_header_len:], out_data) + os.remove(outfile) + # cut extra header chunks input file + self.assertEqual(in_data[:g_extra_header_offset] + \ + in_data[g_extra_header_offset + g_extra_header_len:], out_data) if __name__ == '__main__': gr_unittest.run(test_wavefile, "test_wavefile.xml") diff --git a/gr-blocks/python/blocks/stream_to_vector_decimator.py b/gr-blocks/python/blocks/stream_to_vector_decimator.py index bcbfd96b8b..9896ab8d34 100644 --- a/gr-blocks/python/blocks/stream_to_vector_decimator.py +++ b/gr-blocks/python/blocks/stream_to_vector_decimator.py @@ -1,3 +1,4 @@ +from __future__ import unicode_literals # # Copyright 2008 Free Software Foundation, Inc. # @@ -19,9 +20,11 @@ # Boston, MA 02110-1301, USA. # -import blocks_swig as blocks from gnuradio import gr +from . import blocks_swig as blocks + + class stream_to_vector_decimator(gr.hier_block2): """ Convert the stream to a vector, decimate the vector stream to achieve the vector rate. diff --git a/gr-blocks/python/grc_gnuradio/CMakeLists.txt b/gr-blocks/python/grc_gnuradio/CMakeLists.txt deleted file mode 100644 index 9ff1240997..0000000000 --- a/gr-blocks/python/grc_gnuradio/CMakeLists.txt +++ /dev/null @@ -1,37 +0,0 @@ -# Copyright 2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. - -######################################################################## - -include(GrPython) - -GR_PYTHON_INSTALL( - FILES __init__.py - DESTINATION ${GR_PYTHON_DIR}/grc_gnuradio - COMPONENT "blocks_python" -) - -GR_PYTHON_INSTALL(FILES - blks2/__init__.py - blks2/error_rate.py - blks2/selector.py - blks2/tcp.py - DESTINATION ${GR_PYTHON_DIR}/grc_gnuradio/blks2 - COMPONENT "blocks_python" -) diff --git a/gr-blocks/python/grc_gnuradio/README b/gr-blocks/python/grc_gnuradio/README deleted file mode 100644 index 897eed65ca..0000000000 --- a/gr-blocks/python/grc_gnuradio/README +++ /dev/null @@ -1,11 +0,0 @@ -This is the grc_gnuradio module. -It contains supplemental python modules that grc uses at runtime. -The supplemental modules are meant to mimic modules in gnuradio. -These will be phased-out as new functionaility is merged into gnuradio. - -The blk2s module wraps many blocks in blks2 and gives them streaming outputs. -Will be phased-out by new message passing implementations. -Other blks2 blocks will hopefully make their way into blks2impl. - -The wxgui module contains a top_block + wxgui frame. -Will be phased-out by gui.py in wxgui and a new top block template. diff --git a/gr-blocks/python/grc_gnuradio/__init__.py b/gr-blocks/python/grc_gnuradio/__init__.py deleted file mode 100644 index 8b13789179..0000000000 --- a/gr-blocks/python/grc_gnuradio/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/gr-blocks/python/grc_gnuradio/blks2/__init__.py b/gr-blocks/python/grc_gnuradio/blks2/__init__.py deleted file mode 100644 index d3c8210834..0000000000 --- a/gr-blocks/python/grc_gnuradio/blks2/__init__.py +++ /dev/null @@ -1,30 +0,0 @@ -# Copyright 2008-2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -from selector import selector, valve -from error_rate import error_rate -from tcp import tcp_source, tcp_sink - -try: - from packet import options, packet_encoder, packet_decoder, \ - packet_mod_b, packet_mod_s, packet_mod_i, packet_mod_f, packet_mod_c, \ - packet_demod_b, packet_demod_s, packet_demod_i, packet_demod_f, packet_demod_c -except ImportError: - pass # only available if gr-digital is install diff --git a/gr-blocks/python/grc_gnuradio/blks2/error_rate.py b/gr-blocks/python/grc_gnuradio/blks2/error_rate.py deleted file mode 100644 index df03f551b3..0000000000 --- a/gr-blocks/python/grc_gnuradio/blks2/error_rate.py +++ /dev/null @@ -1,143 +0,0 @@ -# Copyright 2008 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -default_win_size = 1000 - -from gnuradio import gr -from gnuradio import blocks -import gnuradio.gr.gr_threading as _threading -import numpy - -#generate 1s counts array -_1s_counts = [sum([1&(i>>j) for j in range(8)]) for i in range(2**8)] - -class input_watcher(_threading.Thread): - """ - Read samples from the message queue and hand them to the callback. - """ - - def __init__(self, msgq, callback): - self._msgq = msgq - self._callback = callback - _threading.Thread.__init__(self) - self.setDaemon(1) - self.keep_running = True - self.start() - - def run(self): - r = '' - while True: - msg = self._msgq.delete_head() - itemsize = int(msg.arg1()) - nitems = int(msg.arg2()) - s = r + msg.to_string() - i = (nitems-nitems%2)*itemsize - r = s[i:] - s = s[:i] - samples = numpy.fromstring(s, numpy.int8) - self._callback(samples) - -class error_rate(gr.hier_block2): - """ - Sample the incoming data streams (byte) and calculate the bit or symbol error rate. - Write the running rate to the output data stream (float). - """ - - def __init__(self, type='BER', win_size=default_win_size, bits_per_symbol=2): - """ - Error rate constructor. - - Args: - type: a string 'BER' or 'SER' - win_size: the number of samples to calculate over - bits_per_symbol: the number of information bits per symbol (BER only) - """ - #init - gr.hier_block2.__init__( - self, 'error_rate', - gr.io_signature(2, 2, gr.sizeof_char), - gr.io_signature(1, 1, gr.sizeof_float), - ) - - print "Warning: the blks2.error_rate is deprecated." - - assert type in ('BER', 'SER') - self._max_samples = win_size - self._bits_per_symbol = bits_per_symbol - #setup message queue - msg_source = blocks.message_source(gr.sizeof_float, 1) - self._msgq_source = msg_source.msgq() - msgq_sink = gr.msg_queue(2) - msg_sink = blocks.message_sink(gr.sizeof_char, msgq_sink, False) #False -> blocking - inter = blocks.interleave(gr.sizeof_char) - #start thread - self._num_errs = 0 - self._err_index = 0 - self._num_samps = 0 - self._err_array = numpy.zeros(self._max_samples, numpy.int8) - if type == 'BER': - input_watcher(msgq_sink, self._handler_ber) - elif type == 'SER': - input_watcher(msgq_sink, self._handler_ser) - #connect - self.connect(msg_source, self) - self.connect((self, 0), (inter, 0)) - self.connect((self, 1), (inter, 1)) - self.connect(inter, msg_sink) - - def _handler_ber(self, samples): - num = len(samples)/2 - arr = numpy.zeros(num, numpy.float32) - for i in range(num): - old_err = self._err_array[self._err_index] - #record error - self._err_array[self._err_index] = _1s_counts[samples[i*2] ^ samples[i*2 + 1]] - self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err - #increment index - self._err_index = (self._err_index + 1)%self._max_samples - self._num_samps = min(self._num_samps + 1, self._max_samples) - #write sample - arr[i] = float(self._num_errs)/float(self._num_samps*self._bits_per_symbol) - #write message - msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num) - self._msgq_source.insert_tail(msg) - - def _handler_ser(self, samples): - num = len(samples)/2 - arr = numpy.zeros(num, numpy.float32) - for i in range(num): - old_err = self._err_array[self._err_index] - #record error - ref = samples[i*2] - res = samples[i*2 + 1] - if ref == res: - self._err_array[self._err_index] = 0 - else: - self._err_array[self._err_index] = 1 - #update number of errors - self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err - #increment index - self._err_index = (self._err_index + 1)%self._max_samples - self._num_samps = min(self._num_samps + 1, self._max_samples) - #write sample - arr[i] = float(self._num_errs)/float(self._num_samps) - #write message - msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num) - self._msgq_source.insert_tail(msg) diff --git a/gr-blocks/python/grc_gnuradio/blks2/selector.py b/gr-blocks/python/grc_gnuradio/blks2/selector.py deleted file mode 100644 index 0a74309688..0000000000 --- a/gr-blocks/python/grc_gnuradio/blks2/selector.py +++ /dev/null @@ -1,147 +0,0 @@ -# -# Copyright 2008,2013 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -from gnuradio import gr -from gnuradio import blocks - -class selector(gr.hier_block2): - """A hier2 block with N inputs and M outputs, where data is only forwarded through input n to output m.""" - def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index): - """ - Selector constructor. - - Args: - item_size: the size of the gr data stream in bytes - num_inputs: the number of inputs (integer) - num_outputs: the number of outputs (integer) - input_index: the index for the source data - output_index: the index for the destination data - """ - gr.hier_block2.__init__( - self, 'selector', - gr.io_signature(num_inputs, num_inputs, item_size), - gr.io_signature(num_outputs, num_outputs, item_size), - ) - - print "Warning: the blks2.selector block is deprecated." - - #terminator blocks for unused inputs and outputs - self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)] - self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)] - self.copy = blocks.copy(item_size) - #connections - for i in range(num_inputs): self.connect((self, i), self.input_terminators[i]) - for i in range(num_outputs): self.connect(blocks.null_source(item_size), - self.output_terminators[i], (self, i)) - self.item_size = item_size - self.input_index = input_index - self.output_index = output_index - self.num_inputs = num_inputs - self.num_outputs = num_outputs - self._connect_current() - - def _indexes_valid(self): - """ - Are the input and output indexes within range of the number of inputs and outputs? - - Returns: - true if input index and output index are in range - """ - return self.input_index in range(self.num_inputs) and self.output_index in range(self.num_outputs) - - def _connect_current(self): - """If the input and output indexes are valid: - disconnect the blocks at the input and output index from their terminators, - and connect them to one another. Then connect the terminators to one another.""" - if self._indexes_valid(): - self.disconnect((self, self.input_index), self.input_terminators[self.input_index]) - self.disconnect(self.output_terminators[self.output_index], (self, self.output_index)) - self.connect((self, self.input_index), self.copy) - self.connect(self.copy, (self, self.output_index)) - self.connect(self.output_terminators[self.output_index], self.input_terminators[self.input_index]) - - def _disconnect_current(self): - """If the input and output indexes are valid: - disconnect the blocks at the input and output index from one another, - and the terminators at the input and output index from one another. - Reconnect the blocks to the terminators.""" - if self._indexes_valid(): - self.disconnect((self, self.input_index), self.copy) - self.disconnect(self.copy, (self, self.output_index)) - self.disconnect(self.output_terminators[self.output_index], self.input_terminators[self.input_index]) - self.connect((self, self.input_index), self.input_terminators[self.input_index]) - self.connect(self.output_terminators[self.output_index], (self, self.output_index)) - - def set_input_index(self, input_index): - """ - Change the block to the new input index if the index changed. - - Args: - input_index: the new input index - """ - if self.input_index != input_index: - self.lock() - self._disconnect_current() - self.input_index = input_index - self._connect_current() - self.unlock() - - def set_output_index(self, output_index): - """ - Change the block to the new output index if the index changed. - - Args: - output_index: the new output index - """ - if self.output_index != output_index: - self.lock() - self._disconnect_current() - self.output_index = output_index - self._connect_current() - self.unlock() - -class valve(selector): - """Wrapper for selector with 1 input and 1 output.""" - - def __init__(self, item_size, open): - """ - Constructor for valve. - - Args: - item_size: the size of the gr data stream in bytes - open: true if initial valve state is open - """ - if open: output_index = -1 - else: output_index = 0 - selector.__init__(self, item_size, 1, 1, 0, output_index) - - print "Warning: the blks2.valve block is deprecated." - - def set_open(self, open): - """ - Callback to set open state. - - Args: - open: true to set valve state to open - """ - if open: output_index = -1 - else: output_index = 0 - self.set_output_index(output_index) diff --git a/gr-blocks/python/grc_gnuradio/blks2/tcp.py b/gr-blocks/python/grc_gnuradio/blks2/tcp.py deleted file mode 100644 index 6ae24d3a7b..0000000000 --- a/gr-blocks/python/grc_gnuradio/blks2/tcp.py +++ /dev/null @@ -1,74 +0,0 @@ -# -# Copyright 2009 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -from gnuradio import gr, blocks -import socket -import os - -def _get_sock_fd(addr, port, server): - """ - Get the file descriptor for the socket. - As a client, block on connect, dup the socket descriptor. - As a server, block on accept, dup the client descriptor. - - Args: - addr: the ip address string - port: the tcp port number - server: true for server mode, false for client mode - - Returns: - the file descriptor number - """ - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - if server: - sock.bind((addr, port)) - sock.listen(1) - clientsock, address = sock.accept() - return os.dup(clientsock.fileno()) - else: - sock.connect((addr, port)) - return os.dup(sock.fileno()) - -class tcp_source(gr.hier_block2): - def __init__(self, itemsize, addr, port, server=True): - #init hier block - gr.hier_block2.__init__( - self, 'tcp_source', - gr.io_signature(0, 0, 0), - gr.io_signature(1, 1, itemsize), - ) - fd = _get_sock_fd(addr, port, server) - self.connect(blocks.file_descriptor_source(itemsize, fd), self) - - print "Warning: the blks2.tcp_source block is deprecated." - -class tcp_sink(gr.hier_block2): - def __init__(self, itemsize, addr, port, server=False): - #init hier block - gr.hier_block2.__init__( - self, 'tcp_sink', - gr.io_signature(1, 1, itemsize), - gr.io_signature(0, 0, 0), - ) - fd = _get_sock_fd(addr, port, server) - self.connect(self, blocks.file_descriptor_sink(itemsize, fd)) - - print "Warning: the blks2.tcp_sink block is deprecated." |