linting #78

Author: previ

api.py

@@ -3,19 +3,16 @@
 This file contains every method called by the API defined in v2.yml
 """
 
-from flask import jsonify
+import os
+import subprocess
 import json
-from coderbot import CoderBot
-from program import ProgramEngine, Program
-from config import Config
 import connexion
-import time
-import sqlite3
 from tinydb import TinyDB, Query
 from tinydb.operations import delete
-import os
-import subprocess
 from cachetools import cached, TTLCache
+from coderbot import CoderBot
+from program import ProgramEngine
+from config import Config
 
 bot_config = Config.get()
 bot = CoderBot.get_instance(
@@ -24,20 +21,20 @@
 )
 
 def get_serial():
-  """
-  Extract serial from cpuinfo file
-  """
-  cpuserial = "0000000000000000"
-  try:
-    f = open('/proc/cpuinfo','r')
-    for line in f:
-      if line[0:6]=='Serial':
-        cpuserial = line[10:26]
-    f.close()
-  except:
-    cpuserial = "ERROR000000000"
-
-  return cpuserial
+    """
+    Extract serial from cpuinfo file
+    """
+    cpuserial = "0000000000000000"
+    try:
+        f = open('/proc/cpuinfo', 'r')
+        for line in f:
+            if line[0:6] == 'Serial':
+                cpuserial = line[10:26]
+        f.close()
+    except Exception:
+        cpuserial = "ERROR000000000"
+
+    return cpuserial
 
 @cached(cache=TTLCache(maxsize=1, ttl=10))
 def get_status():
@@ -47,10 +44,10 @@ def get_status():
     (Cached method)
     """
     try:
-        temp = os.popen("vcgencmd measure_temp").readline().replace("temp=","")
-    except:
+        temp = os.popen("vcgencmd measure_temp").readline().replace("temp=", "")
+    except Exception:
         temp = "undefined"
