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

utils/data.py

@@ -45,7 +45,6 @@ def prepare_stop_target(inputs, out_steps):
 
 
 def pad_per_step(inputs, pad_len):
-    timesteps = inputs.shape[-1]
     return np.pad(
         inputs, [[0, 0], [0, 0], [0, pad_len]],
         mode='constant',

utils/generic_utils.py

@@ -1,8 +1,6 @@
 import os
 import re
-import sys
 import glob
-import time
 import shutil
 import datetime
 import json
@@ -11,8 +9,6 @@ import subprocess
 import importlib
 import numpy as np
 from collections import OrderedDict, Counter
-from torch.autograd import Variable
-from utils.text import text_to_sequence
 
 
 class AttrDict(dict):
@@ -78,7 +74,7 @@ def remove_experiment_folder(experiment_path):
     """Check folder if there is a checkpoint, otherwise remove the folder"""
 
     checkpoint_files = glob.glob(experiment_path + "/*.pth.tar")
-    if len(checkpoint_files) < 1:
+    if not checkpoint_files:
         if os.path.exists(experiment_path):
             shutil.rmtree(experiment_path)
             print(" ! Run is removed from {}".format(experiment_path))
@@ -87,7 +83,6 @@ def remove_experiment_folder(experiment_path):
 
 
 def copy_config_file(config_file, out_path, new_fields):
-    config_name = os.path.basename(config_file)
     config_lines = open(config_file, "r").readlines()
     # add extra information fields
     for key, value in new_fields.items():

utils/logger.py

@@ -46,7 +46,7 @@ class Logger(object):
 
     def tb_train_iter_stats(self, step, stats):
         self.dict_to_tb_scalar("TrainIterStats", stats, step)
-    
+
     def tb_train_epoch_stats(self, step, stats):
         self.dict_to_tb_scalar("TrainEpochStats", stats, step)
 
@@ -64,12 +64,9 @@ class Logger(object):
 
     def tb_eval_audios(self, step, audios, sample_rate):
         self.dict_to_tb_audios("EvalAudios", audios, step, sample_rate)
-    
+
     def tb_test_audios(self, step, audios, sample_rate):
         self.dict_to_tb_audios("TestAudios", audios, step, sample_rate)
 
     def tb_test_figures(self, step, figures):
         self.dict_to_tb_figure("TestFigures", figures, step)
-
-
-        

utils/synthesis.py

@@ -1,11 +1,6 @@
-import io
-import time
-import librosa
 import torch
 import numpy as np
-from .text import text_to_sequence, phoneme_to_sequence, sequence_to_phoneme
-from .visual import visualize
-from matplotlib import pylab as plt
+from .text import text_to_sequence, phoneme_to_sequence
 
 
 def text_to_seqvec(text, CONFIG, use_cuda):
@@ -31,8 +26,7 @@ def compute_style_mel(style_wav, ap, use_cuda):
         ap.load_wav(style_wav))).unsqueeze(0)
     if use_cuda:
         return style_mel.cuda()
-    else:
-        return style_mel
+    return style_mel
 
 
 def run_model(model, inputs, CONFIG, truncated, speaker_id=None, style_mel=None):
@@ -84,7 +78,7 @@ def synthesis(model,
               style_wav=None,
               truncated=False,
               enable_eos_bos_chars=False,
-              trim_silence=False):
+              do_trim_silence=False):
     """Synthesize voice for the given text.
 
         Args:
@@ -99,7 +93,7 @@ def synthesis(model,
             truncated (bool): keep model states after inference. It can be used
                 for continuous inference at long texts.
             enable_eos_bos_chars (bool): enable special chars for end of sentence and start of sentence.
-            trim_silence (bool): trim silence after synthesis.
+            do_trim_silence (bool): trim silence after synthesis.
     """
     # GST processing
     style_mel = None
