replaces namespace fenrir with fenrirscreenreader

src/fenrirscreenreader/speechDriver/Readme.md

@@ -0,0 +1,3 @@
+espeak = espeak driver
+speechd = speech-dispatcher driver
+generic = generic driver via /bin/say

src/fenrirscreenreader/speechDriver/debugDriver.py

@@ -0,0 +1,74 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# generic driver
+
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self
+    def initialize(self, environment):
+        self._isInitialized = True
+        self.env = environment
+        print('Speech Debug Driver: Iitialized')
+        
+    def shutdown(self):
+        if self._isInitialized:
+            self.cancel()
+        self._isInitialized = False    
+        print('Speech Debug Driver: Shutdown')
+
+    def speak(self,text, queueable=True):
+        if not self._isInitialized:
+            return
+        if not queueable: 
+            self.cancel()
+        print('Speech Debug Driver: Speak:'+text)
+        print('Speech Debug Driver: -----------------------------------')
+
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: Cancel')        
+
+    def setCallback(self, callback):
+        print('Speech Debug Driver: setCallback')    
+
+    def clear_buffer(self):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: clear_buffer')    
+
+    def setVoice(self, voice):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: setVoice:' +  str(voice))    
+
+    def setPitch(self, pitch):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: setPitch:' + str(pitch))    
+
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: setRate:' + str(rate))    
+
+    def setModule(self, module):
+        if not self._isInitialized:
+            return 
+        print('Speech Debug Driver: setModule:' + str(module))    
+
+    def setLanguage(self, language):
+        if not self._isInitialized:
+            return
+        print('Speech Debug Driver: setLanguage:' + str(language))    
+
+    def setVolume(self, volume):
+        if not self._isInitialized:
+            return     
+        print('Speech Debug Driver: setVolume:' + str(volume))

src/fenrirscreenreader/speechDriver/dummyDriver.py

@@ -0,0 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# generic driver
+
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)

src/fenrirscreenreader/speechDriver/emacspeakDriver.py

@@ -0,0 +1,82 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# generic driver
+
+from subprocess import Popen, PIPE
+import pexpect
+import ptyprocess
+import shlex
+import sys
+import time
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)
+    def initialize(self, environment):
+        self.env = environment        
+        try:
+            #self.server = ptyprocess.PtyProcessUnicode.spawn(['/usr/bin/tclsh', self.env['runtime']['settingsManager'].getSetting('speech', 'serverPath')])
+            self.server = pexpect.spawn('tclsh ' + self.env['runtime']['settingsManager'].getSetting('speech', 'serverPath'))
+            self._isInitialized = True            
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver:initialize:' + str(e),debug.debugLevel.ERROR)     
+            print(e)           
+        
+    def shutdown(self):
+        if self.server:
+            try:
+                self.server.terminate()
+            except Exception as e:
+                self.env['runtime']['debug'].writeDebugOut('speechDriver:shutdown:self.server.terminate():' + str(e),debug.debugLevel.ERROR)    
+
+    def speak(self,text, queueable=True):
+        if not self._isInitialized:
+            return
+        if not queueable: 
+            self.cancel()
+        try:
+            cleanText = shlex.split('tts_say "'+text.replace(',','')+'"')            
+            for idx, word in enumerate(cleanText):
+                cleanText[idx] = word
+            cleanText = ' '.join(cleanText)
+            #print(cleanText[0])            
+            #self.server.write('tts_say ' + '"' + cleanText[0] +'"\n')
+            #print(self.server.read(1000))
+            #self.server.sendline('tts_say ' + '"' + cleanText + '"') 
+            self.server.sendline(cleanText) 
+            print(cleanText)
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver:speak:self.server.sendline():' + str(e),debug.debugLevel.ERROR)            
+    
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        try:
+            pass
+            #self.server.write('s\n')      
+            #print(self.server.read(1000))                  
+            #self.server.sendline('stop')
+        except Exception as e:
+            print(e)
+            self.env['runtime']['debug'].writeDebugOut('speechDriver:cancel:self.server.sendline():' + str(e),debug.debugLevel.ERROR)   
+    
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return
+        try:
+            pass        
+            #self.server.write('tts_set_speech_rate ' + str(int(rate * 400)) + '\n')            
+            #self.server.sendline('tts_set_speech_rate ' + str(int(rate * 400)) + '')
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver:setRate:self.server.sendline():' + str(e),debug.debugLevel.ERROR)  
+    
+    def setLanguage(self, language):
+        if not self._isInitialized:
+            return
+        #self.server.write('set_lang ' + language + '\n')
+        #self.server.sendline('set_lang ' + language + '')