-    
+
     uptime = subprocess.check_output(["uptime"]).decode('utf-8').replace('\n', '')
     internet_status = subprocess.check_output(["./utils/check_conn.sh"]).decode('utf-8').replace('\n', '')
     return {'internet_status': internet_status,
@@ -68,28 +65,28 @@ def get_info():
         with open('manifest.json', 'r') as f:
             metadata = json.load(f)
         backend_commit = metadata["backendCommit"][0:7]
-    except:
+    except Exception:
         backend_commit = "undefined"
 
     try:
         coderbot_version = subprocess.check_output(["cat", "/etc/coderbot/version"]).decode('utf-8').replace('\n', '')
-    except:
-        coderbot_version  = 'undefined'
+    except Exception:
+        coderbot_version = 'undefined'
     try:
         kernel = subprocess.check_output(["uname", "-r"]).decode('utf-8').replace('\n', '')
-    except:
+    except Exception:
         kernel = 'undefined'
     try:
         update_status = subprocess.check_output(["cat", "/etc/coderbot/update_status"]).decode('utf-8').replace('\n', '')
-    except:
+    except Exception:
         update_status = 'undefined'
 
-    serial = get_serial();
-    return {'backend_commit':backend_commit,
-            'coderbot_version':coderbot_version,
+    serial = get_serial()
+    return {'backend_commit': backend_commit,
+            'coderbot_version': coderbot_version,
             'update_status': update_status,
-            'kernel':kernel,
-            'serial':serial}
+            'kernel': kernel,
+            'serial': serial}
 
 prog = None
 prog_engine = ProgramEngine.get_instance()
@@ -100,7 +97,7 @@ def get_info():
 
 query = Query()
 
-## Robot control 
+## Robot control
 
 def stop():
     bot.stop()
@@ -117,36 +114,36 @@ def turn(data):
     return 200
 
 def exec(data):
-    prog = prog_engine.create(data["name"], data["code"])
-    return json.dumps(prog.execute())
+    program = prog_engine.create(data["name"], data["code"])
+    return json.dumps(program.execute())
 
 ## System
 
 def status():
-    status = get_status()
+    sts = get_status()
 
     return {
         "status": "ok",
-        "internetConnectivity": status["internet_status"],
-        "temp": status["temp"],
-        "uptime": status["uptime"],
+        "internetConnectivity": sts["internet_status"],
+        "temp": sts["temp"],
+        "uptime": sts["uptime"],
     }
 
 def info():
-    info = get_info()
+    inf = get_info()
     return {
         "model": 1,
-        "version": info["coderbot_version"],
-        "backend commit build": info["backend_commit"],
-        "kernel" : info["kernel"],
-        "update status": info["update_status"],
-        "serial": info["serial"]
+        "version": inf["coderbot_version"],
+        "backend commit build": inf["backend_commit"],
+        "kernel" : inf["kernel"],
+        "update status": inf["update_status"],
+        "serial": inf["serial"]
     }
 
 def restoreSettings():
     with open("data/defaults/config.json") as f:
         Config.write(json.loads(f.read()))
-    bot_config = Config.get()
+    Config.get()
     return "ok"
 
 def updateFromPackage():
@@ -171,7 +168,7 @@ def saveProgram(data, overwrite):
             return "defaultOverwrite"
         # Overwrite existing program with the same name
         else:
-            if (overwrite == "1"):
+            if overwrite == "1":
                 programs.update(data, query.name == data["name"])
                 return 200
             else:

audio.py

@@ -18,34 +18,19 @@
 ############################################################################
 
 import os
-import time
-from sys import byteorder
 from array import array
-from struct import pack
+import time
 import logging
-
-import pyaudio
 import wave
 import audioop
-import logging
+import pyaudio
 
 try:
     from pocketsphinx.pocketsphinx import Decoder
     from sphinxbase.sphinxbase import *
-except:
+except Exception:
     logging.info("pocketsphinx not available")
 
-## GOOGLE Speech API ##
-# [START import_libraries]
-#from __future__ import division
-
-import re
-import sys
-
-#from google.cloud import speech
-#from google.cloud.speech import enums
-#from google.cloud.speech import types
-import pyaudio
 from six.moves import queue
 # [END import_libraries]
 
@@ -76,7 +61,7 @@ def __init__(self):
             #  frames_per_buffer=CHUNK)
             #self.stream_in.start_stream()
             self.stream_in = self.MicrophoneStream(FORMAT, RATE, CHUNK)
-        except Exception as e:
+        except Exception:
             logging.info("Audio: input stream not available")
 
         #self._google_speech_client = speech.SpeechClient()
@@ -89,36 +74,32 @@ def exit(self):
 
     def say(self, what, locale='en'):
         if what and "$" in what:
-            os.system ('omxplayer sounds/' + what[1:])
-        elif what and len(what):
-            os.system ('espeak --stdout -v' + locale + ' -p 90 -a 200 -s 150 -g 10 "' + what + '" 2>>/dev/null | aplay -D hw:1,0')
+            os.system('omxplayer sounds/' + what[1:])
+        elif what and what:
+            os.system('espeak --stdout -v' + locale + ' -p 90 -a 200 -s 150 -g 10 "' + what + '" 2>>/dev/null | aplay -D hw:1,0')
 
     def normalize(self, snd_data):
         "Average the volume out"
         MAXIMUM = 16384
-        times = float(MAXIMUM)/max(abs(i) for i in snd_data)
+        times = float(MAXIMUM) / max(abs(i) for i in snd_data)
 
         r = array('h', snd_data)
         c = 0
         for i in snd_data:
             r[c] = int(i*times)
-            c +=1
+            c += 1
         return r
 
     def record(self, elapse):
-        num_silent = 0
-        snd_started = False
-        c = 0
-
         r = bytearray()
-
         t = time.time()
         with self.stream_in as stream:
             audio_generator = stream.generator()
             for content in audio_generator:
                 r.extend(content)
                 if time.time() - t >= elapse:
                     return r
+        return r
 
     def record_to_file(self, filename, elapse):
         data = self.record(elapse)
@@ -132,7 +113,7 @@ def record_to_file(self, filename, elapse):
         wf.close()
 
     def play(self, filename):
-        os.system ('omxplayer sounds/' + filename)
+        os.system('omxplayer sounds/' + filename)
 
         """
         # open the file for reading.
@@ -160,8 +141,6 @@ def play(self, filename):
         """
 
     def hear(self, level, elapse=1.0):
-        ts_total = time.time()
-
         t = time.time()
         with self.stream_in as stream:
             audio_generator = stream.generator()
@@ -171,9 +150,9 @@ def hear(self, level, elapse=1.0):
                     return True
                 if time.time() - t >= elapse:
                     return False
+        return False
 
     def speech_recog(self, model):
-
         # Create a decoder with certain model
         config = Decoder.default_config()
         config.set_string('-hmm', '/usr/local/share/pocketsphinx/model/en-us/en-us')
@@ -186,7 +165,6 @@ def speech_recog(self, model):
         decoder = Decoder(config)
 
         decoder.start_utt()
-        tstamp = time.time()
         recog_text = ''
 
         with self.stream_in as stream:
@@ -195,38 +173,11 @@ def speech_recog(self, model):
                 decoder.process_raw(content, False, False)
                 if decoder.hyp() and decoder.hyp().hypstr != '':
                     recog_text += decoder.hyp().hypstr
-                    tstamp = time.time()
                     if len(recog_text) > 1:
                         decoder.end_utt()
-                        logging.info("recog text: " + recog_text)
+                        logging.info("recog text: %s", recog_text)
                         return recog_text
-
- #   def speech_recog_google(self, locale):
- #       config = types.RecognitionConfig(
- #           encoding=enums.RecognitionConfig.AudioEncoding.LINEAR16,
- #           sample_rate_hertz=RATE,
- #           language_code=locale)
- #       streaming_config = types.StreamingRecognitionConfig(
- #           config=config,
- #           interim_results=False,
- #           single_utterance=True)
-#
- #       t1 = time.time()
-  #      with self.stream_in as stream:
-   #         audio_generator = stream.generator()
-    #        requests = (types.StreamingRecognizeRequest(audio_content=content)
-     #                   for content in audio_generator)
-#
- #           responses = self._google_speech_client.streaming_recognize(streaming_config, requests)
-
-            # Now, put the transcription responses to use.
-  #          for response in responses:
-   #             if time.time() - t1 > 10:
-    #                return ""
-     #           if response.results:
-      #              result = response.results[0]
-       #             if result.is_final:
-        #                return result.alternatives[0].transcript
+        return recog_text
 
     class MicrophoneStream(object):
         """Opens a recording stream as a generator yielding the audio chunks."""
@@ -244,21 +195,21 @@ def __enter__(self):
             self._audio_interface = pyaudio.PyAudio()
             self._buff = queue.Queue()
             self._audio_stream = self._audio_interface.open(
-              format=self._format,
-              # The API currently only supports 1-channel (mono) audio
-              # https://goo.gl/z757pE
-              channels=1, rate=self._rate,
-              input=True, frames_per_buffer=self._chunk,
-              # Run the audio stream asynchronously to fill the buffer object.
-              # This is necessary so that the input device's buffer doesn't
-              # overflow while the calling thread makes network requests, etc.
-              stream_callback=self._fill_buffer,
+                format=self._format,
+                # The API currently only supports 1-channel (mono) audio
+                # https://goo.gl/z757pE
+                channels=1, rate=self._rate,
+                input=True, frames_per_buffer=self._chunk,
+                # Run the audio stream asynchronously to fill the buffer object.
+                # This is necessary so that the input device's buffer doesn't
+                # overflow while the calling thread makes network requests, etc.
+                stream_callback=self._fill_buffer,
             )
             self.closed = False
 
             return self
 
-        def __exit__(self, type, value, traceback):
+        def __exit__(self, atype, value, traceback):
             self._audio_stream.stop_stream()
             self._audio_stream.close()
             self._audio_interface.terminate()