Moved generic psk and qam modulation into gr-digital.

13 files changed, 1 insertions, 1230 deletions

diff --git a/gnuradio-core/src/python/gnuradio/Makefile.am b/gnuradio-core/src/python/gnuradio/Makefile.am
index 1bec7dd19..eff35e95c 100644
--- a/gnuradio-core/src/python/gnuradio/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/Makefile.am
@@ -22,7 +22,7 @@
 include $(top_srcdir)/Makefile.common
 
 if PYTHON
-SUBDIRS = gr gru gruimpl blks2 blks2impl vocoder utils
+SUBDIRS = gr gru gruimpl blks2 blks2impl vocoder
 
 grpython_PYTHON = 			\
 	__init__.py			\
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am b/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am
index 6a2e7d5f7..34e246b36 100644
--- a/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am
@@ -29,7 +29,6 @@ grblkspythondir = $(grpythondir)/blks2impl
 grblkspython_PYTHON =		\
 	__init__.py		\
 	am_demod.py		\
-	bpsk.py			\
 	channel_model.py	\
 	dbpsk.py		\
 	dbpsk2.py		\
@@ -39,7 +38,6 @@ grblkspython_PYTHON =		\
 	filterbank.py		\
 	fm_demod.py		\
 	fm_emph.py		\
-	generic_mod_demod.py    \
 	generic_usrp.py	\
 	gmsk.py			\
 	cpm.py			\
@@ -58,9 +56,6 @@ grblkspython_PYTHON =		\
 	pfb_interpolator.py	\
 	pkt.py			\
 	psk.py			\
