Merge pull request #129 from pettarin/devel

Added AWS Polly TTS API wrapper

Author: readbeyond

README.md

@@ -235,7 +235,7 @@ which explains how to use the built-in command line tools.
 * Output sync map formats: AUD, CSV, EAF, JSON, SMIL, SRT, SSV, SUB, TEXTGRID, TSV, TTML, TXT, VTT, XML
 * Confirmed working on 38 languages: AFR, ARA, BUL, CAT, CYM, CES, DAN, DEU, ELL, ENG, EPO, EST, FAS, FIN, FRA, GLE, GRC, HRV, HUN, ISL, ITA, JPN, LAT, LAV, LIT, NLD, NOR, RON, RUS, POL, POR, SLK, SPA, SRP, SWA, SWE, TUR, UKR
 * MFCC and DTW computed via Python C extensions to reduce the processing time
-* Several built-in TTS engine wrappers: eSpeak (default), eSpeak-ng, Festival, Nuance TTS API
+* Several built-in TTS engine wrappers: AWS Polly TTS API, eSpeak (default), eSpeak-ng, Festival, Nuance TTS API
 * Default TTS (eSpeak) called via a Python C extension for fast audio synthesis
 * Possibility of running a custom, user-provided TTS engine Python wrapper (e.g., included example for speect)
 * Batch processing of multiple audio/text pairs

README.rst

@@ -251,8 +251,8 @@ Supported Features
    SWE, TUR, UKR
 -  MFCC and DTW computed via Python C extensions to reduce the
    processing time
--  Several built-in TTS engine wrappers: eSpeak (default), eSpeak-ng,
-   Festival, Nuance TTS API
+-  Several built-in TTS engine wrappers: AWS Polly TTS API, eSpeak
+   (default), eSpeak-ng, Festival, Nuance TTS API
 -  Default TTS (eSpeak) called via a Python C extension for fast audio
    synthesis
 -  Possibility of running a custom, user-provided TTS engine Python

aeneas/language.py

@@ -40,6 +40,7 @@ class Language(object):
     Consult the documentation of your TTS engine wrapper to
     see the list of languages supported by it:
 
+    * :class:`~aeneas.ttswrappers.awsttswrapper.AWSTTSWrapper`
     * :class:`~aeneas.ttswrappers.espeakttswrapper.ESPEAKTTSWrapper` (default TTS)
     * :class:`~aeneas.ttswrappers.espeakngttswrapper.ESPEAKNGTTSWrapper`
     * :class:`~aeneas.ttswrappers.festivalttswrapper.FESTIVALTTSWrapper`

aeneas/runtimeconfiguration.py

@@ -561,29 +561,6 @@ class RuntimeConfiguration(Configuration):
     .. versionadded:: 1.5.0
     """
 
-    NUANCE_TTS_API_SLEEP = "nuance_tts_api_sleep"
-    """
-    Wait this number of seconds before the next HTTP POST request
-    to the Nuance TTS API.
-    This parameter can be used to throttle the HTTP usage.
-    It cannot be a negative value.
-
-    Default: ``1.000``.
-
-    .. versionadded:: 1.5.0
-    """
-
-    NUANCE_TTS_API_RETRY_ATTEMPTS = "nuance_tts_api_retry_attempts"
-    """
-    Retry an HTTP POST request to the Nuance TTS API
-    for this number of times before giving up.
-    It must be an integer greater than zero.
-
-    Default: ``5``.
-
-    .. versionadded:: 1.5.0
-    """
-
     SAFETY_CHECKS = "safety_checks"
     """
     If ``True``, perform safety checks on input files and parameters.
@@ -604,9 +581,10 @@ class RuntimeConfiguration(Configuration):
     Maximum length of the audio file of a Task, in seconds.
     If a Task has an audio file longer than this value,
     it will not be executed and an error will be raised.
-    Use ``0`` for disabling this check.
 
