Lint

Author: fronzbot

adc_eval/eval/calc.py

@@ -1,4 +1,5 @@
 """Spectral analysis helper module."""
+
 import numpy as np
 
 
@@ -148,4 +149,4 @@ def get_plot_string(stats, full_scale, fs, nfft, window, xscale=1e6, fscale="MHz
 
     plt_str += "\n"
 
-    return plt_str
+    return plt_str

adc_eval/eval/spectrum.py

@@ -46,15 +46,15 @@ def window_data(data, window="rectangular"):
 
     windows = {
         "rectangular": (np.ones(wsize), 1.0),
-        "hanning": (np.hanning(wsize), 1.633)
+        "hanning": (np.hanning(wsize), 1.633),
     }
-    
+
     if window not in windows:
         print(f"WARNING: {window} not implemented. Defaulting to 'rectangular'.")
         window = "rectangular"
-    
+
     wscale = windows[window][1]
-    
+
     return data * windows[window][0] * wscale
 
 
@@ -73,7 +73,7 @@ def plot_spectrum(
 ):
     """Plot Power Spectrum for input signal."""
     (freq, pwr) = get_spectrum(data, fs=fs, nfft=nfft, single_sided=single_sided)
-    
+
     # Calculate the fullscale range of the spectrum in Watts
     full_scale = calc.dBW(dr**2 / 8)
 
@@ -92,7 +92,7 @@ def plot_spectrum(
 
     # Convert to dBW and perform scalar based on y-axis scaling input
     psd_out = calc.dBW(pwr, places=3) - scalar
-    
+
     # Use Watts if magnitude y-axis scaling is desired
     if lut_key in ["magnitude"]:
         psd_out = pwr
@@ -104,7 +104,9 @@ def plot_spectrum(
         # Get single-sided spectrum for SNDR and Harmonic stats
         (f_ss, psd_ss) = get_spectrum(data, fs=fs, nfft=nfft, single_sided=True)
 
-    sndr_stats = calc.sndr_sfdr(psd_ss, f_ss, fs, nfft, leak=leak, full_scale=full_scale)
+    sndr_stats = calc.sndr_sfdr(
+        psd_ss, f_ss, fs, nfft, leak=leak, full_scale=full_scale
+    )
     harm_stats = calc.find_harmonics(
         psd_ss,
         f_ss,
@@ -124,7 +126,9 @@ def plot_spectrum(
 
     # If plotting, prep plot and generate all required axis strings
     if not no_plot:
-        plt_str = calc.get_plot_string(stats, full_scale, fs, nfft, window, xscale, fscale[0])
+        plt_str = calc.get_plot_string(
+            stats, full_scale, fs, nfft, window, xscale, fscale[0]
+        )
         fig, ax = plt.subplots(figsize=(15, 8))
         ax.plot(freq / xscale, psd_out)
         ax.set_ylabel(f"Power Spectrum ({yunits})", fontsize=18)
@@ -219,10 +223,10 @@ def analyze(
     if fscale not in fscalar:
         print(f"WARNING: {fscale} not implemented. Defaulting to 'MHz'.")
         fscale = "MHz"
-    
+
     # Window the data
     wdata = window_data(data, window=window)
-    
+
     (freq, spectrum, stats) = plot_spectrum(
         wdata,
         fs=fs,
@@ -237,4 +241,4 @@ def analyze(
         fscale=(fscale, fscalar[fscale]),
     )
 
-    return (freq, spectrum, stats)
+    return (freq, spectrum, stats)

adc_eval/filter.py

@@ -4,6 +4,7 @@
 from scipy.signal import remez, freqz
 import matplotlib.pyplot as plt
 from adc_eval.eval import spectrum
+from adc_eval.eval import calc
 
 
 class CICDecimate:
@@ -215,7 +216,7 @@ def run(self, xarray):
     def response(self, fft, no_plot=False):
         """Plots the frequency response of the pre-decimated filter."""
         freq, mag = freqz(self.coeffs, [1], worN=fft, fs=self.fs)
-        yfft = spectrum.dBW(np.abs(mag))
+        yfft = calc.dBW(np.abs(mag))
         if not no_plot:
             fig, ax = plt.subplots(figsize=(15, 8))
             ax.plot(freq / 1e6, yfft)

tests/eval/test_calc.py

@@ -139,9 +139,7 @@ def test_find_harmonics_on_fft_bound(harms, nfft):
     nbin = nfft / 8
     (freq, pwr) = gen_spectrum(nbin, harms, nfft)
 
-    stats = calc.find_harmonics(
-        pwr, freq, nfft, nbin, AMPLITUDE, harms=harms, leak=0
-    )
+    stats = calc.find_harmonics(pwr, freq, nfft, nbin, AMPLITUDE, harms=harms, leak=0)
 
     exp_bin = {
         2: 2 * nbin,
@@ -260,4 +258,4 @@ def test_plot_string(harms, nfft):
     for n in range(2, harms + 1):
         harm_power = round(all_stats["harm"][n]["dB"], 1)
         harm_freq = all_stats["harm"][n]["freq"]
-        assert f"HD{n} = {harm_power} dBFS @ {harm_freq} Hz" in plt_str, msg_txt
+        assert f"HD{n} = {harm_power} dBFS @ {harm_freq} Hz" in plt_str, msg_txt

tests/eval/test_spectrum.py

@@ -19,6 +19,7 @@
     for _ in range(10)
 ]
 
+
 @mock.patch("adc_eval.eval.spectrum.calc_psd")
 def test_get_spectrum(mock_calc_psd):
     """Test that the get_spectrum method returns power spectrum."""
@@ -27,9 +28,11 @@ def test_get_spectrum(mock_calc_psd):
     data = np.array([1])
     exp_spectrum = np.array([fs / nfft])
 
-    mock_calc_psd.return_value = (None, data, None, 2*data)
+    mock_calc_psd.return_value = (None, data, None, 2 * data)
 
-    assert (None, exp_spectrum) == spectrum.get_spectrum(None, fs=fs, nfft=nfft, single_sided=True)
+    assert (None, exp_spectrum) == spectrum.get_spectrum(
+        None, fs=fs, nfft=nfft, single_sided=True
+    )
 
 
 @mock.patch("adc_eval.eval.spectrum.calc_psd")
@@ -40,9 +43,11 @@ def test_get_spectrum_dual(mock_calc_psd):
     data = np.array([1])
     exp_spectrum = np.array([fs / nfft])
 
-    mock_calc_psd.return_value = (None, data, None, 2*data)
+    mock_calc_psd.return_value = (None, data, None, 2 * data)
 
-    assert (None, 2*exp_spectrum) == spectrum.get_spectrum(None, fs=fs, nfft=nfft, single_sided=False)
+    assert (None, 2 * exp_spectrum) == spectrum.get_spectrum(
+        None, fs=fs, nfft=nfft, single_sided=False
+    )
 
 
 @pytest.mark.parametrize("data", [np.random.randn(NLEN) for _ in range(10)])
@@ -181,7 +186,7 @@ def test_window_data_as_list():
     """Tests the window_data function when given a list instead of numpy array."""
     data = np.random.rand(NLEN).tolist()
     wdata = spectrum.window_data(data, window="rectangular")
-    
+
     assert type(data) == type(list())
     assert type(wdata) == type(np.ndarray([]))
 
@@ -191,7 +196,7 @@ def test_window_data_bad_window_type(capfd):
     data = np.random.rand(NLEN)
     wdata = spectrum.window_data(data, window="foobar")
     captured = capfd.readouterr()
-    
+
     assert data.size == wdata.size
     assert data.all() == wdata.all()
     assert "WARNING" in captured.out
@@ -214,7 +219,7 @@ def test_analyze_valid_input_scalar(mock_plot_spectrum):
     """Tests the valid input scalar keys."""
     mock_plot_spectrum.return_value = (None, None, None)
     mock_plot_spectrum.side_effect = lambda *args, **kwargs: (kwargs, None, None)
-    
+
     test_vals = {
         "Hz": 1,
         "kHz": 1e3,
@@ -236,10 +241,10 @@ def test_analyze_no_plot(mock_sndr_sfdr, mock_find_harmonics):
     }
     data_harms = {"harmonics": 3}
     exp_stats = {**data_sndr, **data_harms}
-    
+
     mock_sndr_sfdr.return_value = data_sndr
     mock_find_harmonics = data_harms
-    
+
     (freq, psd, stats) = spectrum.analyze(
         data,
         fs=1,
@@ -253,10 +258,10 @@ def test_analyze_no_plot(mock_sndr_sfdr, mock_find_harmonics):
         single_sided=True,
         fscale="Hz",
     )
-    
-    assert freq.all() == np.linspace(0, 1, int(NFFT/2)).all()
-    assert psd.size == int(NFFT/2)
-    
+
+    assert freq.all() == np.linspace(0, 1, int(NFFT / 2)).all()
+    assert psd.size == int(NFFT / 2)
+
     for key, value in stats.items():
         assert value == exp_stats[key]
 
@@ -271,10 +276,10 @@ def test_analyze_no_plot_dual(mock_sndr_sfdr, mock_find_harmonics):
     }
     data_harms = {"harmonics": 3}
     exp_stats = {**data_sndr, **data_harms}
-    
+
     mock_sndr_sfdr.return_value = data_sndr
     mock_find_harmonics = data_harms
-    
+
     (freq, psd, stats) = spectrum.analyze(
         data,
         fs=1,
@@ -288,8 +293,8 @@ def test_analyze_no_plot_dual(mock_sndr_sfdr, mock_find_harmonics):
         single_sided=False,
         fscale="Hz",
     )
-    
-    assert freq.all() == np.linspace(-0.5, 0.5, NFFT-1).all()
+
+    assert freq.all() == np.linspace(-0.5, 0.5, NFFT - 1).all()
     assert psd.size == NFFT
     for key, value in stats.items():
         assert value == exp_stats[key]
@@ -305,10 +310,10 @@ def test_analyze_no_plot_magnitude(mock_sndr_sfdr, mock_find_harmonics):
     }
     data_harms = {"harmonics": 3}
     exp_stats = {**data_sndr, **data_harms}
-    
+
     mock_sndr_sfdr.return_value = data_sndr
     mock_find_harmonics = data_harms
-    
+
     (freq, psd, stats) = spectrum.analyze(
         data,
         fs=1,
@@ -322,8 +327,8 @@ def test_analyze_no_plot_magnitude(mock_sndr_sfdr, mock_find_harmonics):
         single_sided=True,
         fscale="Hz",
     )
-    
-    assert freq.all() == np.linspace(0, 1, int(NFFT/2)).all()
-    assert psd.size == int(NFFT/2)
+
+    assert freq.all() == np.linspace(0, 1, int(NFFT / 2)).all()
+    assert psd.size == int(NFFT / 2)
     for key, value in stats.items():
-        assert value == exp_stats[key]
+        assert value == exp_stats[key]

tests/test_signals.py

@@ -8,29 +8,30 @@
 
 RTOL = 0.01
 
+
 @pytest.mark.parametrize("nlen", np.random.randint(4, 2**16, 3))
 @pytest.mark.parametrize("fs", np.random.uniform(1, 1e9, 3))
 def test_time(nlen, fs):
     """Test time with random data."""
     value = signals.time(nlen, fs=fs)
     assert value.size == nlen
     assert value[0] == 0
-    assert np.isclose(value[nlen-1], (nlen-1)/fs, rtol=RTOL)
-    
+    assert np.isclose(value[nlen - 1], (nlen - 1) / fs, rtol=RTOL)
+
 
 @pytest.mark.parametrize("nlen", np.random.randint(2**10, 2**16, 3))
 @pytest.mark.parametrize("offset", np.random.uniform(-10, 10, 3))
 @pytest.mark.parametrize("amp", np.random.uniform(0, 10, 3))
 def test_sin(nlen, offset, amp):
     """Test sine generation with random data."""
     fs = np.random.uniform(1, 1e9)
-    fin = np.random.uniform(fs/10, fs/3)
-    
+    fin = np.random.uniform(fs / 10, fs / 3)
+
     t = signals.time(nlen, fs=fs)
     value = signals.sin(t, amp=amp, offset=offset, freq=fin)
-    
+
     exp_peaks = [offset - amp, amp + offset]
-    
+
     assert value.size == nlen
     assert np.isclose(max(value), exp_peaks[1], rtol=RTOL)
     assert np.isclose(min(value), exp_peaks[0], rtol=RTOL)
@@ -42,10 +43,10 @@ def test_noise_length(nlen):
     """Test noise generation with random data."""
     t = signals.time(nlen, fs=1)
     value = signals.noise(t, mean=0, std=1)
-    
+
     # Just check correct size
     assert value.size == nlen
-    
+
 
 @pytest.mark.parametrize("std", np.random.uniform(0, 1, 4))
 def test_noise_length(std):
@@ -56,14 +57,14 @@ def test_noise_length(std):
     autocorr = np.correlate(noise, noise, mode="full")
     autocorr /= max(autocorr)
     asize = autocorr.size
-    
+
     midlag = autocorr.size // 2
-    acorr_nopeak = np.concatenate([autocorr[0:midlag-1], autocorr[midlag+1:]])
-    
+    acorr_nopeak = np.concatenate([autocorr[0 : midlag - 1], autocorr[midlag + 1 :]])
+
     shapiro = stats.shapiro(acorr_nopeak)
-    
+
     # Check that middle lag is 1
     assert autocorr[midlag] == 1
-    
+
     # Now check that noise is gaussian
-    assert shapiro.pvalue < 0.01
+    assert shapiro.pvalue < 0.01