Linting and cleaning

gtts/cli.py

@@ -1,77 +1,107 @@
 # -*- coding: utf-8 -*-
 from gtts import gTTS, Languages, __version__
-import sys, os, codecs, click
+import click
 
 # Click settings
 CONTEXT_SETTINGS = {
     'help_option_names': ['-h', '--help']
 }
 
+
 def validate_text(ctx, param, value):
-    """Validation callback for the 'text' argument. 
-    Ensures 'text' (arg) and 'file' (opt) are mutually exclusive
+    """Validation callback for the <text> argument.
+    Ensures <text> (arg) and <file> (opt) are mutually exclusive
     """
     if not value and 'file' not in ctx.params:
         # No <text> and no <file>
-        raise click.BadParameter("TEXT or -f/--file FILENAME required")
+        raise click.BadParameter(
+            "TEXT or -f/--file FILENAME required")
     if value and 'file' in ctx.params:
         # Both <text> and <file>
-        raise click.BadParameter("TEXT and -f/--file FILENAME can't be used together")
+        raise click.BadParameter(
+            "TEXT and -f/--file FILENAME can't be used together")
     return value
 
+
 def print_languages(ctx, param, value):
     """Prints sorted pretty-printed list of supported languages"""
     if not value or ctx.resilient_parsing:
         return
     langs = Languages().get()
-    click.echo('  '+'\n  '.join(sorted("{}: {}".format(k, langs[k]) for k in langs)))
+    langs_str_list = sorted("{}: {}".format(k, langs[k]) for k in langs)
+    click.echo('  ' + '\n  '.join(langs_str_list))
     ctx.exit()
 
+
 @click.command(context_settings=CONTEXT_SETTINGS)
 @click.argument('text', required=False, callback=validate_text)
-@click.option('-f', '--file',
+@click.option(
+    '-f',
+    '--file',
     type=click.File(),
     help="Input is contents of FILENAME instead of TEXT (use '-' for stdin).")
-@click.option('-o', '--output',
+@click.option(
+    '-o',
+    '--output',
     type=click.File(mode='wb'),
     help="Write to FILENAME instead of stdout.")
-@click.option('-s', '--slow', default=False, is_flag=True,
+@click.option(
+    '-s',
+    '--slow',
+    default=False,
+    is_flag=True,
     help="Read more slowly.")
-@click.option('-l', '--lang', default='en', show_default=True,
+@click.option(
+    '-l',
+    '--lang',
+    default='en',
+    show_default=True,
     help="IETF language tag. Language to speak in. List documented tags with -a/--all.")
-@click.option('--nocheck', default=False, is_flag=True,
+@click.option(
+    '--nocheck',
+    default=False,
+    is_flag=True,
     help="Disable strict IETF language tag checking. Allow undocumented tags.")
-@click.option('--all', default=False, is_flag=True, callback=print_languages,
-    expose_value=False, is_eager=True,
+@click.option(
+    '--all',
+    default=False,
+    is_flag=True,
+    callback=print_languages,
+    expose_value=False,
+    is_eager=True,
     help="Print all documented available IETF language tags and exit.")
-@click.option('--debug', default=False, is_flag=True, help="Show debug information.")
+@click.option(
+    '--debug',
+    default=False,
+    is_flag=True,
+    help="Show debug information.")
 @click.version_option(version=__version__)
 def tts_cli(text, file, output, slow, lang, nocheck, debug):
     """Reads TEXT to MP3 format using Google Translate's Text-to-Speech API.
     (use '-' as TEXT or as -f/--file FILENAME for stdin)
     """
-    
+
     # Language check
     # (We can't do callback validation on <lang> because we
     # have to check against <nocheck> which might not exist
     # in the Click context at the time <lang> is used)
-    check = not nocheck # Readability
+    check = not nocheck  # Readability
     if check:
-        langs_list = Languages().get_list()
-        if lang not in langs_list:
+        if lang not in Languages().get():
             msg = "Use --all to list languages, or add --nocheck to disable language check."
             raise click.BadParameter(msg, param_hint="lang '{}'".format(lang))
 
     # stdin for <text> (auto for <file>)
     if text is '-':
         text = click.get_text_stream('stdin').read()
-    
+
     # stdout (when no <output>)
     if not output:
         output = click.get_binary_stream('stdout')
 
     # <file> input
-    if file: text = file.read() 
+    if file:
+        text = file.read()
 
     # TTS
     tts = gTTS(text=text, lang=lang, slow=slow, lang_check=check, debug=debug)

gtts/lang.py

@@ -1,21 +1,24 @@
 # -*- coding: utf-8 -*-
-import requests, re
+import requests
+import re
 from bs4 import BeautifulSoup
 
 """Google Translate loads a JavaScript Array of 'languages
 codes' that can be read. We intersect with all the
 languages Google Translate provides.
 """
 
+
 class LanguagesFetchError(Exception):
     pass
 
+
 class Languages:
     """Supported languages by Google's Text to Speech API"""