-    Default: ``7200`` seconds.
+    Use ``0`` to disable this check.
+
+    Default: ``0`` seconds.
 
     .. versionadded:: 1.4.1
     """
@@ -617,7 +595,7 @@ class RuntimeConfiguration(Configuration):
     If a Task has more text fragments than this value,
     it will not be executed and an error will be raised.
 
-    Use ``0`` for disabling this check.
+    Use ``0`` to disable this check.
 
     Default: ``0`` (disabled).
 
@@ -670,6 +648,17 @@ class RuntimeConfiguration(Configuration):
     parameter if the command ``text2wave`` is not available in
     one of the directories listed in your ``PATH`` environment variable.
 
+    Specify the value
+    :data:`~aeneas.synthesizer.Synthesizer.AWS` (``aws``)
+    to use the built-in AWS Polly TTS API wrapper;
+    you will need to provide your AWS API Access Key and Secret Access Key
+    by either storing them on disk
+    (e.g., in ``~/.aws/credentials`` and ``~/.aws/config``)
+    or setting them in environment variables.
+    Please refer to
+    http://boto3.readthedocs.io/en/latest/guide/configuration.html
+    for further details.
+
     Specify the value
     :data:`~aeneas.synthesizer.Synthesizer.NUANCE` (``nuance``)
     to use the built-in Nuance TTS API wrapper;
@@ -691,6 +680,34 @@ class RuntimeConfiguration(Configuration):
     .. versionadded:: 1.5.0
     """
 
+    TTS_PATH = "tts_path"
+    """
+    Path to the TTS engine executable
+    or the Python CustomTTSWrapper ``.py`` source file
+    (see the ``aeneas/extra`` directory for examples).
+
+    You might need to use a full path,
+    like ``/path/to/your/ttsengine`` or
+    ``/path/to/your/ttswrapper.py``.
+
+    Default: ``None``, implying to use the default path
+    defined by each TTS wrapper, if it calls the TTS engine
+    via ``subprocess`` (otherwise it does not matter).
+
+    .. versionadded:: 1.5.0
+    """
+
+    TTS_VOICE_CODE = "tts_voice_code"
+    """
+    The code of the TTS voice to use.
+    If you specify this value, it will override the default voice code
+    associated with the language of your text.
+
+    Default: ``None``.
+
+    .. versionadded:: 1.5.0
+    """
+
     TTS_CACHE = "tts_cache"
     """
     If set to ``True``, synthesize each distinct text fragment
@@ -712,30 +729,31 @@ class RuntimeConfiguration(Configuration):
     .. versionadded:: 1.6.0
     """
 
-    TTS_PATH = "tts_path"
+    TTS_API_SLEEP = "tts_api_sleep"
     """
-    Path to the TTS engine executable
-    or the Python CustomTTSWrapper ``.py`` source file
-    (see the ``aeneas/extra`` directory for examples).
+    Wait this number of seconds before the next HTTP POST request
+    to the Nuance TTS API.
+    This parameter can be used to throttle the HTTP usage.
+    It cannot be a negative value.
 
-    You might need to use a full path,
-    like ``/path/to/your/ttsengine`` or
-    ``/path/to/your/ttswrapper.py``.
+    Note that this parameter was called ``nuance_tts_api_sleep``
+    before v1.7.0.
 
-    Default: ``None``, implying to use the default path
-    defined by each TTS wrapper, if it calls the TTS engine
-    via ``subprocess`` (otherwise it does not matter).
+    Default: ``1.000``.
 
     .. versionadded:: 1.5.0
     """
 
-    TTS_VOICE_CODE = "tts_voice_code"
+    TTS_API_RETRY_ATTEMPTS = "tts_api_retry_attempts"
     """
-    The code of the TTS voice to use.
-    If you specify this value, it will override the default voice code
-    associated with the language of your text.
+    Retry an HTTP POST request to the Nuance TTS API
+    for this number of times before giving up.
+    It must be an integer greater than zero.
 
-    Default: ``None``.
+    Note that this parameter was called ``nuance_tts_api_retry_attempts``
+    before v1.7.0.
+
+    Default: ``5``.
 
     .. versionadded:: 1.5.0
     """
