Made code pep8 compliant

CONTRIBUTING.md

@@ -6,6 +6,6 @@
 	- Make actual quality PRs, no +1 etc.
 
 ## General format rules
-	- Use TABS for indentation.
+	- Use SPACES for indentation.
 	- Try to follow the layout of the code.
 	- Follow the file structure, don't deviate from it.

hue_remote/hue_controller.py

@@ -1,152 +1,158 @@
-import requests as req # Used for HTTP requests for the Hue API
-import json # API uses JSON
-import asyncio # ASync stuff
+import requests as req  # Used for HTTP requests for the Hue API
+import json  # API uses JSON
+import asyncio  # ASync stuff
 import time
 
-from lib.func import * # useful functions
+from lib.func import *  # useful functions
 
-import config # Configuration for the controller (/config.py <- change this file)
-from presets import * # presets for the lights
+# Configuration for the controller (/config.py <- change this file)
+import config
+from presets import *  # presets for the lights
 
-LIGHTS = {} # dictionary of all the lights
+LIGHTS = {}  # dictionary of all the lights
+
+loop = asyncio.get_event_loop()  # ASync loop
 
-loop = asyncio.get_event_loop() # ASync loop
 
 def genUrl(params: str):
-	return "http://" + config.address + "/api/" + config.username + params
+    return "http://" + config.address + "/api/" + config.username + params
+
 
 class APIrequest:
-	# Get Req
-	async def get( dest: str="", payload: str="" ):
-		try:
-			apiReq = req.get( genUrl(dest), data = payload )
+    # Get Req
+    async def get(dest: str = "", payload: str = ""):
+        try:
+            apiReq = req.get(genUrl(dest), data=payload)
 
-			if( apiReq.status_code != 200 ): # print out the error if the status code is not 200
-				print(apiReq)
-				print(apiReq.text)
+            if(apiReq.status_code != 200):  # print out the error if the status code is not 200
+                print(apiReq)
+                print(apiReq.text)
 
-			return apiReq
+            return apiReq
 
-		except req.exceptions.RequestException as err:
-			print(err)
+        except req.exceptions.RequestException as err:
+            print(err)
 
-	# PUT Req
-	async def put( dest: str="", payload: str="" ):
-		try:
-			apiReq = req.put( genUrl(dest), data = payload ) # send the payload
+    # PUT Req
+    async def put(dest: str = "", payload: str = ""):
+        try:
+            apiReq = req.put(genUrl(dest), data=payload)  # send the payload
 
-			if( apiReq.status_code != 200 ):
-				print(apiReq)
-				print(apiReq.text)
+            if(apiReq.status_code != 200):
+                print(apiReq)
+                print(apiReq.text)
 
-			return apiReq
+            return apiReq
 
-		except req.exceptions.RequestException as err:
-			print(err)
+        except req.exceptions.RequestException as err:
+            print(err)
 
 
 class controller:
 
