fix: overloads, WeightingFilter multichannel zi, version sync & SonarCloud CI (#45)

* fix: complete overloads, WeightingFilter multichannel zi, version sync

- Add missing calculate_level=True overloads so mypy resolves explicit
  calculate_level=True calls correctly (4 clean overloads covering all
  sigbands × calculate_level combinations)
- Fix WeightingFilter multichannel zi bug: lazy allocation deferred to
  filter() so channel dimension matches actual input shape (same pattern
  as OctaveFilterBank)
- Sync __version__ from '1.1.2' to '1.1.4' to match pyproject.toml
- Update WeightingFilter tests for lazy init + add multichannel test

* fix(ci): pin sonarcloud action to v7 and use standard GITHUB_TOKEN

- Change SonarSource/sonarqube-scan-action@master to @v7 (stable)
- Replace secrets.TOKEN_GH with secrets.GITHUB_TOKEN (auto-available)

* fix: WeightingFilter multichannel→1D zi transition & SonarCloud coverage paths

- Fix needs_init to handle all ndim transitions (1D↔2D) in WeightingFilter
- Add [tool.coverage.run] relative_files=true so coverage.xml uses relative
  source paths matching sonar.sources=src
- Add test_weighting_filter_multichannel_to_mono_transition test

* fix: reduce WeightingFilter.filter() cognitive complexity and fix CI coverage

- Extract _init_filter_state() and _needs_zi_reinit() helpers from filter()
  to reduce Cognitive Complexity from 26 to ~5 (SonarCloud max: 15)
- Change pip install to editable mode (-e) so coverage can trace src/ code
  (fixes 'No data was collected' warning and 0% new_coverage in SonarCloud)

Author: jmrplens

.github/workflows/python-app.yml

@@ -56,7 +56,7 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r requirements.txt
         pip install -r requirements-dev.txt
-        pip install .
+        pip install -e .
     - name: Run tests
       env:
         NUMBA_DISABLE_JIT: 1
@@ -84,9 +84,9 @@ jobs:
       with:
         name: test-results-ubuntu-latest-3.13
     - name: SonarCloud Scan
-      uses: SonarSource/sonarqube-scan-action@master
+      uses: SonarSource/sonarqube-scan-action@v7
       env:
-        GITHUB_TOKEN: ${{ secrets.TOKEN_GH }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
 
   pr-comment:

pyproject.toml

@@ -38,6 +38,9 @@ ignore_missing_imports = true
 [tool.bandit]
 exclude_dirs = ["tests", ".venv"]
 
+[tool.coverage.run]
+relative_files = true
+
 [tool.pytest.ini_options]
 filterwarnings = [
     "ignore:Low sampling rate:UserWarning",

src/pyoctaveband/__init__.py

@@ -19,7 +19,7 @@
 # Use non-interactive backend for plots
 matplotlib.use("Agg")
 
-__version__ = "1.1.2"
+__version__ = "1.1.4"
 
 # Public methods
 __all__ = [

src/pyoctaveband/core.py

@@ -131,52 +131,51 @@ def __repr__(self) -> str:
 
     @overload
     def filter(
-        self, 
-        x: List[float] | np.ndarray, 
+        self,
+        x: List[float] | np.ndarray,
         sigbands: Literal[False] = False,
         mode: str = "rms",
-        detrend: bool = True
+        detrend: bool = True,
+        calculate_level: Literal[True] = True,
     ) -> Tuple[np.ndarray, List[float]]: ...
 
     @overload
     def filter(
-        self, 
-        x: List[float] | np.ndarray, 
+        self,
+        x: List[float] | np.ndarray,
         sigbands: Literal[True],
         mode: str = "rms",
-        detrend: bool = True
+        detrend: bool = True,
+        calculate_level: Literal[True] = True,
     ) -> Tuple[np.ndarray, List[float], List[np.ndarray]]: ...
 
-    # New overloads with calculate_level
     @overload
     def filter(
-            self,
-            x: List[float] | np.ndarray,
-            sigbands: Literal[False] = False,
-            mode: str = "rms",
-            detrend: bool = True,
-            calculate_level: Literal[False] = False
-    ) -> Tuple[None, List[float]]:
-        ...
+        self,
+        x: List[float] | np.ndarray,
+        sigbands: Literal[False] = False,
+        mode: str = "rms",
+        detrend: bool = True,
+        calculate_level: Literal[False] = False,
+    ) -> Tuple[None, List[float]]: ...
 
     @overload
     def filter(
-            self,
-            x: List[float] | np.ndarray,
-            sigbands: Literal[True],
-            mode: str = "rms",
-            detrend: bool = True,
-            calculate_level: Literal[False] = False
-    ) -> Tuple[None, List[float], List[np.ndarray]]:
-        ...
+        self,
+        x: List[float] | np.ndarray,
+        sigbands: Literal[True],
+        mode: str = "rms",
+        detrend: bool = True,
+        calculate_level: Literal[False] = False,
+    ) -> Tuple[None, List[float], List[np.ndarray]]: ...
 
     def filter(
-        self, 
-        x: List[float] | np.ndarray, 
+        self,
+        x: List[float] | np.ndarray,
         sigbands: bool = False,
         mode: str = "rms",
         detrend: bool = True,
-        calculate_level: bool =True
+        calculate_level: bool = True,
     ) -> Tuple[np.ndarray | None, List[float]] | Tuple[np.ndarray | None, List[float], List[np.ndarray]]:
         """
         Apply the pre-designed filter bank to a signal.

src/pyoctaveband/parametric_filters.py

@@ -84,25 +84,51 @@ def __init__(self, fs: int, curve: str = "A",
         zd, pd, kd = signal.bilinear_zpk(z, p, k, fs)
         self.sos = signal.zpk2sos(zd, pd, kd)
 
-        # Calculate initial conditions for filter state
+        # Initialize filter state for stateful block-wise processing.
+        # Uses lazy allocation: zi is sized on first filter() call so that
+        # the channel dimension matches the actual input shape.
         if self.stateful:
-            if not steady_ic:
-                self.zi = np.zeros((self.sos.shape[0], 2))
-            else:
+            self.zi = np.array([])
+            self._steady_ic = steady_ic
+
+    def _init_filter_state(self, x_proc: np.ndarray) -> None:
+        """Allocate or reallocate ``zi`` to match the input shape."""
+        n_sections = self.sos.shape[0]
+        if x_proc.ndim == 1:
+            if self._steady_ic:
                 self.zi = signal.sosfilt_zi(self.sos)
+            else:
+                self.zi = np.zeros((n_sections, 2))
+        else:
+            n_channels = x_proc.shape[0]
+            if self._steady_ic:
+                zi_base = signal.sosfilt_zi(self.sos)
+                self.zi = np.tile(zi_base[:, np.newaxis, :], (1, n_channels, 1))
+            else:
+                self.zi = np.zeros((n_sections, n_channels, 2))
+
+    def _needs_zi_reinit(self, x_proc: np.ndarray) -> bool:
+        """Check whether ``zi`` must be (re)allocated for *x_proc*."""
+        if self.zi.size == 0:
+            return True
+        if x_proc.ndim == 1:
+            return self.zi.ndim != 2
+        return self.zi.ndim != 3 or self.zi.shape[1] != x_proc.shape[0]
 
     def filter(self, x: List[float] | np.ndarray) -> np.ndarray:
         """
         Apply the weighting filter to a signal.
 
-        :param x: Input signal.
+        :param x: Input signal (1D or 2D [channels, samples]).
         :return: Weighted signal.
         """
         x_proc = _typesignal(x)
         if self.curve == "Z":
             return x_proc
 
         if self.stateful:
+            if self._needs_zi_reinit(x_proc):
+                self._init_filter_state(x_proc)
             y, self.zi = signal.sosfilt(self.sos, x_proc, axis=-1, zi=self.zi)
         else:
             y = signal.sosfilt(self.sos, x_proc, axis=-1)

tests/test_stateful_weighting_filter.py

@@ -44,8 +44,58 @@ def test_weighting_filter_steady_ic_initialization():
     # Create a stateful weighting filter with steady_ic=True
     wf = WeightingFilter(fs=48000, stateful=True, steady_ic=True)
 
-    # Check that zi has the expected shape
+    # Lazy init: zi is empty until first filter() call
+    assert wf.zi.size == 0
+
+    # Trigger lazy init with 1D signal
+    x = np.zeros(100)
+    wf.filter(x)
+
     n_sections = wf.sos.shape[0]
-    assert wf.zi.shape[0] == n_sections
-    assert wf.zi.shape[1] == 2
+    assert wf.zi.shape == (n_sections, 2)
+
+
+def test_weighting_filter_multichannel_to_mono_transition():
+    from pyoctaveband import WeightingFilter
+    """zi must reinit when input switches from multichannel to 1D."""
+    rng = np.random.default_rng(77)
+    fs = 48000
+    wf = WeightingFilter(fs, "A", stateful=True)
+
+    # First call: multichannel (4 channels)
+    x_multi = rng.standard_normal((4, 1200))
+    wf.filter(x_multi)
+    assert wf.zi.ndim == 3
+
+    # Second call: 1D — must not crash
+    x_mono = rng.standard_normal(1200)
+    y = wf.filter(x_mono)
+    assert wf.zi.ndim == 2
+    assert y.shape == x_mono.shape
+
+
+def test_weighting_filter_multichannel():
+    from pyoctaveband import WeightingFilter
+    """Stateful block-wise multichannel weighting must match full-signal processing."""
+    rng = np.random.default_rng(99)
+    fs = 48000
+    n_channels = 4
+    n_samples = 4800
+    block_size = 1200
+
+    x = rng.standard_normal((n_channels, n_samples))
+
+    # Full-signal reference (stateless)
+    ref_wf = WeightingFilter(fs, "A")
+    ref_out = ref_wf.filter(x)
+
+    # Block-wise stateful
+    stateful_wf = WeightingFilter(fs, "A", stateful=True)
+    blocks = []
+    for start in range(0, n_samples, block_size):
+        block = x[:, start:start + block_size]
+        blocks.append(stateful_wf.filter(block))
+
+    stateful_out = np.concatenate(blocks, axis=-1)
+    np.testing.assert_allclose(stateful_out, ref_out, rtol=1e-10, atol=1e-12)