@@ -926,12 +944,10 @@ class RuntimeConfiguration(Configuration):
 
         (NUANCE_TTS_API_ID, (None, None, [], u"Nuance Developer API ID")),
         (NUANCE_TTS_API_KEY, (None, None, [], u"Nuance Developer API Key")),
-        (NUANCE_TTS_API_SLEEP, ("1.000", TimeValue, [], u"sleep between Nuance API calls, in s")),
-        (NUANCE_TTS_API_RETRY_ATTEMPTS, (5, int, [], u"number of retries for a failed Nuance API call")),
 
         (SAFETY_CHECKS, (True, bool, [], u"if True, always perform safety checks")),
 
-        (TASK_MAX_AUDIO_LENGTH, ("7200.0", TimeValue, [], u"max length of single audio file, in s (0 to disable)")),
+        (TASK_MAX_AUDIO_LENGTH, ("0", TimeValue, [], u"max length of single audio file, in s (0 to disable)")),
         (TASK_MAX_TEXT_LENGTH, (0, int, [], u"max length of single text file, in fragments (0 to disable)")),
 
         (TMP_PATH, (None, None, [], u"path to the temporary dir")),
@@ -940,6 +956,8 @@ class RuntimeConfiguration(Configuration):
         (TTS_PATH, (None, None, [], u"path of the TTS executable/wrapper")),                # None (= default) or "espeak" or "/usr/bin/espeak"
         (TTS_VOICE_CODE, (None, None, [], u"overrides TTS voice code selected by language with this value")),
         (TTS_CACHE, (False, bool, [], u"if True, cache synthesized audio files")),
+        (TTS_API_SLEEP, ("1.000", TimeValue, [], u"sleep between TTS API calls, in s")),
+        (TTS_API_RETRY_ATTEMPTS, (5, int, [], u"number of retries for a failed TTS API call")),
 
         (TTS_L1, ("espeak", None, [], u"TTS wrapper to use at level 1 (para)")),
         (TTS_PATH_L1, (None, None, [], u"path to level 1 (para) TTS executable/wrapper")),  # None (= default) or "espeak" or "/usr/bin/espeak"

aeneas/synthesizer.py

@@ -37,6 +37,7 @@
 from aeneas.logger import Loggable
 from aeneas.runtimeconfiguration import RuntimeConfiguration
 from aeneas.textfile import TextFile
+from aeneas.ttswrappers.awsttswrapper import AWSTTSWrapper
 from aeneas.ttswrappers.espeakngttswrapper import ESPEAKNGTTSWrapper
 from aeneas.ttswrappers.espeakttswrapper import ESPEAKTTSWrapper
 from aeneas.ttswrappers.festivalttswrapper import FESTIVALTTSWrapper
@@ -54,11 +55,17 @@ class Synthesizer(Loggable):
     :type  rconf: :class:`~aeneas.runtimeconfiguration.RuntimeConfiguration`
     :param logger: the logger object
     :type  logger: :class:`~aeneas.logger.Logger`