-	# Internal get functions
-	async def getLights():
-		return await APIrequest.get("/lights")
-
-	async def getLight(index: int=1):
-		return await APIrequest.get( "/lights/" + str(index) )
-
-	# Lower level light manipulation (async)
-	async def toggleLight(index: int=1, isOn: bool=True):
-		await APIrequest.put( "/lights/" + str(index) + "/state", '{"on":' + boolToString(isOn) + '}' )
-
-	async def toggleLights(isOn: bool=True):
-		for key in LIGHTS:
-			await controller.toggleLight(key, isOn)
-
-	async def setLightRGB( index: int, r:int, g:int, b:int ):
-		h, s, v = rgbToHsv(r, g, b)
-		payload = '{"sat":' + str(s) + ', "bri":' + str(v) + ', "hue":' + str(h) + '}'
-
-		await APIrequest.put( "/lights/" + str(index) + "/state", payload )
-
-	# Normal functions
-	def switchLight( index: int=1 ):
-		key = LIGHTS.get(str(index))
-		if(key):
-			if( key.get("state") ):
-				curPower = LIGHTS[str(index)]["state"]["on"]
-				loop.run_until_complete( controller.toggleLight(index, not curPower))
-		else:
-			print("Error: Light index '" + str(index) + "' out of range")
-
-	def switchLights():
-		for key in LIGHTS:
-			controller.switchLight(key)
-
-	# Light control
-	def setLightColor( index:int, r:int, g:int, b:int ):
-		if( LIGHTS.get(str(index)) ):
-			loop.run_until_complete( controller.setLightRGB(index, r, g, b) )
-		else:
-			print("Error: Light index '" + str(index) + "' out of range")
-
-	def setLightBrightness( index:int, b:int ):
-		if( LIGHTS.get(str(index)) ):
-			payload = '{"bri":' + str(b) + '}'
-			loop.run_until_complete( APIrequest.put( "/lights/" + str(index) + "/state", payload ) )
-		else:
-			print("Error: Light index '" + str(index) + "' out of range")
-
-	def setBrightness( b:int ):
-		for key in LIGHTS:
-			controller.setLightBrightness( key, b )
-
-	def setAllLightsColor( r:int, g:int, b:int ):
-		for key in LIGHTS:
-			controller.setLightColor( key, r, g, b )
-
-	def Power(isOn:bool=True): # Controlling the power of the lights
-		loop.run_until_complete( controller.toggleLights(isOn) )
-
-	def powerLight( index:int, isOn:bool=True ):
-		loop.run_until_complete( controller.toggleLight( index, isOn ) )
-
-	# Presets
-	def setLightPreset( index:int, p:str ):
-		if( LIGHTS.get(str(index)) ):
-			if( PRESETS.get(p) ):
-				preset = PRESETS[p]
-				r, g, b = preset["color"]
-				brightness = preset["brightness"]
-
-				controller.setLightColor( index, r, g, b )
-				controller.setLightBrightness( index, brightness )
-			else:
-				print("Error: Unknown preset '" + p + "'")
-		else:
-			print("Error: Light index '" + str(index) + "' out of range")
-
-	def setPreset( presetID:str, index:int=-1 ):
-		if( PRESETS.get(presetID) ):
-			if( index == -1 ):
-				for key in LIGHTS:
-					controller.setLightPreset( key, presetID )
-			else:
-				controller.setLightPreset( index, presetID )
-		else:
-			print("Error: Unknown preset '" + presetID + "'")
-
-	def countLights():
-		return len(LIGHTS)
-
-	# Controller "system" functions
-	def delay(n:int):
-		time.sleep(n)
-
-	def init():
-		jsonLights = loop.run_until_complete(APIrequest.get("/lights"))
-
-		global LIGHTS
-		LIGHTS = json.loads(jsonLights.text)
-
-	def end():
-		loop.close()
+    # Internal get functions
+    async def getLights():
+        return await APIrequest.get("/lights")
+
+    async def getLight(index: int = 1):
+        return await APIrequest.get("/lights/" + str(index))
+
+    # Lower level light manipulation (async)
+    async def toggleLight(index: int = 1, isOn: bool = True):
+        await APIrequest.put("/lights/" + str(index) + "/state", '{"on":' + boolToString(isOn) + '}')
+
+    async def toggleLights(isOn: bool = True):
+        for key in LIGHTS:
+            await controller.toggleLight(key, isOn)
+
+    async def setLightRGB(index: int, r: int, g: int, b: int):
+        h, s, v = rgbToHsv(r, g, b)
+        payload = '{"sat":' + str(s) + ', "bri":' + \
+            str(v) + ', "hue":' + str(h) + '}'
+
+        await APIrequest.put("/lights/" + str(index) + "/state", payload)
+
+    # Normal functions
+    def switchLight(index: int = 1):
+        key = LIGHTS.get(str(index))
+        if(key):
+            if(key.get("state")):
+                curPower = LIGHTS[str(index)]["state"]["on"]
+                loop.run_until_complete(
+                    controller.toggleLight(index, not curPower))
+        else:
+            print("Error: Light index '" + str(index) + "' out of range")
+
+    def switchLights():
+        for key in LIGHTS:
+            controller.switchLight(key)
+
+    # Light control
+    def setLightColor(index: int, r: int, g: int, b: int):
+        if(LIGHTS.get(str(index))):
+            loop.run_until_complete(controller.setLightRGB(index, r, g, b))
+        else:
+            print("Error: Light index '" + str(index) + "' out of range")
+
+    def setLightBrightness(index: int, b: int):
+        if(LIGHTS.get(str(index))):
+            payload = '{"bri":' + str(b) + '}'
+            loop.run_until_complete(APIrequest.put(
+                "/lights/" + str(index) + "/state", payload))
+        else:
+            print("Error: Light index '" + str(index) + "' out of range")
+
+    def setBrightness(b: int):
+        for key in LIGHTS:
+            controller.setLightBrightness(key, b)
+
+    def setAllLightsColor(r: int, g: int, b: int):
+        for key in LIGHTS:
+            controller.setLightColor(key, r, g, b)
+
+    def Power(isOn: bool = True):  # Controlling the power of the lights
+        loop.run_until_complete(controller.toggleLights(isOn))
+
+    def powerLight(index: int, isOn: bool = True):
+        loop.run_until_complete(controller.toggleLight(index, isOn))
+
+    # Presets
+    def setLightPreset(index: int, p: str):
+        if(LIGHTS.get(str(index))):
+            if(PRESETS.get(p)):
+                preset = PRESETS[p]
+                r, g, b = preset["color"]
+                brightness = preset["brightness"]
+
+                controller.setLightColor(index, r, g, b)
+                controller.setLightBrightness(index, brightness)
+            else:
+                print("Error: Unknown preset '" + p + "'")
+        else:
+            print("Error: Light index '" + str(index) + "' out of range")
+
+    def setPreset(presetID: str, index: int = -1):
+        if(PRESETS.get(presetID)):
+            if(index == -1):
+                for key in LIGHTS:
+                    controller.setLightPreset(key, presetID)
+            else:
+                controller.setLightPreset(index, presetID)
+        else:
+            print("Error: Unknown preset '" + presetID + "'")
+
+    def countLights():
+        return len(LIGHTS)
+
+    # Controller "system" functions
+    def delay(n: int):
+        time.sleep(n)
+
+    def init():
+        jsonLights = loop.run_until_complete(APIrequest.get("/lights"))
+
+        global LIGHTS
+        LIGHTS = json.loads(jsonLights.text)
+
+    def end():
+        loop.close()

