⚡ Optimize EQEffect filter design caching

src/intuitive_daw/audio/processor.py

@@ -100,6 +100,13 @@
         self.mid_gain = mid_gain
         self.high_freq = high_freq
         self.high_gain = high_gain
+
+        # Cache
+        self._last_low_freq = None
+        self._last_sample_rate = None
+        self._sos = None
+        self._gain_linear = None
+        self._last_low_gain = None
 
     def _process_impl(self, audio: np.ndarray) -> np.ndarray:
         """Apply EQ (simplified implementation)"""
@@ -109,14 +116,25 @@
 
         # Apply low shelf
         if abs(self.low_gain) > 0.1:
-            sos = signal.butter(
-                2, 
-                self.low_freq, 
-                btype='low',
-                fs=self.sample_rate,
-                output='sos'
-            )
-            gain = 10.0 ** (self.low_gain / 20.0)
+            if (self.low_freq != self._last_low_freq or
+                self.sample_rate != self._last_sample_rate):
+                self._sos = signal.butter(
+                    2,
+                    self.low_freq,
+                    btype='low',
+                    fs=self.sample_rate,
+                    output='sos'
+                )
+                self._last_low_freq = self.low_freq
+                self._last_sample_rate = self.sample_rate
+
+            if self.low_gain != self._last_low_gain:
+                self._gain_linear = 10.0 ** (self.low_gain / 20.0)
+                self._last_low_gain = self.low_gain
+
+            sos = self._sos
+            gain = self._gain_linear
+
             for ch in range(result.shape[1]):
                 filtered = signal.sosfilt(sos, result[:, ch])
                 result[:, ch] = result[:, ch] + (filtered - result[:, ch]) * (gain - 1)

tests/conftest.py

@@ -0,0 +1,27 @@
+
+import sys
+from unittest.mock import MagicMock
+
+class MockTensor:
+    pass
+
+def pytest_configure(config):
+    """Mock heavy dependencies before tests run"""
+
+    # Create a mock torch that satisfies scipy's checks
+    mock_torch = MagicMock()
+    mock_torch.Tensor = MockTensor
+
+    heavy_modules = {
+        'sounddevice': MagicMock(),
+        'pyaudio': MagicMock(),
+        'torch': mock_torch,
+        'transformers': MagicMock(),
+        'pedalboard': MagicMock(),
+        'mido': MagicMock(),
+        'rtmidi': MagicMock(),
+        'librosa': MagicMock(),
+    }
+
+    for module_name, mock_obj in heavy_modules.items():
+        sys.modules[module_name] = mock_obj

tests/test_audio_processor.py

@@ -0,0 +1,70 @@
+
+import pytest
+import numpy as np
+from src.intuitive_daw.audio.processor import EQEffect
+
+class TestEQEffect:
+    def test_eq_initialization(self):
+        eq = EQEffect()
+        assert eq.name == "EQ"
+        assert eq.is_enabled == True
+        assert eq.low_gain == 0.0
+
+    def test_eq_processing_no_gain(self):
+        """Test that processing with 0 gain returns audio unchanged (mostly)"""
+        sample_rate = 48000
+        duration = 0.1
+        audio = np.random.rand(int(sample_rate * duration), 2)
+
+        eq = EQEffect(sample_rate=sample_rate, low_gain=0.0)
+        processed = eq.process(audio)
+
+        # With 0 gain, it should be identical
+        np.testing.assert_array_equal(processed, audio)
+
+    def test_eq_processing_with_gain(self):
+        """Test that processing with gain modifies the audio"""
+        sample_rate = 48000
+        duration = 0.1
+        audio = np.random.rand(int(sample_rate * duration), 2)
+
+        eq = EQEffect(sample_rate=sample_rate, low_gain=5.0)
+        processed = eq.process(audio)
+
+        # Should be different
+        assert not np.array_equal(processed, audio)
+
+        # Output shape should remain same
+        assert processed.shape == audio.shape
+
+    def test_eq_parameter_change(self):
+        """Test that changing parameters updates processing"""
+        sample_rate = 48000
+        duration = 0.1
+        audio = np.random.rand(int(sample_rate * duration), 2)
+
+        eq = EQEffect(sample_rate=sample_rate, low_gain=5.0)
+        res1 = eq.process(audio)
+
+        # Change gain
+        eq.low_gain = 10.0
+        res2 = eq.process(audio)
+
+        # Should be different
+        assert not np.allclose(res1, res2)
+
+    def test_eq_frequency_change(self):
+        """Test that changing frequency updates processing"""
+        sample_rate = 48000
+        duration = 0.1
+        audio = np.random.rand(int(sample_rate * duration), 2)
+
+        eq = EQEffect(sample_rate=sample_rate, low_gain=5.0, low_freq=100.0)
+        res1 = eq.process(audio)
+
+        # Change frequency
+        eq.low_freq = 200.0
+        res2 = eq.process(audio)
+
+        # Should be different
+        assert not np.allclose(res1, res2)