def gat_with_breakdown(path_to_file, recognizer: sr.Recognizer, breakdown_duration=10, tempfile_name='temp.wav'): """ gat = get audio transcript This breakdown is effective for writing down SRT(s). """ for start, end, total in chop_chop(path_to_file, breakdown_duration, output_file=tempfile_name): last_yield = start with sr.AudioFile(tempfile_name) as source: try: if (content := recognizer.recognize_google(recognizer.record(source))): yield {'start': format_to_ffmpeg_duration(start), 'end': format_to_ffmpeg_duration(end), 'text': content, 'total': total, 'delta': end - last_yield} last_yield = end except sr.UnknownValueError: pass
def GetTextInAudio(audio_msg, chat_id, bot): from speech_recognition import AudioFile, Recognizer, UnknownValueError rec = Recognizer() file_id = audio_msg['file_id'] tempAudio = dirLoc + file_id + '.' + audio_msg['mime_type'].split('/')[1] bot.download_file(file_id, tempAudio) from pydub import AudioSegment filename = file_id + '.wav' file_loc = dirLoc + filename sound = AudioSegment.from_file(tempAudio) sound.export(file_loc, format='wav') with AudioFile(file_loc) as AudioSrc: content = rec.record(AudioSrc) try: text = rec.recognize_google( audio_data=content, language='ja-JP', ) except UnknownValueError: bot.sendMessage(chat_id, 'None') return mainText = t_j2k(text) bot.sendMessage(chat_id, mainText) remove(tempAudio) remove(file_loc)
class MicrophoneMonitor(object): def __init__(self) -> None: self.micro = Recognizer() self.micro.energy_threshold = 4000 self.micro.pause_threshold = 0.5 def monitor_microphone(self, hotword='jarvis'): with Microphone() as source: self.micro.adjust_for_ambient_noise(source, duration=0.5) while True: print('Aguardando comando: ') audio = self.micro.listen(source) try: trigger = self.micro.recognize_google(audio, language='pt') # with open("microphone-results.wav", "wb") as f: # f.write(audio.get_wav_data()) print(trigger) if hotword.lower() in trigger or hotword.capitalize( ) in trigger: print('Comando: ', trigger) return trigger except UnknownValueError: print( "Google Speech Recognition could not understand audio") except RequestError as e: print( "Could not request results from Google Speech Recognition service; {0}" .format(e))
class Ear: # pylint: disable=too-few-public-methods """ listen() -- take audio from microphone, recognize it and return as string """ def __init__(self): self.recognizer = Recognizer() def listen(self): """ listen audio from microphone and convert to the string. :return:data """ self.recognizer = Recognizer() with Microphone() as source: self.recognizer.adjust_for_ambient_noise(source) print("I am listening you...") audio = self.recognizer.listen(source, phrase_time_limit=6) data = "" try: # Uses the default API key # To use another API key: # `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")` data = self.recognizer.recognize_google(audio, language="tr") print("You said : " + data) except UnknownValueError: print("Google Speech Recognition could not understand audio") return self.listen() except RequestError as exception: print("Could not request results from " "Google Speech Recognition service; {0}".format(exception)) return self.listen() return data.lower()
def listen(self) -> str: # Record Audio data = '' recognizer = Recognizer() with Microphone() as source: self.log.debug('Listening on microphone...') try: audio = recognizer.listen(source, timeout=10) except WaitTimeoutError: self.log.debug('Listen timed out.') return data # Speech recognition using Google Speech Recognition try: # Uses the default API key # To use another API key: `r.recognize_google(audio, key='GOOGLE_SPEECH_RECOGNITION_API_KEY')` data = recognizer.recognize_google(audio) self.log.debug(f'You said: "{data}"') except UnknownValueError: self.log.debug( 'Google Speech Recognition could not understand audio') except RequestError as e: self.log.error( f'Could not request results from Google Speech Recognition service: {e}' ) return str(data)
def Audio_file_Read(filename): universal_dict = {} cnt = {} gantu = [0, 0, 0, 0] analysis = {} token = Tokenizer() recog = Recognizer() try: audioFile = sr.AudioFile(filename) with audioFile as source: audio = recog.record(source) recognized = recog.recognize_google(audio, language="ko-KR") res = text_to_word_sequence(recognized) cnt = collections.Counter(res) universal_dict = dict(cnt) if "어" in universal_dict: gantu[0] = universal_dict["어"] if "아니" in universal_dict: gantu[1] = universal_dict["아니"] if "근데" in universal_dict: gantu[2] = universal_dict["근데"] if "이제" in universal_dict: gantu[3] = universal_dict["이제"] text = recognized analysis['text'] = text analysis['data'] = gantu return analysis except UnknownValueError: analysis['text'] = "당신이 말한 문장이 없습니다." analysis['data'] = [0, 0, 0, 0] return analysis
def wav_to_text(wav_file_path, language="es-ES", show_all=False): r = Recognizer() with WavFile(wav_file_path) as source: audio = r.record(source) try: return r.recognize_google(audio_data=audio, language=language, show_all=show_all) except UnknownValueError: raise GolemException("Could not understand audio")
class SimpleSTT(object): def __init__(self): self.recognizer = Recognizer() def transcribe(self, path_to_source): with AudioFile(path_to_source) as source: audio = self.recognizer.listen(source) return self.recognizer.recognize_google(audio)
def VoiceInput(): recog = Recognizer() mic = Microphone(device_index=1) with mic: audio = recog.listen(mic) try: recognized = recog.recognize_google(audio) except UnknownValueError: Response("Try Again") with mic: audio = recog.listen(mic) recognized = recog.recognize_google(audio) except RequestError as exc: Response("Sorry my service is down") print(recognized) return (recognized)
def dothis(message): """ From speech to text :param message: :return: text """ session = message.get_session() ans = '' current_cmd = message.get_setting(session, 'active') if message.attachments['sound']: try: r = Recognizer() mode = 'google' lang = 'ru-RUS' ans = '' for attachment in message.attachments['sound']: ext = attachment[1] path = os.path.abspath(os.curdir) fname = time.strftime("%Y%m%d-%H%M%S") + '.' dir = path + '/temp/' + fname urllib.request.urlretrieve( attachment[0], dir + ext) # getting file if ext != 'wav': subprocess.run(['ffmpeg', '-i', dir + ext, dir + 'wav']) os.remove(dir + ext) with AudioFile(dir + 'wav') as source: song = r.record(source) os.remove(dir + 'wav') if "en" in message.params: lang = 'en-EN' if 'wit' in message.params: mode = 'wit' recg = r.recognize_google( song, language=lang ) if mode == 'google' else r.recognize_wit(song, witkey) ans += f">>>>>>{recg}\n\n" yield ans except Exception as f: ans += "Произошла непредвиденная ошибка: " + str(f) + "\n" finally: if current_cmd: message.delete_active(session) yield str(ans) elif 'Выход' in message.params and current_cmd: message.delete_active(session) yield {'msg': 'Успешно!', 'keyboard': [[], False]} else: if current_cmd is None: message.add_setting(session, 'active', 'stt') yield {'msg': 'Прикрепите аудио или напишите Выход', 'keyboard': [[[('Выход', 'negative')]], False] }
def listen(self): try: with Microphone() as source: recognizer = Recognizer() recognizer.adjust_for_ambient_noise(source) audio = recognizer.listen(source) return recognizer.recognize_google(audio, language=self.lang).lower() except (UnknownValueError, RequestError): return ''
def gettingWordsFromMic(): mic = Microphone() recognizer = Recognizer() print("Say something...") print(Microphone.list_microphone_names()) with mic as source: recognizer.adjust_for_ambient_noise(source) audio = recognizer.listen(source) input("Press a key to process") print(recognizer.recognize_google(audio))
def speech_recog(file_name="input_sample/audio/introduction_ml.mp3", duration=10): convert_mp3_to_wav("input_sample/audio/introduction_ml.mp3") result = 0 class_audio = AudioFile("input_sample/audio/introduction_ml.wav") print(type(class_audio)) recongizer = Recognizer() with class_audio as src_audio: audio = recongizer.record(src_audio, duration=duration) print(recongizer.recognize_google(audio))
def on_listen(recognizer: sr.Recognizer, audio: sr.AudioData): l = len(audio.frame_data) / audio.sample_rate / audio.sample_width e, tr = energy(recognizer, audio) print(f'+{l:6.2f}s {e:6.2f}; [{recognizer.energy_threshold:.2f}]: ', end='') try: t = time() text = recognizer.recognize_google(audio, language='ru-RU').lower() except sr.UnknownValueError as e: print() else: dt = time() - t print(f'Вы сказали ({dt:5.2f}s): {text}')
def start(data): if data.endswith('.wav'): data = converter(data) else: print("Need Conversion") r = Recognizer() with AudioFile(data) as source: audio = r.listen(source) print("Status: Working\r", end="") query = r.recognize_google(audio) file = open("{}.txt".format(data.split('.')[0]), 'w') file.write(query) file.close() print(query)
def audio_to_text(message_input): # initialise the recognizer r = Recognizer() # Use the sysdefault microphone for i, microphone_name in enumerate(Microphone.list_microphone_names()): if microphone_name == "sysdefault": micro = Microphone(device_index=i) with micro as source: # Extract the audio and convert it to text audio = r.listen(source) # recognize speech using Google Speech Recognition and add it to the text input area try: message_input.setText(r.recognize_google(audio)) except UnknownValueError: message_input.setText('The audio was not understood')
class Listener: def __init__(self) -> None: super(Listener, self).__init__() self._recognizer = Recognizer() self._recognizer.energy_threshold = 4000 def listen(self) -> None: """Listens while the microphone is open and turns the audio into readable text.""" with Microphone() as source: print('listening...') self._recognizer.adjust_for_ambient_noise(source) audio_listened = self._recognizer.listen(source) text_listened: Any = self._recognizer.recognize_google( audio_listened, ) self.text: str = text_listened.lower()
def get_audio(): rObject = Recognizer() audio = '' with Microphone() as source: print("Speak...") # recording the audio using speech recognition audio = rObject.listen(source, phrase_time_limit=5) print("Stop.") # limit 5 secs try: text = rObject.recognize_google(audio, language='en-US') print("You: ", text) return text except: chatbot_speaks("Could not understand your audio, Please try again !") return 0
def myCommand(self): #listens for commands r = Recognizer() with Microphone() as source: print('Say something...') r.pause_threshold = 1 r.adjust_for_ambient_noise(source, duration=1) audio = r.listen(source) try: command = r.recognize_google(audio).lower() print('You said: ' + command + '\n') # loop back to continue to listen for commands if unrecognizable speech is received except UnknownValueError: print('....') command = speech.myCommand(self) return command
class VoiceService: def __init__(self): self.client = Recognizer() def capture_audio(self): with Microphone() as mic: audio = self.client.listen(mic) return audio def get_transcript(self, audio, show_all=False): return self.client.recognize_google(audio, show_all=show_all) def capture_and_transcribe_audio(self): audio = self.capture_audio() #print(type(audio)) #> <class 'speech_recognition.AudioData'> transcript = self.get_transcript(audio, show_all=False) return transcript.upper()
class Listener(object): def __init__(self): self.__recognizer = Recognizer() def __get_audio_from_file(self, filename, timeout=None, on_listen=None): with AudioFile(filename) as source: return self.__get_audio_from_source(source, timeout, on_listen) def __get_audio_from_microphone(self, timeout=None, on_listen=None): with Microphone() as source: self.__recognizer.adjust_for_ambient_noise(source, duration=1.0) return self.__get_audio_from_source(source, timeout, on_listen) def __get_audio_from_source(self, source, timeout=None, on_listen=None): if callable(on_listen): on_listen() return self.__recognizer.listen(source, timeout=timeout) def __recognize(self, audio, language, on_recognition=None): if callable(on_recognition): on_recognition() return self.__recognizer.recognize_google(audio, language=language) def get_text_from_audio(self, filename, language="en-us", timeout=None, on_listen=None, on_recognition=None): try: audio = self.__get_audio_from_file(filename, timeout, on_listen) return self.__recognize(audio, language, on_recognition) except FileNotFoundError as error: raise error except: return str() def speech_to_text(self, language="en-us", timeout=None, on_listen=None, on_recognition=None): try: audio = self.__get_audio_from_microphone(timeout, on_listen) return self.__recognize(audio, language, on_recognition) except: return str()
def listening_callback(recognizer: sr.Recognizer, audio) -> None: """ Callback to be called when a phrase was recorded :param recognizer: sr.Recognizer to be used :param audio: phrase as audio """ try: # try to use Google speech recognition to extract the text. # the Google one works best (out of the free ones) txt = recognizer.recognize_google(audio, language=config.recognizer_lang) log("text is: {0}".format(txt), remote=False) send_text_to_server(txt) except sr.UnknownValueError: # happens if the detected phrase is empty (= silence) or cannot be detected log("Unknown value", level=logging.ERROR, remote=False) except sr.RequestError: log("Request error", level=logging.ERROR)
def read_mic_input(r: sr.Recognizer, mic: sr.Microphone) -> Dict: """Use r to transcribe speech recorded from mic, and return a dictionary containing three keys: "success": boolean value indicating whether or not the recognizer's speech transcription was successful or not "error": 'None' if no error occured, or a string containing the error message if an error occured. "transcription": 'None' if speech could not be transcribed, or a string containing the transcribed text. """ with mic as source: # adjust the recognizer sensitivity to account for ambient noise r.adjust_for_ambient_noise(source, duration=0.3) # Record voice input from microhpone audio = r.listen(source) # intialize the response dictionary to be returned response = {"success": True, "error": None, "transcription": None} # Attempt to recognize speech in the recording try: response["transcription"] = r.recognize_google(audio).lower() # clean up the transcription of coordinates and measurements response["transcription"] = response["transcription"].replace("-", " ") response["transcription"] = response["transcription"].replace("/", " ") response["transcription"] = response["transcription"].replace( "\\", " ") response["transcription"] = response["transcription"].replace( " 00", " 0 0") # Update response object if a RequestError or UnknownValueError exception is # caught except sr.RequestError: # API was unreachable or unresponsive response["success"] = False response["error"] = "Error occurred with the API request." except sr.UnknownValueError: # speech could not be transcribed response["error"] = "Unable to recognize speech." return response
def listen(): r = Recognizer() # less writing with Microphone() as source: # using microphone to detect audio r.adjust_for_ambient_noise( source, duration=0.5) #adjust for ambiet sounds for 1 second audio = r.listen(source) # listen for audio data = '' # set data ad nothing try: # in case of errors data = r.recognize_google( audio) # recognize with google's speech recognition print('You said: ' + data) # write what was heard except UnknownValueError: # unknown audio print('I didn\'t get that') # when google api didn't understand audio data = 'None' # return none except RequestError as e: # request error print('Api or connection is not working.\n The error is {0}'.format( e)) # when connection or Api offline data = 'Broken' # return broken return data # return recognized audio as string
class RecognizerOfAudioSource(AudioSource): """Represent recogniser of audio source.""" def __init__(self) -> None: self._recogniser = Recognizer() def __enter__(self) -> Recognizer: return self._recogniser.__enter__() def __exit__(self, exc_type, exc_val, exc_tb) -> None: return self._recogniser.__exit__(exc_type, exc_val, exc_tb) @property def pause(self) -> int: """Return seconds of non-speaking audio before a phrase is considered complete""" return self._recogniser.pause_threshold @pause.setter def pause(self, seconds: int) -> None: if not isinstance(seconds, int): raise TypeError('Seconds should be <int> data type.') def configure_noise(self, source: Microphone, duration: int = 1) -> None: self._recogniser.adjust_for_ambient_noise(source, duration) def listen( self, source: Microphone, timeout: int = None, phrase_time_limit: int = None, config: str= None ) -> AudioData: return self._recogniser.listen(source, timeout, phrase_time_limit, config) def recognise_google( self, audio_data: AudioData, key: int = None, language: str = "en-US", show_all: bool = False ) -> str: return self._recogniser.recognize_google(audio_data, key, language, show_all).lower()
def record_and_recognise(r: sr.Recognizer) -> str: with sr.Microphone() as source: print("Слушаю..") r.pause_threshold = 1 r.adjust_for_ambient_noise(source, duration=1) audio = r.listen(source, phrase_time_limit=5) try: recognized = r.recognize_google(audio, language='ru-RU') if type(recognized) == list: recognized_string = " ".join(recognized) return recognized_string else: return recognized except sr.UnknownValueError: print( "Unknown sounds came from your mouth. Or perhaps we can't hear you." ) except sr.RequestError as e: print("Sound recognition exception; {0}".format(e))
async def process_audio(chat_id, msg): await bot.download_file(msg['voice']['file_id'], "./dest.ogg") filename = "dest.ogg" dest = "dest.flac" r = Recognizer() sound = AudioSegment.from_ogg(filename) os.unlink(filename) sound.export(dest, format="flac") with AudioFile(dest) as source: # listen for the data (load audio to memory) audio_data = r.record(source) # recognize (convert from speech to text) try: text = r.recognize_google(audio_data) print(f"VOICE LOG - {msg['from']['first_name']}: {text}") await process_result(chat_id, text) except UnknownValueError: await bot.sendMessage(chat_id, 'This audio is too short or corrupted, retry!') pass try: os.unlink(dest) except PermissionError: pass
def SpeechToText(): try: rec = Recognizer() with AudioFile(WAVE_OUTPUT_FILENAME) as AudioSrc: content = rec.record(AudioSrc) text = rec.recognize_google( audio_data=content, language='ko-KR', ) mainText = str(text) print('main-> ', mainText) return mainText # for sW in START_WORDS: # if mainText.startswith(sW): # return mainText.split(sW)[1] except (UnknownValueError): print("SPEECH ERROR!") return False
def solve(self): try: sleep(3) # Scrolling Down the Page pyautogui.scroll(-1000) # Locating and Clicking Captcha button on Page cap = pyautogui.locateCenterOnScreen("files/captcha.png") pyautogui.click(cap) try: sleep(3) # Locating and Clicking Headphones button on Page voi = pyautogui.locateCenterOnScreen("files/voice.png") pyautogui.click(voi) except: try: # Move out mouse from the voice button pyautogui.moveTo(200, 200) # Locate Voice2 Button that is little Gray pyautogui.locateCenterOnScreen("files/voice2.png") return self.error except: return self.done except: try: sleep(2) # Move out mouse from the voice button pyautogui.moveTo(200, 200) # Locate Voice2 Button that is little Gray pyautogui.locateCenterOnScreen("files/voice2.png") self.error[1] = "Captcha" return self.error except: return self.done sleep(2) try: # Locate and Right Click on the Download Button down = pyautogui.locateCenterOnScreen("files/down.png") pyautogui.rightClick(down) sleep(1) # Press down button 5 times pyautogui.press(['down'] * 5) sleep(1) # Press Enter (Cursor will be Copy Link Address) pyautogui.press('enter') # Download and Save that audio file from Link copied from above code with open('files/audio.mp3', 'wb') as file: r = ge(paste()) file.write(r.content) sleep(2) if path.exists('files/audio.mp3'): # Convert that mp3 file into wav using ffpmeg call([ 'files/ffmpeg.exe', '-i', 'files/audio.mp3', '-y', 'files/audio.wav' ]) sleep(2) AUDIO_FILE = 'files/audio.wav' # Code to Send That Audio File to Google and Recognize The Audio r = Recognizer() with AudioFile(AUDIO_FILE) as source: audio = r.record(source) try: # Get the Recognized Text capSolved = r.recognize_google(audio) # Go to the text field and write it there pyautogui.hotkey('shift', 'tab') pyautogui.typewrite(capSolved) pyautogui.press('enter') sleep(5) return self.done except UnknownValueError as e: return self.error except RequestError as e: return self.error except: self.error[1] = "Captcha" return self.error
from speech_recognition import Microphone, RequestError, Recognizer, UnknownValueError dir(sr) import pyaudio import webbrowser as wb r1 = Recognizer() # this is the recognizer class from speechRecognition r2 = Recognizer() r3 = Recognizer() with sr.Microphone as source: print('[search Google: search YouTube]') print('Speak Now!!') audio = r3.listen(source) if 'video' in r1.recognize_google(audio): r1 = Recognizer() url = 'https://www.youtube.com/results?search_query=' with sr.Microphone() as source: print('search your query') audio = r1.listen(source) try: get = r1.recognize_google(audio) print(get) wb.get().open_new(url + get) except UnknownValueError: print('error ') except RequestError as e: print('failed'.format(e))
from speech_recognition import Microphone, Recognizer recog=Recognizer() mic=Microphone() with mic: print("talk") audio=recog.listen(mic) recognize=recog.recognize_google(audio) print(recognize)