hue_remote/hue_remote.py

@@ -3,105 +3,111 @@
 
 import sys
 
-import hue_controller as hue # Actual controller 
+import hue_controller as hue  # Actual controller
 
 cmd = "hue"
 
+
 def help():
-	print("--Help page--")
+    print("--Help page--")
+
+    print("'" + cmd + "' : Display this help page")
+    print("'" + cmd + " light (index)' ... : Specify light target, from 1-" +
+          str(hue.controller.countLights()))
+    print("'" + cmd + " lights' ... : Specify all lights\n")
 
-	print( "'" + cmd + "' : Display this help page" )
-	print( "'" + cmd + " light (index)' ... : Specify light target, from 1-" + str(hue.controller.countLights()) )
-	print( "'" + cmd + " lights' ... : Specify all lights\n" )
+    print("--Commands--")
+    print("'on'/'off' : Turn light(s) on/off")
+    print("'switch' : Switch the light(s) power")
+    print("'set ...'")
+    print("	'preset (preset ID)' : Set the preset (from presets.py)")
+    print("	'color (red) (green) (blue)' : Set the color, from 0-255")
+    print("	'brightness (brightness)' : Set the brightness, from 0-255")
 
-	print("--Commands--")
-	print( "'on'/'off' : Turn light(s) on/off" )
-	print( "'switch' : Switch the light(s) power" )
-	print( "'set ...'" )
-	print( "	'preset (preset ID)' : Set the preset (from presets.py)" )
-	print( "	'color (red) (green) (blue)' : Set the color, from 0-255" )
-	print( "	'brightness (brightness)' : Set the brightness, from 0-255" )
+    print("\nExamples:\n'hue light 2 on' : Turn on light 2\n'hue lights set color 255 255 255' : Set all lights colors to white")
 
