[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

audio_filters/__init__.py

@@ -20,7 +20,7 @@
 
 __all__ = [
     "EqualLoudnessFilter",
-    "IIRFilter", 
+    "IIRFilter",
     "make_highpass",
     "make_lowpass",
-]
+]

audio_filters/demo_equal_loudness_filter.py

@@ -14,130 +14,136 @@
 from audio_filters.equal_loudness_filter import EqualLoudnessFilter
 
 
-def generate_test_signal(frequency: float, duration: float, samplerate: int, amplitude: float = 0.5) -> List[float]:
+def generate_test_signal(
+    frequency: float, duration: float, samplerate: int, amplitude: float = 0.5
+) -> List[float]:
     """
     Generate a simple sine wave test signal.
-    
+
     Args:
         frequency: Frequency of the sine wave in Hz
         duration: Duration of the signal in seconds
         samplerate: Sample rate in Hz
         amplitude: Amplitude of the sine wave (0-1)
-    
+
     Returns:
         List of audio samples
     """
     samples = []
     total_samples = int(duration * samplerate)
-    
+
     for i in range(total_samples):
         t = i / samplerate  # Time in seconds
         sample = amplitude * math.sin(2 * math.pi * frequency * t)
         samples.append(sample)
-    
+
     return samples
 
 
 def demonstrate_equal_loudness_filter():
     """Main demonstration function."""
     print("🎵 Equal Loudness Filter Demonstration")
     print("=" * 50)
-    
+
     # Create filter instance
     samplerate = 44100
     filter_instance = EqualLoudnessFilter(samplerate)
-    
+
     print(f"Filter initialized with sample rate: {samplerate} Hz")
     print(f"Filter order: {filter_instance.yulewalk_filter.order}")
     print()
-    
+
     # Test 1: Process silence
     print("📌 Test 1: Processing silence")
     silence_result = filter_instance.process(0.0)
     print(f"Input: 0.0 → Output: {silence_result}")
     assert silence_result == 0.0, "Silence should remain silence"
     print("✅ Silence test passed!")
     print()
-    
+
     # Test 2: Process various amplitude levels
     print("📌 Test 2: Processing different amplitude levels")
     test_amplitudes = [0.1, 0.25, 0.5, 0.75, 1.0, -0.1, -0.25, -0.5, -0.75, -1.0]
-    
+
     for amplitude in test_amplitudes:
         result = filter_instance.process(amplitude)
         print(f"Input: {amplitude:6.2f} → Output: {result:10.6f}")
     print("✅ Amplitude test completed!")
     print()
-    
+
     # Test 3: Process a sine wave
     print("📌 Test 3: Processing a 1kHz sine wave")
     test_freq = 1000  # 1kHz
-    duration = 0.01   # 10ms
+    duration = 0.01  # 10ms
     sine_wave = generate_test_signal(test_freq, duration, samplerate, 0.3)
-    
+
     print(f"Generated {len(sine_wave)} samples of {test_freq}Hz sine wave")
-    
+
     # Process the sine wave
     filtered_samples = []
     for sample in sine_wave[:10]:  # Show first 10 samples
         filtered_sample = filter_instance.process(sample)
         filtered_samples.append(filtered_sample)
         print(f"Sample: {sample:8.5f} → Filtered: {filtered_sample:8.5f}")
-    
+
     print("✅ Sine wave processing test completed!")
     print()
-    
+
     # Test 4: Filter reset functionality
     print("📌 Test 4: Testing filter reset")
-    
+
     # Process some samples to build internal state
     for _ in range(5):
         filter_instance.process(0.5)
-    
+
     print("Processed 5 samples to build internal state")
-    
+
     # Check state before reset
     history_before = filter_instance.yulewalk_filter.input_history.copy()
     print(f"Input history before reset: {history_before[:3]}...")  # Show first 3 values
-    
+
     # Reset the filter
     filter_instance.reset()
-    
+
     # Check state after reset
     history_after = filter_instance.yulewalk_filter.input_history.copy()
     print(f"Input history after reset: {history_after[:3]}...")
