style: pre-commit fixes

Author: pre-commit-ci[bot]

src/dspeed/utils.py

@@ -94,21 +94,24 @@ def __init__(
             self.ufunc = fun
         else:
             otypes = types[-self.nout :] if self.nout > 0 else None
-            if self.nout>0:
+            if self.nout > 0:
                 self.ufunc = np.vectorize(fun, otypes=otypes, signature=self.signature)
             else:
                 # vectorize requires an output, so we'll give it an output
                 def fun_return(*args):
                     fun(*args)
                     return True
-                self.ufunc = np.vectorize(lambda *args: fun, otypes="?", signature=self.signature+"->()")
+
+                self.ufunc = np.vectorize(
+                    lambda *args: fun, otypes="?", signature=self.signature + "->()"
+                )
 
     def __call__(self, *args):
         """Call wrapped function with "in place" outputs"""
 
         assert len(args) == self.nargs
 
-        if self.copy_out and self.nout>0:
+        if self.copy_out and self.nout > 0:
             ins = args[: self.nin]
             outs = args[-self.nout :]
             # print([i.shape for i in ins], [o.shape for o in outs])

tests/conftest.py

@@ -1,7 +1,5 @@
 import copy
-import inspect
 import os
-import re
 import shutil
 import uuid
 from getpass import getuser
@@ -84,7 +82,7 @@ def numba_vs_python(func, *inputs):
         if func.signature:
             sig = func.signature
         else:
-            sig = ",".join(["()"]*func.nin) + "->" + ",".join(["()"]*func.nout)
+            sig = ",".join(["()"] * func.nin) + "->" + ",".join(["()"] * func.nout)
 
         if len(inputs) == func.nargs:
             # outputs passed as inputs; required when size of output
@@ -96,8 +94,10 @@ def numba_vs_python(func, *inputs):
             outputs_numba = [copy.deepcopy(arg) for arg in inputs]
 
             # unwrapped python outputs
-            #func_unwrapped = np.vectorize(inspect.unwrap(func), signature=func.signature)
-            func_unwrapped = GUFuncWrapper(func, sig, ''.join([np.array(ar).dtype.char for ar in outputs_numba]))
+            # func_unwrapped = np.vectorize(inspect.unwrap(func), signature=func.signature)
+            func_unwrapped = GUFuncWrapper(
+                func, sig, "".join([np.array(ar).dtype.char for ar in outputs_numba])
+            )
             func_unwrapped(*inputs)
             outputs_python = [copy.deepcopy(arg) for arg in inputs]
 
@@ -110,16 +110,20 @@ def numba_vs_python(func, *inputs):
                 outputs_numba = [outputs_numba]
 
             # unwrapped python outputs
-            types = ''.join([np.array(ar).dtype.char for ar in outputs_numba]) + "->" + ''.join([np.array(ar).dtype.char for ar in outputs_numba])
+            types = (
+                "".join([np.array(ar).dtype.char for ar in outputs_numba])
+                + "->"
+                + "".join([np.array(ar).dtype.char for ar in outputs_numba])
+            )
             func_unwrapped = GUFuncWrapper(func, sig, types)
 
             # now outputs must be passed as args. Scalars must be
             # converted to rank 1 arrays
             outputs_python = []
             scalars = []
             for i, ar in enumerate(outputs_numba):
-                if len(ar.shape)==0:
-                    outputs_python.append(np.zeros_like(ar).reshape((1)))
+                if len(ar.shape) == 0:
+                    outputs_python.append(np.zeros_like(ar).reshape(1))
                     scalars.append(i)
                 else:
                     outputs_python.append(np.zeros_like(ar))
@@ -134,9 +138,12 @@ def numba_vs_python(func, *inputs):
 
         # assert that numba and python are the same up to floating point
         # precision, setting nans to be equal
-        assert all(np.allclose(o_nb, o_py, equal_nan=True) for o_nb, o_py in zip(outputs_numba, outputs_python))
+        assert all(
+            np.allclose(o_nb, o_py, equal_nan=True)
+            for o_nb, o_py in zip(outputs_numba, outputs_python)
+        )
 
         # return value for comparison with expected solution
-        return outputs_numba if len(outputs_numba)>1 else outputs_numba[0]
+        return outputs_numba if len(outputs_numba) > 1 else outputs_numba[0]
 
     return numba_vs_python

tests/processors/test_fixed_time_pickoff.py

@@ -15,19 +15,27 @@ def test_fixed_time_pickoff(compare_numba_vs_python):
     # test for nan if w_in has a nan
     w_in = np.ones(len_wf)
     w_in[4] = np.nan
-    assert np.isnan(compare_numba_vs_python(fixed_time_pickoff, w_in, 1, np.int8(ord("i"))))
+    assert np.isnan(
+        compare_numba_vs_python(fixed_time_pickoff, w_in, 1, np.int8(ord("i")))
+    )
 
     # test for nan if nan is passed to t_in
     w_in = np.ones(len_wf)
-    assert np.isnan(compare_numba_vs_python(fixed_time_pickoff, w_in, np.nan, np.int8(ord("i"))))
+    assert np.isnan(
+        compare_numba_vs_python(fixed_time_pickoff, w_in, np.nan, np.int8(ord("i")))
+    )
 
     # test for nan if t_in is negative
     w_in = np.ones(len_wf)
-    assert np.isnan(compare_numba_vs_python(fixed_time_pickoff, w_in, -1, np.int8(ord("i"))))
+    assert np.isnan(
+        compare_numba_vs_python(fixed_time_pickoff, w_in, -1, np.int8(ord("i")))
+    )
 
     # test for nan if t_in is too large
     w_in = np.ones(len_wf)
-    assert np.isnan(compare_numba_vs_python(fixed_time_pickoff, w_in, len_wf, np.int8(ord("i"))))
+    assert np.isnan(
+        compare_numba_vs_python(fixed_time_pickoff, w_in, len_wf, np.int8(ord("i")))
+    )
 
     # test for DSPFatal errors being raised
     # noninteger t_in with integer interpolation
@@ -54,7 +62,10 @@ def test_fixed_time_pickoff(compare_numba_vs_python):
     sols = [4, 3, 4, 3.5, 3.5, 3.5]
 
     for char, sol in zip(chars, sols):
-        assert compare_numba_vs_python(fixed_time_pickoff, w_in, 3.5, np.int8(ord(char))) == sol
+        assert (
+            compare_numba_vs_python(fixed_time_pickoff, w_in, 3.5, np.int8(ord(char)))
+            == sol
+        )
 
     # sine wave tests
     w_in = np.sin(np.arange(len_wf))
@@ -71,7 +82,8 @@ def test_fixed_time_pickoff(compare_numba_vs_python):
 
     for char, sol in zip(chars, sols):
         assert np.isclose(
-            compare_numba_vs_python(fixed_time_pickoff, w_in, 3.25, np.int8(ord(char))), sol
+            compare_numba_vs_python(fixed_time_pickoff, w_in, 3.25, np.int8(ord(char))),
+            sol,
         )
 
     # last few corner cases of 'h'
@@ -84,5 +96,6 @@ def test_fixed_time_pickoff(compare_numba_vs_python):
 
     for ftp, sol in zip(ftps, sols):
         assert np.isclose(
-            compare_numba_vs_python(fixed_time_pickoff, w_in, ftp, np.int8(ord("h"))), sol
+            compare_numba_vs_python(fixed_time_pickoff, w_in, ftp, np.int8(ord("h"))),
+            sol,
         )

tests/processors/test_inl_correction.py

@@ -21,9 +21,7 @@ def test_inl_correction(compare_numba_vs_python):
     w_in = np.arange(len_wf, dtype=np.int32)
     inl = np.full(len_inl, 0.5, dtype=np.float32)
     expected = w_in.astype(np.float32) + 0.5
-    assert np.allclose(
-        compare_numba_vs_python(inl_correction, w_in, inl), expected
-    )
+    assert np.allclose(compare_numba_vs_python(inl_correction, w_in, inl), expected)
 
     # Case 3: ADC code out of range
     w_in = np.array([300], dtype=np.int32)
@@ -35,6 +33,4 @@ def test_inl_correction(compare_numba_vs_python):
     w_in = np.array([0, 1, 2, 3], dtype=np.int32)
     inl = np.array([0.1, -0.1, 0.2, -0.2] + [0.0] * (len_inl - 4), dtype=np.float32)
     expected = w_in.astype(np.float32) + inl[:4]
-    assert np.allclose(
-        compare_numba_vs_python(inl_correction, w_in, inl), expected
-    )
+    assert np.allclose(compare_numba_vs_python(inl_correction, w_in, inl), expected)

tests/processors/test_multi_a.py

@@ -25,32 +25,22 @@ def test_multi_a_filter(compare_numba_vs_python):
         multi_a_filter(w_in, maxs_in, np.zeros(21))
 
     # test vt_max_len is 0
-    assert (
-        len(compare_numba_vs_python(multi_a_filter, w_in, np.array([])))
-        == 0
-    )
+    assert len(compare_numba_vs_python(multi_a_filter, w_in, np.array([]))) == 0
 
     # test all nan
     assert np.isnan(
         compare_numba_vs_python(multi_a_filter, w_in, np.array([np.nan]))
     ).all()
 
     # test output
-    assert (
-        compare_numba_vs_python(multi_a_filter, w_in, np.array([10]))[0]
-        == 1
-    )
+    assert compare_numba_vs_python(multi_a_filter, w_in, np.array([10]))[0] == 1
 
     # test output with remaining nans
-    out = compare_numba_vs_python(
-        multi_a_filter, w_in, np.array([10, np.nan, np.nan])
-    )
+    out = compare_numba_vs_python(multi_a_filter, w_in, np.array([10, np.nan, np.nan]))
     assert out[0] == 1
     assert np.isnan(out[1:]).all()
 
     # test output with 1 nan
-    out = compare_numba_vs_python(
-        multi_a_filter, w_in, np.array([10, np.nan, 12])
-    )
+    out = compare_numba_vs_python(multi_a_filter, w_in, np.array([10, np.nan, 12]))
     assert out[0] == 1 and out[2] == 1
     assert np.isnan(out[1])

tests/processors/test_time_point_thresh.py

@@ -93,7 +93,9 @@ def test_interpolated_time_point_thresh(compare_numba_vs_python):
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     w_in[4] = np.nan
     assert np.isnan(
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1.0, 11.0, 0, np.int8(105))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1.0, 11.0, 0, np.int8(105)
+        )
     )
 
     # test for nan if nan is passed to a_threshold