src/fenrirscreenreader/speechDriver/espeakDriver.py

@@ -0,0 +1,58 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# Espeak driver
+
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)
+        self._es = None
+
+    def initialize(self, environment):
+        self.env = environment          
+        try:
+            from espeak import espeak 
+            self._es = espeak
+            self._isInitialized = True
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut(str(e),debug.debugLevel.ERROR)         
+            self._initialized = False
+
+    def speak(self,text, interrupt=True):
+        if not self._isInitialized:
+            return
+        if not interrupt:
+            self.cancel()
+        if self.language != None:
+            if self.language != '':
+                self._es.set_voice(self.language)   
+        elif self.voice != None:
+            if self.voice != '':                
+                self._es.set_voice(self.voice)         
+        self._es.synth(text)
+
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        self._es.cancel()
+        return
+
+    def setPitch(self, pitch):
+        if not self._isInitialized:
+            return
+        return self._es.set_parameter(self._es.Parameter().Pitch, int(pitch * 99)) 
+        
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return
+        return self._es.set_parameter(self._es.Parameter().Rate, int(rate * 899 + 100))
+
+    def setVolume(self, volume):
+        if not self._isInitialized:
+            return    
+        return self._es.set_parameter(self._es.Parameter().Volume, int(volume * 200))

src/fenrirscreenreader/speechDriver/genericDriver.py

