Merge pull request #1 from yeyeto2788/master

A bit of refactoring and linting

Author: SecT0uch

action.py

@@ -1,45 +1,54 @@
-import time
 import json
-import redis
 import subprocess
 import sys
+
+import redis
+
 sys.path.append('..')
 
+
 class Action():
 
-	def __init__(self, config):
-		self.config = config
-		self.name = config.get("name", "Action")
-		self.type = config.get("type", "event")
-		self.key = config.get("key", None).replace(" ", "_").lower() if config.get("key") is not None else self.name.replace(" ", "_").lower()
-		# Actions will be either objects to publish for events or a command string to execute
-		self.action = config.get("action")
-		try:
-			self.r = config["redis"] if config["redis"] is not None else redis.Redis(host='127.0.0.1', port=6379)
-		except KeyError:
-			self.r = redis.Redis(host='127.0.0.1', port=6379)
-		return
-
-	def init_action(self):
-		if self.type == 'event':
-			self.topic = self.config.get("topic", "mudpi")
-		elif self.type == 'command':
-			self.shell = self.config.get("shell", False)
-
-	def trigger(self, value=None):
-		if self.type == 'event':
-			self.emitEvent()
-		elif self.type == 'command':
-			self.runCommand(value)
-		return
-
-	def emitEvent(self):
-		self.r.publish(self.topic, json.dumps(self.action))
-		return
-
-	def runCommand(self, value=None):
-		if value is None:
-			completed_process = subprocess.run([self.action], shell=self.shell)
-		else:
-			completed_process = subprocess.run([self.action, json.dumps(value)], shell=self.shell)
-		return
+    def __init__(self, config):
+        self.config = config
+        self.name = config.get("name", "Action")
+        self.type = config.get("type", "event")
+        self.key = config.get("key", None).replace(" ",
+                                                   "_").lower() if config.get(
+            "key") is not None else self.name.replace(" ", "_").lower()
+        # Actions will be either objects to publish for events
+		# or a command string to execute
+        self.action = config.get("action")
+
+        try:
+            self.r = config["redis"] if config[
+                                            "redis"] is not None else redis.Redis(
+                host='127.0.0.1', port=6379)
+        except KeyError:
+            self.r = redis.Redis(host='127.0.0.1', port=6379)
+        return
+
+    def init_action(self):
+        if self.type == 'event':
+            self.topic = self.config.get("topic", "mudpi")
+        elif self.type == 'command':
+            self.shell = self.config.get("shell", False)
+
+    def trigger(self, value=None):
+        if self.type == 'event':
+            self.emit_event()
+        elif self.type == 'command':
+            self.run_command(value)
+        return
+
+    def emit_event(self):
+        self.r.publish(self.topic, json.dumps(self.action))
+        return
+
+    def run_command(self, value=None):
+        if value is None:
+            completed_process = subprocess.run([self.action], shell=self.shell)
+        else:
+            completed_process = subprocess.run(
+                [self.action, json.dumps(value)], shell=self.shell)
+        return

config_load.py

@@ -1,8 +1,10 @@
-import json 
+import json
 
-def loadConfigJson():
-	configs = {}
-	with open('mudpi.config') as loadedfile:
-		configs = json.load(loadedfile)
-		loadedfile.close()
-		return configs
+
+def load_config_json():
+    configs = {}
+
+    with open('mudpi.config') as loadedfile:
+        configs = json.load(loadedfile)
+        loadedfile.close()
+        return configs

controls/arduino/button_control.py

@@ -35,5 +35,5 @@ def read(self):
 		self.previous_state = state
 		return state
 
-	def readRaw(self):
+	def read_raw(self):
 		return super().read()

controls/arduino/control.py

@@ -39,13 +39,13 @@ def init_control(self):
 
 	def read(self):
 		#Read the sensor(s), parse the data and store it in redis if redis is configured
-		return self.readPin()
+		return self.read_pin()
 
-	def readRaw(self):
+	def read_raw(self):
 		#Read the sensor(s) but return the raw data, useful for debugging
 		pass
 
-	def readPin(self):
+	def read_pin(self):
 		#Read the pin from the ardiuno. Can be analog or digital based on "analog_pin_mode"
 		data = self.api.analogRead(self.pin) if self.analog_pin_mode else self.api.digitalRead(self.pin)
 		return data

controls/arduino/potentiometer_control.py

@@ -33,6 +33,6 @@ def read(self):
 		self.previous_state = state
 		return state
 
-	def readRaw(self):
+	def read_raw(self):
 		return super().read()
 

controls/arduino/switch_control.py

@@ -36,5 +36,5 @@ def read(self):
 		self.previous_state = state
 		return state
 
-	def readRaw(self):
+	def read_raw(self):
 		return super().read()

controls/pi/button_control.py

@@ -25,6 +25,6 @@ def read(self):
 			super().emitEvent(1)
 		return state
 