-	print("\nExamples:\n'hue light 2 on' : Turn on light 2\n'hue lights set color 255 255 255' : Set all lights colors to white")
 
 boolConvert = {
-	"on": True,
-	"off": False
+    "on": True,
+    "off": False
 }
 
 # this is the most spaghetti-ish code I have ever written but it works
 
-def parseCommand( cmd:list, pos:int, i=-1 ):
-	index = int(i)
-	try:
-		if( cmd[pos] == "on" or cmd[pos] == "off" ):
-			if( index == -1 ):
-				hue.controller.Power( boolConvert[cmd[pos]] )
-			else:
-				hue.controller.powerLight( index, boolConvert[cmd[pos]] )
 
-			return
+def parseCommand(cmd: list, pos: int, i=-1):
+    index = int(i)
+    try:
+        if(cmd[pos] == "on" or cmd[pos] == "off"):
+            if(index == -1):
+                hue.controller.Power(boolConvert[cmd[pos]])
+            else:
+                hue.controller.powerLight(index, boolConvert[cmd[pos]])
 
-		elif( cmd[pos] == "switch" ):
-			if(index == -1):
-				hue.controller.switchLights()
-			else:
-				hue.controller.switchLight(index)
+            return
 
-			return
+        elif(cmd[pos] == "switch"):
+            if(index == -1):
+                hue.controller.switchLights()
+            else:
+                hue.controller.switchLight(index)
 
-		elif( cmd[pos] == "set" ):
-			if( cmd[pos+1] == "preset" ):
-				hue.controller.setPreset( cmd[pos+2], index )
-				return
+            return
 
-			elif( cmd[pos+1] == "color" ):
-				if( len(cmd) > pos+4 ):
-					r, g, b = int(cmd[pos+2]), int(cmd[pos+3]), int(cmd[pos+4])
+        elif(cmd[pos] == "set"):
+            if(cmd[pos+1] == "preset"):
+                hue.controller.setPreset(cmd[pos+2], index)
+                return
 
-					if( index == -1 ):
-						hue.controller.setAllLightsColor( r, g, b ) # this code is bad
-					else:
-						hue.controller.setLightColor( index, r, g, b )
+            elif(cmd[pos+1] == "color"):
+                if(len(cmd) > pos+4):
+                    r, g, b = int(cmd[pos+2]), int(cmd[pos+3]), int(cmd[pos+4])
 
-					return
-				else:
-					print("Error: Missing parameters")
-					help()
+                    if(index == -1):
+                        hue.controller.setAllLightsColor(
+                            r, g, b)  # this code is bad
+                    else:
+                        hue.controller.setLightColor(index, r, g, b)
 
-			elif( cmd[pos+1] == "brightness" ):
-				if( len(cmd) > pos+2 ):
-					bri = int(cmd[pos+2])
+                    return
+                else:
+                    print("Error: Missing parameters")
+                    help()
 
-					if( index == -1 ):
-						hue.controller.setBrightness(bri)
-					else:
-						hue.controller.setLightBrightness( index, bri )
+            elif(cmd[pos+1] == "brightness"):
+                if(len(cmd) > pos+2):
+                    bri = int(cmd[pos+2])
 
-					return
-		help() # display help if function did nothing
+                    if(index == -1):
+                        hue.controller.setBrightness(bri)
+                    else:
+                        hue.controller.setLightBrightness(index, bri)
 
-	except (RuntimeError, TypeError, NameError, IndexError) as err:
-		help() # display the help page if parameters are missing (it will give out an IndexError)
-		print( "\n\nError: " + str(err) )
+                    return
+        help()  # display help if function did nothing
+
+    except (RuntimeError, TypeError, NameError, IndexError) as err:
+        help()  # display the help page if parameters are missing (it will give out an IndexError)
+        print("\n\nError: " + str(err))
 
 
 def parseCommandline():
-	cmd = sys.argv
+    cmd = sys.argv
 