-    
+
     URL_BASE = 'http://translate.google.com'
     JS_FILE = 'desktop_module_main.js'
-   
+
     """Special undocumented language codes observed
     to provide different dialects or accents
     """
@@ -28,17 +31,17 @@ class Languages:
         'en-us': 'English (US)',
         'en-ca': 'English (Canada)',
         'en-uk': 'English (UK)',
-        'en-gb': 'English (UK)', 
+        'en-gb': 'English (UK)',
         'en-au': 'English (Australia)',
         # French
         'fr-ca': 'French (Canada)',
         # Portuguese
         'pt-br': 'Portuguese (Brazil)',
         'pt-pt': 'Portuguese (Portugal)',
         # Spanish
-        'es-es' : 'Spanish (Spain)',
-        'es-us' : 'Spanish (United States)'
-    } 
+        'es-es': 'Spanish (Spain)',
+        'es-us': 'Spanish (United States)'
+    }
 
     def __init__(self):
         self.langs = dict()
@@ -50,7 +53,7 @@ def get(self):
 
     def get_list(self):
         langs_dict = self.get()
-        langs_list = list(langs_dict.keys()) 
+        langs_list = list(langs_dict.keys())
         return langs_list
 
     def _fetch_langs(self):
@@ -84,10 +87,13 @@ def _fetch_langs(self):
             Out: {'af': 'Afrikaans', [...]}
             """
             langs_html = soup.find('select', {'id': 'gt-sl'}).findAll('option')
-            langs = {l['value']:l.text for l in langs_html if l['value'] in tts_langs}
+            langs = {
+                l['value']: l.text for l in langs_html if l['value'] in tts_langs}
             return langs
         except Exception as e:
-            raise LanguagesFetchError("Unable to get language list: {}".format(str(e)))
+            raise LanguagesFetchError(
+                "Unable to get language list: {}".format(str(e)))
+
 
 if __name__ == "__main__":
     pass

gtts/tts.py

@@ -1,28 +1,39 @@
 # -*- coding: utf-8 -*-
-from . import Languages, LanguagesFetchError 
+from . import Languages, LanguagesFetchError
 from six.moves import urllib
 from requests.packages.urllib3.exceptions import InsecureRequestWarning
 from gtts_token.gtts_token import Token
-import re, requests, warnings
+import re
+import requests
+import warnings
+
 
 class gTTSError(Exception):
     pass
 
+
 class Speed:
     """Google TTS API read speeds"""
-    
-    # The API supports two speeds. 
+
+    # The API supports two speeds.
     # (speed <= 0.3: slow; speed > 0.3: normal; default: 1)
     SLOW = 0.3
     NORMAL = 1
 
+
 class gTTS:
     """gTTS (Google Text to Speech): an interface to Google's Text to Speech API"""
 
     GOOGLE_TTS_URL = "https://translate.google.com/translate_tts"
-    MAX_CHARS = 100 # Max characters the Google TTS API takes at a time
-
-    def __init__(self, text, lang = 'en', slow = False, lang_check = False, debug = False):
+    MAX_CHARS = 100  # Max characters the Google TTS API takes at a time
+
+    def __init__(
+            self,
+            text,
+            lang='en',
+            slow=False,
+            lang_check=False,
+            debug=False):
         self.debug = debug
 
         # Language