@@ -0,0 +1,192 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# generic driver
+
+from fenrirscreenreader.core import debug
+from threading import Thread, Lock
+from queue import Queue, Empty
+import shlex
+from subprocess import Popen
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class speakQueue(Queue):
+    def clear(self):
+        try:
+            while True:
+                self.get_nowait()
+        except Empty:
+            pass
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)
+        self.proc = None
+        self.speechThread = Thread(target=self.worker)
+        self.lock = Lock()
+        self.textQueue = speakQueue()
+    def initialize(self, environment):   
+        self.env = environment  
+        self.minVolume = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMinVolume')
+        self.maxVolume = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMaxVolume')        
+        self.minPitch = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMinPitch')        
+        self.maxPitch = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMaxPitch')
+        self.minRate = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMinRate')
+        self.maxRate = self.env['runtime']['settingsManager'].getSettingAsInt('speech', 'fenrirMaxRate')
+        
+        self.speechCommand = self.env['runtime']['settingsManager'].getSetting('speech', 'genericSpeechCommand')
+        if self.speechCommand == '':
+            self.speechCommand = 'espeak -a fenrirVolume -s fenrirRate -p fenrirPitch -v fenrirVoice -- "fenrirText"'
+        if False: #for debugging overwrite here
+            #self.speechCommand = 'spd-say --wait -r 100 -i 100  "fenrirText"'  
+            self.speechCommand = 'flite -t "fenrirText"'           
+        
+        self._isInitialized = True   
+        if self._isInitialized:
+            self.speechThread.start()   
+    def shutdown(self):
+        if not self._isInitialized:
+            return
+        self.cancel()    
+        self.textQueue.put(-1)
+
+    def speak(self,text, queueable=True):
+        if not self._isInitialized:
+            return
+        if not queueable: 
+            self.cancel()        
+        utterance = {
+          'text': text,
+          'volume': self.volume,
+          'rate': self.rate,
+          'pitch': self.pitch,
+          'module': self.module,
+          'language': self.language,
+          'voice': self.voice,
+        }        
+        self.textQueue.put(utterance.copy())
+
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        self.clear_buffer()
+        self.lock.acquire(True)
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception as e:
+                self.env['runtime']['debug'].writeDebugOut('speechDriver:Cancel:self.proc.terminate():' + str(e),debug.debugLevel.WARNING)                                
+                try:
+                    self.proc.kill()
+                except Exception as e:
+                    self.env['runtime']['debug'].writeDebugOut('speechDriver:Cancel:self.proc.kill():' + str(e),debug.debugLevel.WARNING)                    
+            self.proc = None            
+        self.lock.release()
+    def setCallback(self, callback):
+        print('SpeechDummyDriver: setCallback')    
+
+    def clear_buffer(self):
+        if not self._isInitialized:
+            return
+        self.textQueue.clear()     
+    
+    def setVoice(self, voice):
+        if not self._isInitialized:
+            return
+        self.voice = str(voice)
+
+    def setPitch(self, pitch):
+        if not self._isInitialized:
+            return
+        self.pitch = str(self.minPitch + pitch * (self.maxPitch - self.minPitch ))
+
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return
+        self.rate = str(self.minRate + rate * (self.maxRate - self.minRate ))
+
+    def setModule(self, module):
+        if not self._isInitialized:
+            return 
+        self.module = str(module)
+
+    def setLanguage(self, language):
+        if not self._isInitialized:
+            return
+        self.language = str(language)
+
+    def setVolume(self, volume):
+        if not self._isInitialized:
+            return     
+        self.volume = str(self.minVolume + volume * (self.maxVolume - self.minVolume ))
+    
+    def worker(self):
+        while True:
+            utterance = self.textQueue.get()
+
+            if isinstance(utterance, int):
+                if utterance == -1:
+                    return
+                else:
+                    continue
+            elif not isinstance(utterance, dict):
+                continue
+            # no text means nothing to speak
+            if not 'text' in utterance:
+                continue
+            if not isinstance(utterance['text'],str):
+                continue            
+            if utterance['text'] == '':
+                continue
+            # check for valid data fields
+            if not 'volume' in utterance:
+                utterance['volume'] = ''
+            if not isinstance(utterance['volume'],str):
+                utterance['volume'] = ''
+            if not 'module' in utterance:
+                utterance['module'] = ''
+            if not isinstance(utterance['module'],str):
+                utterance['module'] = ''
+            if not 'language' in utterance:
+                utterance['language'] = ''
+            if not isinstance(utterance['language'],str):
+                utterance['language'] = ''
+            if not 'voice' in utterance:
+                utterance['voice'] = ''
+            if not isinstance(utterance['voice'],str):
+                utterance['voice'] = ''
+            if not 'pitch' in utterance:
+                utterance['pitch'] = ''
+            if not isinstance(utterance['pitch'],str):
+                utterance['pitch'] = ''
+            if not 'rate' in utterance:
+                utterance['rate'] = ''
+            if not isinstance(utterance['rate'],str):
+                utterance['rate'] = ''
+
+            popenSpeechCommand = shlex.split(self.speechCommand)
+            for idx, word in enumerate(popenSpeechCommand):
+                word = word.replace('fenrirVolume', str(utterance['volume'] ))
+                word = word.replace('fenrirModule', str(utterance['module']))
+                word = word.replace('fenrirLanguage', str(utterance['language']))
+                word = word.replace('fenrirVoice', str(utterance['voice']))
+                word = word.replace('fenrirPitch', str(utterance['pitch']))
+                word = word.replace('fenrirRate', str(utterance['rate']))
+                word = word.replace('fenrirText', str(utterance['text']))
+                popenSpeechCommand[idx] = word
+
+            try:
+                self.env['runtime']['debug'].writeDebugOut('speechDriver:worker:' + ' '.join(popenSpeechCommand),debug.debugLevel.INFO)                                            
+                self.lock.acquire(True)
+                self.proc = Popen(popenSpeechCommand, shell=False)
+                self.lock.release()	
+                self.proc.wait()
+            except Exception as e:
+                self.env['runtime']['debug'].writeDebugOut('speechDriver:worker:' + str(e),debug.debugLevel.ERROR)    
+
+            self.lock.acquire(True)
+            self.proc = None
+            self.lock.release()
+

src/fenrirscreenreader/speechDriver/pyttsxDriver.py