-	if( len(cmd) > 1 ):
-		if( cmd[1] == "light" ):
-			parseCommand( cmd, 3, cmd[2] )
+    if(len(cmd) > 1):
+        if(cmd[1] == "light"):
+            parseCommand(cmd, 3, cmd[2])
 
-		elif( cmd[1] == "lights" ):
-			parseCommand( cmd, 2 )
-	else:
-		help()
+        elif(cmd[1] == "lights"):
+            parseCommand(cmd, 2)
+    else:
+        help()
 
 
 def init():
-	hue.controller.init() # very important to initialize the controller
-	parseCommandline()
-	hue.controller.end() # also to end it
+    hue.controller.init()  # very important to initialize the controller
+    parseCommandline()
+    hue.controller.end()  # also to end it
+
 
-init() # actually call the init function
+init()  # actually call the init function

hue_remote/lib/func.py

@@ -5,19 +5,24 @@ boolStr = {
     False: "false"
 }
 
-def boolToString(v: bool): # To fix the dumb python syntax
+
+def boolToString(v: bool):  # To fix the dumb python syntax
     return boolStr[v]
 
-def rgbToDecimal( r:int, g:int, b:int ):
+
+def rgbToDecimal(r: int, g: int, b: int):
     return round(r/255, 1), round(g/255, 1), round(b/255, 1)
 
+
 def svNumFix(n: float):
     return int(round(n*254, 0))
 
+
 def hueNumFix(n: float):
     return int(round(n*65535, 0))
 
-def rgbToHsv( r:int, g:int, b:int ):
+
+def rgbToHsv(r: int, g: int, b: int):
     R, G, B = rgbToDecimal(r, g, b)
     H, S, V = colorsys.rgb_to_hsv(R, G, B)
     return hueNumFix(H), svNumFix(S), svNumFix(V)

hue_remote/presets.py

@@ -31,8 +31,8 @@ PRESETS = {
         "brightness": 255
     },
 
-    "ice" : {
-        "color": ( 80, 100, 255 ),
+    "ice": {
+        "color": (80, 100, 255),
         "brightness": 120
     },
 

speech/speech.py

@@ -1,36 +1,39 @@
 import speech_recognition as sr
 
+
 class sr_microphone(object):
-	recognizer = sr.Recognizer()
+    recognizer = sr.Recognizer()
 
-	muted = True
+    muted = True
 
-	def getInput(self): # use the object as a generator
-		print("Awaiting input")
-		if( not self.muted ):
-			try:
-				with sr.Microphone() as src:
-					self.recognizer.adjust_for_ambient_noise( src, duration=0.2 ) # adjust for ambient noise
+    def getInput(self):  # use the object as a generator
+        print("Awaiting input")
+        if(not self.muted):
+            try:
+                with sr.Microphone() as src:
+                    self.recognizer.adjust_for_ambient_noise(
+                        src, duration=0.2)  # adjust for ambient noise
 
-					audio = self.recognizer.listen(src)
+                    audio = self.recognizer.listen(src)
 
-					# Make audio -> text
-					return (self.recognizer.recognize_google( audio )).lower() # use googles recognizer and lower its output
+                    # Make audio -> text
+                    # use googles recognizer and lower its output
+                    return (self.recognizer.recognize_google(audio)).lower()
 
-			except sr.RequestError as err:
-				print("Unable to request results: {0}".format(err))
+            except sr.RequestError as err:
+                print("Unable to request results: {0}".format(err))
 
-			except sr.UnknownValueError as err:
-				print("Unknown Error: {0}".format(err))
+            except sr.UnknownValueError as err:
+                print("Unknown Error: {0}".format(err))
 
-	def setMuted( self, setm: bool=True ):
-		self.muted = setm
+    def setMuted(self, setm: bool = True):
+        self.muted = setm
 
-	def switchMute( self ):
-		self.setMuted( not self.muted )
+    def switchMute(self):
+        self.setMuted(not self.muted)
 
 
 # Small test
 voice = sr_microphone()
 voice.setMuted(False)
-print( voice.getInput() )
+print(voice.getInput())