@@ -119,6 +113,6 @@ def synthesis(model,
     # plot results
     wav = inv_spectrogram(postnet_output, ap, CONFIG)
     # trim silence
-    if trim_silence:
+    if do_trim_silence:
         wav = trim_silence(wav)
     return wav, alignment, decoder_output, postnet_output, stop_tokens

utils/text/__init__.py

@@ -7,17 +7,17 @@ from utils.text import cleaners
 from utils.text.symbols import symbols, phonemes, _phoneme_punctuations
 
 # Mappings from symbol to numeric ID and vice versa:
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-_id_to_symbol = {i: s for i, s in enumerate(symbols)}
+_SYMBOL_TO_ID = {s: i for i, s in enumerate(symbols)}
+_ID_TO_SYMBOL = {i: s for i, s in enumerate(symbols)}
 
-_phonemes_to_id = {s: i for i, s in enumerate(phonemes)}
-_id_to_phonemes = {i: s for i, s in enumerate(phonemes)}
+_PHONEMES_TO_ID = {s: i for i, s in enumerate(phonemes)}
+_ID_TO_PHONEMES = {i: s for i, s in enumerate(phonemes)}
 
 # Regular expression matching text enclosed in curly braces:
-_curly_re = re.compile(r'(.*?)\{(.+?)\}(.*)')
+_CURLY_RE = re.compile(r'(.*?)\{(.+?)\}(.*)')
 
 # Regular expression matchinf punctuations, ignoring empty space
-pat = r'['+_phoneme_punctuations+']+'
+PHONEME_PUNCTUATION_PATTERN = r'['+_phoneme_punctuations+']+'
 
 
 def text2phone(text, language):
@@ -26,11 +26,11 @@ def text2phone(text, language):
     '''
     seperator = phonemizer.separator.Separator(' |', '', '|')
     #try:
-    punctuations = re.findall(pat, text)
+    punctuations = re.findall(PHONEME_PUNCTUATION_PATTERN, text)
     ph = phonemize(text, separator=seperator, strip=False, njobs=1, backend='espeak', language=language)
     ph = ph[:-1].strip() # skip the last empty character
     # Replace \n with matching punctuations.
-    if len(punctuations) > 0:
+    if punctuations:
         # if text ends with a punctuation.
         if text[-1] == punctuations[-1]:
             for punct in punctuations[:-1]:
@@ -47,20 +47,20 @@ def text2phone(text, language):
 
 def phoneme_to_sequence(text, cleaner_names, language, enable_eos_bos=False):
     if enable_eos_bos:
-        sequence = [_phonemes_to_id['^']]
+        sequence = [_PHONEMES_TO_ID['^']]
     else:
         sequence = []
     text = text.replace(":", "")
     clean_text = _clean_text(text, cleaner_names)
-    phonemes = text2phone(clean_text, language)
-    if phonemes is None:
+    to_phonemes = text2phone(clean_text, language)
+    if to_phonemes is None:
         print("!! After phoneme conversion the result is None. -- {} ".format(clean_text))
     # iterate by skipping empty strings - NOTE: might be useful to keep it to have a better intonation.
-    for phoneme in filter(None, phonemes.split('|')):
+    for phoneme in filter(None, to_phonemes.split('|')):
         sequence += _phoneme_to_sequence(phoneme)
     # Append EOS char
     if enable_eos_bos:
-        sequence.append(_phonemes_to_id['~'])
+        sequence.append(_PHONEMES_TO_ID['~'])
     return sequence
 
 
@@ -68,8 +68,8 @@ def sequence_to_phoneme(sequence):
     '''Converts a sequence of IDs back to a string'''
     result = ''
     for symbol_id in sequence:
-        if symbol_id in _id_to_phonemes:
-            s = _id_to_phonemes[symbol_id]
+        if symbol_id in _ID_TO_PHONEMES:
+            s = _ID_TO_PHONEMES[symbol_id]
             result += s
     return result.replace('}{', ' ')
 
@@ -89,8 +89,8 @@ def text_to_sequence(text, cleaner_names):
     '''
     sequence = []
     # Check for curly braces and treat their contents as ARPAbet:
-    while len(text):
-        m = _curly_re.match(text)
+    while text:
+        m = _CURLY_RE.match(text)
         if not m:
             sequence += _symbols_to_sequence(_clean_text(text, cleaner_names))
             break
@@ -105,8 +105,8 @@ def sequence_to_text(sequence):
     '''Converts a sequence of IDs back to a string'''
     result = ''
     for symbol_id in sequence:
-        if symbol_id in _id_to_symbol:
-            s = _id_to_symbol[symbol_id]
+        if symbol_id in _ID_TO_SYMBOL:
+            s = _ID_TO_SYMBOL[symbol_id]
             # Enclose ARPAbet back in curly braces:
             if len(s) > 1 and s[0] == '@':
                 s = '{%s}' % s[1:]
@@ -123,12 +123,12 @@ def _clean_text(text, cleaner_names):
     return text
 
 
-def _symbols_to_sequence(symbols):
-    return [_symbol_to_id[s] for s in symbols if _should_keep_symbol(s)]
+def _symbols_to_sequence(syms):
+    return [_SYMBOL_TO_ID[s] for s in syms if _should_keep_symbol(s)]
 
 
-def _phoneme_to_sequence(phonemes):
-    return [_phonemes_to_id[s] for s in list(phonemes) if _should_keep_phoneme(s)]
+def _phoneme_to_sequence(phons):
+    return [_PHONEMES_TO_ID[s] for s in list(phons) if _should_keep_phoneme(s)]
 
 
 def _arpabet_to_sequence(text):
@@ -136,8 +136,8 @@ def _arpabet_to_sequence(text):
 
 
 def _should_keep_symbol(s):
-    return s in _symbol_to_id and s not in ['~', '^', '_']
+    return s in _SYMBOL_TO_ID and s not in ['~', '^', '_']
 
 
 def _should_keep_phoneme(p):
-    return p in _phonemes_to_id and p not in ['~', '^', '_']
+    return p in _PHONEMES_TO_ID and p not in ['~', '^', '_']

utils/text/cmudict.py

@@ -2,16 +2,16 @@
 
 import re
 
-# valid_symbols = [
-#     'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1',
-#     'AH2', 'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0',
-#     'AY1', 'AY2', 'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0',
-#     'ER1', 'ER2', 'EY', 'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0',
-#     'IH1', 'IH2', 'IY', 'IY0', 'IY1', 'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG',
-#     'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0', 'OY1', 'OY2', 'P', 'R', 'S', 'SH',
-#     'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW', 'UW0', 'UW1', 'UW2', 'V', 'W',
-#     'Y', 'Z', 'ZH'
-# ]
+VALID_SYMBOLS = [
+    'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1',
+    'AH2', 'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0',
+    'AY1', 'AY2', 'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0',
+    'ER1', 'ER2', 'EY', 'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0',
+    'IH1', 'IH2', 'IY', 'IY0', 'IY1', 'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG',
+    'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0', 'OY1', 'OY2', 'P', 'R', 'S', 'SH',
+    'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW', 'UW0', 'UW1', 'UW2', 'V', 'W',
+    'Y', 'Z', 'ZH'
+]
 
 
 class CMUDict:
@@ -37,19 +37,19 @@ class CMUDict:
         '''Returns list of ARPAbet pronunciations of the given word.'''
         return self._entries.get(word.upper())
 
-    def get_arpabet(self, word, cmudict, punctuation_symbols):
+    @staticmethod
+    def get_arpabet(word, cmudict, punctuation_symbols):
         first_symbol, last_symbol = '', ''
-        if len(word) > 0 and word[0] in punctuation_symbols:
+        if word and word[0] in punctuation_symbols:
             first_symbol = word[0]
             word = word[1:]
-        if len(word) > 0 and word[-1] in punctuation_symbols:
+        if word and word[-1] in punctuation_symbols:
             last_symbol = word[-1]
             word = word[:-1]
         arpabet = cmudict.lookup(word)
         if arpabet is not None:
             return first_symbol + '{%s}' % arpabet[0] + last_symbol
-        else:
-            return first_symbol + word + last_symbol
+        return first_symbol + word + last_symbol
 
 
 _alt_re = re.compile(r'\([0-9]+\)')
@@ -58,7 +58,7 @@ _alt_re = re.compile(r'\([0-9]+\)')
 def _parse_cmudict(file):
     cmudict = {}
     for line in file:
-        if len(line) and (line[0] >= 'A' and line[0] <= 'Z' or line[0] == "'"):
+        if line and (line[0] >= 'A' and line[0] <= 'Z' or line[0] == "'"):
             parts = line.split('  ')
             word = re.sub(_alt_re, '', parts[0])
             pronunciation = _get_pronunciation(parts[1])
@@ -73,6 +73,6 @@ def _parse_cmudict(file):
 def _get_pronunciation(s):
     parts = s.strip().split(' ')
     for part in parts:
-        if part not in _valid_symbol_set:
+        if part not in VALID_SYMBOLS:
             return None
     return ' '.join(parts)

utils/text/number_norm.py

@@ -66,14 +66,13 @@ def _expand_dollars(m):
         dollar_unit = 'dollar' if dollars == 1 else 'dollars'
         cent_unit = 'cent' if cents == 1 else 'cents'
         return '%s %s, %s %s' % (dollars, dollar_unit, cents, cent_unit)
-    elif dollars:
+    if dollars:
         dollar_unit = 'dollar' if dollars == 1 else 'dollars'
         return '%s %s' % (dollars, dollar_unit)
-    elif cents:
+    if cents:
         cent_unit = 'cent' if cents == 1 else 'cents'
         return '%s %s' % (cents, cent_unit)
-    else:
-        return 'zero dollars'
+    return 'zero dollars'
 
 
 def _standard_number_to_words(n, digit_group):
@@ -99,12 +98,11 @@ def _number_to_words(n):
     # Handle special cases first, then go to the standard case:
     if n >= 1000000000000000000:
         return str(n)  # Too large, just return the digits
-    elif n == 0:
+    if n == 0:
         return 'zero'
-    elif n % 100 == 0 and n % 1000 != 0 and n < 3000:
+    if n % 100 == 0 and n % 1000 != 0 and n < 3000:
         return _standard_number_to_words(n // 100, 0) + ' hundred'
-    else:
-        return _standard_number_to_words(n, 0)
+    return _standard_number_to_words(n, 0)
 
 
 def _expand_number(m):

utils/visual.py

@@ -1,4 +1,3 @@
-import numpy as np
 import librosa
 import matplotlib
 matplotlib.use('Agg')
@@ -49,7 +48,7 @@ def visualize(alignment, spectrogram_postnet, stop_tokens, text, hop_length, CON
         print(text)
     plt.yticks(range(len(text)), list(text))
     plt.colorbar()
-    
+
     stop_tokens = stop_tokens.squeeze().detach().to('cpu').numpy()
     plt.subplot(num_plot, 1, 2)
     plt.plot(range(len(stop_tokens)), list(stop_tokens))
@@ -65,12 +64,12 @@ def visualize(alignment, spectrogram_postnet, stop_tokens, text, hop_length, CON
     if spectrogram is not None:
         plt.subplot(num_plot, 1, 4)
         librosa.display.specshow(spectrogram.T, sr=CONFIG.audio['sample_rate'],
-                                hop_length=hop_length, x_axis="time", y_axis="linear")
+                                 hop_length=hop_length, x_axis="time", y_axis="linear")
         plt.xlabel("Time", fontsize=label_fontsize)
         plt.ylabel("Hz", fontsize=label_fontsize)
         plt.tight_layout()
         plt.colorbar()
-    
+
     if output_path:
         print(output_path)
         fig.savefig(output_path)