Merged r9481:9518 on jblum/grc_reorganize into trunk. Reorganized grc source under gnuradio.grc module. Trunk passes make distcheck.

git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@9525 221aa14e-8319-0410-a670-987f0aec2ac5

6 files changed, 141 insertions, 147 deletions

diff --git a/grc/src/grc_gnuradio/blks2/Makefile.am b/grc/src/grc_gnuradio/blks2/Makefile.am
index 307ec863f..e3a0b8a38 100644
--- a/grc/src/grc_gnuradio/blks2/Makefile.am
+++ b/grc/src/grc_gnuradio/blks2/Makefile.am
@@ -19,9 +19,9 @@
 # Boston, MA 02110-1301, USA.
 # 
 
-include $(top_srcdir)/Makefile.common
+include $(top_srcdir)/grc/Makefile.inc
 
-ourpythondir = $(pythondir)/grc_gnuradio/blks2
+ourpythondir = $(grc_gnuradio_prefix)/blks2
 
 ourpython_PYTHON = \
 	__init__.py \
diff --git a/grc/src/grc_gnuradio/blks2/__init__.py b/grc/src/grc_gnuradio/blks2/__init__.py
index cd1b793c4..a26228f88 100644
--- a/grc/src/grc_gnuradio/blks2/__init__.py
+++ b/grc/src/grc_gnuradio/blks2/__init__.py
@@ -1,22 +1,22 @@
 # 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.
-# 
+#
 
 from queue import queue_sink_thread
 from queue import queue_sink_c, queue_sink_f, queue_sink_i, queue_sink_s, queue_sink_b
@@ -25,4 +25,3 @@ from queue import queue_source_c, queue_source_f, queue_source_i, queue_source_s
 from selector import selector, valve
 from packet import packet_encoder, packet_decoder
 from error_rate import error_rate
-
diff --git a/grc/src/grc_gnuradio/blks2/error_rate.py b/grc/src/grc_gnuradio/blks2/error_rate.py
index eb09940cb..9b2df58ef 100644
--- a/grc/src/grc_gnuradio/blks2/error_rate.py
+++ b/grc/src/grc_gnuradio/blks2/error_rate.py
@@ -1,22 +1,22 @@
 # 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
 
@@ -31,7 +31,7 @@ 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
@@ -39,7 +39,7 @@ class input_watcher(_threading.Thread):
 		self.setDaemon(1)
 		self.keep_running = True
 		self.start()
-		
+
 	def run(self):
 		r = ''
 		while True:
@@ -49,27 +49,27 @@ class input_watcher(_threading.Thread):
 			s = r + msg.to_string()
 			i = (nitems-nitems%2)*itemsize
 			r = s[i:]
-			s = s[:i]			
+			s = s[:i]
 			samples = numpy.fromstring(s, numpy.int8)
-			self._callback(samples)		
-		
+			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):	
-		"""!
+
+	def __init__(self, type='BER', win_size=default_win_size, bits_per_symbol=2):
+		"""
 		Error rate constructor.
 		@param type a string 'BER' or 'SER'
 		@param win_size the number of samples to calculate over
 		@param 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), 
+			self, 'error_rate',
+			gr.io_signature(2, 2, gr.sizeof_char),
 			gr.io_signature(1, 1, gr.sizeof_float),
 		)
 		assert type in ('BER', 'SER')
@@ -95,12 +95,12 @@ class error_rate(gr.hier_block2):
 		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]									
+			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
@@ -111,13 +111,13 @@ class error_rate(gr.hier_block2):
 			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)			
-		
+		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]									
+			old_err = self._err_array[self._err_index]
 			#record error
 			ref = samples[i*2]
 			res = samples[i*2 + 1]
@@ -134,5 +134,4 @@ class error_rate(gr.hier_block2):
 			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)		