@@ -0,0 +1,86 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# Espeak driver
+
+from threading import Thread, Lock
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)
+        self._engine = None
+    def initialize(self, environment):
+        self.env = environment                   
+    def shutdown(self):
+        if self._isInitialized:
+            self.cancel()            
+            self._engine.endLoop()
+        self._initialized = False            
+    def eventLoop(self):
+        self._engine.startLoop()
+    def startEngine(self):
+        try:
+            import pyttsx3
+            if self.module != '':
+                self._engine = pyttsx3.init(self.module)
+            else:
+                self._engine = pyttsx3.init()                            
+            self.eventLoopThread = Thread(target=self.eventLoop)
+            self._isInitialized = True
+            self.eventLoopThread.start()
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('SpeechDriver:initialize:' + str(e),debug.debugLevel.ERROR)    
+    
+    def speak(self,text, interrupt=True):
+        if not self._isInitialized:
+            self.startEngine()
+            if not self._isInitialized:            
+                return
+        if not interrupt:
+            self.cancel()
+        try:
+            self._engine.setProperty('volume', self.volume) 
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('SpeechDriver:speak:volume:' + str(e),debug.debugLevel.ERROR) 
+        try:
+            self._engine.setProperty('rate', self.rate) 
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('SpeechDriver:speak:rate:' + str(e),debug.debugLevel.ERROR) 
+        try:
+            self._engine.setProperty('pitch', self.pitch)       
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('SpeechDriver:speak:pitch:' + str(e),debug.debugLevel.ERROR)                                 
+        if self.language != None:
+            if self.language != '':
+                try:
+                    self._engine.setProperty('voice', self.language)       
+                except Exception as e:
+                    self.env['runtime']['debug'].writeDebugOut('SpeechDriver:speak:language:' + str(e),debug.debugLevel.ERROR)               
+
+        elif self.voice != None:
+            if self.voice != '':
+                try:
+                    self._engine.setProperty('voice', self.voice) 
+                except Exception as e:
+                    self.env['runtime']['debug'].writeDebugOut('SpeechDriver:speak:voice:' + str(e),debug.debugLevel.ERROR)
+        self._engine.say(text)
+
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        self._engine.stop()
+        self._engine.proxy.stop()
+
+    def setPitch(self, pitch):
+        if not self._isInitialized:
+            return
+        self.pitch = pitch
+        
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return
+        self.rate = rate

src/fenrirscreenreader/speechDriver/speechdDriver.py

@@ -0,0 +1,94 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+# speech-dispatcher driver
+
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.speechDriver import speechDriver
+
+class driver(speechDriver):
+    def __init__(self):
+        speechDriver.__init__(self)
+        self._sd = None
+
+    def initialize(self, environment):
+        self.env = environment
+        try:
+            import speechd 
+            self._sd =  speechd.SSIPClient('fenrir')
+            self._punct = speechd.PunctuationMode()
+            self._isInitialized = True
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver initialize:' + str(e),debug.debugLevel.ERROR)                 
+                    
+    def shutdown(self):
+        if not self._isInitialized:
+            return
+        self.cancel()
+        try:
+            self._sd.close()
+        except:
+            pass
+        self._isInitialized = False            
+        
+    def speak(self,text, queueable=True):
+        if not queueable:
+            self.cancel()      
+        if not self._isInitialized:
+            self.initialize(self.env)
+            if not self._isInitialized:
+                return
+        try:
+            self._sd.set_output_module(self.module)
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver setModule:' + str(e),debug.debugLevel.ERROR)
+                    
+        try:
+            if self.voice:
+                if self.voice != '':
+                    self._sd.set_voice(self.voice)
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver setVoice:' + str(e),debug.debugLevel.ERROR)                
+        try:
+            if self.language != '':        
+                self._sd.set_synthesis_voice(self.language)        
+            self._sd.set_punctuation(self._punct.NONE)              
+            self._sd.speak(text)            
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver speak:' + str(e),debug.debugLevel.ERROR)                 
+            self._isInitialized = False
+
+    def cancel(self):
+        if not self._isInitialized:
+            return
+        try:
+            self._sd.cancel()
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver cancel:' + str(e),debug.debugLevel.ERROR)                         
+            self._isInitialized = False        
+                               
+    def setPitch(self, pitch):
+        if not self._isInitialized:
+            return
+        try:
+            self._sd.set_pitch(int(-100 + pitch * 200)) 
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver setPitch:' + str(e),debug.debugLevel.ERROR)                                         
+
+    def setRate(self, rate):
+        if not self._isInitialized:
+            return 
+        try:
+            self._sd.set_rate(int(-100 + rate * 200))
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver setRate:' + str(e),debug.debugLevel.ERROR)                                                                              
+        
+    def setVolume(self, volume):
+        if not self._isInitialized:
+            return 
+        try:               
+            self._sd.set_volume(int(-100 + volume * 200))
+        except Exception as e:
+            self.env['runtime']['debug'].writeDebugOut('speechDriver setVolume:' + str(e),debug.debugLevel.ERROR)