-	psk2.py			\
-	qam.py			\
-	qpsk.py			\
 	rational_resampler.py	\
 	standard_squelch.py	\
 	stream_to_vector_decimator.py \
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py b/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py
deleted file mode 100644
index 16524de94..000000000
--- a/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#
-# Copyright 2005,2006,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.
-# 
-
-"""
-BPSK modulation and demodulation.
-"""
-
-from math import pi, log
-from cmath import exp
-
-from gnuradio import gr, modulation_utils2
-from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod
-
-# Default number of points in constellation.
-_def_constellation_points = 2
-# Whether differential coding is used.
-_def_differential = True
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           BPSK constellation
-# /////////////////////////////////////////////////////////////////////////////
-
-def bpsk_constellation(m=_def_constellation_points):
-    if m != _def_constellation_points:
-        raise ValueError("BPSK can only have 2 constellation points.")
-    return gr.constellation_bpsk()
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           BPSK modulator
-# /////////////////////////////////////////////////////////////////////////////
-
-class bpsk_mod(generic_mod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered BPSK modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_mod block for list of parameters.
-	"""
-
-        constellation = gr.constellation_bpsk()
-        if constellation_points != 2:
-            raise ValueError('Number of constellation points must be 2 for BPSK.')
-        super(bpsk_mod, self).__init__(constellation, *args, **kwargs)
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           BPSK demodulator
-#
-# /////////////////////////////////////////////////////////////////////////////
-
-class bpsk_demod(generic_demod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered BPSK modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_demod block for list of parameters.
-        """
-
-        constellation = gr.constellation_bpsk()
-        if constellation_points != 2:
-            raise ValueError('Number of constellation points must be 2 for BPSK.')
-        super(bpsk_demod, self).__init__(constellation, *args, **kwargs)
-
-#
-# Add these to the mod/demod registry
-#
-modulation_utils2.add_type_1_mod('bpsk', bpsk_mod)
-modulation_utils2.add_type_1_demod('bpsk', bpsk_demod)
-modulation_utils2.add_type_1_constellation('bpsk', bpsk_constellation)
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py b/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py
deleted file mode 100644
index 44779754b..000000000
--- a/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py
+++ /dev/null
@@ -1,395 +0,0 @@
-#
-# Copyright 2005,2006,2007,2009,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.
-# 
-
-# See gnuradio-examples/python/digital for examples
-
-"""
-Generic modulation and demodulation.
-"""
-
-from gnuradio import gr
-from gnuradio.modulation_utils2 import extract_kwargs_from_options_for_class
-from gnuradio.utils import mod_codes
-
-# default values (used in __init__ and add_options)
-_def_samples_per_symbol = 2
-_def_excess_bw = 0.35
-_def_verbose = False
-_def_log = False
-
-# Frequency correction
-_def_freq_alpha = 0.010
-# Symbol timing recovery 
-_def_timing_alpha = 0.100
-_def_timing_beta = 0.010
-_def_timing_max_dev = 1.5
-# Fine frequency / Phase correction
-_def_phase_alpha = 0.1
-# Number of points in constellation
-_def_constellation_points = 16
-# Whether differential coding is used.
-_def_differential = True
-
-def add_common_options(parser):
-    """
-    Sets options common to both modulator and demodulator.
-    """
-    parser.add_option("-p", "--constellation-points", type="int", default=_def_constellation_points,
-                      help="set the number of constellation points (must be a power of 2 (power of 4 for QAM) [default=%default]")
-    parser.add_option("", "--differential", action="store_true", dest="differential", default=True,
-                      help="use differential encoding [default=%default]")
-    parser.add_option("", "--not-differential", action="store_false", dest="differential",
-                      help="do not use differential encoding [default=%default]")
-    parser.add_option("", "--mod-code", type="choice", choices=mod_codes.codes,
-                      default=mod_codes.NO_CODE,
-                      help="Select modulation code from: %s [default=%%default]"
-                            % (', '.join(mod_codes.codes),))
-    parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
-                      help="set RRC excess bandwith factor [default=%default]")
-    
-
-# /////////////////////////////////////////////////////////////////////////////
-#                             Generic modulator
-# /////////////////////////////////////////////////////////////////////////////
-
-class generic_mod(gr.hier_block2):
-
-    def __init__(self, constellation,
-                 differential=_def_differential,
-                 samples_per_symbol=_def_samples_per_symbol,
-                 excess_bw=_def_excess_bw,
-                 verbose=_def_verbose,
-                 log=_def_log):
-        """
-	Hierarchical block for RRC-filtered differential generic modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-        
-	@param constellation: determines the modulation type
-	@type constellation: gnuradio.gr.gr_constellation
-	@param samples_per_symbol: samples per baud >= 2
-	@type samples_per_symbol: integer
-	@param excess_bw: Root-raised cosine filter excess bandwidth
-	@type excess_bw: float
-        @param verbose: Print information about modulator?
-        @type verbose: bool
-        @param log: Log modulation data to files?
-        @type log: bool
-	"""
-
-	gr.hier_block2.__init__(self, "generic_mod",
-				gr.io_signature(1, 1, gr.sizeof_char),       # Input signature
-				gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
-
-        self._constellation = constellation.base()
-        self._samples_per_symbol = samples_per_symbol
-        self._excess_bw = excess_bw
-        self._differential = differential
- 
-        if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
-            raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol)
-        
-	ntaps = 11 * self._samples_per_symbol
-
-        arity = pow(2,self.bits_per_symbol())
-        
-        # turn bytes into k-bit vectors
-        self.bytes2chunks = \
-          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
-
-        if self._constellation.apply_pre_diff_code():
-            self.symbol_mapper = gr.map_bb(self._constellation.pre_diff_code())
-
-        if differential:
-            self.diffenc = gr.diff_encoder_bb(arity)
-
-        self.chunks2symbols = gr.chunks_to_symbols_bc(self._constellation.points())
-
-        # pulse shaping filter
-	self.rrc_taps = gr.firdes.root_raised_cosine(
-	    self._samples_per_symbol,   # gain (samples_per_symbol since we're
-                                        # interpolating by samples_per_symbol)
-	    self._samples_per_symbol,   # sampling rate
-	    1.0,		        # symbol rate
-	    self._excess_bw,            # excess bandwidth (roll-off factor)
-            ntaps)
-	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
-                                                   self.rrc_taps)
-
-	# Connect
-        blocks = [self, self.bytes2chunks]
-        if self._constellation.apply_pre_diff_code():
-            blocks.append(self.symbol_mapper)
-        if differential:
-            blocks.append(self.diffenc)
-        blocks += [self.chunks2symbols, self.rrc_filter, self]
-        self.connect(*blocks)
-
-        if verbose:
-            self._print_verbage()
-            
-        if log:
-            self._setup_logging()
-            
-
-    def samples_per_symbol(self):
-        return self._samples_per_symbol
-
-    def bits_per_symbol(self):   # static method that's also callable on an instance
-        return self._constellation.bits_per_symbol()
-
-    def add_options(parser):
-        """
-        Adds generic modulation options to the standard parser
-        """
-        add_common_options(parser)
-    add_options=staticmethod(add_options)
-
-    def extract_kwargs_from_options(cls, options):
-        """
-        Given command line options, create dictionary suitable for passing to __init__
-        """
-        return extract_kwargs_from_options_for_class(cls, options)
-    extract_kwargs_from_options=classmethod(extract_kwargs_from_options)
-
-
-    def _print_verbage(self):
-        print "\nModulator:"
-        print "bits per symbol:     %d" % self.bits_per_symbol()
-        print "RRC roll-off factor: %.2f" % self._excess_bw
-
-    def _setup_logging(self):
-        print "Modulation logging turned on."
-        self.connect(self.bytes2chunks,
-                     gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
-        if self._constellation.apply_pre_diff_code():
-            self.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat"))
-        if self._differential:
-            self.connect(self.diffenc,
-                         gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
-        self.connect(self.chunks2symbols,
-                     gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
-        self.connect(self.rrc_filter,
-                     gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
-              
-
-# /////////////////////////////////////////////////////////////////////////////
-#                             Generic demodulator
-#
-#      Differentially coherent detection of differentially encoded generically
-#      modulated signal.
-# /////////////////////////////////////////////////////////////////////////////
-
-class generic_demod(gr.hier_block2):
-
-    def __init__(self, constellation,
-                 samples_per_symbol=_def_samples_per_symbol,
-                 differential=_def_differential,
-                 excess_bw=_def_excess_bw,
-                 freq_alpha=_def_freq_alpha,
-                 timing_alpha=_def_timing_alpha,
-                 timing_max_dev=_def_timing_max_dev,
-                 phase_alpha=_def_phase_alpha,
-                 verbose=_def_verbose,
-                 log=_def_log):
-        """
-	Hierarchical block for RRC-filtered differential generic demodulation.
-
-	The input is the complex modulated signal at baseband.
-	The output is a stream of bits packed 1 bit per byte (LSB)
-
-	@param constellation: determines the modulation type
-	@type constellation: gnuradio.gr.gr_constellation
-	@param samples_per_symbol: samples per symbol >= 2
-	@type samples_per_symbol: float
-	@param excess_bw: Root-raised cosine filter excess bandwidth
-	@type excess_bw: float
-        @param freq_alpha: loop filter gain for frequency recovery
-        @type freq_alpha: float
-        @param timing_alpha: loop alpha gain for timing recovery
-        @type timing_alpha: float
-        @param timing_max_dev: timing loop maximum rate deviations
-        @type timing_max_dev: float
-        @param phase_alpha: loop filter gain in phase loop
-        @type phase_alphas: float
-        @param verbose: Print information about modulator?
-        @type verbose: bool
-        @param debug: Print modualtion data to files?
-        @type debug: bool
-	"""
-        
-	gr.hier_block2.__init__(self, "generic_demod",
-				gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
-				gr.io_signature(1, 1, gr.sizeof_char))       # Output signature
-				
-        self._constellation = constellation.base()
-        self._samples_per_symbol = samples_per_symbol
-        self._excess_bw = excess_bw
-        self._phase_alpha = phase_alpha
-        self._freq_alpha = freq_alpha
-        self._freq_beta = 0.10*self._freq_alpha
-        self._timing_alpha = timing_alpha
-        self._timing_beta = _def_timing_beta
-        self._timing_max_dev=timing_max_dev
-        self._differential = differential
-
-        if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
-            raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol)
-
-        arity = pow(2,self.bits_per_symbol())
-
-        # Automatic gain control
-        self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
-
-        # Frequency correction
-        self.freq_recov = gr.fll_band_edge_cc(self._samples_per_symbol, self._excess_bw,
-                                              11*int(self._samples_per_symbol),
-                                              self._freq_alpha, self._freq_beta)
-
-        # symbol timing recovery with RRC data filter
-        nfilts = 32
-        ntaps = 11 * int(self._samples_per_symbol*nfilts)
-        taps = gr.firdes.root_raised_cosine(nfilts, nfilts,
-                                            1.0/float(self._samples_per_symbol),
-                                            self._excess_bw, ntaps)
-        self.time_recov = gr.pfb_clock_sync_ccf(self._samples_per_symbol,
-                                                self._timing_alpha,
-                                                taps, nfilts, nfilts/2, self._timing_max_dev)
-        self.time_recov.set_beta(self._timing_beta)
-
-        #self._phase_beta  = 0.25 * self._phase_alpha * self._phase_alpha
-        self._phase_beta  = 0.25 * self._phase_alpha * self._phase_alpha
-        fmin = -0.25
-        fmax = 0.25
-        
-        self.receiver = gr.constellation_receiver_cb(
-            self._constellation,
-            self._phase_alpha, self._phase_beta,
-            fmin, fmax)
-        
-        # Do differential decoding based on phase change of symbols
-        if differential:
-            self.diffdec = gr.diff_decoder_bb(arity)
-
-        if self._constellation.apply_pre_diff_code():
-            self.symbol_mapper = gr.map_bb(
-                mod_codes.invert_code(self._constellation.pre_diff_code()))
-
-        # unpack the k bit vector into a stream of bits
-        self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
-
-        if verbose:
-            self._print_verbage()
-
-        if log:
-            self._setup_logging()
-
-        # Connect and Initialize base class
-        blocks = [self, self.agc, self.freq_recov, self.time_recov, self.receiver]
-        if differential:
-            blocks.append(self.diffdec)
-        if self._constellation.apply_pre_diff_code():
-            blocks.append(self.symbol_mapper)
-        blocks += [self.unpack, self]
-        self.connect(*blocks)
-
-    def samples_per_symbol(self):
-        return self._samples_per_symbol
-
-    def bits_per_symbol(self):   # staticmethod that's also callable on an instance
-        return self._constellation.bits_per_symbol()
-
-    def _print_verbage(self):
-        print "\nDemodulator:"
-        print "bits per symbol:     %d"   % self.bits_per_symbol()
-        print "RRC roll-off factor: %.2f" % self._excess_bw
-        print "FLL gain:            %.2e" % self._freq_alpha
-        print "Timing alpha gain:   %.2e" % self._timing_alpha
-        print "Timing beta gain:    %.2e" % self._timing_beta
-        print "Timing max dev:      %.2f" % self._timing_max_dev
-        print "Phase track alpha:   %.2e" % self._phase_alpha
-        print "Phase track beta:    %.2e" % self._phase_beta
-
-    def _setup_logging(self):
-        print "Modulation logging turned on."
-        self.connect(self.agc,
-                     gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
-        self.connect((self.freq_recov, 0),
-                     gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov.dat"))
-        self.connect((self.freq_recov, 1),
-                     gr.file_sink(gr.sizeof_float, "rx_freq_recov_freq.dat"))
-        self.connect((self.freq_recov, 2),
-                     gr.file_sink(gr.sizeof_float, "rx_freq_recov_phase.dat"))
-        self.connect((self.freq_recov, 3),
-                     gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov_error.dat"))
-        self.connect((self.time_recov, 0),
-                     gr.file_sink(gr.sizeof_gr_complex, "rx_time_recov.dat"))
-        self.connect((self.time_recov, 1),
-                     gr.file_sink(gr.sizeof_float, "rx_time_recov_error.dat"))
-        self.connect((self.time_recov, 2),
-                     gr.file_sink(gr.sizeof_float, "rx_time_recov_rate.dat"))
-        self.connect((self.time_recov, 3),
-                     gr.file_sink(gr.sizeof_float, "rx_time_recov_phase.dat"))
-        self.connect((self.receiver, 0),
-                     gr.file_sink(gr.sizeof_char, "rx_receiver.dat"))
-        self.connect((self.receiver, 1),
-                     gr.file_sink(gr.sizeof_float, "rx_receiver_error.dat"))
-        self.connect((self.receiver, 2),
-                     gr.file_sink(gr.sizeof_float, "rx_receiver_phase.dat"))
-        self.connect((self.receiver, 3),
-                     gr.file_sink(gr.sizeof_float, "rx_receiver_freq.dat"))
-        if self._differential:
-            self.connect(self.diffdec,
-                         gr.file_sink(gr.sizeof_char, "rx_diffdec.dat"))        
-        if self._constellation.apply_pre_diff_code():
-            self.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))        
-        self.connect(self.unpack,
-                     gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
-        
-    def add_options(parser):
-        """
-        Adds generic demodulation options to the standard parser
-        """
-        # Add options shared with modulator.
-        add_common_options(parser)
-        # Add options specific to demodulator.
-        parser.add_option("", "--freq-alpha", type="float", default=_def_freq_alpha,
-                          help="set frequency lock loop alpha gain value [default=%default]")
-        parser.add_option("", "--phase-alpha", type="float", default=_def_phase_alpha,
-                          help="set phase tracking loop alpha value [default=%default]")
-        parser.add_option("", "--timing-alpha", type="float", default=_def_timing_alpha,
-                          help="set timing symbol sync loop gain alpha value [default=%default]")
-        parser.add_option("", "--timing-beta", type="float", default=_def_timing_beta,
-                          help="set timing symbol sync loop gain beta value [default=%default]")
-        parser.add_option("", "--timing-max-dev", type="float", default=_def_timing_max_dev,
-                          help="set timing symbol sync loop maximum deviation [default=%default]")
-    add_options=staticmethod(add_options)
-    
-    def extract_kwargs_from_options(cls, options):
-        """
-        Given command line options, create dictionary suitable for passing to __init__
-        """
-        return extract_kwargs_from_options_for_class(cls, options)
-    extract_kwargs_from_options=classmethod(extract_kwargs_from_options)
-
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py b/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py
deleted file mode 100644
index aaa9659a4..000000000
--- a/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#
-# Copyright 2005,2006,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.
-# 
-
-"""
-PSK modulation and demodulation.
-"""
-
-from math import pi, log
-from cmath import exp
-
-from gnuradio import gr, modulation_utils2
-from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod
-from gnuradio.utils import mod_codes, gray_code
-
-# Default number of points in constellation.
-_def_constellation_points = 4
-# The default encoding (e.g. gray-code, set-partition)
-_def_mod_code = mod_codes.GRAY_CODE
-
-def create_encodings(mod_code, arity):
-    post_diff_code = None
-    if mod_code not in mod_codes.codes:
-        raise ValueError('That modulation code does not exist.')
-    if mod_code == mod_codes.GRAY_CODE:
-        pre_diff_code = gray_code.gray_code(arity)
-    elif mod_code == mod_codes.SET_PARTITION_CODE:
-        pre_diff_code = set_partition_code.set_partition_code(arity) 
-    elif mod_code == mod_codes.NO_CODE:
-        pre_diff_code = []
-    else:
-        raise ValueError('That modulation code is not implemented for this constellation.')
-    return (pre_diff_code, post_diff_code)
-    
-# /////////////////////////////////////////////////////////////////////////////
-#                           PSK constellation
-# /////////////////////////////////////////////////////////////////////////////
-
-def psk_constellation(m=_def_constellation_points, mod_code=_def_mod_code):
-    """
-    Creates a PSK constellation object.
-    """
-    k = log(m) / log(2.0)
-    if (k != int(k)):
-        raise StandardError('Number of constellation points must be a power of two.')
-    points = [exp(2*pi*(0+1j)*i/m) for i in range(0,m)]
-    pre_diff_code, post_diff_code = create_encodings(mod_code, m)
-    if post_diff_code is not None:
-        inverse_post_diff_code = mod_codes.invert_code(post_diff_code)
-        points = [points[x] for x in inverse_post_diff_code]
-    constellation = gr.constellation_psk(points, pre_diff_code, m)
-    return constellation
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           PSK modulator
-# /////////////////////////////////////////////////////////////////////////////
-
-class psk_mod(generic_mod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 mod_code=_def_mod_code,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered PSK modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_mod block for list of parameters.
-	"""
-
-        constellation = psk_constellation(constellation_points, mod_code)
-        super(psk_mod, self).__init__(constellation, *args, **kwargs)
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           PSK demodulator
-#
-# /////////////////////////////////////////////////////////////////////////////
-
-class psk_demod(generic_demod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 mod_code=_def_mod_code,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered PSK modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_demod block for list of parameters.
-        """
-
-        constellation = psk_constellation(constellation_points, mod_code)
-        super(psk_demod, self).__init__(constellation, *args, **kwargs)
-
-#
-# Add these to the mod/demod registry
-#
-modulation_utils2.add_type_1_mod('psk', psk_mod)
-modulation_utils2.add_type_1_demod('psk', psk_demod)
-modulation_utils2.add_type_1_constellation('psk', psk_constellation)
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/qam.py b/gnuradio-core/src/python/gnuradio/blks2impl/qam.py
deleted file mode 100644
index 9c135b25a..000000000
--- a/gnuradio-core/src/python/gnuradio/blks2impl/qam.py
+++ /dev/null
@@ -1,226 +0,0 @@
-#
-# Copyright 2005,2006,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.
-# 
-
-"""
-QAM modulation and demodulation.
-"""
-
-from math import pi, sqrt, log
-
-from gnuradio import gr, modulation_utils2
-from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod
-from gnuradio.utils.gray_code import gray_code
-from gnuradio.utils import mod_codes
-
-# Default number of points in constellation.
-_def_constellation_points = 16
-# Whether the quadrant bits are coded differentially.
-_def_differential = True
-# Whether gray coding is used.  If differential is True then gray
-# coding is used within but not between each quadrant.
-_def_mod_code = mod_codes.NO_CODE
-
-def is_power_of_four(x):
-    v = log(x)/log(4)
-    return int(v) == v
-
-def get_bit(x, n):
-    """ Get the n'th bit of integer x (from little end)."""
-    return (x&(0x01 << n)) >> n
-
-def get_bits(x, n, k):
-    """ Get the k bits of integer x starting at bit n(from little end)."""
-    # Remove the n smallest bits
-    v = x >> n 
-    # Remove all bits bigger than n+k-1
-    return v % pow(2, k)
-
-def make_differential_constellation(m, gray_coded):
-    """
-    Create a constellation with m possible symbols where m must be
-    a power of 4.
-
-    Points are laid out in a square grid.
-
-    Bits referring to the quadrant are differentilly encoded,
-    remaining bits are gray coded.
-
-    """
-    sqrtm = pow(m, 0.5)
-    if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)):
-        raise ValueError("m must be a power of 4 integer.")
-    # Each symbol holds k bits.
-    k = int(log(m) / log(2.0))
-    # First create a constellation for one quadrant containing m/4 points.
-    # The quadrant has 'side' points along each side of a quadrant.
-    side = int(sqrtm/2)
-    if gray_coded:
-        # Number rows and columns using gray codes.
-        gcs = gray_code(side)
-        # Get inverse gray codes.
-        i_gcs = dict([(v, key) for key, v in enumerate(gcs)])
-    else:
-        i_gcs = dict([(i, i) for i in range(0, side)])
-    # The distance between points is found.
-    step = 1/(side-0.5)
-
-    gc_to_x = [(i_gcs[gc]+0.5)*step for gc in range(0, side)]
-
-    # Takes the (x, y) location of the point with the quadrant along
-    # with the quadrant number. (x, y) are integers referring to which
-    # point within the quadrant it is.
-    # A complex number representing this location of this point is returned.
-    def get_c(gc_x, gc_y, quad):
-        if quad == 0:
-            return complex(gc_to_x[gc_x], gc_to_x[gc_y])
-        if quad == 1:
-            return complex(-gc_to_x[gc_y], gc_to_x[gc_x])
-        if quad == 2:
-            return complex(-gc_to_x[gc_x], -gc_to_x[gc_y])
-        if quad == 3:
-            return complex(gc_to_x[gc_y], -gc_to_x[gc_x])
-        raise StandardError("Impossible!")
-
-    # First two bits determine quadrant.
-    # Next (k-2)/2 bits determine x position.
-    # Following (k-2)/2 bits determine y position.
-    # How x and y relate to real and imag depends on quadrant (see get_c function).
-    const_map = []
-    for i in range(m):
-        y = get_bits(i, 0, (k-2)/2)
-        x = get_bits(i, (k-2)/2, (k-2)/2)
-        quad = get_bits(i, k-2, 2)
-        const_map.append(get_c(x, y, quad))
-
-    return const_map
-
-def make_not_differential_constellation(m, gray_coded):
-    side = int(pow(m, 0.5))
-    if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)):
-        raise ValueError("m must be a power of 4 integer.")
-    # Each symbol holds k bits.
-    k = int(log(m) / log(2.0))
-    if gray_coded:
-        # Number rows and columns using gray codes.
-        gcs = gray_code(side)
-        # Get inverse gray codes.
-        i_gcs = mod_codes.invert_code(gcs)
-    else:
-        i_gcs = range(0, side)
-    # The distance between points is found.
-    step = 2.0/(side-1)
-
-    gc_to_x = [-1 + i_gcs[gc]*step for gc in range(0, side)]
-    # First k/2 bits determine x position.
-    # Following k/2 bits determine y position.
-    const_map = []
-    for i in range(m):
-        y = gc_to_x[get_bits(i, 0, k/2)]
-        x = gc_to_x[get_bits(i, k/2, k/2)]
-        const_map.append(complex(x,y))
-    return const_map
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           QAM constellation
-# /////////////////////////////////////////////////////////////////////////////
-
-def qam_constellation(constellation_points=_def_constellation_points,
-                      differential=_def_differential,
-                      mod_code=_def_mod_code):
-    """
-    Creates a QAM constellation object.
-    """
-    if mod_code == mod_codes.GRAY_CODE:
-        gray_coded = True
-    elif mod_code == mod_codes.NO_CODE:
-        gray_coded = False
-    else:
-        raise ValueError("Mod code is not implemented for QAM")
-    if differential:
-        points = make_differential_constellation(constellation_points, gray_coded)
-    else:
-        points = make_not_differential_constellation(constellation_points, gray_coded)
-    side = int(sqrt(constellation_points))
-    width = 2.0/(side-1)
-    # No pre-diff code
-    # Should add one so that we can gray-code the quadrant bits too.
-    pre_diff_code = []
-    constellation = gr.constellation_rect(points, pre_diff_code, 4, side, side, width, width)
-    return constellation
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           QAM modulator
-# /////////////////////////////////////////////////////////////////////////////
-
-class qam_mod(generic_mod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 differential=_def_differential,
-                 mod_code=_def_mod_code,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered QAM modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_mod block for list of parameters.
-	"""
-
-        constellation = qam_constellation(constellation_points, differential, mod_code)
-        # We take care of the gray coding in the constellation generation so it doesn't 
-        # need to be done in the block.
-        super(qam_mod, self).__init__(constellation, differential=differential,
-                                      *args, **kwargs)
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           QAM demodulator
-#
-# /////////////////////////////////////////////////////////////////////////////
-
-class qam_demod(generic_demod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 differential=_def_differential,
-                 mod_code=_def_mod_code,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered QAM modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_demod block for list of parameters.
-        """
-        constellation = qam_constellation(constellation_points, differential, mod_code)
-        # We take care of the gray coding in the constellation generation so it doesn't 
-        # need to be done in the block.
-        super(qam_demod, self).__init__(constellation, differential=differential,
-                                        *args, **kwargs)
-
-#
-# Add these to the mod/demod registry
-#
-modulation_utils2.add_type_1_mod('qam', qam_mod)
-modulation_utils2.add_type_1_demod('qam', qam_demod)
-modulation_utils2.add_type_1_constellation('qam', qam_constellation)
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py b/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py
deleted file mode 100644
index 4af8d0018..000000000
--- a/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#
-# Copyright 2005,2006,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.
-# 
-
-"""
-QPSK modulation.
-
-Demodulation is not included since the generic_mod_demod
-doesn't work for non-differential encodings.
-"""
-
-from gnuradio import gr, modulation_utils2
-from gnuradio.blks2impl.generic_mod_demod import generic_mod
-
-
-# Default number of points in constellation.
-_def_constellation_points = 4
-# Whether differential coding is used.
-_def_differential = False
-_def_gray_coded = True
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           QPSK constellation
-# /////////////////////////////////////////////////////////////////////////////
-
-def qpsk_constellation(m=_def_constellation_points): 
-    if m != _def_constellation_points:
-        raise ValueError("QPSK can only have 4 constellation points.")
-    return gr.constellation_qpsk()
-
-# /////////////////////////////////////////////////////////////////////////////
-#                           QPSK modulator
-# /////////////////////////////////////////////////////////////////////////////
-
-class qpsk_mod(generic_mod):
-
-    def __init__(self, constellation_points=_def_constellation_points,
-                 differential=_def_differential,
-                 gray_coded=_def_gray_coded,
-                 *args, **kwargs):
-
-        """
-	Hierarchical block for RRC-filtered QPSK modulation.
-
-	The input is a byte stream (unsigned char) and the
-	output is the complex modulated signal at baseband.
-
-        See generic_mod block for list of parameters.
-	"""
-
-        constellation = gr.constellation_qpsk()
-        if constellation_points != 4:
-            raise ValueError("QPSK can only have 4 constellation points.")
-        if differential or not gray_coded:
-            raise ValueError("This QPSK mod/demod works only for gray-coded, non-differential.")
-        super(qpsk_mod, self).__init__(constellation, differential, gray_coded, *args, **kwargs)
-
-#
-# Add these to the mod/demod registry
-#
-modulation_utils2.add_type_1_mod('qpsk', qpsk_mod)
-modulation_utils2.add_type_1_constellation('qpsk', qpsk_constellation)
diff --git a/gnuradio-core/src/python/gnuradio/utils/Makefile.am b/gnuradio-core/src/python/gnuradio/utils/Makefile.am
deleted file mode 100644
index c35951b44..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/Makefile.am
+++ /dev/null
@@ -1,35 +0,0 @@
-#
-# Copyright 2007,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.
-# 
-
-include $(top_srcdir)/Makefile.common
-
-if PYTHON
-utilspythondir = $(grpythondir)/utils
-
-TESTS = 				\
-	run_tests
-
-nobase_utilspython_PYTHON = \
-	__init__.py \
-	gray_code.py \
-	mod_codes.py \
-	alignment.py
-endif
\ No newline at end of file
diff --git a/gnuradio-core/src/python/gnuradio/utils/__init__.py b/gnuradio-core/src/python/gnuradio/utils/__init__.py
deleted file mode 100644
index b3e997f9f..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/__init__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-# 
diff --git a/gnuradio-core/src/python/gnuradio/utils/alignment.py b/gnuradio-core/src/python/gnuradio/utils/alignment.py
deleted file mode 100644
index d32365866..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/alignment.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-# 
-"""
-This module contains functions for aligning sequences.
-
->>> import random
->>> random.seed(1234)
->>> ran_seq = [random.randint(0,1) for i in range(0, 100)]
->>> offset_seq = [0] * 20 + ran_seq
->>> correct, overlap, offset = align_sequences(ran_seq, offset_seq)
->>> print(correct, overlap, offset)
-(1.0, 100, -20)
->>> offset_err_seq = []
->>> for bit in offset_seq:
-...     if random.randint(0,4) == 4:
-...         offset_err_seq.append(random.randint(0,1))
-...     else:
-...         offset_err_seq.append(bit)
->>> correct, overlap, offset = align_sequences(ran_seq, offset_err_seq)
->>> print(overlap, offset)
-(100, -20)
-
-"""
-
-import random
-
-# DEFAULT PARAMETERS
-# If the fraction of matching bits between two sequences is greater than
-# this the sequences are assumed to be aligned.
-def_correct_cutoff = 0.9
-# The maximum offset to test during sequence alignment.
-def_max_offset = 500
-# The maximum number of samples to take from two sequences to check alignment.
-def_num_samples = 1000
-
-def compare_sequences(d1, d2, offset, sample_indices=None):
-    """
-    Takes two binary sequences and an offset and returns the number of
-    matching entries and the number of compared entries.
-    d1 & d2 -- sequences
-    offset -- offset of d2 relative to d1
-    sample_indices -- a list of indices to use for the comparison
-    """
-    max_index = min(len(d1), len(d2)+offset)
-    if sample_indices is None:
-        sample_indices = range(0, max_index)
-    correct = 0
-    total = 0
-    for i in sample_indices:
-        if i >= max_index:
-            break
-        if d1[i] == d2[i-offset]:
-            correct += 1
-        total += 1
-    return (correct, total)
-
-def random_sample(size, num_samples=def_num_samples, seed=None):
-    """
-    Returns a set of random integers between 0 and (size-1).
-    The set contains no more than num_samples integers.
-    """
-    random.seed(seed)
-    if num_samples > size:
-        indices = set(range(0, size))
-    else:
-        if num_samples > size/2:
-            num_samples = num_samples/2
-        indices = set([])
-        while len(indices) < num_samples:
-            index = random.randint(0, size-1)
-            indices.add(index)
-    indices = list(indices)
-    indices.sort()
-    return indices
-
-def align_sequences(d1, d2,
-                    num_samples=def_num_samples,
-                    max_offset=def_max_offset,
-                    correct_cutoff=def_correct_cutoff,
-                    seed=None,
-                    indices=None):
-    """
-    Takes two sequences and finds the offset and which the two sequences best
-    match.  It returns the fraction correct, the number of entries compared,
-    the offset.
-    d1 & d2 -- sequences to compare
-    num_samples -- the maximum number of entries to compare
-    max_offset -- the maximum offset between the sequences that is checked
-    correct_cutoff -- If the fraction of bits correct is greater than this then
-                      the offset is assumed to optimum.
-    seed -- a random number seed
-    indices -- an explicit list of the indices used to compare the two sequences
-    """
-    max_overlap = max(len(d1), len(d2))
-    if indices is None:
-        indices = random_sample(max_overlap, num_samples, seed)
-    max_frac_correct = 0
-    best_offset = None
-    best_compared = None
-    best_correct = None
-    pos_range = range(0, min(len(d1), max_offset))
-    neg_range = range(-1, -min(len(d2), max_offset), -1)
-    # Interleave the positive and negative offsets.
-    int_range = [item for items in zip(pos_range, neg_range) for item in items]
-    for offset in int_range:
-        correct, compared = compare_sequences(d1, d2, offset, indices)
-        frac_correct = 1.0*correct/compared
-        if frac_correct > max_frac_correct:
-            max_frac_correct = frac_correct
-            best_offset = offset
-            best_compared = compared
-            best_correct = correct
-            if frac_correct > correct_cutoff:
-                break
-    return max_frac_correct, best_compared, best_offset, indices
-    
-if __name__ == "__main__":
-    import doctest
-    doctest.testmod()
-    
diff --git a/gnuradio-core/src/python/gnuradio/utils/gray_code.py b/gnuradio-core/src/python/gnuradio/utils/gray_code.py
deleted file mode 100644
index 926a1ded1..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/gray_code.py
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-# 
-
-class GrayCodeGenerator(object):
-    """
-    Generates and caches gray codes.
-    """
-
-    def __init__(self):
-        self.gcs = [0, 1]
-        # The last power of two passed through.
-        self.lp2 = 2
-        # The next power of two that will be passed through.
-        self.np2 = 4
-        # Curent index
-        self.i = 2
-
-    def get_gray_code(self, length):
-        """
-        Returns a list of gray code of given length.
-        """
-        if len(self.gcs) < length:
-            self.generate_new_gray_code(length)
-        return self.gcs[:length]
-    
-    def generate_new_gray_code(self, length):
-        """
-        Generates new gray code and places into cache.
-        """
-        while len(self.gcs) < length:
-            if self.i == self.lp2:
-                # if i is a power of two then gray number is of form 1100000...
-                result = self.i + self.i/2
-            else:
-                # if not we take advantage of the symmetry of all but the last bit
-                # around a power of two.
-                result = self.gcs[2*self.lp2-1-self.i] + self.lp2
-            self.gcs.append(result)
-            self.i += 1
-            if self.i == self.np2:
-                self.lp2 = self.i
-                self.np2 = self.i*2
-
-_gray_code_generator = GrayCodeGenerator()
-
-gray_code = _gray_code_generator.get_gray_code
-
diff --git a/gnuradio-core/src/python/gnuradio/utils/mod_codes.py b/gnuradio-core/src/python/gnuradio/utils/mod_codes.py
deleted file mode 100644
index caacda5cc..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/mod_codes.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-# 
-
-GRAY_CODE = 'gray'
-SET_PARTITION_CODE = 'set-partition'
-NO_CODE = 'none'
-
-codes = (GRAY_CODE, SET_PARTITION_CODE, NO_CODE)
-
-def invert_code(code):
-    c = enumerate(code)
-    ic = [(b, a) for (a, b) in c]
-    ic.sort()
-    return [a for (b, a) in ic]
diff --git a/gnuradio-core/src/python/gnuradio/utils/run_tests.in b/gnuradio-core/src/python/gnuradio/utils/run_tests.in
deleted file mode 100644
index adcbdfd21..000000000
--- a/gnuradio-core/src/python/gnuradio/utils/run_tests.in
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-
-# 1st parameter is absolute path to component source directory
-# 2nd parameter is absolute path to component build directory
-# 3rd parameter is path to Python QA directory
-
-# Note: calling master run_tests.sh in gnuradio core is not strictly
-# correct, as it will result in a partially bogus PYTHONPATH, but it
-# does make the correct paths in the second half so all is well.
-
-# Nothing in here at the moment.