def speech_to_text(f):
# Creates an instance of a speech config with specified subscription key and service region.
# Replace with your own subscription key and region identifier from here: https://aka.ms/speech/sdkregion
speech_key, service_region = "2a9ce48acf3b4e31bd16ad0dadbe287b", "centralindia"
speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
# Creates an audio configuration that points to an audio file.
# Replace with your own audio filename.
audio_filename = f
audio_input = speechsdk.audio.AudioConfig(filename=audio_filename)
# Creates a recognizer with the given settings
speech_config.speech_recognition_language="en-IN"
#speech_config.request_word_level_timestamps()
#speech_config.enable_dictation()
speech_config.output_format = speechsdk.OutputFormat(1)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_input)
#result = speech_recognizer.recognize_once()
all_results = []
#https://docs.microsoft.com/en-us/python/api/azure-cognitiveservices-speech/azure.cognitiveservices.speech.recognitionresult?view=azure-python
def handle_final_result(evt):
all_results.append(evt.result.text)
done = False
def stop_cb(evt):
print('CLOSING on {}'.format(evt))
speech_recognizer.stop_continuous_recognition()
nonlocal done
done= True
#Appends the recognized text to the all_results variable.
speech_recognizer.recognized.connect(handle_final_result)
#Connect callbacks to the events fired by the speech recognizer & displays the info/status
#Ref:https://docs.microsoft.com/en-us/python/api/azure-cognitiveservices-speech/azure.cognitiveservices.speech.eventsignal?view=azure-python
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))
# stop continuous recognition on either session stopped or canceled events
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
#print("Printing all results:")
#print(all_results)
return all_results
def transcript(audio_filepath):
logger.debug("Speech to text request received")
locale = "en-US" # Change as per requirement
logger.debug(audio_filepath)
audio_config = speechsdk.audio.AudioConfig(filename=audio_filepath)
speech_config = speechsdk.SpeechConfig(subscription=speech_key,
region=service_region)
speech_config.request_word_level_timestamps()
speech_config.speech_recognition_language = locale
speech_config.output_format = speechsdk.OutputFormat(1)
# Creates a recognizer with the given settings
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config,
audio_config=audio_config)
#speech_recognizer.recognized.connect(lambda evt: print('JSON: {}'.format(evt.result.json)))
# Variable to monitor status
done = False
# Service callback for recognition text
transcript_display_list = []
def parse(evt):
stt = json.loads(evt.result.json)
transcript_display_list.append(stt['DisplayText'])
# Service callback that stops continuous recognition upon receiving an event `evt`
def stop_cb(evt):
print('CLOSING on {}'.format(evt))
speech_recognizer.stop_continuous_recognition()
nonlocal done
done = True
# Do something with the combined responses
print(transcript_display_list)
# Connect callbacks to the events fired by the speech recognizer
speech_recognizer.recognizing.connect(
lambda evt: logger.debug('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(parse)
speech_recognizer.session_started.connect(
lambda evt: logger.debug('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(
lambda evt: logger.debug('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(
lambda evt: logger.debug('CANCELED {}'.format(evt)))
# stop continuous recognition on either session stopped or canceled events
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
# Start continuous speech recognition
logger.debug("Initiating speech to text")
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
return transcript_display_list
def get_speech_recognizer(audio_filename):
logger.info("Loading speech recognizer from " + audio_filename)
audio_input = speechsdk.audio.AudioConfig(filename=audio_filename)
speech_config.speech_recognition_language = "en-US"
speech_config.request_word_level_timestamps()
speech_config.enable_dictation()
speech_config.output_format = speechsdk.OutputFormat(1)
return speechsdk.SpeechRecognizer(speech_config=speech_config,
audio_config=audio_input)
def stt_azure(videoID):
audioFile = videoID + '.wav'
print('[LOG] - Audio file name: ', audioFile)
speech_key, service_region = "", ""
speech_config = speechsdk.SpeechConfig(subscription=speech_key,
region=service_region)
audio_input = speechsdk.audio.AudioConfig(filename=audioFile)
speech_config.speech_recognition_language = "en-US"
speech_config.request_word_level_timestamps()
speech_config.enable_dictation()
speech_config.output_format = speechsdk.OutputFormat(1)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config,
audio_config=audio_input)
all_results = []
def handle_final_result(evt):
all_results.append(evt.result.text)
done = False
def stop_cb(evt):
print('CLOSING on {}'.format(evt))
speech_recognizer.stop_continuous_recognition()
nonlocal done
done = True
speech_recognizer.recognized.connect(handle_final_result)
speech_recognizer.recognizing.connect(
lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(
lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(
lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(
lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(
lambda evt: print('CANCELED {}'.format(evt)))
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
return (all_results)
def speech_recognize_from_microphone():
"""performs keyword-triggered speech recognition with input microphone"""
speech_config = speechsdk.SpeechConfig(subscription=speech_key,
region=service_region)
speech_config.request_word_level_timestamps()
speech_config.output_format = speechsdk.OutputFormat(1)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)
done = False
def stop_cb(evt):
"""callback that signals to stop continuous recognition upon receiving an event `evt`"""
print('CLOSING on {}'.format(evt))
nonlocal done
done = True
def recognized_cb(evt):
"""callback for recognized event"""
if evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
#print('RECOGNIZED: {}'.format(evt.result.text))
#print('All params: {}'.format(evt.result))
#print(evt.result.json)
response = json.loads(evt.result.json)
#print('All params: {}'.format(response))
Text = response["DisplayText"]
duration = 0
for word in response["NBest"][0]["Words"]:
duration += word["Duration"]
duration = duration / 10000000
print("dur :" + str(duration) + " text: " + Text)
# Connect callbacks to the events fired by the speech recognizer
speech_recognizer.recognized.connect(recognized_cb)
speech_recognizer.session_started.connect(
lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(
lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(
lambda evt: print('CANCELED {}'.format(evt)))
# stop continuous recognition on either session stopped or canceled events
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
# Start keyword recognition
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
speech_recognizer.stop_continuous_recognition()
def leang_ai(filename, outfile):
# add your code here
import azure.cognitiveservices.speech as speechsdk
import time
import datetime
# Creates an instance of a speech config with specified subscription key and service region.
# Replace with your own subscription key and region identifier from here: https://aka.ms/speech/sdkregion
speech_key, service_region = os.environ["SPEECH_KEY"], os.environ["SERVICE_REGION"]
speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
# Creates an audio configuration that points to an audio file.
# Replace with your own audio filename.
#audio_filename = "see_you_again2.wav"
audio_filename = filename
audio_config = speechsdk.audio.AudioConfig(filename=audio_filename)
# Creates a recognizer with the given settings
speech_config.speech_recognition_language="en-US"
speech_config.request_word_level_timestamps()
speech_config.enable_dictation()
speech_config.output_format = speechsdk.OutputFormat(1)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
#result = speech_recognizer.recognize_once()
all_results = []
#https://docs.microsoft.com/en-us/python/api/azure-cognitiveservices-speech/azure.cognitiveservices.speech.recognitionresult?view=azure-python
def handle_final_result(evt):
all_results.append(evt.result.text+"\n")
with open(outfile,"a") as fl:
fl.writelines(evt.result.text+"\n")
fl.save(outfile)
done = False
def stop_cb(evt):
print('CLOSING on {}'.format(evt))
speech_recognizer.stop_continuous_recognition_async()
nonlocal done
done= True
#Appends the recognized text to the all_results variable.
speech_recognizer.recognized.connect(handle_final_result)
#Connect callbacks to the events fired by the speech recognizer & displays the info/status
#Ref:https://docs.microsoft.com/en-us/python/api/azure-cognitiveservices-speech/azure.cognitiveservices.speech.eventsignal?view=azure-python
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
#speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
#speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
#speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))
# stop continuous recognition on either session stopped or canceled events
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
#speechText = "Your Result."
return ' '.join(map(str,all_results))
with open('cred.yaml', 'r') as f:
cred = yaml.safe_load(f.read())
# Create SDK config
speech_key, service_region = cred["speech_key"], "westeurope"
speech_config = speechsdk.SpeechConfig(subscription=speech_key,
region=service_region)
# Creates a recognizer with the given settings
speech_config.speech_recognition_language = "en-US"
speech_config.request_word_level_timestamps()
audio_config = speechsdk.audio.AudioConfig(filename="audio.wav")
speech_config.enable_dictation() # TODO: is this really necessary?
speech_config.output_format = speechsdk.OutputFormat(1)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config,
audio_config=audio_config)
all_results = []
results = []
transcript = []
words = []
done = False
def stop_cb(evt):
print('CLOSING on {}'.format(evt))
speech_recognizer.stop_continuous_recognition()
global done