add more claude tests

Author: skjerns

pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 ]
 description = "A collection of utility functions for MEG analysis."
 readme = "README.md"
-requires-python = ">=3.6"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

tests/test_decoding.py

@@ -25,5 +25,113 @@ def test_predict_proba_along_n_jobs(self):
         out2 = decoding.predict_proba_along(clf, X, axes=0, n_jobs=2)
         np.testing.assert_array_equal(out1, out2)
 
+class TestStratify(unittest.TestCase):
+
+    def _make_imbalanced(self):
+        rng = np.random.default_rng(0)
+        X = rng.standard_normal((40, 5))
+        y = np.array([0] * 30 + [1] * 10)
+        return X, y
+
+    def test_undersample_balances(self):
+        """Undersampling reduces all classes to the minority count."""
+        X, y = self._make_imbalanced()
+        _, y_out = decoding.stratify(X, y, strategy='undersample', random_state=0)
+        counts = np.bincount(y_out)
+        np.testing.assert_array_equal(counts, [10, 10])
+
+    def test_oversample_balances(self):
+        """Oversampling raises all classes to the majority count."""
+        X, y = self._make_imbalanced()
+        _, y_out = decoding.stratify(X, y, strategy='oversample', random_state=0)
+        counts = np.bincount(y_out)
+        np.testing.assert_array_equal(counts, [30, 30])
+
+    def test_y_matches_X(self):
+        """Each output label matches the label of the corresponding input row."""
+        X, y = self._make_imbalanced()
+        X_out, y_out = decoding.stratify(X, y, strategy='undersample', random_state=0)
+        for i in range(len(y_out)):
+            orig_idx = np.where(np.all(X == X_out[i], axis=1))[0]
+            self.assertTrue(len(orig_idx) > 0)
+            self.assertEqual(y[orig_idx[0]], y_out[i])
+
+    def test_output_contains_original_rows(self):
+        """Every row in the output is an exact copy of an input row."""
+        X, y = self._make_imbalanced()
+        X_out, _ = decoding.stratify(X, y, strategy='undersample', random_state=0)
+        for row in X_out:
+            self.assertTrue(any(np.allclose(row, orig) for orig in X))
+
+    def test_invalid_strategy_raises(self):
+        """Unknown strategy string raises ValueError."""
+        X, y = self._make_imbalanced()
+        with self.assertRaises(ValueError):
+            decoding.stratify(X, y, strategy='badstrat')
+
+    def test_y_2d_raises(self):
+        """Passing a 2-D array as y raises ValueError."""
+        X, _ = self._make_imbalanced()
+        y_2d = np.ones((40, 2))
+        with self.assertRaises(ValueError):
+            decoding.stratify(X, y_2d)
+
+    def test_random_state_reproducible(self):
+        """The same random seed produces identical outputs on repeated calls."""
+        X, y = self._make_imbalanced()
+        X1, y1 = decoding.stratify(X, y, strategy='undersample', random_state=42)
+        X2, y2 = decoding.stratify(X, y, strategy='undersample', random_state=42)
+        np.testing.assert_array_equal(y1, y2)
+        np.testing.assert_array_equal(X1, X2)
+
+    def test_random_state_different(self):
+        """Different seeds produce different sample orderings."""
+        rng = np.random.default_rng(1)
+        X = rng.standard_normal((200, 5))
+        y = np.array([0] * 150 + [1] * 50)
+        _, y1 = decoding.stratify(X, y, strategy='undersample', random_state=0)
+        _, y2 = decoding.stratify(X, y, strategy='undersample', random_state=99)
+        self.assertFalse(np.array_equal(y1, y2))
+
+    def test_already_balanced(self):
+        """Both strategies leave an already-balanced dataset at the same size."""
+        rng = np.random.default_rng(0)
+        X = rng.standard_normal((20, 5))
+        y = np.array([0] * 10 + [1] * 10)
+        for strategy in ('undersample', 'oversample'):
+            _, y_out = decoding.stratify(X, y, strategy=strategy, random_state=0)
+            counts = np.bincount(y_out)
+            np.testing.assert_array_equal(counts, [10, 10])
+
+    def test_oversample_no_replace_when_equal(self):
+        """Oversampling a balanced dataset does not duplicate any samples."""
+        rng = np.random.default_rng(0)
+        X = rng.standard_normal((20, 5))
+        y = np.array([0] * 10 + [1] * 10)
+        _, y_out = decoding.stratify(X, y, strategy='oversample', random_state=0)
+        counts = np.bincount(y_out)
+        np.testing.assert_array_equal(counts, [10, 10])
+
+    def test_works_with_dataframe(self):
+        """stratify accepts a pandas DataFrame and returns correct row counts."""
+        import pandas as pd
+        N = 40
+        X = pd.DataFrame(np.eye(N))
+        y = np.array([0] * 30 + [1] * 10)
+        X_out, y_out = decoding.stratify(X, y, strategy='undersample', random_state=0)
+        self.assertEqual(len(X_out), 20)
+        self.assertEqual(len(y_out), 20)
+
+    def test_verbose_no_crash(self):
+        """verbose=True prints the target count without raising an error."""
+        import io
+        from contextlib import redirect_stdout
+        X, y = self._make_imbalanced()
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            decoding.stratify(X, y, strategy='undersample', random_state=0, verbose=True)
+        self.assertIn('10', buf.getvalue())
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

