Feature/initial (#1)

* initial commit
* systemd service implementation

CustomLogger.py

@@ -0,0 +1,105 @@
+import logging
+import inspect 
+
+class IndentFormatter(logging.Formatter):
+    """
+    A custom logging formatter that adds indentation based on the call stack depth
+    and includes the function name in the log record.
+    Attributes:
+        baseline (int): The baseline stack depth when the formatter is initialized.
+    Methods:
+        __init__(fmt=None, datefmt=None):
+            Initializes the IndentFormatter with optional format and date format.
+        format(rec):
+            Formats the specified record as text, adding indentation and function name.
+    """
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+
+    FORMATS = {
+        logging.DEBUG: grey + format + reset,
+        logging.INFO: grey + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+
+
+    def __init__( self, fmt=None, datefmt=None ):
+        """
+        Initializes the CustomLogger instance.
+        Args:
+            fmt (str, optional): The format string for the log messages. Defaults to None.
+            datefmt (str, optional): The format string for the date in log messages. Defaults to None.
+        Attributes:
+            baseline (int): The baseline stack depth when the logger is initialized.
+        """
+        logging.Formatter.__init__(self, fmt, datefmt)
+        self.baseline = len(inspect.stack())
+
+    def format( self, rec ):
+        """
+        Formats the log record by adding indentation and function name.
+        This method customizes the log record by adding an indentation level
+        based on the current stack depth and includes the name of the function
+        from which the log call was made. It then uses the base Formatter class
+        to format the record and returns the formatted string.
+        Args:
+            rec (logging.LogRecord): The log record to be formatted.
+        Returns:
+            str: The formatted log record string.
+        """
+        log_fmt = self.FORMATS.get(rec.levelno)
+        formatter = logging.Formatter(log_fmt)
+
+        stack = inspect.stack()
+        rec.indent = '    '*(len(stack)-self.baseline-3)
+        rec.function = stack[8][3]
+        out = logging.Formatter.format(self, rec)
+        del rec.indent; del rec.function
+        return out
+    
+class MessageProcessorFilter(logging.Filter):
+    def filter(self, record):
+        # Suppress INFO level messages from MessageProcessor.py
+        if record.levelno == logging.INFO and record.pathname.endswith("MessageProcessor.py"):
+            return False
+        return True
+    
+# The following code sets up a custom logger with indentation support.
+# It creates a custom formatter, a logger instance, and a stream handler.
+# The custom formatter is set to the handler, which is then added to the logger.
+# Finally, the logging level is set to INFO.
+
+formatter = IndentFormatter("%(asctime)s - (%(filename)30s:%(lineno)-3d) - [%(levelname)-7s]: %(indent)s%(message)s ")
+logger = logging.getLogger('logger')
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+def setDebugMode():
+    """
+    Set the logging level to DEBUG and log a message indicating that debug mode is enabled.
+    This function sets the logging level of the logger to DEBUG, which means that all messages
+    at the DEBUG level and above will be logged. It also logs a debug message to indicate that
+    debug mode has been activated.
+    """
+    logger.setLevel(logging.DEBUG)
+    logger.debug("Debug mode is on...")
+
+def setSilent():
+    """
+    Sets the logger to silent mode, where only messages at the ERROR level or higher are displayed.
+    If the current logging level is not 'DEBUG', this function will log an informational message
+    indicating that silent mode is being activated and then set the logging level to ERROR.
+    """
+    if logger.level != logging.DEBUG:
+        logger.info("Silent Mode is turning on, only Messages at Level ERROR or higher are displayed")
+        #logger.setLevel(logging.ERROR)
+        # Add the filter to suppress INFO level messages from MessageProcessor.py
+        logger.addFilter(MessageProcessorFilter())