How to use the amodem.common function in amodem

def test_detect():
    P = sum(equalizer.prefix)
    t = np.arange(P * config.Nsym) * config.Ts
    x = np.cos(2 * np.pi * config.Fc * t)

    detector = detect.Detector(config, pylab=common.Dummy())
    samples, amp, freq_err = detector.run(x)
    assert abs(1 - amp) < 1e-12
    assert abs(freq_err) < 1e-12

    x = np.cos(2 * np.pi * (2*config.Fc) * t)
    with pytest.raises(ValueError):
        detector.run(x)

    with pytest.raises(ValueError):
        detector.max_offset = 0
        detector.run(x)

def _bitstream(self, symbols, error_handler):
        streams = []
        symbol_list = []
        generators = common.split(symbols, n=len(self.omegas))
        for freq, S in zip(self.frequencies, generators):
            equalized = []
            S = common.icapture(S, result=equalized)
            symbol_list.append(equalized)

            freq_handler = functools.partial(error_handler, freq=freq)
            bits = self.modem.decode(S, freq_handler)  # list of bit tuples
            streams.append(bits)  # bit stream per frequency

        return common.izip(streams), symbol_list

            self.take = lambda size: common.take(src, size)

def main():
    config = Configuration()

    for fname in sys.argv[1:]:
        x = common.load(open(fname, 'rb'))
        t = np.arange(len(x)) * config.Ts
        pylab.figure()
        pylab.title(fname)
        spectrogram(t, x, config.Fs)

    pylab.show()

def estimate(self, buf, skip=5):
        filt = dsp.exp_iwt(-self.omega, self.Nsym) / (0.5 * self.Nsym)
        frames = common.iterate(buf, self.Nsym)
        symbols = [np.dot(filt, frame) for frame in frames]
        symbols = np.array(symbols[skip:-skip])

        amplitude = np.mean(np.abs(symbols))
        log.info('Carrier symbols amplitude : %.3f', amplitude)

        phase = np.unwrap(np.angle(symbols)) / (2 * np.pi)
        indices = np.arange(len(phase))
        a, b = dsp.linear_regression(indices, phase)
        self.plt.figure()
        self.plt.plot(indices, phase, ':')
        self.plt.plot(indices, a * indices + b)

        freq_err = a / (self.Tsym * self.freq)
        log.info('Frequency error: %.3f ppm', freq_err * 1e6)
        self.plt.title('Frequency drift: {0:.3f} ppm'.format(freq_err * 1e6))