def create_ssip_client(self): from speechd.client import SpawnError, SSIPClient try: self.ssip_client = SSIPClient('calibre') except SpawnError as err: raise TTSSystemUnavailable( _('Could not find speech-dispatcher on your system. Please install it.' ), str(err))
def create_ssip_client(self): from speechd.client import Priority, SpawnError, SSIPClient, SSIPCommunicationError try: self.ssip_client = SSIPClient('calibre') except SSIPCommunicationError as err: ex = err.additional_exception() if isinstance(ex, SpawnError): raise TTSSystemUnavailable(_('Could not find speech-dispatcher on your system. Please install it.'), str(err)) raise except SpawnError as err: raise TTSSystemUnavailable(_('Could not find speech-dispatcher on your system. Please install it.'), str(err)) self.ssip_client.set_priority(Priority.TEXT)
class Client: mark_template = '<mark name="{}"/>' name = 'speechd' min_rate = -100 max_rate = 100 chunk_size = 0 @classmethod def escape_marked_text(cls, text): return prepare_string_for_xml(text) def __init__(self, settings=None, dispatch_on_main_thread=lambda f: f()): self.ssip_client = None self.status = {'synthesizing': False, 'paused': False} self.settings = settings or {} self.dispatch_on_main_thread = dispatch_on_main_thread self.current_marked_text = None self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False self.current_callback = None self.settings_applied = False self.system_default_output_module = None def create_ssip_client(self): from speechd.client import Priority, SpawnError, SSIPClient, SSIPCommunicationError try: self.ssip_client = SSIPClient('calibre') except SSIPCommunicationError as err: ex = err.additional_exception() if isinstance(ex, SpawnError): raise TTSSystemUnavailable(_('Could not find speech-dispatcher on your system. Please install it.'), str(err)) raise except SpawnError as err: raise TTSSystemUnavailable(_('Could not find speech-dispatcher on your system. Please install it.'), str(err)) self.ssip_client.set_priority(Priority.TEXT) def __del__(self): if self.ssip_client is not None: try: self.ssip_client.cancel() except Exception: pass self.ssip_client.close() self.ssip_client = None shutdown = __del__ def ensure_state(self, use_ssml=False): if self.ssip_client is None: self.create_ssip_client() if self.system_default_output_module is None: self.system_default_output_module = self.ssip_client.get_output_module() if self.system_default_output_module == '(null)': raise ValueError(_('Speech dispatcher on this system is not configured with any available voices. Install some voices first.')) if not self.settings_applied: self.apply_settings() self.set_use_ssml(use_ssml) def apply_settings(self, new_settings=None): if new_settings is not None: self.settings = new_settings if self.settings_applied: self.shutdown() self.settings_applied = False self.ensure_state() om = self.settings.get('output_module') if om: self.ssip_client.set_output_module(om) voice = self.settings.get('voice') if voice: self.ssip_client.set_synthesis_voice(voice[0]) rate = self.settings.get('rate') if rate: self.ssip_client.set_rate(rate) self.settings_applied = True def set_use_ssml(self, on): from speechd.client import DataMode, SSIPCommunicationError mode = DataMode.SSML if on else DataMode.TEXT try: self.ssip_client.set_data_mode(mode) except SSIPCommunicationError: self.ssip_client.close() self.ssip_client = None self.ensure_state(on) def speak_simple_text(self, text): self.stop() self.ensure_state(use_ssml=False) self.current_marked_text = self.last_mark = None def callback(callback_type, index_mark=None): self.dispatch_on_main_thread(partial(self.update_status, callback_type, index_mark)) self.ssip_client.speak(text, callback) def update_status(self, callback_type, index_mark=None): from speechd.client import CallbackType event = None if callback_type is CallbackType.INDEX_MARK: self.last_mark = index_mark event = Event(EventType.mark, index_mark) elif callback_type is CallbackType.BEGIN: self.status = {'synthesizing': True, 'paused': False} event = Event(EventType.resume if self.next_begin_is_for_resume else EventType.begin) self.next_begin_is_for_resume = False elif callback_type is CallbackType.END: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.end) elif callback_type is CallbackType.CANCEL: if self.next_cancel_is_for_pause: self.status = {'synthesizing': True, 'paused': True} event = Event(EventType.pause) else: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.cancel) self.next_cancel_is_for_pause = False return event def speak_marked_text(self, marked_text, callback=lambda ev: None): self.stop() text = ''.join(add_markup(marked_text, self.mark_template, self.escape_marked_text, self.chunk_size)) self.current_marked_text = text self.last_mark = None def callback_wrapper(callback_type, index_mark=None): event = self.update_status(callback_type, index_mark) if event is not None: try: callback(event) except Exception: import traceback traceback.print_exc() def cw(callback_type, index_mark=None): self.dispatch_on_main_thread(partial(callback_wrapper, callback_type, index_mark)) self.current_callback = cw self.ensure_state(use_ssml=True) self.ssip_client.speak(wrap_in_ssml(text), callback=self.current_callback) def pause(self): if self.status['synthesizing'] and not self.status['paused']: self.next_cancel_is_for_pause = True self.ssip_client.stop() def resume(self): if self.current_marked_text is None or not self.status['synthesizing'] or not self.status['paused']: return self.next_begin_is_for_resume = True if self.last_mark is None: text = self.current_marked_text else: mark = self.mark_template.format(self.last_mark) idx = self.current_marked_text.find(mark) if idx == -1: text = self.current_marked_text else: text = self.current_marked_text[idx:] self.ensure_state(use_ssml=True) self.ssip_client.speak(wrap_in_ssml(text), callback=self.current_callback) resume_after_configure = resume def stop(self): self.current_callback = self.current_marked_text = self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False if self.ssip_client is not None: self.ssip_client.stop() def config_widget(self, backend_settings, parent): from calibre.gui2.tts.linux_config import Widget return Widget(self, backend_settings, parent) def get_voice_data(self): ans = getattr(self, 'voice_data', None) if ans is None: self.ensure_state() ans = self.voice_data = {} output_module = self.ssip_client.get_output_module() for om in self.ssip_client.list_output_modules(): self.ssip_client.set_output_module(om) ans[om] = tuple(self.ssip_client.list_synthesis_voices()) self.ssip_client.set_output_module(output_module) return ans def change_rate(self, steps=1): rate = current_rate = self.settings.get('rate') or 0 step_size = (self.max_rate - self.min_rate) // 10 rate += steps * step_size rate = max(self.min_rate, min(rate, self.max_rate)) if rate != current_rate: self.settings['rate'] = rate prev_state = self.status.copy() self.apply_settings() if prev_state['synthesizing'] and not prev_state['paused']: self.status['synthesizing'] = True self.status['paused'] = True self.resume_after_configure() return self.settings
class Client: mark_template = '<mark name="{}"/>' @classmethod def escape_marked_text(cls, text): return prepare_string_for_xml(text) def __init__(self, dispatch_on_main_thread): self.create_ssip_client() self.status = {'synthesizing': False, 'paused': False} self.dispatch_on_main_thread = dispatch_on_main_thread self.current_marked_text = None self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False self.current_callback = None def create_ssip_client(self): from speechd.client import Priority, SpawnError, SSIPClient try: self.ssip_client = SSIPClient('calibre') except SpawnError as err: raise TTSSystemUnavailable( _('Could not find speech-dispatcher on your system. Please install it.' ), str(err)) self.ssip_client.set_priority(Priority.TEXT) def __del__(self): if hasattr(self, 'ssip_client'): self.ssip_client.cancel() self.ssip_client.close() del self.ssip_client shutdown = __del__ def set_use_ssml(self, on): from speechd.client import DataMode, SSIPCommunicationError mode = DataMode.SSML if on else DataMode.TEXT try: self.ssip_client.set_data_mode(mode) except SSIPCommunicationError: self.ssip_client.close() self.create_ssip_client() self.ssip_client.set_data_mode(mode) def speak_simple_text(self, text): self.stop() self.set_use_ssml(False) self.current_marked_text = self.last_mark = None def callback(callback_type, index_mark=None): self.dispatch_on_main_thread( partial(self.update_status, callback_type, index_mark)) self.ssip_client.speak(text, callback) def update_status(self, callback_type, index_mark=None): from speechd.client import CallbackType event = None if callback_type is CallbackType.INDEX_MARK: self.last_mark = index_mark event = Event(EventType.mark, index_mark) elif callback_type is CallbackType.BEGIN: self.status = {'synthesizing': True, 'paused': False} event = Event(EventType.resume if self. next_begin_is_for_resume else EventType.begin) self.next_begin_is_for_resume = False elif callback_type is CallbackType.END: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.end) elif callback_type is CallbackType.CANCEL: if self.next_cancel_is_for_pause: self.status = {'synthesizing': True, 'paused': True} event = Event(EventType.pause) else: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.cancel) self.next_cancel_is_for_pause = False return event def speak_marked_text(self, text, callback): self.stop() self.current_marked_text = text self.last_mark = None def callback_wrapper(callback_type, index_mark=None): event = self.update_status(callback_type, index_mark) if event is not None: try: callback(event) except Exception: import traceback traceback.print_exc() def cw(callback_type, index_mark=None): self.dispatch_on_main_thread( partial(callback_wrapper, callback_type, index_mark)) self.current_callback = cw self.set_use_ssml(True) self.ssip_client.speak(text, callback=self.current_callback) def pause(self): if self.status['synthesizing'] and not self.status['paused']: self.next_cancel_is_for_pause = True self.ssip_client.stop() def resume(self): if self.current_marked_text is None or not self.status[ 'synthesizing'] or not self.status['paused']: return self.next_begin_is_for_resume = True if self.last_mark is None: text = self.current_marked_text else: mark = self.mark_template.format(self.last_mark) idx = self.current_marked_text.find(mark) if idx == -1: text = self.current_marked_text else: text = self.current_marked_text[idx:] self.ssip_client.speak(text, callback=self.current_callback) def stop(self): self.current_callback = self.current_marked_text = self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False self.ssip_client.stop()
from pokerengine.pokerchips import PokerChips from random import choice from getopt import getopt, GetoptError from sys import argv, exit, stderr from string import join import gettext gettext.install('textpoker', '') self_voicing = False autoPlay = False try: from speechd.client import SSIPClient speechd = SSIPClient("textpoker") def info(text): if self_voicing: speechd.speak(text) print text except: def info(text): print text players = 5 game = None
class Client: mark_template = '<mark name="{}"/>' name = 'speechd' @classmethod def escape_marked_text(cls, text): return prepare_string_for_xml(text) def __init__(self, dispatch_on_main_thread): self.status = {'synthesizing': False, 'paused': False} self.dispatch_on_main_thread = dispatch_on_main_thread self.current_marked_text = None self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False self.current_callback = None self.settings_applied = False self.ssip_client = None self.system_default_output_module = None def create_ssip_client(self): from speechd.client import Priority, SpawnError, SSIPClient try: self.ssip_client = SSIPClient('calibre') except SpawnError as err: raise TTSSystemUnavailable( _('Could not find speech-dispatcher on your system. Please install it.' ), str(err)) self.ssip_client.set_priority(Priority.TEXT) def __del__(self): if self.ssip_client is not None: self.ssip_client.cancel() self.ssip_client.close() self.ssip_client = None shutdown = __del__ def ensure_state(self, use_ssml=False): if self.ssip_client is None: self.create_ssip_client() if self.system_default_output_module is None: self.system_default_output_module = self.ssip_client.get_output_module( ) if not self.settings_applied: self.apply_settings() self.set_use_ssml(use_ssml) def apply_settings(self, new_settings=None): if self.settings_applied: self.shutdown() self.settings_applied = False self.ensure_state() self.settings_applied = True # TODO: Implement this def set_use_ssml(self, on): from speechd.client import DataMode, SSIPCommunicationError mode = DataMode.SSML if on else DataMode.TEXT try: self.ssip_client.set_data_mode(mode) except SSIPCommunicationError: self.ssip_client.close() self.ssip_client = None self.ensure_state(on) def speak_simple_text(self, text): self.stop() self.ensure_state(use_ssml=False) self.current_marked_text = self.last_mark = None def callback(callback_type, index_mark=None): self.dispatch_on_main_thread( partial(self.update_status, callback_type, index_mark)) self.ssip_client.speak(text, callback) def update_status(self, callback_type, index_mark=None): from speechd.client import CallbackType event = None if callback_type is CallbackType.INDEX_MARK: self.last_mark = index_mark event = Event(EventType.mark, index_mark) elif callback_type is CallbackType.BEGIN: self.status = {'synthesizing': True, 'paused': False} event = Event(EventType.resume if self. next_begin_is_for_resume else EventType.begin) self.next_begin_is_for_resume = False elif callback_type is CallbackType.END: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.end) elif callback_type is CallbackType.CANCEL: if self.next_cancel_is_for_pause: self.status = {'synthesizing': True, 'paused': True} event = Event(EventType.pause) else: self.status = {'synthesizing': False, 'paused': False} event = Event(EventType.cancel) self.next_cancel_is_for_pause = False return event def speak_marked_text(self, text, callback): self.stop() self.current_marked_text = text self.last_mark = None def callback_wrapper(callback_type, index_mark=None): event = self.update_status(callback_type, index_mark) if event is not None: try: callback(event) except Exception: import traceback traceback.print_exc() def cw(callback_type, index_mark=None): self.dispatch_on_main_thread( partial(callback_wrapper, callback_type, index_mark)) self.current_callback = cw self.ensure_state(use_ssml=False) self.ssip_client.speak(text, callback=self.current_callback) def pause(self): if self.status['synthesizing'] and not self.status['paused']: self.next_cancel_is_for_pause = True self.ssip_client.stop() def resume(self): if self.current_marked_text is None or not self.status[ 'synthesizing'] or not self.status['paused']: return self.next_begin_is_for_resume = True if self.last_mark is None: text = self.current_marked_text else: mark = self.mark_template.format(self.last_mark) idx = self.current_marked_text.find(mark) if idx == -1: text = self.current_marked_text else: text = self.current_marked_text[idx:] self.ssip_client.speak(text, callback=self.current_callback) def stop(self): self.current_callback = self.current_marked_text = self.last_mark = None self.next_cancel_is_for_pause = False self.next_begin_is_for_resume = False if self.ssip_client is not None: self.ssip_client.stop() def config_widget(self, backend_settings, parent): from calibre.gui2.tts.linux_config import Widget return Widget(self, backend_settings, parent) def get_voice_data(self): ans = getattr(self, 'voice_data', None) if ans is None: self.ensure_state() ans = self.voice_data = {} output_module = self.ssip_client.get_output_module() for om in self.ssip_client.list_output_modules(): self.ssip_client.set_output_module(om) ans[om] = tuple(self.ssip_client.list_synthesis_voices()) self.ssip_client.set_output_module(output_module) return ans
class Client: def __init__(self): self.create_ssip_client() self.pending_events = [] def create_ssip_client(self): from speechd.client import SpawnError, SSIPClient try: self.ssip_client = SSIPClient('calibre') except SpawnError as err: raise TTSSystemUnavailable( _('Could not find speech-dispatcher on your system. Please install it.' ), str(err)) def __del__(self): if hasattr(self, 'ssip_client'): self.ssip_client.close() del self.ssip_client shutdown = __del__ def set_use_ssml(self, on): from speechd.client import DataMode, SSIPCommunicationError mode = DataMode.SSML if on else DataMode.TEXT try: self.ssip_client.set_data_mode(mode) except SSIPCommunicationError: self.ssip_client.close() self.create_ssip_client() self.ssip_client.set_data_mode(mode) def speak_simple_text(self, text): self.set_use_ssml(False) self.ssip_client.speak(text) def speak_marked_text(self, text, callback): from speechd.client import CallbackType def callback_wrapper(callback_type, index_mark=None): if callback_type is CallbackType.INDEX_MARK: event = Event(EventType.mark, index_mark) elif callback_type is CallbackType.BEGIN: event = Event(EventType.begin) elif callback_type is CallbackType.END: event = Event(EventType.end) elif callback_type is CallbackType.CANCEL: event = Event(EventType.cancel) elif callback_type is CallbackType.PAUSE: event = Event(EventType.pause) elif callback_type is CallbackType.RESUME: event = Event(EventType.resume) else: return self.pending_events.append(event) callback() self.set_use_ssml(True) self.ssip_client.speak(text, callback=callback_wrapper) def get_events(self): events = self.pending_events self.pending_events = [] return events