tests/test_sigproc.py

@@ -13,6 +13,7 @@
 import matplotlib.pyplot as plt
 from meg_utils.sigproc import curves, fit_curve
 from meg_utils.sigproc import notch
+from meg_utils.sigproc import sliding_window
 from scipy.fft import rfft, rfftfreq
 
 class TestFitCurve(unittest.TestCase):
@@ -98,5 +99,84 @@ def test_notch(self):
             out = notch(data, freqs=[50], sfreq=sfreq)
 
 
+class TestSlidingWindow(unittest.TestCase):
+
+    def test_output_shape_1d(self):
+        """Shape is (n_windows, win_size) for a 1-D input."""
+        out = sliding_window(np.arange(10), win_size=4, stride=1)
+        self.assertEqual(out.shape, (7, 4))
+
+    def test_output_shape_2d(self):
+        """Shape along the slid axis becomes n_windows, win_size is appended."""
+        out = sliding_window(np.ones((3, 20)), win_size=5, stride=2)
+        self.assertEqual(out.shape, (3, 8, 5))
+
+    def test_output_shape_axis0(self):
+        """Sliding along axis=0 replaces the first dimension with n_windows."""
+        out = sliding_window(np.ones((20, 3)), win_size=5, stride=2, axis=0)
+        self.assertEqual(out.shape, (8, 3, 5))
+
+    def test_output_shape_3d(self):
+        """Correct shape for a 3-D input sliding along the middle axis."""
+        out = sliding_window(np.ones((2, 10, 4)), win_size=3, stride=2, axis=1)
+        self.assertEqual(out.shape, (2, 4, 4, 3))
+
+    def test_window_values(self):
+        """Each window contains the correct consecutive elements."""
+        out = sliding_window(np.arange(6), win_size=3, stride=1)
+        np.testing.assert_array_equal(out[0], [0, 1, 2])
+        np.testing.assert_array_equal(out[1], [1, 2, 3])
+        np.testing.assert_array_equal(out[2], [2, 3, 4])
+        np.testing.assert_array_equal(out[3], [3, 4, 5])
+
+    def test_stride_skips_correctly(self):
+        """stride > 1 advances the window start by that many elements."""
+        out = sliding_window(np.arange(10), win_size=3, stride=3)
+        np.testing.assert_array_equal(out[0], [0, 1, 2])
+        np.testing.assert_array_equal(out[1], [3, 4, 5])
+        np.testing.assert_array_equal(out[2], [6, 7, 8])
+
+    def test_is_view_shares_memory(self):
+        """Output shares memory with the input — no data copy is made."""
+        arr = np.arange(100, dtype=float)
+        out = sliding_window(arr, win_size=10, stride=1)
+        self.assertTrue(np.shares_memory(arr, out))
+
+    def test_view_reflects_source_changes(self):
+        """Mutating the source array is immediately visible through the view."""
+        arr = np.arange(20, dtype=float)
+        out = sliding_window(arr, win_size=3, stride=1)
+        arr[0] = 999.0
+        self.assertEqual(out[0, 0], 999.0)
+
+    def test_read_only(self):
+        """Output is read-only; writing to it raises ValueError."""
+        out = sliding_window(np.arange(10, dtype=float), win_size=3, stride=1)
+        with self.assertRaises(ValueError):
+            out[0, 0] = 99.0
+
+    def test_win_size_equals_length(self):
+        """win_size equal to axis length returns exactly one window."""
+        arr = np.arange(5)
+        out = sliding_window(arr, win_size=5, stride=1)
+        self.assertEqual(out.shape, (1, 5))
+        np.testing.assert_array_equal(out[0], arr)
+
+    def test_win_size_exceeds_length_raises(self):
+        """win_size larger than the axis length raises ValueError."""
+        with self.assertRaises(ValueError):
+            sliding_window(np.arange(5), win_size=6)
+
+    def test_invalid_stride_raises(self):
+        """stride <= 0 raises ValueError."""
+        with self.assertRaises(ValueError):
+            sliding_window(np.arange(10), win_size=3, stride=0)
+
+    def test_invalid_win_size_raises(self):
+        """win_size <= 0 raises ValueError."""
+        with self.assertRaises(ValueError):
+            sliding_window(np.arange(10), win_size=0)
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)