@@ -53,14 +64,14 @@ def __init__(self, text, lang = 'en', slow = False, lang_check = False, debug =
         if self._len(text) <= self.MAX_CHARS:
             text_parts = [text]
         else:
-            text_parts = self._tokenize(text, self.MAX_CHARS)           
+            text_parts = self._tokenize(text, self.MAX_CHARS)
 
         # Clean
         def strip(x): return x.replace('\n', '').strip()
         text_parts = [strip(x) for x in text_parts]
         text_parts = [x for x in text_parts if len(x) > 0]
         self.text_parts = text_parts
-        
+
         # Google Translate token
         self.token = Token()
 
@@ -72,25 +83,28 @@ def save(self, savefile):
     def write_to_fp(self, fp):
         """Do the Web request and save to a file-like object"""
         for idx, part in enumerate(self.text_parts):
-            payload = { 'ie' : 'UTF-8',
-                        'q' : part,
-                        'tl' : self.lang,
-                        'ttsspeed' : self.speed,
-                        'total' : len(self.text_parts),
-                        'idx' : idx,
-                        'client' : 'tw-ob',
-                        'textlen' : self._len(part),
-                        'tk' : self.token.calculate_token(part)}
+            payload = {'ie': 'UTF-8',
+                       'q': part,
+                       'tl': self.lang,
+                       'ttsspeed': self.speed,
+                       'total': len(self.text_parts),
+                       'idx': idx,
+                       'client': 'tw-ob',
+                       'textlen': self._len(part),
+                       'tk': self.token.calculate_token(part)}
             headers = {
-                "Referer" : "http://translate.google.com/",
+                "Referer": "http://translate.google.com/",
                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36"
             }
-            if self.debug: print(payload)
+            if self.debug:
+                print(payload)
             try:
                 # Disable requests' ssl verify to accomodate certain proxies and firewalls
-                # Filter out urllib3's insecure warnings. We can live without ssl verify here
+                # Filter out urllib3's insecure warnings. We can live without
+                # ssl verify here
                 with warnings.catch_warnings():
-                    warnings.filterwarnings("ignore", category=InsecureRequestWarning)
+                    warnings.filterwarnings(
+                        "ignore", category=InsecureRequestWarning)
                     r = requests.get(self.GOOGLE_TTS_URL,
                                      params=payload,
                                      headers=headers,
@@ -99,7 +113,9 @@ def write_to_fp(self, fp):
                 if self.debug:
                     print("Headers: {}".format(r.request.headers))
                     print("Request url: {}".format(r.request.url))
-                    print("Response: {}, Redirects: {}".format(r.status_code, r.history))
+                    print(
+                        "Response: {}, Redirects: {}".format(
+                            r.status_code, r.history))
                 r.raise_for_status()
                 for chunk in r.iter_content(chunk_size=1024):
                     fp.write(chunk)
@@ -121,7 +137,7 @@ def _len(self, text):
 
     def _tokenize(self, text, max_size):
         """Tokenizer on basic punctuation"""
-        
+
         punc = "¡!()[]¿?.,…‥،;:—。，、：？！\n"
         punc_list = [re.escape(c) for c in punc]
         pattern = '|'.join(punc_list)
@@ -134,13 +150,15 @@ def _tokenize(self, text, max_size):
 
     def _minimize(self, thestring, delim, max_size):
         """Recursive function that splits <thestring> in chunks
-        of maximum <max_size> chars delimited by <delim>. Returns list.""" 
-        
+        of maximum <max_size> chars delimited by <delim>. Returns list."""
+
         if self._len(thestring) > max_size:
             idx = thestring.rfind(delim, 0, max_size)
-            return [thestring[:idx]] + self._minimize(thestring[idx:], delim, max_size)
+            return [thestring[:idx]] + \
+                self._minimize(thestring[idx:], delim, max_size)
         else:
             return [thestring]
 
+
 if __name__ == "__main__":
     pass