-    :raises: OSError: if a custom TTS engine is requested but it cannot be loaded
-    :raises: ImportError: if the Nuance TTS API wrapper is requested but
-                          the``requests`` module is not installed
+    :raises: OSError: if a custom TTS engine is requested
+                      but it cannot be loaded
+    :raises: ImportError: if the AWS Polly TTS API wrapper is requested
+                          but the ``boto3`` module is not installed, or
+                          if the Nuance TTS API wrapper is requested
+                          but the``requests`` module is not installed
     """
 
+    AWS = "aws"
+    """ Select AWS Polly TTS API wrapper """
+
     CUSTOM = "custom"
     """ Select custom TTS engine wrapper """
 
@@ -74,7 +81,7 @@ class Synthesizer(Loggable):
     NUANCE = "nuance"
     """ Select Nuance TTS API wrapper """
 
-    ALLOWED_VALUES = [CUSTOM, ESPEAK, ESPEAKNG, FESTIVAL, NUANCE]
+    ALLOWED_VALUES = [AWS, CUSTOM, ESPEAK, ESPEAKNG, FESTIVAL, NUANCE]
     """ List of all the allowed values """
 
     TAG = u"Synthesizer"
@@ -110,9 +117,13 @@ def _select_tts_engine(self):
                 self.log(u"Creating CustomTTSWrapper instance... done")
             except Exception as exc:
                 self.log_exc(u"Unable to load custom TTS wrapper", exc, True, OSError)
-        elif requested_tts_engine == self.FESTIVAL:
-            self.log(u"TTS engine: Festival")
-            self.tts_engine = FESTIVALTTSWrapper(rconf=self.rconf, logger=self.logger)
+        elif requested_tts_engine == self.AWS:
+            try:
+                import boto3
+            except ImportError as exc:
+                self.log_exc(u"Unable to import boto3 for AWS Polly TTS API wrapper", exc, True, ImportError)
+            self.log(u"TTS engine: AWS Polly TTS API")
+            self.tts_engine = AWSTTSWrapper(rconf=self.rconf, logger=self.logger)
         elif requested_tts_engine == self.NUANCE:
             try:
                 import requests
@@ -123,6 +134,9 @@ def _select_tts_engine(self):
         elif requested_tts_engine == self.ESPEAKNG:
             self.log(u"TTS engine: eSpeak-ng")
             self.tts_engine = ESPEAKNGTTSWrapper(rconf=self.rconf, logger=self.logger)
+        elif requested_tts_engine == self.FESTIVAL:
+            self.log(u"TTS engine: Festival")
+            self.tts_engine = FESTIVALTTSWrapper(rconf=self.rconf, logger=self.logger)
         else:
             self.log(u"TTS engine: eSpeak")
             self.tts_engine = ESPEAKTTSWrapper(rconf=self.rconf, logger=self.logger)

aeneas/tests/test_runtimeconfiguration.py

@@ -142,14 +142,14 @@ def test_set_rconf_string(self):
             (u"mfcc_mask_min_nonspeech_length=5", "mfcc_mask_min_nonspeech_length", 5),
             (u"nuance_tts_api_id=foo", "nuance_tts_api_id", "foo"),
             (u"nuance_tts_api_key=bar", "nuance_tts_api_key", "bar"),
-            (u"nuance_tts_api_sleep=5.000", "nuance_tts_api_sleep", TimeValue("5.000")),
-            (u"nuance_tts_api_retry_attempts=3", "nuance_tts_api_retry_attempts", 3),
             (u"safety_checks=False", "safety_checks", False),
             (u"task_max_audio_length=1000", "task_max_audio_length", TimeValue("1000")),
             (u"task_max_text_length=1000", "task_max_text_length", 1000),
             (u"tmp_path=/foo/bar", "tmp_path", "/foo/bar"),
             (u"tts=festival", "tts", "festival"),
             (u"tts_path=/foo/bar/festival", "tts_path", "/foo/bar/festival"),
+            (u"tts_api_sleep=5.000", "tts_api_sleep", TimeValue("5.000")),
+            (u"tts_api_retry_attempts=3", "tts_api_retry_attempts", 3),
             (u"tts_voice_code=ru", "tts_voice_code", "ru"),
             (u"tts_cache=True", "tts_cache", True),
             (u"tts_l1=festival", "tts_l1", "festival"),

aeneas/tests/tool_test_execute_task.py

@@ -68,6 +68,9 @@ def test_list_values_help(self):
     def test_list_values_bad(self):
         self.execute([("", "--list-values=foo")], 2)
 
+    def test_list_values_aws(self):
+        self.execute([("", "--list-values=aws")], 2)
+
     def test_list_values_espeak(self):
         self.execute([("", "--list-values=espeak")], 2)
 

aeneas/tools/execute_task.py

@@ -45,6 +45,7 @@
 from aeneas.task import TaskConfiguration
 from aeneas.textfile import TextFileFormat
 from aeneas.tools.abstract_cli_program import AbstractCLIProgram
+from aeneas.ttswrappers.awsttswrapper import AWSTTSWrapper
 from aeneas.ttswrappers.espeakngttswrapper import ESPEAKNGTTSWrapper
 from aeneas.ttswrappers.espeakttswrapper import ESPEAKTTSWrapper
 from aeneas.ttswrappers.festivalttswrapper import FESTIVALTTSWrapper
@@ -394,6 +395,7 @@ class ExecuteTaskCLI(AbstractCLIProgram):
     PARAMETERS = TaskConfiguration.parameters(sort=True, as_strings=True)
 
     VALUES = {
+        "aws": AWSTTSWrapper.CODE_TO_HUMAN_LIST,
         "espeak": ESPEAKTTSWrapper.CODE_TO_HUMAN_LIST,
         "espeak-ng": ESPEAKNGTTSWrapper.CODE_TO_HUMAN_LIST,
         "festival": FESTIVALTTSWrapper.CODE_TO_HUMAN_LIST,
@@ -428,7 +430,7 @@ class ExecuteTaskCLI(AbstractCLIProgram):
             u"--list-values : list all parameters for which values can be listed",
             u"--list-values=PARAM : list all allowed values for parameter PARAM",
             u"--output-html : output HTML file for fine tuning",
-            u"--presets-word : apply presets for word-level alignment (MFCC masking)", 
+            u"--presets-word : apply presets for word-level alignment (MFCC masking)",
             u"--rate : print rate of each fragment",
             u"--skip-validator : do not validate the given config string",
             u"--zero : print fragments with zero duration",

aeneas/tools/synthesize_text.py

@@ -168,12 +168,23 @@ def perform_command(self):
                 backwards=backwards
             )
             self.print_success(u"Created file '%s'" % output_file_path)
+            synt.clear_cache()
             return self.NO_ERROR_EXIT_CODE
         except ImportError as exc:
-            self.print_error(u"You need to install Python module requests to use the Nuance TTS API wrapper. Run:")
-            self.print_error(u"$ pip install requests")
-            self.print_error(u"or, to install for all users:")
-            self.print_error(u"$ sudo pip install requests")
+            tts = self.rconf[RuntimeConfiguration.TTS]
+            if tts == Synthesizer.AWS:
+                self.print_error(u"You need to install Python module boto3 to use the AWS Polly TTS API wrapper. Run:")
+                self.print_error(u"$ pip install boto3")
+                self.print_error(u"or, to install for all users:")
+                self.print_error(u"$ sudo pip install boto3")
+            elif tts == Synthesizer.NUANCE:
+                self.print_error(u"You need to install Python module requests to use the Nuance TTS API wrapper. Run:")
+                self.print_error(u"$ pip install requests")
+                self.print_error(u"or, to install for all users:")
+                self.print_error(u"$ sudo pip install requests")
+            else:
+                self.print_error(u"An unexpected error occurred while synthesizing text:")
+                self.print_error(u"%s" % exc)
         except Exception as exc:
             self.print_error(u"An unexpected error occurred while synthesizing text:")
             self.print_error(u"%s" % exc)

aeneas/ttswrappers/README.md

@@ -13,8 +13,10 @@ The TTS engine can be called using one of these methods:
 
 Currently, the available TTS engines are:
 
-* `ESPEAKTTSWrapper` for `eSpeak` (C extension, subprocess)
-* `FESTIVALTTSWrapper` for `festival` (subprocess)
+* `AWSTTSWrapper` for `AWS Polly TTS API` (Python calling remote AWS Polly API)
+* `ESPEAKTTSWrapper` for `eSpeak` (C extension, subprocess; default TTS Wrapper)
+* `ESPEAKNGTTSWrapper` for `eSpeak-ng` (subprocess)
+* `FESTIVALTTSWrapper` for `Festival` (subprocess)
 * `NuanceTTSWrapper` for `Nuance TTS API` (Python calling remote Nuance API)
 
 Moreover, custom TTS wrappers can be specified at runtime.