| # config.py - A simple dialog based tool for basic configuration of |
| # Speech Dispatcher and problem diagnostics. |
| # |
| # Copyright (C) 2008, 2010 Brailcom, o.p.s. |
| # 2016 Sebastian Humenda |
| # |
| # This program is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2 of the License, or |
| # (at your option) any later version. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with this program. If not, see <https://www.gnu.org/licenses/>. |
| |
| import argparse |
| import datetime |
| import fileinput |
| import gettext |
| import locale |
| import os |
| import shutil |
| import shlex |
| import socket |
| import sys |
| import time |
| |
| from xdg import BaseDirectory |
| |
| # Configuration and sound data paths |
| from . import buildconfig |
| |
| # Locale/gettext configuration |
| |
| locale.setlocale(locale.LC_ALL, '') |
| gettext.bindtextdomain (buildconfig.GETTEXT_PACKAGE, buildconfig.LOCALEDIR) |
| gettext.textdomain(buildconfig.GETTEXT_PACKAGE) |
| _ = gettext.gettext |
| |
| # two globals |
| use_espeak_synthesis = False |
| dont_ask = False |
| |
| def report(msg): |
| """Output information messages for the user on stdout |
| and if desired, by espeak synthesis""" |
| print(msg) |
| if use_espeak_synthesis: |
| os.system("espeak %s" % shlex.quote(msg)) |
| |
| def input_audio_icon(): |
| """Produce a sound for the event 'input requested' used in question()""" |
| if use_espeak_synthesis: |
| os.system("espeak \"Type in\"") |
| |
| def question(text, default): |
| """Ask a simple question and suggest the default value""" |
| |
| while 1: |
| if isinstance(default, bool): |
| if default: |
| default_str = "yes" |
| else: |
| default_str = "no" |
| else: |
| default_str = str(default) |
| report(text + " ["+default_str+"] :") |
| input_audio_icon() |
| |
| if not dont_ask: |
| str_inp = input(">") |
| |
| # On plain enter, return default |
| if dont_ask or (len(str_inp) == 0): |
| return default |
| # If a value was typed, check it and convert it |
| elif isinstance(default, bool): |
| if str_inp in ["yes","y", "Y", "true","t", "1"]: |
| return True |
| elif str_inp in ["no", "n", "N", "false", "f", "0"]: |
| return False |
| else: |
| report ("Unknown answer (type 'yes' or 'no')") |
| continue |
| elif isinstance(default, int): |
| return int(str_inp) |
| elif isinstance(default, str): |
| return str_inp |
| else: |
| raise TypeError("Invalid type for the default value") |
| |
| def question_with_suggested_answers(text, default, suggest): |
| """Ask a question with suggested answers. If the answer typed is not |
| in 'suggest', the user is notified and given an opportunity to correct |
| his choice""" |
| |
| reply = question(text, default) |
| while reply not in suggest: |
| report(_("""The value you have chosen is not among the suggested values. |
| You have chosen '%s'.""" % reply)) |
| report(_("The suggested values are " + str(suggest))) |
| correct = question(_("Do you want to correct your answer?"), True) |
| if correct: |
| reply = question(text, default) |
| else: |
| return reply |
| return reply |
| |
| def question_with_required_answers(text, default, required): |
| """Ask a question and repeat it until the answer typed in is in 'required'""" |
| |
| reply = question(text, default) |
| while reply not in required: |
| report(_("You have chosen '%s'. Please choose one of %s" % (reply, str(required)))) |
| reply = question(text, default) |
| return reply |
| |
| def setup_argparse(): |
| """Set up an argparser instance with all the options accepted.""" |
| parser = argparse.ArgumentParser( |
| description=_('A simple tool for basic configuration of Speech Dispatcher and problem diagnostics')) |
| parser.add_argument('-u', '--create-user-conf', |
| dest='create_user_configuration', action="store_true", default=False, |
| help=_("Create Speech Dispatcher configuration for the given user")) |
| parser.add_argument('-c', '--config-basic-settings-user', |
| dest='config_basic_settings_user', action="store_true", default=False, |
| help=_("Configure basic settings in user configuration")) |
| parser.add_argument('-C', '--config-basic-settings-system', |
| dest='config_basic_settings_system', action="store_true", default=False, |
| help=_("Configure basic settings in system-wide configuration")) |
| parser.add_argument('-d', '--diagnostics', dest='diagnostics', |
| action="store_true", default=False, |
| help=_("Diagnose problems with the current setup")) |
| parser.add_argument('-s', '--test-spd-say', dest='test_spd_say', |
| action="store_true", default=False, |
| help=_("Test connection to Speech Dispatcher using spd-say")) |
| parser.add_argument('--test-festival', dest='test_festival', |
| action="store_true", default=False, |
| help=_("Test whether Festival works as a server")) |
| parser.add_argument('--test-espeak', dest='test_espeak', action="store_true", |
| default=False, help=_("Test whether Espeak works as a standalone binary")) |
| parser.add_argument('--test-alsa', dest='test_alsa', action="store_true", |
| default=False, help=_("Test ALSA audio output")) |
| parser.add_argument('--test-pulse', dest='test_pulse', action="store_true", |
| default=False, help=_("Test Pulse Audio output")) |
| parser.add_argument('-e', '--espeak', dest='use_espeak_synthesis', |
| action="store_true", default=use_espeak_synthesis, |
| help=_("Use espeak to synthesize messages")) |
| parser.add_argument('-n', '--dont-ask', dest='dont_ask', |
| action="store_true", default=False, |
| help=_("Do not ask any questions, always use default values")) |
| parser.add_argument('-D', '--debug', dest='debug', |
| action="store_true", default=False, |
| help=_("Debug a problem and generate a report")) |
| parser.add_argument('--version', dest='version', |
| action="store_true", |
| help=_("Print version and copyright info")) |
| return parser |
| |
| class Tests: |
| """Tests of functionality of Speech Dispatcher and its dependencies |
| and methods for determination of proper paths""" |
| |
| def __init__(self): |
| self.festival_socket = None |
| |
| def version(self): |
| """Print version and copyright info""" |
| report(f"spd-conf {buildconfig.VERSION}\n") |
| report(_("""Copyright (C) %d-%d Brailcom, o.p.s. |
| This is free software; you can redistribute it and/or modify it |
| under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. Please see COPYING for more details.\n\n""") % \ |
| (2002, 2012)) |
| |
| def user_conf_dir(self): |
| """Return user configuration directory""" |
| return os.path.join(BaseDirectory.xdg_config_home, "speech-dispatcher") |
| |
| def system_conf_dir(self): |
| """Determine system configuration directory""" |
| return buildconfig.SPD_CONF_PATH |
| |
| def user_conf_dir_exists(self): |
| """Determine whether user configuration directory exists""" |
| return os.path.exists(self.user_conf_dir()) |
| |
| def festival_connect(self, host="localhost", port=1314): |
| """ |
| Try to connect to festival and determine whether it is possible. |
| On success self.festival_socket is initialized with the opened socket. |
| """ |
| self.festival_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| try: |
| self.festival_socket.connect((socket.gethostbyname(host), port)) |
| except socket.error as e: |
| (num, reason) = e.args |
| report(_("""ERROR: It was not possible to connect to Festival on the |
| given host and port. Connection failed with error %d : %s .""" % (num, reason))) |
| report(_("""Hint: Most likely, your Festival server is not running now |
| or not at the default port %d. |
| |
| Try /etc/init.d/festival start or run 'festival --server' from the command line.""" % port)) |
| return False |
| return True |
| |
| def festival_with_freebsoft_utils(self): |
| """Test whether festival works and contains working festival-freebsoft-utils. |
| """ |
| if not self.festival_socket: |
| if not self.festival_connect(): |
| return False |
| self.festival_socket.send(bytes("(require 'speech-dispatcher)\n", "ascii")) |
| reply = str(self.festival_socket.recv(1024)) |
| if "LP" in reply: |
| report(_("Festival contains freebsoft-utils.")) |
| return True |
| else: |
| report(_("""ERROR: Your Festival server is working but it doesn't seem |
| to load festival-freebsoft-utils. You need to install festival-freebsoft-utils |
| to be able to use Festival with Speech Dispatcher.""")) |
| return False |
| |
| def python_speechd_in_path(self): |
| """Try whether python speechd library is installed.""" |
| import importlib |
| try: |
| importlib.import_module('speechd') |
| except ImportError: |
| report(_("""Python can't find the Speech Dispatcher library. |
| Is it installed? This won't prevent Speech Dispatcher to work, but no |
| Python applications like Orca will be able to use it. |
| Search for package like python-speechd, download and install it.""")) |
| return False |
| return True |
| |
| def audio_try_play(self, type): |
| """Try to play a sound through the standard playback utility for the |
| given audio method.""" |
| wavfile = os.path.join(buildconfig.SPD_SOUND_DATA_PATH,"test.wav") |
| |
| binary = None |
| |
| if type == 'alsa': |
| binary = 'aplay' |
| elif type == 'pulse': |
| binary = "paplay" |
| else: |
| raise NotImplementedError("Test for this audio system is not implemented") |
| |
| if not shutil.which(binary): |
| report(_("""%s selected, but %s not installed. This might be a false |
| warning, but most likely sound is not working.""" % (type, binary))) |
| reply = question(_("Are you sure that %s audio is working?" % type), False) |
| return reply |
| |
| cmd = '%s %s' % (binary, wavfile) |
| if os.system(cmd): |
| report(_("Can't play audio via\n %s" % cmd)) |
| report(_("""Your audio doesn't seem to work, please fix audio first or choose |
| a different method.""")) |
| return False |
| |
| |
| reply = question(_("Did you hear the sound?"), True) |
| |
| if not reply: |
| report(_("""Please examine the above output from the sound playback |
| utility. If everything seems right, are you sure your audio is loud enough and |
| not muted in the mixer? Please fix your audio system first or choose a different |
| audio output method in configuration.""")) |
| return False |
| else: |
| report(_("Audio output '%s' works" % type)) |
| return True |
| |
| def test_spd_say(self): |
| """Test Speech Dispatcher using spd_say""" |
| |
| report(_("Testing Speech Dispatcher using spd_say")) |
| |
| while True: |
| if os.system("spd-say -P important \"Speech Dispatcher works\""): |
| report(_("""Can't execute the spd-say binary, |
| it is very likely that Speech Dispatcher is not installed.""")) |
| return False |
| hearing_test = question(_("Did you hear the message about Speech Dispatcher working?"), True) |
| if hearing_test: |
| report(_("Speech Dispatcher is installed and working!")) |
| return True |
| else: |
| report(_("Speech Dispatcher is installed but there is some problem")) |
| return False |
| |
| def test_festival(self): |
| """Test whether Festival works as a server""" |
| report(_("Testing whether Festival works as a server")) |
| |
| ret = self.festival_with_freebsoft_utils() |
| if not ret: |
| report(_("Festival server is not working.")) |
| return False |
| else: |
| report(_("Festival server seems to work correctly")) |
| return True |
| |
| def test_espeak(self): |
| """Test the espeak utility""" |
| |
| report(_("Testing whether Espeak works")) |
| if shutil.which('espeak'): |
| report(_("Espeak is installed")) |
| return True |
| else: |
| report(_("""Can't execute the espeak binary, it is likely that espeak |
| is not installed.""")) |
| return False |
| |
| def test_alsa(self): |
| """Test ALSA sound output""" |
| report(_("Testing ALSA sound output")) |
| return self.audio_try_play(type='alsa') |
| |
| def test_pulse(self): |
| """Test Pulse Audio sound output""" |
| report(_("Testing PULSE sound output")) |
| return self.audio_try_play(type='pulse') |
| |
| def diagnostics(self, speechd_running = True, output_modules=None, |
| audio_output=None): |
| """Perform a complete diagnostics""" |
| working_modules = [] |
| working_audio = [] |
| |
| if speechd_running: |
| # Test whether Speech Dispatcher works |
| if self.test_spd_say(): |
| spd_say_working = True |
| skip = question(_("Speech Dispatcher works. Do you want to skip other tests?"), |
| True) |
| if skip: |
| return {'spd_say_working': True} |
| else: |
| spd_say_working = False |
| else: |
| spd_say_working = False |
| |
| if not spd_say_working: |
| if not question(_(""" |
| Speech Dispatcher isn't running or we can't connect to it (see above), |
| do you want to proceed with other tests? (They can help to determine |
| what is wrong)"""), True): |
| return {'spd_say_working': False} |
| |
| def decide_to_test(identifier, name, listing): |
| """Ask the user whether to test a specific capability.""" |
| if not listing: |
| return False |
| elif identifier in listing and \ |
| question(_("Do you want to test the %s now?" % name), True): |
| return True |
| else: |
| return False |
| |
| if decide_to_test('festival', "Festival synthesizer", output_modules): |
| if self.test_festival(): |
| working_modules += ["festival"] |
| |
| if decide_to_test('espeak', "Espeak synthesizer", output_modules): |
| if self.test_espeak(): |
| working_modules += ["espeak"] |
| |
| if decide_to_test('alsa', "ALSA sound system", audio_output): |
| if self.test_alsa(): |
| working_audio += ["alsa"] |
| |
| if decide_to_test('pulse', "Pulse Audio sound system", audio_output): |
| if self.test_pulse(): |
| working_audio += ["pulse"] |
| |
| report(_("Testing whether Python Speech Dispatcher library is in path and importable")) |
| python_speechd_working = self.python_speechd_in_path() |
| |
| return {'spd_say_working': spd_say_working, |
| 'audio': working_audio, |
| 'synthesizers': working_modules, |
| 'python_speechd' : python_speechd_working} |
| |
| def write_diagnostics_results(self, results): |
| """Write out diagnostics results using report()""" |
| |
| report(_(""" |
| |
| Diagnostics results:""")) |
| if 'spd_say_working' in results: |
| if results['spd_say_working']: |
| report(_("Speech Dispatcher is working")) |
| else: |
| report(_("Speech Dispatcher not working through spd-say")) |
| if 'synthesizers' in results: |
| report(_("Synthesizers that were tested and seem to work: %s") % |
| str(results['synthesizers'])) |
| if 'audio' in results: |
| report(_("Audio systems that were tested and seem to work: %s") % |
| str(results['audio'])) |
| if 'python_speechd' in results: |
| if(results['python_speechd']): |
| report(_("Python Speech Dispatcher module is importable")) |
| else: |
| report(_("""Python Speech Dispatcher module not importable. |
| Either not installed or not in path.""")) |
| report(_("End of diagnostics results")) |
| |
| def user_configuration_seems_complete(self): |
| """Decide if the user configuration seems reasonably complete""" |
| if not os.path.exists(os.path.join(self.user_conf_dir(), "speechd.conf")): |
| return False |
| |
| if not len(os.listdir(self.user_conf_dir())) > 2: |
| return False |
| |
| if not os.path.exists(os.path.join(self.user_conf_dir(), "modules")): |
| return False |
| |
| if not os.path.exists(os.path.join(self.user_conf_dir(), "clients")): |
| return False |
| |
| return True |
| |
| def debug_and_report(self, type = None): |
| """Start Speech Dispatcher in debugging mode, collect the debugging output |
| and offer to send it to the developers""" |
| |
| report(_("Starting collecting debugging output, configuration and logfiles")) |
| |
| if not type: |
| type = question_with_required_answers(_(""" |
| Do you want to debug 'system' or 'user' Speech Dispatcher?"""), |
| 'user', ['user', 'system']) |
| |
| # Try to kill running Speech Dispatcher |
| reply = question(_("""It is necessary to kill the currently running Speech Dispatcher |
| processes. Do you want to do it now?"""), True) |
| if reply: |
| os.system("killall speech-dispatcher") |
| # Attempt to workaround the psmisc 22.15 bug with 16 char max process names |
| os.system("killall speech-dispatch") |
| else: |
| report(_(""" |
| You decided not to kill running Speech Dispatcher processes. |
| Please make sure your Speech Dispatcher is not running now.""")) |
| reply = question(_("Is your Speech Dispatcher not running now?"), True) |
| if not reply: |
| report(_("Can't continue, please stop your Speech Dispatcher and try again")) |
| |
| time.sleep(2) |
| |
| # All debugging files are written to TMPDIR/speech-dispatcher/ |
| if 'TMPDIR' in os.environ: |
| tmpdir = os.environ['TMPDIR'] |
| else: |
| tmpdir = "/tmp/" |
| debugdir_path = os.path.join(tmpdir, "speechd-debug") |
| date = datetime.date.today() |
| debugarchive_path = os.path.join(tmpdir, "speechd-debug-%d-%d-%d.tar.gz" % |
| (date.day, date.month, date.year)) |
| |
| # Start Speech Dispatcher with debugging enabled |
| if type == 'user': |
| report(_("Speech Dispatcher will be started now in debugging mode")) |
| speechd_started = not os.system("speech-dispatcher -D") |
| configure_directory = self.user_conf_dir() |
| else: |
| report(_("Warning: You must be root or under sudo to do this.") ) |
| report(_(""" |
| Please start your system Speech Dispatcher now with parameter '-D'""")) |
| reply = question(_("Is your Speech Dispatcher running now?"), True) |
| if reply: |
| speechd_started = True |
| else: |
| report(_("Can't continue")) |
| configure_directory = self.system_conf_dir() |
| time.sleep(2) |
| |
| if not speechd_started: |
| reply = question(_("Speech Dispatcher failed to start, continuing anyway?"), |
| False) |
| |
| report(_("Trying to speak some messages")) |
| ret = os.system("spd-say \"Speech Dispatcher debugging 1\"") |
| if not ret: |
| os.system("spd-say \"Speech Dispatcher debugging 2\"") |
| os.system("spd-say \"Speech Dispatcher debugging 3\"") |
| else: |
| report(_("Can't test Speech Dispatcher connection, can't connect")) |
| |
| report(_("Please wait (about 5 seconds)")) |
| time.sleep(5) |
| |
| report(_("Collecting debugging output and your configuration information") ) |
| |
| os.system("umask 077") |
| os.system("tar -cz %s %s > %s" % |
| (debugdir_path, configure_directory, debugarchive_path)) |
| os.system("killall speech-dispatcher") |
| # Attempt to workaround the psmisc 22.15 bug with 16 char max process names |
| os.system("killall speech-dispatch") |
| os.system("rm -rf %s" % debugdir_path) |
| |
| report(_(""" |
| Please send %s to speechd-discuss@nongnu.org with |
| a short description of what you did. We will get in touch with you soon |
| and suggest a solution.""" % debugarchive_path)) |
| |
| class Configure: |
| |
| """Setup user configuration and/or set basic options in user/system configuration""" |
| |
| default_output_module = None |
| default_language = None |
| default_audio_method = None |
| def __init__(self, test): |
| self.test = test |
| |
| def remove_user_configuration(self): |
| """Remove user configuration tree""" |
| shutil.rmtree(self.test.user_conf_dir()) |
| |
| def options_substitute(self, configfile, options): |
| """Substitute the given options with given values. |
| |
| Arguments: |
| configfile -- the file path of the configuration file as a string |
| options -- a list of tuples (option_name, value)""" |
| |
| # Parse config file in-place and replace the desired options+values |
| for line in fileinput.input(configfile, inplace=True, backup=".bak"): |
| # Check if the current line contains any of the desired options |
| for opt, value in options.items(): |
| if opt in line: |
| # Now count unknown words and try to judge if this is |
| # real configuration or just a comment |
| unknown = 0 |
| for word in line.split(): |
| if word =='#' or word == '\t': |
| continue |
| elif word == opt: |
| # If a foreign word went before our option identifier, |
| # we are not in code but in comments |
| if unknown != 0: |
| unknown = 2 |
| break |
| else: |
| unknown += 1 |
| |
| # Only consider the line as the actual code when the keyword |
| # is followed by exactly one word value. Otherwise consider this |
| # line as plain comment and leave intact |
| if unknown == 1: |
| # Convert value into string representation in spd_val |
| if isinstance(value, bool): |
| if value: |
| spd_val = "1" |
| elif not value: |
| spd_val = "2" |
| elif isinstance(value, int): |
| spd_val = str(value) |
| else: |
| spd_val = str(value) |
| |
| print(opt + " " + spd_val) |
| break |
| |
| else: |
| print(line, end=' ') |
| |
| def create_user_configuration(self): |
| """Create user configuration in the standard location""" |
| |
| # Ask before touching things that we do not have to! |
| if self.test.user_conf_dir_exists(): |
| if self.test.user_configuration_seems_complete(): |
| reply = question(_("""User configuration already exists. |
| Do you want to rewrite it with a new one?"""), False) |
| if not reply: |
| report(_("Keeping configuration intact and continuing with settings.")) |
| return |
| else: |
| self.remove_user_configuration() |
| else: |
| reply = question(_("""User configuration already exists, but it seems to be incomplete. |
| Do you want to keep it?"""), False) |
| if not reply: |
| self.remove_user_configuration() |
| else: |
| report(_("Keeping configuration intact and aborting.")) |
| return |
| # Copy the original intact configuration files |
| # creating a conf/ subdirectory |
| config_root = self.test.user_conf_dir() |
| shutil.copytree(buildconfig.SPD_CONF_ORIG_PATH, config_root) |
| # Ensure the files are writeable when copying from immutable directory. |
| umask = os.umask(0) |
| os.umask(umask) |
| os.chmod(self.test.user_conf_dir() , 0o755 & ~umask) |
| for root, dirs, files in os.walk(self.test.user_conf_dir()): |
| for d in dirs: |
| os.chmod(os.path.join(root, d), 0o755 & ~umask) |
| for f in files: |
| os.chmod(os.path.join(root, f), 0o644 & ~umask) |
| |
| report(_("User configuration created in %s" % self.test.user_conf_dir())) |
| |
| def configure_basic_settings(self, type='user'): |
| """Ask for basic settings and rewrite them in the configuration file""" |
| |
| if type == 'user': |
| report(_("Configuring user settings for Speech Dispatcher")) |
| elif type == 'system': |
| report(_("Warning: You must be root or under sudo to do this.")) |
| report(_("Configuring system settings for Speech Dispatcher")) |
| else: |
| raise ValueError("Invalid configuration type") |
| |
| # Now determine the most important config option |
| self.default_output_module = question_with_suggested_answers( |
| "Default output module", |
| "espeak-ng", |
| ["espeak-ng", "espeak", "festival", "flite", "ivona", "pico", |
| "espeak-ng-mbrola-generic", "espeak-mbrola-generic", "swift-generic", |
| "epos-generic", "dtk-generic", "ibmtts", "cicero", "kali", |
| "mary-generic", "baratinoo"]) |
| |
| self.default_language = question( |
| "Default language (two/three-letter iso language code like \"en\" or \"cs\", possibly with a region qualification.)", |
| "en-US") |
| |
| self.default_audio_method = question_with_suggested_answers( |
| "Default audio output method", |
| "pulse", |
| ["pulse", "libao", "alsa", "oss", "pulse,alsa"]) |
| |
| default_speech_rate = question( |
| _("Default speech rate (on the scale of -100..100, 0 is default, 50 is faster, -50 is slower)"), |
| "0") |
| |
| default_speech_pitch = question( |
| _("Default speech pitch (on the scale of -100..100, 0 is default, 50 is higher, -50 is lower)"), |
| "0") |
| |
| default_speech_pitch_range = question( |
| _("Default speech pitch range (on the scale of -100..100, 0 is default, 50 is higher, -50 is lower)"), |
| "0") |
| |
| # Substitute given configuration options |
| if type == 'user': |
| configfile = os.path.join(self.test.user_conf_dir(), "speechd.conf") |
| elif type == 'system': |
| configfile = os.path.join(self.test.system_conf_dir(), "speechd.conf") |
| |
| self.options_substitute(configfile, |
| {"DefaultModule": self.default_output_module, |
| "DefaultLanguage": self.default_language, |
| "AudioOutputMethod": self.default_audio_method, |
| "DefaultRate": default_speech_rate, |
| "DefaultPitch": default_speech_pitch, |
| "DefaultPitchRange": default_speech_pitch_range, |
| }) |
| if type == 'user': |
| setup_autostart = question( |
| _("""Do you want to have Speech Dispatcher automatically started from ~/.config/autostart ? |
| This is usually not necessary, most applications will start Speech Dispatcher automatically."""), |
| False) |
| if setup_autostart: |
| shutil.copy( |
| os.path.join(buildconfig.SPD_DESKTOP_CONF_PATH, "speechd.desktop"), |
| os.path.join(BaseDirectory.xdg_config_home, "autostart/") |
| ) |
| |
| report(_(""" |
| Configuration written to %s |
| Basic configuration now complete. You might still need to fine tune it by |
| manually editing the configuration file above. Especially if you need to |
| use special audio settings, non-standard synthesizer ports etc.""" % configfile)) |
| |
| def speechd_start_user(self): |
| """Start Speech Dispatcher in user-mode""" |
| |
| report(_("Starting Speech Dispatcher in user-mode")) |
| |
| err = os.system("speech-dispatcher") |
| if err: |
| report(_("Can't start Speech Dispatcher. Exited with status %d" % err)) |
| reply = question(_("""Perhaps this is because your Speech Dispatcher is already running. |
| Do you want to kill all running Speech Dispatchers and try again?"""), True) |
| if reply: |
| os.system("killall speech-dispatcher") |
| # Attempt to workaround the psmisc 22.15 bug with 16 char max process names |
| os.system("killall speech-dispatch") |
| err = os.system("speech-dispatcher") |
| if err: |
| report(_("Can't start Speech Dispatcher")) |
| return False |
| else: |
| return False |
| return True |
| |
| def speechd_start_system(self): |
| """Start Speech Dispatcher in system-mode""" |
| |
| report(_("Warning: You must be root or under sudo to do this.") ) |
| report(_("Starting Speech Dispatcher in system-mode")) |
| |
| reply = question(_("Is your system using an /etc/init.d/speech-dispatcher script?"), |
| True) |
| if reply: |
| report(_("Stopping Speech Dispatcher in case any is running already")) |
| os.system("/etc/init.d/speech-dispatcher stop") |
| report(_("Starting Speech Dispatcher via /etc/init.d/speech-dispatcher")) |
| ret = os.system("/etc/init.d/speech-dispatcher start") |
| if ret: |
| report(_("Can't start Speech Dispatcher. Exited with status %d" % ret)) |
| return False |
| else: |
| report(_("""Do not know how to start system Speech Dispatcher, |
| you have to start it manually to continue.""")) |
| reply = question(_("Have you started Speech Dispatcher now?"), True) |
| if not reply: |
| report(_("Can't continue")) |
| return False |
| return True |
| |
| def complete_config(self): |
| """Create a complete configuration, run diagnosis and if necessary, debugging""" |
| |
| speechd_type = question_with_required_answers( |
| _("Do you want to create/setup a 'user' or 'system' configuration?"), |
| 'user', ['user', 'system']) |
| |
| if speechd_type == 'user': |
| self.create_user_configuration() |
| self.configure_basic_settings(type='user') |
| elif speechd_type == 'system': |
| self.configure_basic_settings(type='system') |
| else: |
| raise ValueError("Invalid configuration type") |
| |
| reply = question(_("Do you want to start/restart Speech Dispatcher now and run some tests?"), True) |
| if not reply: |
| report(_("Your configuration is now done but not tested")) |
| return |
| else: |
| if speechd_type == 'user': |
| started = self.speechd_start_user() |
| elif speechd_type == 'system': |
| started = self.speechd_start_system() |
| |
| if not started: |
| report(_("Your Speech Dispatcher is not running")) |
| |
| result = self.test.diagnostics(speechd_running = started, |
| audio_output=[self.default_audio_method], |
| output_modules=[self.default_output_module]) |
| self.test.write_diagnostics_results(result) |
| |
| if not started: |
| reply = question(_("Do you want to run debugging now and send a request for help to the developers?"), |
| False) |
| if reply: |
| self.test.debug_and_report(type=speechd_type) |
| |
| |
| # Basic objects |
| |
| def main(): |
| global dont_ask, use_espeak_synthesis |
| |
| options = setup_argparse() |
| options = options.parse_args() |
| dont_ask = options.dont_ask |
| use_espeak_synthesis = options.use_espeak_synthesis |
| test = Tests() |
| configure = Configure(test) # that should possibly be refactored, test should not be passed |
| |
| |
| if not options.version: |
| report(_("\nSpeech Dispatcher configuration tool\n")) |
| |
| if options.create_user_configuration: |
| # Check for and/or create basic user configuration |
| configure.create_user_configuration() |
| reply = question(_("Do you want to continue with basic settings?"), True) |
| if reply: |
| configure.configure_basic_settings(type='user') |
| elif options.config_basic_settings_user: |
| configure.configure_basic_settings(type='user') |
| |
| elif options.config_basic_settings_system: |
| configure.configure_basic_settings(type='system') |
| |
| elif options.test_festival: |
| test.test_festival() |
| |
| elif options.test_spd_say: |
| test.test_spd_say() |
| |
| elif options.test_espeak: |
| test.test_espeak() |
| |
| elif options.test_alsa: |
| test.audio_try_play(type='alsa') |
| |
| elif options.test_pulse: |
| test.audio_try_play(type='pulse') |
| |
| elif options.diagnostics: |
| ret = test.diagnostics() |
| test.write_diagnostics_results(ret) |
| |
| elif options.debug: |
| test.debug_and_report() |
| |
| elif options.version: |
| test.version() |
| |
| else: |
| reply = question(_("Do you want to setup a completely new configuration?"), True) |
| if reply: |
| configure.complete_config() |
| else: |
| reply = question(_("Do you want to run diagnosis of problems?"), True) |
| if reply: |
| ret=test.diagnostics() |
| test.write_diagnostics_results(ret) |
| else: |
| report(_("""Please run this command again and select what you want to do |
| or read the quick help available through '-h' or '--help'.""")) |
| |
| if __name__ == "__main__": |
| sys.exit(main()) |