@@ -115,76 +117,98 @@ def test_interpolated_time_point_thresh(compare_numba_vs_python):
     # test for nan if t_start out of range
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert np.isnan(
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1.0, 12, 0, np.int8(105))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1.0, 12, 0, np.int8(105)
+        )
     )
 
     # test walk backward mode 'i'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(105))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(105)
+        )
         == 7.0
     )
 
     # test walk forward mode 'i'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(105))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(105)
+        )
         == 4.0
     )
 
     # test walk backward mode 'f'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(102))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(102)
+        )
         == 8.0
     )
 
     # test walk forward mode 'f'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(102))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(102)
+        )
         == 5.0
     )
 
     # test walk backward mode 'f'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(99))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(99)
+        )
         == 7.0
     )
 
     # test walk forward mode 'f'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(99))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(99)
+        )
         == 4.0
     )
 
     # test walk backward mode 'n'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(110))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1, 11, 0, np.int8(110)
+        )
         == 7.5
     )
 
     # test walk forward mode 'n'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(110))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 3, 0, 1, np.int8(110)
+        )
         == 4.5
     )
 
     # test walk backward mode 'l'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 1.5, 11, 0, np.int8(108))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 1.5, 11, 0, np.int8(108)
+        )
         == 8.5
     )
 
     # test walk forward mode 'l'
     w_in = np.concatenate([np.arange(-1, 5, 1), np.arange(-1, 5, 1)], dtype="float")
     assert (
-        compare_numba_vs_python(interpolated_time_point_thresh, w_in, 3.5, 0, 1, np.int8(108))
+        compare_numba_vs_python(
+            interpolated_time_point_thresh, w_in, 3.5, 0, 1, np.int8(108)
+        )
         == 4.5
     )