-    
-    assert all(val == 0.0 for val in history_after), "History should be cleared after reset"
+
+    assert all(val == 0.0 for val in history_after), (
+        "History should be cleared after reset"
+    )
     print("✅ Reset test passed!")
     print()
-    
+
     # Test 5: Filter information
     print("📌 Test 5: Filter configuration information")
     filter_info = filter_instance.get_filter_info()
-    
+
     for key, value in filter_info.items():
         if isinstance(value, list):
             print(f"{key}: [{len(value)} coefficients]")
         else:
             print(f"{key}: {value}")
-    
+
     print("✅ Filter info test completed!")
     print()
-    
+
     # Test 6: Different sample rates
     print("📌 Test 6: Testing different sample rates")
     test_samplerates = [22050, 44100, 48000, 96000]
-    
+
     for sr in test_samplerates:
         test_filter = EqualLoudnessFilter(sr)
         result = test_filter.process(0.5)
         print(f"Sample rate: {sr:6d} Hz → Result: {result:10.6f}")
-    
+
     print("✅ Sample rate test completed!")
     print()
-    
+
     print("🎉 All demonstrations completed successfully!")
-    print("\nThe Equal Loudness Filter is ready for use in audio processing applications!")
+    print(
+        "\nThe Equal Loudness Filter is ready for use in audio processing applications!"
+    )
 
 
 if __name__ == "__main__":
@@ -149,4 +155,4 @@ def demonstrate_equal_loudness_filter():
         sys.exit(1)
     except Exception as e:
         print(f"❌ Demonstration failed: {e}")
-        sys.exit(1)
+        sys.exit(1)

audio_filters/equal_loudness_filter.py

@@ -1,7 +1,7 @@
 """
 Equal-loudness filter implementation for audio processing.
 
-This module implements an equal-loudness filter which compensates for the human ear's 
+This module implements an equal-loudness filter which compensates for the human ear's
 non-linear response to sound using cascaded IIR filters.
 """
 
@@ -23,44 +23,44 @@ def _yulewalk_approximation(
 ) -> tuple[np.ndarray, np.ndarray]:
     """
     Simplified Yule-Walker approximation for filter design.
-    
+
     This is a basic implementation that approximates the yulewalker functionality
     using numpy for creating filter coefficients from frequency response data.
-    
+
     Args:
         order: Filter order
         frequencies: Normalized frequencies (0 to 1)
         gains: Desired gains at those frequencies
-    
+
     Returns:
         Tuple of (a_coeffs, b_coeffs) for the IIR filter
     """
     # Simple approach: create coefficients that approximate the desired response
     # This is a simplified version - in practice, yulewalker uses more sophisticated methods
-    
+
     # Create a basic filter response approximation
     # Using a simple polynomial fit approach
     try:
         # Fit polynomial to log-magnitude response
         log_gains = np.log10(gains + 1e-10)  # Avoid log(0)
         coeffs = np.polyfit(frequencies, log_gains, min(order, len(frequencies) - 1))
-        
+
         # Convert polynomial coefficients to filter coefficients
         a_coeffs = np.zeros(order + 1)
         b_coeffs = np.zeros(order + 1)
-        
+
         a_coeffs[0] = 1.0  # Normalized
-        
+
         # Simple mapping from polynomial to filter coefficients
         for i in range(min(len(coeffs), order)):
             b_coeffs[i] = coeffs[-(i + 1)] * 0.1  # Scale factor for stability
-        
+
         # Ensure some basic coefficients are set
         if b_coeffs[0] == 0:
             b_coeffs[0] = 0.1
-            
+
         return a_coeffs, b_coeffs
-        
+
     except (np.linalg.LinAlgError, ValueError):
         # Fallback to simple pass-through filter
         a_coeffs = np.zeros(order + 1)
