added exclude process_builder

Author: max-wittig

json_tool.py

@@ -12,14 +12,17 @@ def __init__(self, filename="log.json"):
 
     def open_file(self):
         self.file = open(self.filename, "r")
-        self.fileContent = self.file.read()
 
     def create_file(self):
         self.file = open(self.filename, "w")
 
     def get_file_content(self):
+        self.fileContent = self.file.read()
         return self.fileContent
 
+    def get_json(self):
+        return json.loads(self.get_file_content())
+
     def write_process_list_to_file(self, process_object_list):
         self.create_file()
         if self.file is not None:
@@ -28,6 +31,10 @@ def write_process_list_to_file(self, process_object_list):
                 self.process_list.append(process.to_json())
             json.dump(self.process_list, self.file, indent=2)
 
+    def write_settings_to_file(self, settings):
+        self.create_file()
+        json.dump(settings.to_json(), self.file, indent=2)
+
     def get_existing_process_list(self):
         if self.fileContent is not None:
             process_object_list = []

main.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+from setting import Setting
+from process_tracker import ProcessTracker
+from settings_builder import SettingsBuilder
+import threading
+import sys
+import getopt
+import time
+
+
+def show_help():
+    print("\n")
+    print("--------USAGE--------")
+    print("-h --help                                              : prints this help page")
+    print("-l <arg> --load <arg>                                  : load settings file from <arg>")
+    print("-o <arg> --output <arg>                                : specify output filename")
+    print("-i 'arg1 arg2 arg3' ... --include 'arg1 arg2 arg3' ... : set processes that should be tracked")
+    print("-e 'arg1 arg2 arg3' ... --exclude 'arg1 arg2 arg3' ... : set processes that shouldn't be tracked")
+    print("---------------------")
+    print("\n")
+    sys.exit(0)
+
+
+def main():
+    settings = Setting()
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hl:o:i:e:b:",
+                                   ["help", "load=", "output=", "included=", "excluded=", "build="])
+    except getopt.GetoptError as err:
+        # print help information and exit:
+        print(err)  # will print something like "option -a not recognized"
+        sys.exit(2)
+
+    for o, a in opts:
+        if o in ("-h", "--help"):
+            show_help()
+        elif o in ("-l", "--load"):
+            try:
+                settings.load_from_file("settings/" + a)
+                print(a)
+            except:
+                print("settings file not found")
+                exit(1)
+        elif o in ("-o", "--output"):
+            settings.set_log_filename(a)
+        elif o in ("-i", "--included"):
+            processes_to_track = a.split(' ')
+            settings.set_processes_to_track(processes_to_track)
+        elif o in ("-e", "--excluded"):
+            excluded_processes = a.split(' ')
+            settings.set_excluded_processes(excluded_processes)
+        elif o in ("-b", "--build"):
+            settings_builder = SettingsBuilder()
+            settings_builder.build_exclude_settings()
+            settings_builder.save_settings("settings/" + a)
+            print("settings saved in " + a)
+            sys.exit(0)
+
+        else:
+            assert False, "unhandled option"
+
+    print("time_delay=" + str(settings.get_time_delay()))
+    process_tracker = ProcessTracker(settings)
+    thread = threading.Thread(target=process_tracker.start_logging, args=(settings.get_time_delay(), ))
+    """thread dies, if main dies"""
+    thread.setDaemon(True)
+    thread.start()
+    time.sleep(2)
+    print("------------------------------")
+    input("Press return to stop logging\n------------------------------\n")
+    process_tracker.stop_logging()
+    """wait for thread to finish"""
+    thread.join()
+    process_tracker.write_process_list()
+
+if __name__ == '__main__':
+    main()

process_tracker.py

@@ -1,13 +1,8 @@
-#!/usr/bin/python3
-import getopt
-import sys
 import psutil
-import threading
 import time
 from task import Task
 from process import Process
 from json_tool import JsonReaderWriter
-from setting import Setting
 
 
 class ProcessTracker:
@@ -16,8 +11,7 @@ def __init__(self, settings):
         self.json_reader_writer = JsonReaderWriter(self.filename)
         self.running = False
         self.process_object_list = []
-        self.processes_to_track = settings.get_processes_to_track()
-        self.excluded_processes = settings.get_excluded_processes()
+        self.settings = settings
 
     def is_name_already_in_process_list(self, process_name):
         is_contained = False
@@ -29,15 +23,15 @@ def is_name_already_in_process_list(self, process_name):
     def user_include_filter_processes(self, return_process_list):
         filtered_list = []
         for process in return_process_list:
-            for u_process in self.processes_to_track:
+            for u_process in self.settings.get_processes_to_track():
                 if process == u_process:
                     filtered_list.append(process)
         return filtered_list
 
     def user_exclude_filter_processes(self, return_process_list):
-        filtered_list = return_process_list
+        filtered_list = return_process_list.copy()
         for process in return_process_list:
-            for u_process in self.excluded_processes:
+            for u_process in self.settings.get_excluded_processes():
                 if process == u_process:
                     filtered_list.remove(process)
         return filtered_list
@@ -51,9 +45,9 @@ def get_process_list_without_doubles(self):
                 return_process_list.append(process.name())
 
         """excluded processes are priority"""
-        if len(self.excluded_processes) > 0:
+        if len(self.settings.get_excluded_processes()) > 0:
             return self.user_exclude_filter_processes(return_process_list)
-        elif len(self.processes_to_track) > 0:
+        elif len(self.settings.get_processes_to_track()) > 0:
             """filters out processes, which the user doesn't want to see"""
             return self.user_include_filter_processes(return_process_list)
         else:
@@ -137,66 +131,3 @@ def write_process_list(self):
         self.json_reader_writer.write_process_list_to_file(self.process_object_list)
 
 
-def show_help():
-    print("\n")
-    print("--------USAGE--------")
-    print("-h --help                                              : prints this help page")
-    print("-l <arg> --load <arg>                                  : load settings file from <arg>")
-    print("-o <arg> --output <arg>                                : specify output filename")
-    print("-i 'arg1 arg2 arg3' ... --include 'arg1 arg2 arg3' ... : set processes that should be tracked")
-    print("-e 'arg1 arg2 arg3' ... --exclude 'arg1 arg2 arg3' ... : set processes that shouldn't be tracked")
-    print("---------------------")
-    print("\n")
-    sys.exit(0)
-
-
-def main():
-    settings = Setting()
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], "hl:o:i:e:b:",
-                                   ["help", "load=", "output=", "included=", "excluded=", "build="])
-    except getopt.GetoptError as err:
-        # print help information and exit:
-        print(err)  # will print something like "option -a not recognized"
-        sys.exit(2)
-
-    for o, a in opts:
-        if o in ("-h", "--help"):
-            show_help()
-        elif o in ("-l", "--load"):
-            try:
-                settings.load_from_file("settings/" + a)
-                print(a)
-            except:
-                print("settings file not found")
-                exit(1)
-        elif o in ("-o", "--output"):
-            settings.set_log_filename(a)
-        elif o in ("-i", "--included"):
-            processes_to_track = a.split(' ')
-            settings.set_processes_to_track(processes_to_track)
-        elif o in ("-e", "--excluded"):
-            excluded_processes = a.split(' ')
-            settings.set_excluded_processes(excluded_processes)
-        elif o in ("-b", "--build"):
-            excluded_processes = a.split(' ')
-            settings.set_excluded_processes(excluded_processes)
-        else:
-            assert False, "unhandled option"
-
-    print("time_delay=" + str(settings.get_time_delay()))
-    process_tracker = ProcessTracker(settings)
-    thread = threading.Thread(target=process_tracker.start_logging, args=(settings.get_time_delay(), ))
-    """thread dies, if main dies"""
-    thread.setDaemon(True)
-    thread.start()
-    time.sleep(2)
-    print("------------------------------")
-    input("Press return to stop logging\n------------------------------\n")
-    process_tracker.stop_logging()
-    """wait for thread to finish"""
-    thread.join()
-    process_tracker.write_process_list()
-
-if __name__ == '__main__':
-    main()

setting.py

@@ -1,4 +1,5 @@
 import json
+from json_tool import JsonReaderWriter
 
 
 class Setting:
@@ -36,13 +37,23 @@ def get_excluded_processes(self):
     def set_excluded_processes(self, excluded_processes):
         self.excluded_processes = excluded_processes
 
+    def to_json(self):
+        settings = {
+            "processes_to_track": self.processes_to_track,
+            "time_delay": self.time_delay,
+            "excluded_processes": self.excluded_processes,
+            "log_filename": self.log_filename
+        }
+        return settings
+
     def parse(self):
         self.processes_to_track = self.file_content_object["processes_to_track"]
         self.time_delay = self.file_content_object["time_delay"]
         self.excluded_processes = self.file_content_object["excluded_processes"]
         self.log_filename = self.file_content_object["log_filename"]
 
     def read_json(self):
-        self.file = open(self.filename)
-        self.file_content_object = json.loads(self.file.read())
+        json_reader = JsonReaderWriter(filename=self.filename)
+        json_reader.open_file()
+        self.file_content_object = json_reader.get_json()
         self.parse()