Installation¶

Install from pypi:

pip install talkey

Usage¶

At its simplest use case:

import talkey
tts = talkey.Talkey()
tts.say('Old McDonald had a farm')

If you get a talkey.base.TTSError: No supported languages error, it means that you don’t have a supported TTS engine installed. Please see below.

import talkey
tts = talkey.Talkey(
    preferred_languages = ['en', 'af', 'el', 'fr'],
    espeak = {
        'languages': {
            'en': {
                'voice': 'english-mb-en1',
                'words_per_minute': 130
            },
        }
    })
tts.say('Old McDonald had a farm')

Installing TTS engines¶

sudo apt-get install festival

sudo apt-get install flite

sudo apt-get install libttspico-utils

sudo apt-get install espeak

sudo apt-get install mbrola-en1

talkey module:¶

talkey.enumerate_engines()¶

Returns list of engine SLUGs in order of preference

talkey.create_engine(engine, options=None, defaults=None)¶

Creates an instance of an engine. There is a two-stage instantiation process with engines.

1. options:

   The keyword options to instantiate the engine class

2. defaults:

   The default configuration for the engine (options often depends on instantiated TTS engine)

class talkey.Talkey(preferred_languages=None, preferred_factor=80.0, engine_preference=None, **config)¶

Manages engines and allows multi-lingual say()

preferred_languages

A list of languages that are weighted in preference. This is a weighting to assist the detection of language by classify().

preferred_factor

The weighting factor to prefer the preferred_languages list. Higher number skews towards preference.

engine_preference

Specify preferred engines in order of preference.

**config

Engine-specfic configuration, e.g.:

# Key is the engine SLUG, in this case ``espeak``
espeak={
    # Specify the engine options:
    'options': {
        'enabled': True,
    },

    # Specify some default voice options
    'defaults': {
            'words_per_minute': 150,
            'variant': 'f4',
    },

    # Here you specify language-specific voice options
    # e.g. for english we prefer the mbrola en1 voice
    'languages': {
        'en': {
            'voice': 'english-mb-en1',
            'words_per_minute': 130
        },
    }
}

classify(txt)¶

Classifies text by language. Uses preferred_languages weighting.

get_engine_for_lang(lang)¶

Determines the preferred engine/voice for a language.

say(txt, lang=None)¶

Says the text.

if lang is None, then uses classify() to detect language.

exception talkey.TTSError(error, valid_set=None)¶

The exception that Talkey will throw if any error occurs.

Engine options:¶

Voice options:¶

Engine interface¶

class talkey.base.AbstractTTSEngine(**_options)¶

Generic parent class for all speakers

SLUG = None¶

The SLUG is used to identify the engine as text

classmethod _get_init_options()¶

AbstractMethod: Returns dict of engine options

_get_languages()¶

AbstractMethod: Returns dict of supported languages and voices

_get_options()¶

AbstractMethod: Returns dict of voice options

_is_available()¶

AbstractMethod: Boolean on if engine is available

_say(phrase, language, voice, voiceinfo, options)¶

AbstractMethod: Let engin actually says the phrase

Phrase:	The text phrase to say
Language:	The requested language
Voice:	The requested voice
Voiceinfo:	Data about the requested voice
Options:	Extra options

configure(**_options)¶

Sets language-specific configuration.

Raises TTSError on error.

configure_default(**_options)¶

Sets default configuration.

Raises TTSError on error.

classmethod get_init_options()¶

Returns a dict describing the engine options.

Uses cls._get_init_options()

get_languages()¶

Returns dict of supported languages and voices.

Raises TTSError if not available.

get_options()¶

Returns dict of voice options.

Raises TTSError if not available.

is_available()¶

Boolean on if engine available.

Checks if enabled, can output audio and self._is_available()

play(filename, translate=False)¶

Plays the sounds.

Filename:	The input file name
Translate:	If True, it runs it through audioread which will translate from common compression formats to raw WAV.

say(phrase, **_options)¶

Says the phrase, optionally allows to select/override any voice options.

Creating your own engine¶

Subclass talkey.base.AbstractTTSEngine, and provide the abstract methods:

from talkey.base import AbstractTTSEngine

class SampleTTS(AbstractTTSEngine):
    SLUG = "sample"

    @classmethod
    def _get_init_options(cls):
        # Engine options
        return {
            'enabled': {
                'description': 'Disabled by default',
                'type': 'bool',
                'default': False,
            },
        }

    def _is_available(self):
        # Checks for engine availability/readiness
        return True

    def _get_options(self):
        # Same format as _get_init_options
        # This is the voice options
        return {
            'mooing': {
                'description': 'Cows sound effect',
                'type': 'bool',
                'default': False,
            },
        }

    def _get_languages(self):
        # Dict of languages containing voices
        return {
            'en': {
                'default': 'english',
                'voices': {
                    'english': {
                        # Any extra options describing this voice
                        # (for private use)
                    },
                    'cowlish': {
                        # Any extra options describing this voice
                        # (for private use)
                    }
                }
            },
            ...
        }

    def _say(self, phrase, language, voice, voiceinfo, options):
        # Actually run the phrase through the TTS Engine.
        # All parameters will be always provided for you
        ...