@@ -74,27 +74,27 @@ class EqualLoudnessFilter:
     """
     An equal-loudness filter which compensates for the human ear's non-linear response
     to sound.
-    
+
     This filter corrects the frequency response by cascading a Yule-Walker approximation
     filter and a Butterworth high-pass filter.
-    
-    The filter is designed for use with sample rates of 44.1kHz and above. If you're 
+
+    The filter is designed for use with sample rates of 44.1kHz and above. If you're
     using a lower sample rate, use with caution.
-    
+
     The equal-loudness contours are based on the Robinson-Dadson curves (1956), which
     describe how the human ear perceives different frequencies at various loudness levels.
-    
+
     References:
         - Robinson, D. W., & Dadson, R. S. (1956). A re-determination of the equal-
           loudness relations for pure tones. British Journal of Applied Physics, 7(5), 166.
         - Original MATLAB implementation by David Robinson, 2001
-        
+
     Examples:
         >>> filt = EqualLoudnessFilter(48000)
         >>> processed_sample = filt.process(0.5)
         >>> isinstance(processed_sample, float)
         True
-        
+
         >>> # Process silence
         >>> filt = EqualLoudnessFilter()
         >>> filt.process(0.0)
@@ -104,17 +104,17 @@ class EqualLoudnessFilter:
     def __init__(self, samplerate: int = 44100) -> None:
         """
         Initialize the equal-loudness filter.
-        
+
         Args:
             samplerate: Sample rate in Hz (default: 44100)
-            
+
         Raises:
             ValueError: If samplerate is not positive
         """
         if samplerate <= 0:
             msg = "Sample rate must be positive"
             raise ValueError(msg)
-            
+
         self.samplerate = samplerate
         self.yulewalk_filter = IIRFilter(10)
         self.butterworth_filter = make_highpass(150, samplerate)
@@ -138,17 +138,17 @@ def __init__(self, samplerate: int = 44100) -> None:
     def process(self, sample: Union[float, int]) -> float:
         """
         Process a single sample through both filters.
-        
+
         The sample is first processed through the Yule-Walker approximation filter
         to apply the equal-loudness curve correction, then through a high-pass
         Butterworth filter to remove low-frequency artifacts.
-        
+
         Args:
             sample: Input audio sample (should be normalized to [-1, 1] range)
-            
+
         Returns:
             Processed audio sample as float
-            
+
         Examples:
             >>> filt = EqualLoudnessFilter()
             >>> filt.process(0.0)
@@ -160,17 +160,17 @@ def process(self, sample: Union[float, int]) -> float:
         """
         # Convert to float for processing
         sample_float = float(sample)
-        
+
         # Apply Yule-Walker approximation filter first
         tmp = self.yulewalk_filter.process(sample_float)
-        
+
         # Then apply Butterworth high-pass filter
         return self.butterworth_filter.process(tmp)
 
     def reset(self) -> None:
         """
         Reset the filter's internal state (clear history).
-        
+
         This is useful when starting to process a new audio stream
         to avoid artifacts from previous processing.
         """
@@ -181,7 +181,7 @@ def reset(self) -> None:
     def get_filter_info(self) -> dict[str, Union[int, float, list[float]]]:
         """
         Get information about the filter configuration.
-        
+
         Returns:
             Dictionary containing filter parameters and coefficients
         """
@@ -197,17 +197,17 @@ def get_filter_info(self) -> dict[str, Union[int, float, list[float]]]:
 if __name__ == "__main__":
     # Demonstration of the filter
     import doctest
-    
+
     doctest.testmod()
-    
+
     # Create a simple test
     filter_instance = EqualLoudnessFilter(44100)
     test_samples = [0.0, 0.1, 0.5, -0.3, 1.0, -1.0]
-    
+
     print("Equal-Loudness Filter Demo:")
     print("Sample Rate: 44100 Hz")
     print("Test samples and their filtered outputs:")
-    
+
     for sample in test_samples:
         filtered = filter_instance.process(sample)
-        print(f"Input: {sample:6.1f} → Output: {filtered:8.6f}")
+        print(f"Input: {sample:6.1f} → Output: {filtered:8.6f}")

audio_filters/tests/__init__.py

@@ -2,4 +2,4 @@
 Test suite for audio_filters module.
 
 This package contains comprehensive tests for all audio filter implementations.
-"""
+"""