title: SpeechRecognition Error Python
body: <p>I have installed speech recognition both on python3 and python on raspbian when I try to run my python file I get the following error</p>
  
  <blockquote>
    <p>(hhsmartmirror) pi@raspberrypi:~/AI-Smart-Mirror $ python bot.py
    Traceback (most recent call last):   File "bot.py", line 13, in
    
        from speech import Speech   File "/home/pi/AI-Smart-Mirror/speech.py", line 3, in 
        import speech_recognition as sr ImportError: No module named speech_recognition</p>
  </blockquote>
  
  <p>code files:</p>
  
  <pre><code>#bot.py
  #speechrecognition, pyaudio, brew install portaudio
  import sys
  sys.path.append("./")
  
  import requests
  import datetime
  import dateutil.parser
  import json
  import traceback
  from nlg import NLG
  from speech import Speech
  from knowledge import Knowledge
  from vision import Vision
  
  my_name = "Aaron"
  launch_phrase = "ok mirror"
  use_launch_phrase = True
  weather_api_token = "Bearer d1e49b263abd08d422822b72b4c3eec4"
  wit_ai_token = "Bearer CL47LPKJWMNDNWPVMY4RPTZR3JDCZ2GZ"
  debugger_enabled = True
  camera = 0
  
  
  class Bot(object):
      def __init__(self):
          self.nlg = NLG(user_name=my_name)
          self.speech = Speech(launch_phrase=launch_phrase, debugger_enabled=debugger_enabled)
          self.knowledge = Knowledge(weather_api_token)
          self.vision = Vision(camera=camera)
  
      def start(self):
          """
          Main loop. Waits for the launch phrase, then decides an action.
          :return:
          """
          while True:
              requests.get("http://localhost:8080/clear")
              if self.vision.recognize_face():
                  print "Found face"
                  if use_launch_phrase:
                      recognizer, audio = self.speech.listen_for_audio()
                      if self.speech.is_call_to_action(recognizer, audio):
                          self.__acknowledge_action()
                          self.decide_action()
                  else:
                      self.decide_action()
  
      def decide_action(self):
          """
          Recursively decides an action based on the intent.
          :return:
          """
          recognizer, audio = self.speech.listen_for_audio()
  
          # received audio data, now we'll recognize it using Google Speech Recognition
          speech = self.speech.google_speech_recognition(recognizer, audio)
  
          if speech is not None:
              try:
                  r = requests.get('https://api.wit.ai/message?v=20160918&amp;q=%s' % speech,
                                   headers={"Authorization": wit_ai_token})
                  print r.text
                  json_resp = json.loads(r.text)
                  entities = None
                  intent = None
                  if 'entities' in json_resp and 'Intent' in json_resp['entities']:
                      entities = json_resp['entities']
                      intent = json_resp['entities']['Intent'][0]["value"]
  
                  print intent
                  if intent == 'greeting':
                      self.__text_action(self.nlg.greet())
                  elif intent == 'snow white':
                      self.__text_action(self.nlg.snow_white())
                  elif intent == 'weather':
                      self.__weather_action(entities)
                  elif intent == 'news':
                      self.__news_action()
                  elif intent == 'maps':
                      self.__maps_action(entities)
                  elif intent == 'holidays':
                      self.__holidays_action()
                  elif intent == 'appearance':
                      self.__appearance_action()
                  elif intent == 'user status':
                      self.__user_status_action(entities)
                  elif intent == 'user name':
                      self.__user_name_action()
                  elif intent == 'personal status':
                      self.__personal_status_action()
                  elif intent == 'joke':
                      self.__joke_action()
                  elif intent == 'insult':
                      self.__insult_action()
                      return
                  elif intent == 'appreciation':
                      self.__appreciation_action()
                      return
                  else: # No recognized intent
                      self.__text_action("I'm sorry, I don't know about that yet.")
                      return
  
              except Exception as e:
                  print "Failed wit!"
                  print(e)
                  traceback.print_exc()
                  self.__text_action("I'm sorry, I couldn't understand what you meant by that")
                  return
  
              self.decide_action()
  
      def __joke_action(self):
          joke = self.nlg.joke()
  
          if joke is not None:
              self.__text_action(joke)
          else:
              self.__text_action("I couldn't find any jokes")
  
      def __user_status_action(self, nlu_entities=None):
          attribute = None
  
          if (nlu_entities is not None) and ("Status_Type" in nlu_entities):
              attribute = nlu_entities['Status_Type'][0]['value']
  
          self.__text_action(self.nlg.user_status(attribute=attribute))
  
      def __user_name_action(self):
          if self.nlg.user_name is None:
              self.__text_action("I don't know your name. You can configure it in bot.py")
  
          self.__text_action(self.nlg.user_name)
  
      def __appearance_action(self):
          requests.get("http://localhost:8080/face")
  
      def __appreciation_action(self):
          self.__text_action(self.nlg.appreciation())
  
      def __acknowledge_action(self):
          self.__text_action(self.nlg.acknowledge())
  
      def __insult_action(self):
          self.__text_action(self.nlg.insult())
  
      def __personal_status_action(self):
          self.__text_action(self.nlg.personal_status())
  
      def __text_action(self, text=None):
          if text is not None:
              requests.get("http://localhost:8080/statement?text=%s" % text)
              self.speech.synthesize_text(text)
  
      def __news_action(self):
          headlines = self.knowledge.get_news()
  
          if headlines:
              requests.post("http://localhost:8080/news", data=json.dumps({"articles":headlines}))
              self.speech.synthesize_text(self.nlg.news("past"))
              interest = self.nlg.article_interest(headlines)
              if interest is not None:
                  self.speech.synthesize_text(interest)
          else:
              self.__text_action("I had some trouble finding news for you")
  
      def __weather_action(self, nlu_entities=None):
  
          current_dtime = datetime.datetime.now()
          skip_weather = False # used if we decide that current weather is not important
  
          weather_obj = self.knowledge.find_weather()
          temperature = weather_obj['temperature']
          icon = weather_obj['icon']
          wind_speed = weather_obj['windSpeed']
  
          weather_speech = self.nlg.weather(temperature, current_dtime, "present")
          forecast_speech = None
  
          if nlu_entities is not None:
              if 'datetime' in nlu_entities:
                  if 'grain' in nlu_entities['datetime'][0] and nlu_entities['datetime'][0]['grain'] == 'day':
                      dtime_str = nlu_entities['datetime'][0]['value'] # 2016-09-26T00:00:00.000-07:00
                      dtime = dateutil.parser.parse(dtime_str)
                      if current_dtime.date() == dtime.date(): # hourly weather
                          forecast_obj = {'forecast_type': 'hourly', 'forecast': weather_obj['daily_forecast']}
                          forecast_speech = self.nlg.forecast(forecast_obj)
                      elif current_dtime.date() &lt; dtime.date(): # sometime in the future ... get the weekly forecast/ handle specific days
                          forecast_obj = {'forecast_type': 'daily', 'forecast': weather_obj['weekly_forecast']}
                          forecast_speech = self.nlg.forecast(forecast_obj)
                          skip_weather = True
              if 'Weather_Type' in nlu_entities:
                  weather_type = nlu_entities['Weather_Type'][0]['value']
                  print weather_type
                  if weather_type == "current":
                      forecast_obj = {'forecast_type': 'current', 'forecast': weather_obj['current_forecast']}
                      forecast_speech = self.nlg.forecast(forecast_obj)
                  elif weather_type == 'today':
                      forecast_obj = {'forecast_type': 'hourly', 'forecast': weather_obj['daily_forecast']}
                      forecast_speech = self.nlg.forecast(forecast_obj)
                  elif weather_type == 'tomorrow' or weather_type == '3 day' or weather_type == '7 day':
                      forecast_obj = {'forecast_type': 'daily', 'forecast': weather_obj['weekly_forecast']}
                      forecast_speech = self.nlg.forecast(forecast_obj)
                      skip_weather = True
  
  
          weather_data = {"temperature": temperature, "icon": icon, 'windSpeed': wind_speed, "hour": datetime.datetime.now().hour}
          requests.post("http://localhost:8080/weather", data=json.dumps(weather_data))
  
          if not skip_weather:
              self.speech.synthesize_text(weather_speech)
  
          if forecast_speech is not None:
              self.speech.synthesize_text(forecast_speech)
  
      def __maps_action(self, nlu_entities=None):
  
          location = None
          map_type = None
          if nlu_entities is not None:
              if 'location' in nlu_entities:
                  location = nlu_entities['location'][0]["value"]
              if "Map_Type" in nlu_entities:
                  map_type = nlu_entities['Map_Type'][0]["value"]
  
          if location is not None:
              maps_url = self.knowledge.get_map_url(location, map_type)
              maps_action = "Sure. Here's a map of %s." % location
              body = {'url': maps_url}
              requests.post("http://localhost:8080/image", data=json.dumps(body))
              self.speech.synthesize_text(maps_action)
          else:
              self.__text_action("I'm sorry, I couldn't understand what location you wanted.")
  
      def __holidays_action(self):
          holidays = self.knowledge.get_holidays()
          next_holiday = self.__find_next_holiday(holidays)
          requests.post("http://localhost:8080/holidays", json.dumps({"holiday": next_holiday}))
          self.speech.synthesize_text(self.nlg.holiday(next_holiday['localName']))
  
      def __find_next_holiday(self, holidays):
          today = datetime.datetime.now()
          for holiday in holidays:
              date = holiday['date']
              if (date['day'] &gt; today.day) and (date['month'] &gt; today.month):
                  return holiday
  
          # next year
          return holidays[0]
  
  if __name__ == "__main__":
      bot = Bot()
      bot.start()
  
  
  
  
  
  
  
  
  
  
  
  
  # speech.py
  # speechrecognition, pyaudio, brew install portaudio
  import speech_recognition as sr
  import os
  import requests
  from gtts import gTTS
  from pydub import AudioSegment
  from pydub.playback import play
  
  
  class Speech(object):
      def __init__(self, launch_phrase="mirror mirror", debugger_enabled=False):
          self.launch_phrase = launch_phrase
          self.debugger_enabled = debugger_enabled
          self.__debugger_microphone(enable=False)
  
      def google_speech_recognition(self, recognizer, audio):
          speech = None
          try:
              speech = recognizer.recognize_google(audio)
              print("Google Speech Recognition thinks you said " + speech)
          except sr.UnknownValueError:
              print("Google Speech Recognition could not understand audio")
          except sr.RequestError as e:
              print("Could not request results from Google Speech Recognition service; {0}".format(e))
  
          return speech
  
      def listen_for_audio(self):
          # obtain audio from the microphone
          r = sr.Recognizer()
          m = sr.Microphone()
          with m as source:
              r.adjust_for_ambient_noise(source)
              self.__debugger_microphone(enable=True)
              print "I'm listening"
              audio = r.listen(source)
  
          self.__debugger_microphone(enable=False)
          print "Found audio"
          return r, audio
  
      def is_call_to_action(self, recognizer, audio):
          speech = self.google_speech_recognition(recognizer, audio)
  
          if speech is not None and self.launch_phrase in speech.lower():
              return True
  
          return False
  
      def synthesize_text(self, text):
          tts = gTTS(text=text, lang='en')
          tts.save("tmp.mp3")
          song = AudioSegment.from_mp3("tmp.mp3")
          play(song)
          os.remove("tmp.mp3")
  
      def __debugger_microphone(self, enable=True):
          if self.debugger_enabled:
              try:
                  r = requests.get("http://localhost:8080/microphone?enabled=%s" % str(enable))
                  if r.status_code != 200:
                      print("Used wrong endpoint for microphone debugging")
              except Exception as e:
                  print(e)
  </code></pre>