title: How to continuously to do speech recognition while outputting the recognized word as soon as possible
body: <p>I am working on a project that involves speech recognition using the SpeechRecognition module. One thing I want to do to improve my speech recognition is to  be able to output the words that have been recognized as soon as possible. I want it to be similar to whenever you speak into Google Translate, as soon as you say a word it outputs it on the screen to let you know that you have said it. </p>
  
  <p>Some of the things I have tried are to have an array that stores separate audio recordings and have speech recognition iterate through the array recognizing each audio recording and then outputting that. This did not work because different words take different times to say. </p>
  
  <p>I looked further into the Google API for speech recognition given to me by the SpeechRecognition module and wanted to see how I could adjust the actual library by adding print statements in some places to achieve the goal. I did not know where to put, as I am a beginner in speech recognition and that I do not know much about the Google Speech Recognition API.</p>
  
  <p>Here is the google api code, it accesses the cloud to do sr.</p>
  
  <pre><code>def recognize_google(self, audio_data, key=None, language="en-US", show_all=False):
          """
          Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Google Speech Recognition API.
  
          The Google Speech Recognition API key is specified by ``key``. If not specified, it uses a generic key that works out of the box. This should generally be used for personal or testing purposes only, as it **may be revoked by Google at any time**.
  
          To obtain your own API key, simply following the steps on the `API Keys &lt;http://www.chromium.org/developers/how-tos/api-keys&gt;`__ page at the Chromium Developers site. In the Google Developers Console, Google Speech Recognition is listed as "Speech API".
  
          The recognition language is determined by ``language``, an RFC5646 language tag like ``"en-US"`` (US English) or ``"fr-FR"`` (International French), defaulting to US English. A list of supported language tags can be found in this `StackOverflow answer &lt;http://stackoverflow.com/a/14302134&gt;`__.
  
          Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the raw API response as a JSON dictionary.
  
          Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
          """
          assert isinstance(audio_data, AudioData), "``audio_data`` must be audio data"
          assert key is None or isinstance(key, str), "``key`` must be ``None`` or a string"
          assert isinstance(language, str), "``language`` must be a string"
  
          flac_data = audio_data.get_flac_data(
              convert_rate=None if audio_data.sample_rate &gt;= 8000 else 8000,  # audio samples must be at least 8 kHz
              convert_width=2  # audio samples must be 16-bit
          )
          if key is None: key = "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw"
          url = "http://www.google.com/speech-api/v2/recognize?{}".format(urlencode({
              "client": "chromium",
              "lang": language,
              "key": key,
          }))
          request = Request(url, data=flac_data, headers={"Content-Type": "audio/x-flac; rate={}".format(audio_data.sample_rate)})
  
          # obtain audio transcription results
          try:
              response = urlopen(request, timeout=self.operation_timeout)
          except HTTPError as e:
              raise RequestError("recognition request failed: {}".format(e.reason))
          except URLError as e:
              raise RequestError("recognition connection failed: {}".format(e.reason))
          response_text = response.read().decode("utf-8")
  
          # ignore any blank blocks
          actual_result = []
          for line in response_text.split("\n"):
              if not line: continue
              result = json.loads(line)["result"]
              if len(result) != 0:
                  actual_result = result[0]
                  print(actual_result)
                  sleep(1000)
                  break
  
          # return results
          if show_all: return actual_result
          if not isinstance(actual_result, dict) or len(actual_result.get("alternative", [])) == 0: raise UnknownValueError()
  
          if "confidence" in actual_result["alternative"]:
              # return alternative with highest confidence score
              best_hypothesis = max(actual_result["alternative"], key=lambda alternative: alternative["confidence"])
          else:
              # when there is no confidence available, we arbitrarily choose the first hypothesis.
              best_hypothesis = actual_result["alternative"][0]
          if "transcript" not in best_hypothesis: raise UnknownValueError()
          return best_hypothesis["transcript"]
  </code></pre>
  
  <p>Here is my base code (the things I previously tried are not shown here): It is able to successfully do speech recognition.  </p>
  
  <pre><code>r = sr.Recognizer()
  m = sr.Microphone(); 
  
  r = sr.Recognizer()
  on = True 
  while on :
      with sr.Microphone() as source:
          audio = r.listen(source)
  
          try:
              text = r.recognize_google(audio)
              print("You said: {}".format(text))
          except:
              print("Sorry, we did not recognize your voice")
  </code></pre>
  
  <p>The final method you should know is the recording function to make audio files or objects: </p>
  
  <pre><code>def listen(self, source, timeout=None, phrase_time_limit=None, snowboy_configuration=None):
          """
          Records a single phrase from ``source`` (an ``AudioSource`` instance) into an ``AudioData`` instance, which it returns.
  
          This is done by waiting until the audio has an energy above ``recognizer_instance.energy_threshold`` (the user has started speaking), and then recording until it encounters ``recognizer_instance.pause_threshold`` seconds of non-speaking or there is no more audio input. The ending silence is not included.
  
          The ``timeout`` parameter is the maximum number of seconds that this will wait for a phrase to start before giving up and throwing an ``speech_recognition.WaitTimeoutError`` exception. If ``timeout`` is ``None``, there will be no wait timeout.
  
          The ``phrase_time_limit`` parameter is the maximum number of seconds that this will allow a phrase to continue before stopping and returning the part of the phrase processed before the time limit was reached. The resulting audio will be the phrase cut off at the time limit. If ``phrase_timeout`` is ``None``, there will be no phrase time limit.
  
          The ``snowboy_configuration`` parameter allows integration with `Snowboy &lt;https://snowboy.kitt.ai/&gt;`__, an offline, high-accuracy, power-efficient hotword recognition engine. When used, this function will pause until Snowboy detects a hotword, after which it will unpause. This parameter should either be ``None`` to turn off Snowboy support, or a tuple of the form ``(SNOWBOY_LOCATION, LIST_OF_HOT_WORD_FILES)``, where ``SNOWBOY_LOCATION`` is the path to the Snowboy root directory, and ``LIST_OF_HOT_WORD_FILES`` is a list of paths to Snowboy hotword configuration files (`*.pmdl` or `*.umdl` format).
  
          This operation will always complete within ``timeout + phrase_timeout`` seconds if both are numbers, either by returning the audio data, or by raising a ``speech_recognition.WaitTimeoutError`` exception.
          """
          assert isinstance(source, AudioSource), "Source must be an audio source"
          assert source.stream is not None, "Audio source must be entered before listening, see documentation for ``AudioSource``; are you using ``source`` outside of a ``with`` statement?"
          assert self.pause_threshold &gt;= self.non_speaking_duration &gt;= 0
          if snowboy_configuration is not None:
              assert os.path.isfile(os.path.join(snowboy_configuration[0], "snowboydetect.py")), "``snowboy_configuration[0]`` must be a Snowboy root directory containing ``snowboydetect.py``"
              for hot_word_file in snowboy_configuration[1]:
                  assert os.path.isfile(hot_word_file), "``snowboy_configuration[1]`` must be a list of Snowboy hot word configuration files"
  
          seconds_per_buffer = float(source.CHUNK) / source.SAMPLE_RATE
          pause_buffer_count = int(math.ceil(self.pause_threshold / seconds_per_buffer))  # number of buffers of non-speaking audio during a phrase, before the phrase should be considered complete
          phrase_buffer_count = int(math.ceil(self.phrase_threshold / seconds_per_buffer))  # minimum number of buffers of speaking audio before we consider the speaking audio a phrase
          non_speaking_buffer_count = int(math.ceil(self.non_speaking_duration / seconds_per_buffer))  # maximum number of buffers of non-speaking audio to retain before and after a phrase
  
          # read audio input for phrases until there is a phrase that is long enough
          elapsed_time = 0  # number of seconds of audio read
          buffer = b""  # an empty buffer means that the stream has ended and there is no data left to read
          while True:
              frames = collections.deque()
  
              if snowboy_configuration is None:
                  # store audio input until the phrase starts
                  while True:
                      # handle waiting too long for phrase by raising an exception
                      elapsed_time += seconds_per_buffer
                      if timeout and elapsed_time &gt; timeout:
                          raise WaitTimeoutError("listening timed out while waiting for phrase to start")
  
                      buffer = source.stream.read(source.CHUNK)
                      if len(buffer) == 0: break  # reached end of the stream
                      frames.append(buffer)
                      if len(frames) &gt; non_speaking_buffer_count:  # ensure we only keep the needed amount of non-speaking buffers
                          frames.popleft()
  
                      # detect whether speaking has started on audio input
                      energy = audioop.rms(buffer, source.SAMPLE_WIDTH)  # energy of the audio signal
                      if energy &gt; self.energy_threshold: break
  
                      # dynamically adjust the energy threshold using asymmetric weighted average
                      if self.dynamic_energy_threshold:
                          damping = self.dynamic_energy_adjustment_damping ** seconds_per_buffer  # account for different chunk sizes and rates
                          target_energy = energy * self.dynamic_energy_ratio
                          self.energy_threshold = self.energy_threshold * damping + target_energy * (1 - damping)
              else:
                  # read audio input until the hotword is said
                  snowboy_location, snowboy_hot_word_files = snowboy_configuration
                  buffer, delta_time = self.snowboy_wait_for_hot_word(snowboy_location, snowboy_hot_word_files, source, timeout)
                  elapsed_time += delta_time
                  if len(buffer) == 0: break  # reached end of the stream
                  frames.append(buffer)
  
              # read audio input until the phrase ends
              pause_count, phrase_count = 0, 0
              phrase_start_time = elapsed_time
              while True:
                  # handle phrase being too long by cutting off the audio
                  elapsed_time += seconds_per_buffer
                  if phrase_time_limit and elapsed_time - phrase_start_time &gt; phrase_time_limit:
                      break
  
                  buffer = source.stream.read(source.CHUNK)
                  if len(buffer) == 0: break  # reached end of the stream
                  frames.append(buffer)
                  phrase_count += 1
  
                  # check if speaking has stopped for longer than the pause threshold on the audio input
                  energy = audioop.rms(buffer, source.SAMPLE_WIDTH)  # unit energy of the audio signal within the buffer
                  if energy &gt; self.energy_threshold:
                      pause_count = 0
                  else:
                      pause_count += 1
                  if pause_count &gt; pause_buffer_count:  # end of the phrase
                      break
  
              # check how long the detected phrase is, and retry listening if the phrase is too short
              phrase_count -= pause_count  # exclude the buffers for the pause before the phrase
              if phrase_count &gt;= phrase_buffer_count or len(buffer) == 0: break  # phrase is long enough or we've reached the end of the stream, so stop listening
  
          # obtain frame data
          for i in range(pause_count - non_speaking_buffer_count): frames.pop()  # remove extra non-speaking frames at the end
          frame_data = b"".join(frames)
  
          return AudioData(frame_data, source.SAMPLE_RATE, source.SAMPLE_WIDTH)
  </code></pre>
  
  <p>I would like to achieve software that is able to take the current code and implement in such a way it outputs the recognized word as soon as possible. It would be similar to when you speak in Google Translate.</p>