-		
+		self._msgq_source.insert_tail(msg)
diff --git a/grc/src/grc_gnuradio/blks2/packet.py b/grc/src/grc_gnuradio/blks2/packet.py
index 5276de109..fcdfb9ae2 100644
--- a/grc/src/grc_gnuradio/blks2/packet.py
+++ b/grc/src/grc_gnuradio/blks2/packet.py
@@ -1,22 +1,22 @@
 # 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.
-# 
+#
 
 from gnuradio import gr, packet_utils
 import gnuradio.gr.gr_threading as _threading
@@ -31,11 +31,11 @@ DEFAULT_MSGQ_LIMIT = 2
 DEFAULT_THRESHOLD = 12
 
 #######################################################################################
-##	Packet Encoder
+## Packet Encoder
 #######################################################################################
 
 class _packet_encoder_thread(_threading.Thread):
-	
+
 	def __init__(self, msgq, payload_length, send):
 		self._msgq = msgq
 		self._payload_length = payload_length
@@ -44,24 +44,24 @@ class _packet_encoder_thread(_threading.Thread):
 		self.setDaemon(1)
 		self.keep_running = True
 		self.start()
-		
+
 	def run(self):
 		sample = '' #residual sample
 		while self.keep_running:
 			msg = self._msgq.delete_head() #blocking read of message queue
-			sample = sample + msg.to_string() #get the body of the msg as a string	
-			while len(sample) >= self._payload_length:		
+			sample = sample + msg.to_string() #get the body of the msg as a string
+			while len(sample) >= self._payload_length:
 				payload = sample[0:self._payload_length]
-				sample = sample[self._payload_length:]			
-				self._send(payload)	
+				sample = sample[self._payload_length:]
+				self._send(payload)
 
 class packet_encoder(gr.hier_block2):
 	"""
 	Hierarchical block for wrapping packet-based modulators.
 	"""
-	
+
 	def __init__(self, item_size_in, samples_per_symbol, bits_per_symbol, access_code='', pad_for_usrp=True, payload_length=-1):
-		"""!
+		"""
 		packet_mod constructor.
 		@param item_size_in the size of the input data stream in bytes
 		@param samples_per_symbol number of samples per symbol
@@ -79,8 +79,8 @@ class packet_encoder(gr.hier_block2):
 			access_code = packet_utils.default_access_code
 		if not packet_utils.is_1_0_string(access_code):
 			raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
-		self._access_code = access_code		
-		self._pad_for_usrp = pad_for_usrp		
+		self._access_code = access_code
+		self._pad_for_usrp = pad_for_usrp
 		if payload_length < 0: #get payload length
 			payload_length = DEFAULT_PAYLOAD_LEN
 		if payload_length%self._item_size_in != 0:	#verify that packet length is a multiple of the stream size
@@ -88,12 +88,12 @@ class packet_encoder(gr.hier_block2):
 		self._payload_length = payload_length
 		#create blocks
 		msg_source = gr.message_source(gr.sizeof_char, DEFAULT_MSGQ_LIMIT)
-		self._msgq_out = msg_source.msgq()		
+		self._msgq_out = msg_source.msgq()
 		self._msgq_in = gr.msg_queue(DEFAULT_MSGQ_LIMIT)
