How to convert speech to text in kivy

In the code examples for SpeechRecognition, it appears that your line:

with sr.Microphone as self.source:

should actually be :

with sr.Microphone() as self.source:

I am building a drawing program that uses speech input, so I to, have been working with kivy and speech_recognition. Here is my code it is broken across to py files. I hope this helps. I found this while trying to figure out how to make the speech to text non-blocking. So if you figure that out or someone else does it would be good to know. I just started looking so maybe I will get a solution in the next few minutes. (I hope) I suppose I could use multiple threads but there are probably some hooks in kivy or speech_recognition that will let me do it more easily.

#Input_Loop.py
import sys

# https://www.techwithtim.net/tutorials/kivy-tutorial/simple-drawing-app/


from kivy.config import Config  # disable multy touch simulation
Config.set('input', 'mouse', 'mouse,multitouch_on_demand')

import kivy
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.uix.label import Label

from kivy.graphics import Rectangle
from kivy.graphics import Color
from kivy.graphics import Line

from kivy.graphics import Ellipse
from kivy.core.window import Window

import Free_Google_ASR
import speech_recognition as sr

print("User Current Version:-", sys.version)

class Touch(Widget):
    #point_log = ()


    def __init__(self, **kwargs):
        super(Touch, self).__init__(**kwargs)
        self.asr = Free_Google_ASR.Free_Google_ASR()
        #with self.canvas:
            #Color(1, 0, 0, 1, mode='rgba')
            #self.rect = Rectangle(pos=(0, 0), size=(50, 50))
        self.mode = 'draw'

        self._keyboard = Window.request_keyboard(
            self._keyboard_closed, self, 'text')
        if self._keyboard.widget:
            # If it exists, this widget is a VKeyboard object which you can use
            # to change the keyboard layout.
            pass
        self._keyboard.bind(on_key_down=self._on_keyboard_down)
        self._keyboard.bind(on_key_up=self._on_keyboard_up)

        self.lines = []

    def on_touch_down(self, touch):
        self.point_log = ()

        print("Mouse down", touch)

    def on_touch_move(self, touch):
        with self.canvas:
            self.point_log += touch.pos
            if len(self.point_log) >= 4:
                Color(0, 1, 0, 1, mode='rgba')
                self.line = Line(points=self.point_log)
        print("Mouse move", touch)

    def on_touch_up(self, touch):
        print("Mouse up", touch)

    def _keyboard_closed(self):
        print('My keyboard have been closed!')
        self._keyboard.unbind(on_key_down=self._on_keyboard_down)
        self._keyboard.unbind(on_key_up=self._on_keyboard_up)
        self._keyboard = None

    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
        print('The key', keycode, 'have been pressed')
        if text == 'f':
            r = self.asr.get_command()
            print(r)
        print(' - text is %r' % text)
        print(' - modifiers are %r' % modifiers)
        self.mode = keycode
        # Keycode is composed of an integer + a string
        # If we hit escape, release the keyboard
        if keycode[1] == 'escape':
            keyboard.release()
        # Return True to accept the key. Otherwise, it will be used by
        # the system.
        return True

    def _on_keyboard_up(self, key, scancode, *args):
        print("key up", scancode[1])
        #print('The key', key, 'have been released')
        #print(' - scancode is %r' % scancode)
        #print(' - codepoint are %r' % codepoint)
        self.mode = 'draw'
        return True

class MyApp_2(App):
    def build(self):
        return Touch()

class MyApp(App):
    def build(self):
        return Label(text="Hello World")

if __name__ == '__main__':
    MyApp_2().run()



#Free_Google_ASR.py
import speech_recognition as sr

class Free_Google_ASR:

    def __init__(self):
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
        # check that recognizer and microphone arguments are appropriate type
        if not isinstance(self.recognizer, sr.Recognizer):
            raise TypeError("`recognizer` must be `Recognizer` instance")

        if not isinstance(self.microphone, sr.Microphone):
            raise TypeError("`microphone` must be `Microphone` instance")


        # set up the response object
        self.response = {
            "success": True,
            "error": None,
            "transcription": None
        }

        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            print("ready!")

    def get_command(self):

        # adjust the recognizer sensitivity to ambient noise and record audio
        # from the microphone

        with self.microphone as source:
            print("started listening")
            self.audio = self.recognizer.listen(source)
            print("got something")

        # try recognizing the speech in the recording
        # if a RequestError or UnknownValueError exception is caught,
        #     update the response object accordingly
        try:
            self.response["transcription"] = self.recognizer.recognize_google(self.audio)
        except sr.RequestError:
            # API was unreachable or unresponsive
            self.response["success"] = False
            self.response["error"] = "API unavailable"
        except sr.UnknownValueError:
            # speech was unintelligible
            self.response["error"] = "Unable to recognize speech"

        return self.response

    def test_loop(self):
        while(True):
            i = 0
            while(True):
                guess = self.get_command()
                if guess["transcription"]:
                    break
                if not guess["success"]:
                    break
                print(i, ": I didn't catch that. What did you say?\n")
                i+=1
                # if there was an error, stop the game
            if guess["error"]:
                print("ERROR: {}".format(guess["error"]))
                break
            # show the user the transcription
            print("You said: {}".format(guess["transcription"]))