Fix Pylint issues

utils/audio.py

@@ -1,11 +1,8 @@
-import os
 import librosa
 import soundfile as sf
-import pickle
-import copy
 import numpy as np
-from pprint import pprint
-from scipy import signal, io
+import scipy.io
+import scipy.signal
 
 
 class AudioProcessor(object):
@@ -27,7 +24,7 @@ class AudioProcessor(object):
                  clip_norm=True,
                  griffin_lim_iters=None,
                  do_trim_silence=False,
-                 **kwargs):
+                 **_):
 
         print(" > Setting up Audio Processor...")
 
@@ -55,7 +52,7 @@ class AudioProcessor(object):
 
     def save_wav(self, wav, path):
         wav_norm = wav * (32767 / max(0.01, np.max(np.abs(wav))))
-        io.wavfile.write(path, self.sample_rate, wav_norm.astype(np.int16))
+        scipy.io.wavfile.write(path, self.sample_rate, wav_norm.astype(np.int16))
 
     def _linear_to_mel(self, spectrogram):
         _mel_basis = self._build_mel_basis()
@@ -78,11 +75,12 @@ class AudioProcessor(object):
 
     def _normalize(self, S):
         """Put values in [0, self.max_norm] or [-self.max_norm, self.max_norm]"""
+        #pylint: disable=no-else-return
         if self.signal_norm:
             S_norm = ((S - self.min_level_db) / - self.min_level_db)
             if self.symmetric_norm:
                 S_norm = ((2 * self.max_norm) * S_norm) - self.max_norm
-                if self.clip_norm :
+                if self.clip_norm:
                     S_norm = np.clip(S_norm, -self.max_norm, self.max_norm)
                 return S_norm
             else:
@@ -95,18 +93,19 @@ class AudioProcessor(object):
 
     def _denormalize(self, S):
         """denormalize values"""
+        #pylint: disable=no-else-return
         S_denorm = S
         if self.signal_norm:
             if self.symmetric_norm:
                 if self.clip_norm:
-                    S_denorm = np.clip(S_denorm, -self.max_norm, self.max_norm) 
+                    S_denorm = np.clip(S_denorm, -self.max_norm, self.max_norm)
                 S_denorm = ((S_denorm + self.max_norm) * -self.min_level_db / (2 * self.max_norm)) + self.min_level_db
                 return S_denorm
             else:
                 if self.clip_norm:
                     S_denorm = np.clip(S_denorm, 0, self.max_norm)
                 S_denorm = (S_denorm * -self.min_level_db /
-                    self.max_norm) + self.min_level_db
+                            self.max_norm) + self.min_level_db
                 return S_denorm
         else:
             return S
@@ -122,18 +121,19 @@ class AudioProcessor(object):
         min_level = np.exp(self.min_level_db / 20 * np.log(10))
         return 20 * np.log10(np.maximum(min_level, x))
 
-    def _db_to_amp(self, x):
+    @staticmethod
+    def _db_to_amp(x):
         return np.power(10.0, x * 0.05)
 
     def apply_preemphasis(self, x):
         if self.preemphasis == 0:
             raise RuntimeError(" !! Preemphasis is applied with factor 0.0. ")
-        return signal.lfilter([1, -self.preemphasis], [1], x)
+        return scipy.signal.lfilter([1, -self.preemphasis], [1], x)
 
     def apply_inv_preemphasis(self, x):
         if self.preemphasis == 0:
             raise RuntimeError(" !! Preemphasis is applied with factor 0.0. ")
-        return signal.lfilter([1], [1, -self.preemphasis], x)
+        return scipy.signal.lfilter([1], [1, -self.preemphasis], x)
 
     def spectrogram(self, y):
         if self.preemphasis != 0:
@@ -158,8 +158,7 @@ class AudioProcessor(object):
         # Reconstruct phase
         if self.preemphasis != 0:
             return self.apply_inv_preemphasis(self._griffin_lim(S**self.power))
-        else:
-            return self._griffin_lim(S**self.power)
+        return self._griffin_lim(S**self.power)
 
     def inv_mel_spectrogram(self, mel_spectrogram):
         '''Converts mel spectrogram to waveform using librosa'''
@@ -168,12 +167,11 @@ class AudioProcessor(object):
         S = self._mel_to_linear(S)  # Convert back to linear
         if self.preemphasis != 0:
             return self.apply_inv_preemphasis(self._griffin_lim(S**self.power))
-        else:
-            return self._griffin_lim(S**self.power)
+        return self._griffin_lim(S**self.power)
 
     def out_linear_to_mel(self, linear_spec):
         S = self._denormalize(linear_spec)
-        S = self._db_to_amp(S + self.ref_level_db)  
+        S = self._db_to_amp(S + self.ref_level_db)
         S = self._linear_to_mel(np.abs(S))
         S = self._amp_to_db(S) - self.ref_level_db
         mel = self._normalize(S)
@@ -183,7 +181,7 @@ class AudioProcessor(object):
         angles = np.exp(2j * np.pi * np.random.rand(*S.shape))
         S_complex = np.abs(S).astype(np.complex)
         y = self._istft(S_complex * angles)
-        for i in range(self.griffin_lim_iters):
+        for _ in range(self.griffin_lim_iters):
             angles = np.exp(1j * np.angle(self._stft(y)))
             y = self._istft(S_complex * angles)
         return y
@@ -240,16 +238,19 @@ class AudioProcessor(object):
         if self.do_trim_silence:
             try:
                 x = self.trim_silence(x)
-            except ValueError as e:
+            except ValueError:
                 print(f' [!] File cannot be trimmed for silence - {filename}')
         assert self.sample_rate == sr, "%s vs %s"%(self.sample_rate, sr)
         return x
 
-    def encode_16bits(self, x):
+    @staticmethod
+    def encode_16bits(x):
         return np.clip(x * 2**15, -2**15, 2**15 - 1).astype(np.int16)
 
-    def quantize(self, x, bits):
+    @staticmethod
+    def quantize(x, bits):
         return (x + 1.) * (2**bits - 1) / 2
 
-    def dequantize(self, x, bits):
+    @staticmethod
+    def dequantize(x, bits):
         return 2 * x / (2**bits - 1) - 1