-		msg_sink = gr.message_sink(self._item_size_in, self._msgq_in, False) #False -> blocking		
+		msg_sink = gr.message_sink(self._item_size_in, self._msgq_in, False) #False -> blocking
 		#initialize hier2
 		gr.hier_block2.__init__(
-			self, 
+			self,
 			"packet_encoder",
 			gr.io_signature(1, 1, self._item_size_in), # Input signature
 			gr.io_signature(1, 1, gr.sizeof_char) # Output signature
@@ -103,12 +103,12 @@ class packet_encoder(gr.hier_block2):
 		self.connect(msg_source, self)
 		#start thread
 		_packet_encoder_thread(self._msgq_in, self._payload_length, self._send_packet)
-		
+
 	def _send_packet(self, payload):
-		"""!
+		"""
 		Wrap the payload in a packet and push onto the message queue.
 		@param payload string, data to send
-		"""	
+		"""
 		packet = packet_utils.make_packet(
 			payload,
 			self._samples_per_symbol,
@@ -118,13 +118,13 @@ class packet_encoder(gr.hier_block2):
 		)
 		msg = gr.message_from_string(packet)
 		self._msgq_out.insert_tail(msg)
-	
+
 #######################################################################################
-##	Packet Decoder
+## Packet Decoder
 #######################################################################################
 
 class _packet_decoder_thread(_threading.Thread):
-    
+
     def __init__(self, msgq, callback):
         _threading.Thread.__init__(self)
         self.setDaemon(1)
@@ -144,9 +144,9 @@ class packet_decoder(gr.hier_block2):
 	"""
 	Hierarchical block for wrapping packet-based demodulators.
 	"""
-	
+
 	def __init__(self, item_size_out, access_code='', threshold=-1):
-		"""!
+		"""
 		packet_demod constructor.
 		@param item_size_out the size of the output data stream in bytes
 		@param access_code AKA sync vector
@@ -159,19 +159,19 @@ class packet_decoder(gr.hier_block2):
 			access_code = packet_utils.default_access_code
 		if not packet_utils.is_1_0_string(access_code):
 			raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
-		self._access_code = access_code		
+		self._access_code = access_code
 		#threshold
-		if threshold < 0: threshold = DEFAULT_THRESHOLD 
-		self._threshold = threshold  
+		if threshold < 0: threshold = DEFAULT_THRESHOLD
+		self._threshold = threshold
 		#blocks
 		self._msgq_in = gr.msg_queue(DEFAULT_MSGQ_LIMIT) #holds packets from the PHY
 		correlator = gr.correlate_access_code_bb(self._access_code, self._threshold)
-		framer_sink = gr.framer_sink_1(self._msgq_in)		
+		framer_sink = gr.framer_sink_1(self._msgq_in)
 		msg_source = gr.message_source(self._item_size_out, DEFAULT_MSGQ_LIMIT)
-		self._msgq_out = msg_source.msgq()		
+		self._msgq_out = msg_source.msgq()
 		#initialize hier2
 		gr.hier_block2.__init__(
-			self, 
+			self,
 			"packet_decoder",
 			gr.io_signature(1, 1, gr.sizeof_char), # Input signature
 			gr.io_signature(1, 1, self._item_size_out) # Output signature
@@ -183,12 +183,10 @@ class packet_decoder(gr.hier_block2):
 		_packet_decoder_thread(self._msgq_in, self._recv_packet)
 
 	def _recv_packet(self, ok, payload):
-		"""!
+		"""
 		Extract the payload from the packet and push onto message queue.
 		@param ok boolean ok
 		@param payload data received
 		"""
 		msg = gr.message_from_string(payload, 0, self._item_size_out, len(payload)/self._item_size_out)
-		if ok: self._msgq_out.insert_tail(msg)			
-
-
+		if ok: self._msgq_out.insert_tail(msg)
diff --git a/grc/src/grc_gnuradio/blks2/queue.py b/grc/src/grc_gnuradio/blks2/queue.py
index cec35e52a..25ea1c616 100644
--- a/grc/src/grc_gnuradio/blks2/queue.py
+++ b/grc/src/grc_gnuradio/blks2/queue.py
@@ -1,37 +1,37 @@
 # 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.
-# 
+#
 
 from gnuradio import gr
 import gnuradio.gr.gr_threading as _threading
 import numpy
 
 #######################################################################################
-##	Queue Sink Thread
+## Queue Sink Thread
 #######################################################################################
 class queue_sink_thread(_threading.Thread):
-	"""!
+	"""
 	Read samples from the queue sink and execute the callback.
 	"""
-	
+
 	def __init__(self, queue_sink, callback):
-		"""!
+		"""
 		Queue sink thread contructor.
 		@param queue_sink the queue to pop messages from
 		@param callback the function of one argument
@@ -42,31 +42,31 @@ class queue_sink_thread(_threading.Thread):
 		self.setDaemon(1)
 		self.keep_running = True
 		self.start()
-		
+
 	def run(self):
 		while self.keep_running:
 			self._callback(self._queue_sink.pop())
 
 #######################################################################################
-##	Queue Sink
+## Queue Sink
 #######################################################################################
 class _queue_sink_base(gr.hier_block2):
-	"""!
+	"""
 	Queue sink base, a queue sink for any size queue.
 	Easy read access to a gnuradio data stream from python.
 	Call pop to read a sample from a gnuradio data stream.
 	Samples are cast as python data types, complex, float, or int.
 	"""
-	
+
 	def __init__(self, vlen=1):
-		"""!
+		"""
 		Queue sink base contructor.
 		@param vlen the vector length
 		"""
 		self._vlen = vlen
 		#initialize hier2
 		gr.hier_block2.__init__(
-			self, 
+			self,
 			"queue_sink",
 			gr.io_signature(1, 1, self._item_size*self._vlen), # Input signature
 			gr.io_signature(0, 0, 0) # Output signature
@@ -77,9 +77,9 @@ class _queue_sink_base(gr.hier_block2):
 		#connect
 		self.connect(self, message_sink)
 		self.arr = ''
-		
+
 	def pop(self):
-		"""!
+		"""
 		Pop a new sample off the front of the queue.
 		@return a new sample
 		"""
@@ -95,59 +95,59 @@ class _queue_sink_base(gr.hier_block2):
 class queue_sink_c(_queue_sink_base):
 	_item_size = gr.sizeof_gr_complex
 	_numpy = numpy.complex64
-	def _cast(self, arg): return complex(arg.real, arg.imag)		
-	
+	def _cast(self, arg): return complex(arg.real, arg.imag)
+
 class queue_sink_f(_queue_sink_base):
 	_item_size = gr.sizeof_float
 	_numpy = numpy.float32
 	_cast = float
-	
+
 class queue_sink_i(_queue_sink_base):
 	_item_size = gr.sizeof_int
 	_numpy = numpy.int32
 	_cast = int
-	
+
 class queue_sink_s(_queue_sink_base):
 	_item_size = gr.sizeof_short
 	_numpy = numpy.int16
 	_cast = int
-	
+
 class queue_sink_b(_queue_sink_base):
 	_item_size = gr.sizeof_char
 	_numpy = numpy.int8
 	_cast = int
-	
+
 #######################################################################################
-##	Queue Source
+## Queue Source
 #######################################################################################
 class _queue_source_base(gr.hier_block2):
-	"""!
+	"""
 	Queue source base, a queue source for any size queue.
 	Easy write access to a gnuradio data stream from python.
 	Call push to to write a sample into the gnuradio data stream.
 	"""
-	
+
 	def __init__(self, vlen=1):
-		"""!
+		"""
 		Queue source base contructor.
 		@param vlen the vector length
 		"""
 		self._vlen = vlen
 		#initialize hier2
 		gr.hier_block2.__init__(
-			self, 
+			self,
 			"queue_source",
 			gr.io_signature(0, 0, 0), # Input signature
 			gr.io_signature(1, 1, self._item_size*self._vlen) # Output signature
 		)
 		#create message sink
-		message_source = gr.message_source(self._item_size*self._vlen, 1) 
+		message_source = gr.message_source(self._item_size*self._vlen, 1)
 		self._msgq = message_source.msgq()
 		#connect
 		self.connect(message_source, self)
-		
+
 	def push(self, item):
-		"""!
+		"""
 		Push an item into the back of the queue.
 		@param item the item
 		"""
@@ -159,20 +159,19 @@ class _queue_source_base(gr.hier_block2):
 class queue_source_c(_queue_source_base):
 	_item_size = gr.sizeof_gr_complex
 	_numpy = numpy.complex64
-	
+
 class queue_source_f(_queue_source_base):
 	_item_size = gr.sizeof_float
 	_numpy = numpy.float32
-	
+
 class queue_source_i(_queue_source_base):
 	_item_size = gr.sizeof_int
 	_numpy = numpy.int32
-	
+
 class queue_source_s(_queue_source_base):
 	_item_size = gr.sizeof_short
 	_numpy = numpy.int16
-	
+
 class queue_source_b(_queue_source_base):
 	_item_size = gr.sizeof_char
 	_numpy = numpy.int8
-
diff --git a/grc/src/grc_gnuradio/blks2/selector.py b/grc/src/grc_gnuradio/blks2/selector.py
index 787f6547f..0997a5ce7 100644
--- a/grc/src/grc_gnuradio/blks2/selector.py
+++ b/grc/src/grc_gnuradio/blks2/selector.py
@@ -1,92 +1,92 @@
 #!/usr/bin/env python
 #
 # 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.
-# 
+#
 
 from gnuradio import gr
-		
+
 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):	
-		"""!
+	def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
+		"""
 		SelectorHelper constructor.
 		@param item_size the size of the gr data stream in bytes
 		@param num_inputs the number of inputs (integer)
 		@param num_outputs the number of outputs (integer)
 		@param input_index the index for the source data
 		@param output_index the index for the destination data
-		"""	
+		"""
 		gr.hier_block2.__init__(
-			self, 'selector', 
-			gr.io_signature(num_inputs, num_inputs, item_size), 
+			self, 'selector',
+			gr.io_signature(num_inputs, num_inputs, item_size),
 			gr.io_signature(num_outputs, num_outputs, item_size),
 		)
-		#terminator blocks for unused inputs and outputs	
+		#terminator blocks for unused inputs and outputs
 		self.input_terminators = [gr.null_sink(item_size)] * num_inputs
 		self.output_terminators = [gr.head(item_size, 0)] * num_outputs
 		self.copy = None
-		#connections		
+		#connections
 		for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
-		for i in range(num_outputs): self.connect(gr.null_source(item_size), self.output_terminators[i], (self, i))	
-		self.item_size = item_size		
+		for i in range(num_outputs): self.connect(gr.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.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?
 		@return 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, 
+		"""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, self.input_index), self.input_terminators[self.input_index])
 			self.disconnect(self.output_terminators[self.output_index], (self, self.output_index))
 			self.copy = gr.skiphead(self.item_size, 0)
 			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])	
-		
+			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, 
+		"""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])
-			del self.copy			
-			self.copy = None			
+			del self.copy
+			self.copy = None
 			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.
 		@param input_index the new input index
 		"""
@@ -95,25 +95,25 @@ class selector(gr.hier_block2):
 			self._disconnect_current()
 			self.input_index = input_index
 			self._connect_current()
-			self.unlock()		
-		
+			self.unlock()
+
 	def set_output_index(self, output_index):
-		"""!
+		"""
 		Change the block to the new output index if the index changed.
 		@param output_index the new output index
-		"""		
-		if self.output_index != output_index:	
+		"""
+		if self.output_index != output_index:
 			self.lock()
 			self._disconnect_current()
 			self.output_index = output_index
-			self._connect_current()			
-			self.unlock()	
+			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.
 		@param item_size the size of the gr data stream in bytes
 		@param open true if initial valve state is open
@@ -121,13 +121,12 @@ class valve(selector):
 		if open: output_index = -1
 		else: output_index = 0
 		selector.__init__(self, item_size, 1, 1, 0, output_index)
-		
+
 	def set_open(self, open):
-		"""!
+		"""
 		Callback to set open state.
 		@param open true to set valve state to open
 		"""
 		if open: output_index = -1
 		else: output_index = 0
 		self.set_output_index(output_index)
-