-	def readRaw(self):
+	def read_raw(self):
 		return super().read()
 

controls/pi/control.py

@@ -60,13 +60,13 @@ def init_control(self):
 	def read(self):
 		#Read the sensor(s), parse the data and store it in redis if redis is configured
 		#If edge detection is being used return the detection event instead
-		return self.readPin() if self.edge_detection is None else GPIO.event_detected(self.pin)
+		return self.read_pin() if self.edge_detection is None else GPIO.event_detected(self.pin)
 
-	def readRaw(self):
+	def read_raw(self):
 		#Read the sensor(s) but return the raw data, useful for debugging
 		pass
 
-	def readPin(self):
+	def read_pin(self):
 		#Read the pin from the pi digital reads only
 		data = self.gpio.input(self.pin)
 		return data

controls/pi/switch_control.py

@@ -37,6 +37,6 @@ def read(self):
 		self.previous_state = state
 		return state
 
-	def readRaw(self):
+	def read_raw(self):
 		return super().read()
 

logger/Logger.py

@@ -1,7 +1,6 @@
 import logging
 import sys
 
-
 LOG_LEVEL = {
     "unknown": logging.NOTSET,
     "debug": logging.DEBUG,
@@ -11,8 +10,8 @@
     "error": logging.ERROR,
 }
 
-class Logger:
 
+class Logger:
     logger = None
 
     def __init__(self, config: dict):
@@ -25,24 +24,28 @@ def __init__(self, config: dict):
                 "terminal_log_level": "info"
             }
             # raise Exception("No Logger configs were found!")
-        
-        self.__log = logging.getLogger(config['name']+"_stream")
+
+        self.__log = logging.getLogger(config['name'] + "_stream")
         self.__file_log = logging.getLogger(config['name'])
 
         try:
-            file_log_level = LOG_LEVEL[logger_config["file_log_level"]] if not config["debug"] else LOG_LEVEL["debug"]
-            stream_log_level = LOG_LEVEL[logger_config["terminal_log_level"]] if not config["debug"] else LOG_LEVEL["debug"]
+            file_log_level = LOG_LEVEL[logger_config["file_log_level"]] if not \
+            config["debug"] else LOG_LEVEL["debug"]
+            stream_log_level = LOG_LEVEL[
+                logger_config["terminal_log_level"]] if not config[
+                "debug"] else LOG_LEVEL["debug"]
         except KeyError:
             file_log_level = LOG_LEVEL["unknown"]
             stream_log_level = LOG_LEVEL["unknown"]
-        
+
         self.__log.setLevel(stream_log_level)
         self.__file_log.setLevel(file_log_level)
 
         try:
             try:
                 if len(logger_config['file']) != 0:
-                    open(logger_config['file'], 'w').close()  # testing file path
+                    open(logger_config['file'],
+                         'w').close()  # testing file path
                     file_handler = logging.FileHandler(logger_config['file'])
                     file_handler.setLevel(file_log_level)
 
@@ -51,32 +54,35 @@ def __init__(self, config: dict):
                     self.WRITE_TO_FILE = False
             except FileNotFoundError:
                 self.WRITE_TO_FILE = False
-        
+
         except KeyError as e:
             self.WRITE_TO_FILE = False
 
-            self.log(LOG_LEVEL["warning"], "File Handler could not be started due to a KeyError: {0}".format(e))
-        
+            self.log(LOG_LEVEL["warning"],
+                     "File Handler could not be started due to a KeyError: {0}".format(
+                         e))
+
         stream_handler = logging.StreamHandler(sys.stdout)
         stream_handler.setLevel(stream_log_level)
 
-        file_formatter = logging.Formatter("[%(asctime)s][%(name)s][%(levelname)s] %(message)s", "%H:%M:%S")
+        file_formatter = logging.Formatter(
+            "[%(asctime)s][%(name)s][%(levelname)s] %(message)s", "%H:%M:%S")
         stream_formatter = logging.Formatter("%(message)s")
         file_handler.setFormatter(file_formatter)
         stream_handler.setFormatter(stream_formatter)
 
         if self.WRITE_TO_FILE:
             self.__file_log.addHandler(file_handler)
         self.__log.addHandler(stream_handler)
-    
+
     @staticmethod
     def log_to_file(log_level: int, msg: str):
         """
         Logs the given message ONLY to the log file.
         """
         if Logger.log is not None:
             Logger.logger.log_this_file(log_level, msg)
-    
+
     @staticmethod
     def log(log_level: int, msg: str):  # for ease of access from outside
         """
@@ -94,7 +100,7 @@ def log_this_file(self, log_level: int, msg: str):
         msg = msg.replace("\033[1;31m", "")
         msg = msg.replace("\033[0;0m", "")
         self.__file_log.log(log_level, msg)
-    
+
     def log_this(self, log_level: int, msg: str):
         self.__log.log(log_level, msg)
         if self.WRITE_TO_FILE: