def _generator(self, q): while not self.closed: # Use a blocking get() to ensure there's at least one chunk of # data, and stop iteration if the chunk is None, indicating the # end of the audio stream. chunk = q.get() if chunk is None: return audioData = [chunk] # Now consume whatever other data's still buffered. while True: try: chunk = q.get(block=False) if chunk is None: return audioData.append(chunk) except queue.Empty: break except: break audioData = b''.join(audioData) yield audioData logger.debug('microphone generator loop exited')
def __enter__(self): logger.debug('MicrophoneStream.enter ENTER') self.closed = False try: self._audio_stream = self._audio_interface.open( input_device_index=self._inputDeviceIndex, format=self._format, channels=self._num_channels, rate=self._rate, input=True, frames_per_buffer=self._chunk_size, # Run the audio stream asynchronously to fill the buffer object. # This is necessary so that the input device's buffer doesn't # overflow while the calling thread makes network requests, etc. stream_callback=self._fill_buff, ) except OSError: logger.error("microphone __enter__.OSError") self.closed = True raise Exception("Microphone Not Functioning") self.initRecording() logger.debug('MicrophoneStream.enter EXIT') return self
def canceled(self, evt): logger.debug( 'microsoftTranscribe.ProcessEvents.CANCELED: {}'.format(evt)) logger.error( 'microsoftTranscribe terminated. Ensure you have the correct API Key and service region.' ) self.responseQueue.put('canceled')
def saveRecording(self): logger.debug("microphoneStream.saveRecording ENTER") # Record the audio file if self._wavfile is not None: audioGenerator = self.recordingGenerator() for audioData in audioGenerator: self._wavfile.writeframes(audioData) logger.debug("microphoneStream.saveRecording EXIT")
def run(self): if self._ONLINE: logger.warn("Transcribe Engine already Started") return logger.info( "Transcribe Engine Starting with the %s%s Speech-To-Text Service" % (speakreader.CONFIG.SPEECH_TO_TEXT_SERVICE[0].upper(), speakreader.CONFIG.SPEECH_TO_TEXT_SERVICE[1:])) FILENAME_DATESTRING = datetime.datetime.now().strftime( FILENAME_DATE_FORMAT) TRANSCRIPT_FILENAME = FILENAME_PREFIX + FILENAME_DATESTRING + "." + TRANSCRIPT_FILENAME_SUFFIX RECORDING_FILENAME = FILENAME_PREFIX + FILENAME_DATESTRING + "." + RECORDING_FILENAME_SUFFIX tf = os.path.join(speakreader.CONFIG.TRANSCRIPTS_FOLDER, TRANSCRIPT_FILENAME) self.queueManager.transcriptHandler.setFileName(tf) try: self.microphoneStream = MicrophoneStream( speakreader.CONFIG.INPUT_DEVICE) self.microphoneStream.recordingFilename = RECORDING_FILENAME self.microphoneStream.meterQueue = self.queueManager.meterHandler.getReceiverQueue( ) except Exception as e: logger.debug("MicrophoneStream Exception: %s" % e) self.transcriptQueue.put_nowait(self.OFFLINE_MESSAGE) return if speakreader.CONFIG.SPEECH_TO_TEXT_SERVICE == 'google' and self.GOOGLE_SERVICE: transcribeService = googleTranscribe(self.microphoneStream) elif speakreader.CONFIG.SPEECH_TO_TEXT_SERVICE == 'IBM' and self.IBM_SERVICE: transcribeService = ibmTranscribe(self.microphoneStream) elif speakreader.CONFIG.SPEECH_TO_TEXT_SERVICE == 'microsoft' and self.MICROSOFT_SERVICE: transcribeService = microsoftTranscribe(self.microphoneStream) else: logger.warn( "No Supported Transcribe Service Selected. Can't start Transcribe Engine." ) return self.transcriptFile = open(tf, "a+") self.transcriptQueue.put_nowait(self.ONLINE_MESSAGE) self._ONLINE = True try: with self.microphoneStream as stream: while self._ONLINE: responses = transcribeService.transcribe() self.process_responses(responses) logger.info("Transcription Engine Stream Closed") except Exception as e: logger.error(e) self.transcriptFile.close() self.transcriptQueue.put_nowait(self.OFFLINE_MESSAGE) self._ONLINE = False logger.info("Transcribe Engine Terminated")
def delete(path, days): try: days = int(days) except ValueError: return delete_date = datetime.datetime.now() - datetime.timedelta(days=days) with os.scandir(path=path) as files: for file in files: file_info = file.stat() if datetime.datetime.fromtimestamp(file_info.st_ctime) < delete_date: filename = os.path.join(path, file.name) logger.debug("Deleting: %s" % filename) os.remove(filename)
def eventSource(type, listenerQueue, remoteIP, sessionID): while self.SR.transcribeEngine.queueManager.is_initialized: try: data = listenerQueue.get(timeout=2) if data is None: close_event = json.dumps({"event": "close"}) yield 'data: {}\n\n'.format(close_event) break yield 'data: {}\n\n'.format(json.dumps(data)) except queue.Empty: continue logger.debug("Exiting " + type.capitalize() + " Listener loop for IP: " + remoteIP + " with sessionID: " + sessionID)
def recognize_using_websocket(self, *args): logger.debug("ibmTransribe.recognize_using_websocket ENTER") self.speech_to_text.recognize_using_websocket( audio=self.audio_source, content_type='audio/l16; rate=%s' % self.audio_device._outputSampleRate, recognize_callback=self.mycallback, interim_results=True, max_alternatives=1, inactivity_timeout=-1, smart_formatting=True, word_alternatives_threshold=0.75, profanity_filter=bool(speakreader.CONFIG.ENABLE_CENSORSHIP), ) logger.debug("ibmTransribe.recognize_using_websocket EXIT")
def transcribe(self): # Generator to return transcription results if not self.is_supported: return logger.debug("googleTranscribe.transcribe ENTER") while True: audio_generator = self.audio_device.streamGenerator() requests = (speech.StreamingRecognizeRequest( audio_content=content, ) for content in audio_generator) responses = self.client.streaming_recognize( requests=requests, config=self.streaming_config) try: for response in responses: if not response.results: continue result = response.results[0] if not result.is_final and not speakreader.CONFIG.SHOW_INTERIM_RESULTS: continue if not result.alternatives: continue transcript = { 'transcript': result.alternatives[0].transcript, 'is_final': result.is_final, } yield transcript logger.debug("googleTranscribe.transcribe EXIT") break except exceptions.OutOfRange: """ Google Cloud limits stream to about 5 minutes. Just loop. """ continue except exceptions.DeadlineExceeded: """ Google Cloud limits stream to about 5 minutes. Just loop. """ continue
def transcribe(self): if not self.is_supported: return # Generator to return transcription results logger.debug("microsoftTranscribe.transcribe Enter") audio_format = speechsdk.audio.AudioStreamFormat( samples_per_second=16000, bits_per_sample=16, channels=1) audio_stream_callback = AudioStreamCallback( self.audio_device._streamBuff) audio_stream = speechsdk.audio.PullAudioInputStream( audio_stream_callback, audio_format) self.audio_config = speechsdk.audio.AudioConfig(stream=audio_stream) self.speech_recognizer = speechsdk.SpeechRecognizer( speech_config=self.speech_config, audio_config=self.audio_config) # Connect callbacks to the events fired by the speech recognizer self.speech_recognizer.recognizing.connect( self.eventProcessor.recognizing) self.speech_recognizer.recognized.connect( self.eventProcessor.recognized) self.speech_recognizer.session_started.connect( self.eventProcessor.session_started) self.speech_recognizer.session_stopped.connect( self.eventProcessor.session_stopped) self.speech_recognizer.canceled.connect(self.eventProcessor.canceled) # Start continuous speech recognition self.speech_recognizer.start_continuous_recognition() while True: response = self.eventProcessor.responseQueue.get() if response is None: self.speech_recognizer.stop_continuous_recognition() self.audio_device.closed = True break if response == 'canceled': self.audio_device.closed = True break yield response logger.debug("microsoftTranscribe.transcribe Exit")
def transcribe(self): if not self.is_supported: return # Generator to return transcription results logger.debug('ibmTranscribe.transcribe ENTER') recognize_thread = Thread(target=self.recognize_using_websocket, args=()) recognize_thread.start() while True: response = self.mycallback.responseQueue.get() if response is None: break yield response self.audio_source.completed_recording() recognize_thread.join() logger.debug('ibmTranscribe.transcribe EXIT')
def __exit__(self, type, value, traceback): if self.closed: return logger.debug('MicrophoneStream.exit ENTER') self._audio_stream.stop_stream() self._audio_stream.close() self._streamBuff.put(None) if speakreader.CONFIG.SAVE_RECORDINGS: self._recordingBuff.put(None) self.closed = True # Signal the generator to terminate so that the client's # streaming_recognize method will not block the process termination. self._audio_interface.terminate() if self._wavfile is not None: self._wavfile.close() self._wavfile = None logger.debug('MicrophoneStream.exit EXIT')
def checkForUpdate(self): # Check for new versions if speakreader.CONFIG.CHECK_GITHUB: self._check_github() else: self.LATEST_VERSION_HASH = self.INSTALLED_VERSION_HASH if not self.INSTALLED_VERSION_HASH: self.UPDATE_AVAILABLE = True elif self.COMMITS_BEHIND > 0 and speakreader.GITHUB_BRANCH in ('master', 'beta') and \ speakreader.VERSION_RELEASE != self.LATEST_RELEASE: self.UPDATE_AVAILABLE = 'release' elif self.COMMITS_BEHIND > 0 and self.INSTALLED_VERSION_HASH != self.LATEST_VERSION_HASH: self.UPDATE_AVAILABLE = 'commit' else: self.UPDATE_AVAILABLE = False if logger.VERBOSE: d = self.__dict__ for k, v in d.items(): logger.debug(str(k) + ": " + str(v))
def _exec_command(self, cmd, cwd=None): if cwd is None: cwd = speakreader.PROG_DIR logger.debug('Trying to execute: "' + cmd + '" with shell in ' + cwd) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=cwd, shell=True) while True: out = p.stdout.readline().decode('utf-8').replace('\r', '').replace( '\n', '') return_code = p.poll() if out == '' and return_code is not None: break if out != '': yield out if return_code: raise subprocess.CalledProcessError(return_code, cmd)
def initRecording(self): logger.debug("microphoneStream.initRecording ENTER") if speakreader.CONFIG.SAVE_RECORDINGS: wavfile = os.path.join(speakreader.CONFIG.RECORDINGS_FOLDER, self.recordingFilename) try: w = wave.open(wavfile, 'rb') data = w.readframes(w.getnframes()) self._wavfile = wave.open(wavfile, 'wb') self._wavfile.setparams(w.getparams()) w.close() self._wavfile.writeframes(data) except FileNotFoundError: self._wavfile = wave.open(wavfile, 'wb') self._wavfile.setnchannels(self._num_channels) self._wavfile.setsampwidth(2) self._wavfile.setframerate(self._outputSampleRate) recordingThread = Thread(target=self.saveRecording, args=(), name='recordingThread') recordingThread.start() logger.debug("microphoneStream.initRecording EXIT")
def runGit(self, args): if speakreader.CONFIG.GIT_PATH: git_locations = ['"' + speakreader.CONFIG.GIT_PATH + '"'] else: git_locations = ['git'] output = err = None for cur_git in git_locations: cmd = cur_git + ' ' + args try: logger.debug('Trying to execute: "' + cmd + '" with shell in ' + speakreader.PROG_DIR) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, cwd=speakreader.PROG_DIR) output, err = p.communicate() output = output.decode('utf-8').strip() for line in output.split('\n'): if line: logger.debug('Git output: ' + line) except OSError: logger.debug('Command failed: %s', cmd) continue if 'not found' in output or "not recognized as an internal or external command" in output: logger.debug('Unable to find git with command ' + cmd) output = None elif 'fatal:' in output or err: logger.error( 'Git returned bad info. Are you sure this is a git installation?' ) output = None elif output: break return (output, err)
def on_inactivity_timeout(self, error): logger.debug('ibmTranscribe.ProcessResponses.Inactivity timeout: {}'.format(error))
def session_stopped(self, evt): logger.debug( 'microsoftTranscribe.ProcessEvents.SESSION_STOPPED {}'.format(evt)) self.responseQueue.put(None)
def session_started(self, evt): logger.debug( 'microsoftTranscribe.ProcessEvents.SESSION_STARTED: {}'.format( evt))
def __init__(self, input_device): logger.debug('MicrophoneStream INIT') self._audio_interface = pyaudio.PyAudio() self._inputDeviceName = input_device self._inputDeviceIndex = None self._num_channels = 1 self._format = pyaudio.paInt16 self._outputSampleRate = SAMPLERATE self.meterQueue = None self.meter_peak_np = np.empty(0, dtype=np.int16) self.meter_time = float(0) self.recordingFilename = None numdevices = self._audio_interface.get_default_host_api_info().get( 'deviceCount') defaultHostAPIindex = self._audio_interface.get_default_host_api_info( ).get('index') defaultInputDeviceIndex = self._audio_interface.get_default_input_device_info( ).get('index') defaultInputDeviceName = self._audio_interface.get_default_input_device_info( ).get('name') for i in range(0, numdevices): inputDevice = self._audio_interface.get_device_info_by_host_api_device_index( defaultHostAPIindex, i) if self._inputDeviceName == inputDevice.get('name'): self._inputDeviceIndex = inputDevice.get('index') break if self._inputDeviceIndex is None: self._inputDeviceName = defaultInputDeviceName self._inputDeviceIndex = defaultInputDeviceIndex deviceInfo = self._audio_interface.get_device_info_by_index( self._inputDeviceIndex) self._rate = int(deviceInfo.get('defaultSampleRate')) try: if self._audio_interface.is_format_supported( self._outputSampleRate, input_device=self._inputDeviceIndex, input_channels=self._num_channels, input_format=self._format): self._rate = self._outputSampleRate except ValueError: pass self.resampler = sr.Resampler() self.resampler_ratio = self._outputSampleRate / self._rate self._chunk_size = int(self._rate / 10) self._wavfile = None # Create a thread-safe buffer of audio data self._streamBuff = queue.Queue() self._recordingBuff = queue.Queue() self.closed = True # 2 bytes in 16 bit samples self._bytes_per_sample = 2 * self._num_channels self._bytes_per_second = self._rate * self._bytes_per_sample self._bytes_per_chunk = (self._chunk_size * self._bytes_per_sample) self._chunks_per_second = (self._bytes_per_second // self._bytes_per_chunk)
def on_listening(self): logger.debug('ibmTranscribe.ProcessResponses.Listening Service is listening')
def __init__(self, initOptions): if SpeakReader._INITIALIZED: return with INIT_LOCK: global PROG_DIR PROG_DIR = initOptions['prog_dir'] global DATA_DIR DATA_DIR = initOptions['data_dir'] global CONFIG CONFIG = initOptions['config'] assert CONFIG is not None if isinstance(initOptions['http_port'], int): self.HTTP_PORT = initOptions['http_port'] else: self.HTTP_PORT = int(CONFIG.HTTP_PORT) if self.HTTP_PORT < 21 or self.HTTP_PORT > 65535: logger.warn("HTTP_PORT out of bounds: 21 < %s < 65535", self.HTTP_PORT) self.HTTP_PORT = 8880 # Check if pyOpenSSL is installed. It is required for certificate generation # and for CherryPy. if CONFIG.ENABLE_HTTPS: try: import OpenSSL except ImportError: logger.warn("The pyOpenSSL module is missing. Install this " "module to enable HTTPS. HTTPS will be disabled.") CONFIG.ENABLE_HTTPS = False if not CONFIG.HTTPS_CERT: CONFIG.HTTPS_CERT = os.path.join(DATA_DIR, 'server.crt') if not CONFIG.HTTPS_KEY: CONFIG.HTTPS_KEY = os.path.join(DATA_DIR, 'server.key') if not (os.path.exists(CONFIG.HTTPS_CERT) and os.path.exists(CONFIG.HTTPS_KEY)): logger.warn("Disabled HTTPS because of missing certificate and key.") CONFIG.ENABLE_HTTPS = False # Check if we has a jwt_secret if CONFIG.JWT_SECRET == '' or not CONFIG.JWT_SECRET: logger.debug("Generating JWT secret...") CONFIG.JWT_SECRET = generate_uuid() CONFIG.write() ################################################################################################### # Get Version Information and check for updates ################################################################################################### self.versionInfo = Version() ################################################################################################### # Get the Input Device ################################################################################################### self.get_input_device() ################################################################################################### # Initialize the Transcribe Engine ################################################################################################### self.transcribeEngine = TranscribeEngine() if CONFIG.START_TRANSCRIBE_ON_STARTUP : self.startTranscribeEngine() ################################################################################################### # Initialize the webserver ################################################################################################### logger.info('WebServer Initializing') webServerOptions = { 'config': CONFIG, 'prog_dir': PROG_DIR, 'data_dir': DATA_DIR, 'http_port': self.HTTP_PORT, } self.webServer = webstart.initialize(webServerOptions) self.webServer.root.SR = self cherrypy.server.start() # Launch the WebBrowser if CONFIG.LAUNCH_BROWSER and not initOptions['nolaunch']: launch_browser(CONFIG.HTTP_HOST, self.HTTP_PORT, CONFIG.HTTP_ROOT + 'manage') ################################################################################################### # Run cleanup of old logs, transcripts, and recordings and start a scheduler to run every 24 hours ################################################################################################### self.cleanup_files() self.scheduler = BackgroundScheduler() self.scheduler.add_job(self.cleanup_files, 'interval', hours=24) self.scheduler.start() SpeakReader._INITIALIZED = True
def update(self): if speakreader.CONFIG.SERVER_ENVIRONMENT.lower() != 'production': logger.info( "Updating bypassed because this is not a production environment" ) return False if not self.UPDATE_AVAILABLE: logger.info("No Updates Available") return False if self.INSTALL_TYPE == 'git': output, err = self.runGit( 'diff --name-only %s/%s' % (speakreader.CONFIG.GIT_REMOTE, speakreader.CONFIG.GIT_BRANCH)) if output == '': logger.debug("No differences found from the origin") elif output == 'requirements.txt': logger.warn( 'Requirements file is out of sync. Restoring to original.') output, err = self.runGit('checkout %s/%s requirements.txt' % (speakreader.CONFIG.GIT_REMOTE, speakreader.CONFIG.GIT_BRANCH)) else: logger.error("Differences Found. Unable to update.") logger.info('Output: ' + str(output)) return False output, err = self.runGit('pull ' + speakreader.CONFIG.GIT_REMOTE + ' ' + speakreader.CONFIG.GIT_BRANCH) if not output: logger.error('Unable to download latest version') return False for line in output.split('\n'): if 'Already up-to-date.' in line: logger.info('No update available, not updating') logger.info('Output: ' + str(output)) return False elif line.endswith(('Aborting', 'Aborting.')): logger.error('Unable to update from git: ' + line) logger.info('Output: ' + str(output)) return False else: tar_download_url = 'https://api.github.com/repos/{}/{}/tarball/{}'.format( speakreader.CONFIG.GIT_USER, speakreader.CONFIG.GIT_REPO, speakreader.CONFIG.GIT_BRANCH) if speakreader.CONFIG.GIT_TOKEN: tar_download_url = tar_download_url + '?access_token=%s' % speakreader.CONFIG.GIT_TOKEN update_dir = os.path.join(speakreader.PROG_DIR, 'update') version_path = os.path.join(speakreader.PROG_DIR, 'version.txt') logger.info('Downloading update from: ' + tar_download_url) try: data = requests.get(tar_download_url, timeout=10) except Exception as e: logger.warn('Failed to establish a connection to GitHub') return False if not data: logger.error( "Unable to retrieve new version from '%s', can't update", tar_download_url) return False download_name = speakreader.CONFIG.GIT_BRANCH + '-github' tar_download_path = os.path.join(speakreader.PROG_DIR, download_name) # Save tar to disk with open(tar_download_path, 'wb') as f: f.write(data.content) # Extract the tar to update folder logger.info('Extracting file: ' + tar_download_path) tar = tarfile.open(tar_download_path) tar.extractall(update_dir) tar.close() # Delete the tar.gz logger.info('Deleting file: ' + tar_download_path) os.remove(tar_download_path) # Find update dir name update_dir_contents = [ x for x in os.listdir(update_dir) if os.path.isdir(os.path.join(update_dir, x)) ] if len(update_dir_contents) != 1: logger.error("Invalid update data, update failed: " + str(update_dir_contents)) return False content_dir = os.path.join(update_dir, update_dir_contents[0]) # walk temp folder and move files to main folder for dirname, dirnames, filenames in os.walk(content_dir): dirname = dirname[len(content_dir) + 1:] for curfile in filenames: old_path = os.path.join(content_dir, dirname, curfile) new_path = os.path.join(speakreader.PROG_DIR, dirname, curfile) if os.path.isfile(new_path): os.remove(new_path) os.renames(old_path, new_path) # Update version.txt try: with open(version_path, 'w') as f: f.write(str(self.LATEST_VERSION_HASH)) except IOError as e: logger.error( "Unable to write current version to version.txt, update not complete: %s" % e) return False self.pip_update() self.pip_sync() logger.info("Update Complete") return True
def _check_github(self): self.COMMITS_BEHIND = 0 # Get the latest version available from github logger.debug('Retrieving latest version information from GitHub') url = 'https://api.github.com/repos/%s/%s/commits/%s' % ( speakreader.CONFIG.GIT_USER, speakreader.CONFIG.GIT_REPO, speakreader.CONFIG.GIT_BRANCH) if speakreader.CONFIG.GIT_TOKEN: url = url + '?access_token=%s' % speakreader.CONFIG.GIT_TOKEN try: response = requests.get(url, timeout=10) except Exception as e: logger.warn('Failed to establish a connection to GitHub') return if response.ok: version = response.json() else: logger.warn( 'Could not get the latest version information from GitHub for ' + speakreader.CONFIG.GIT_REMOTE + '/' + speakreader.CONFIG.GIT_BRANCH + '. Are you running a local development version?') return self.LATEST_VERSION_HASH = version['sha'] # See how many commits behind we are if not self.INSTALLED_VERSION_HASH: logger.info( 'You are running an unknown version of SpeakReader. Run the updater to identify your version' ) self.LATEST_RELEASE = "Unknown" return # Get latest release tag logger.debug('Retrieving latest release information from GitHub') url = 'https://api.github.com/repos/%s/%s/releases' % ( speakreader.CONFIG.GIT_USER, speakreader.CONFIG.GIT_REPO) if speakreader.CONFIG.GIT_TOKEN: url = url + '?access_token=%s' % speakreader.CONFIG.GIT_TOKEN try: response = requests.get(url, timeout=10) except Exception as e: logger.warn('Failed to establish a connection to GitHub') return if response.ok: releases = response.json() else: logger.warn('Could not get releases from GitHub.') return if speakreader.CONFIG.GIT_BRANCH == 'master': release = next((r for r in releases if not r['prerelease']), releases[0]) elif speakreader.CONFIG.GIT_BRANCH == 'beta': release = next((r for r in releases), releases[0]) else: release = releases[0] self.LATEST_RELEASE = release['tag_name'] url = 'https://github.com/%s/%s/releases/tag/%s' \ % (speakreader.CONFIG.GIT_USER, speakreader.CONFIG.GIT_REPO, self.LATEST_RELEASE) if speakreader.CONFIG.GIT_TOKEN: url = url + '?access_token=%s' % speakreader.CONFIG.GIT_TOKEN self.LATEST_RELEASE_URL = url logger.info("Installed release is %s - %s" % (self.INSTALLED_RELEASE, self.INSTALLED_VERSION_HASH)) logger.info(" Latest release is %s - %s" % (self.LATEST_RELEASE, self.LATEST_VERSION_HASH)) if self.LATEST_VERSION_HASH == self.INSTALLED_VERSION_HASH: logger.info('SpeakReader is up to date') return logger.debug( 'Comparing currently installed version with latest GitHub version') url = 'https://api.github.com/repos/%s/%s/compare/%s...%s' % ( speakreader.CONFIG.GIT_USER, speakreader.CONFIG.GIT_REPO, self.LATEST_VERSION_HASH, self.INSTALLED_VERSION_HASH) if speakreader.CONFIG.GIT_TOKEN: url = url + '?access_token=%s' % speakreader.CONFIG.GIT_TOKEN try: response = requests.get(url, timeout=10) except Exception as e: logger.warn('Failed to establish a connection to GitHub') return if response.ok: commits = response.json() else: logger.warn('Could not get commits behind from GitHub.') return try: self.COMMITS_BEHIND = int(commits['behind_by']) logger.debug("In total, %d commits behind", self.COMMITS_BEHIND) except KeyError: logger.info( 'Cannot compare versions. Are you running a local development version?' ) self.COMMITS_BEHIND = 0 if self.COMMITS_BEHIND > 0: logger.info('Updates Available. You are %s commits behind' % self.COMMITS_BEHIND) elif self.COMMITS_BEHIND == 0: logger.info('SpeakReader is up to date')
def __init__(self): logger.debug("microsoftTranscribe.ProcessEvents.Init") self.responseQueue = Queue(maxsize=100)
def __init__(self): logger.debug("ibmTranscribe.ProcessResponse.Init ENTER") self.responseQueue = Queue(maxsize=100) RecognizeCallback.__init__(self)
def on_close(self): self.responseQueue.put_nowait(None) logger.debug("ibmTranscribe.ProcessResponses.Close Connection closed")
def on_connected(self): logger.debug('ibmTranscribe.ProcessResponses.Connection successful')