PyLogger/PyLogger.py at main · amorenojr/PyLogger · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from datetime import datetime
from enum import Enum, auto
from pathlib import Path
from os import remove

class EnumLogLevel(Enum):
    """
    Enumerated type representing the log level.
    """

    Info = auto()
    """Info Level"""

    Debug = auto()
    """Info Level"""

    Warning = auto()
    """Warning Level"""

    Error = auto()
    """Error Level"""

    Critical = auto()
    """Critical Level"""

    Verbose = auto()
    """Verbose Level"""

class PyLogger:

    @property
    def LogFilePath(self) -> Path:
        """Log file path."""
        return self.__LogFilePath

    @LogFilePath.setter
    def LogFilePath(self, value: Path):
        self.__LogFilePath = value

    # https://stackoverflow.com/questions/287871/how-do-i-print-colored-text-to-the-terminal#answer-21786287
    LogLevelColorMap = [["\x1b[1;37;40m","\x1b[0m"], # Info
                        ["\x1b[1;32;40m","\x1b[0m"], # Debug
                        ["\x1b[1;33;40m","\x1b[0m"], # Warning
                        ["\x1b[1;31;40m","\x1b[0m"], # Error
                        ["\x1b[5;30;41m","\x1b[0m"], # Critical
                        ["\x1b[1;34;40m","\x1b[0m"]] # Verbose


    def __init__(self, logFilePath: str | Path) -> None:
        self.LogFilePath = Path(logFilePath) if isinstance(logFilePath, str) else logFilePath
        if self.LogFilePath.exists():
            remove(str(self.LogFilePath))
        self.__Queue = []
        self.LogStartTime = datetime.now()
        self.RecordStartTime = self.LogStartTime
        self.Info("Log Started.")

    def __del__(self):
        self.Info("Log Ended (Total run-time {TotalRunTime}).".format(TotalRunTime = datetime.now() - self.LogStartTime))

    def __AppendLog(self, msg: str, printOut: bool, logLevel: EnumLogLevel, report: bool = True):

        self.__Queue.append("{LogMsg}".format(LogMsg = msg))

        if report:
            self.RecordEndTime = datetime.now()
            self.ElapsedTime = self.RecordEndTime - self.RecordStartTime
            ElapsedTimeStr = datetime.utcfromtimestamp(self.ElapsedTime.total_seconds()).strftime("%H:%M:%S.%f")
            self.__Queue.insert(0, "{TimeStamp} ({ElapsedTime}) {LogLevel}: ".format(TimeStamp = self.RecordEndTime.strftime('%Y-%m-%d %H:%M:%S'),
                                                                                    LogLevel = self.__GetLevelStr(logLevel),
                                                                                    ElapsedTime = ElapsedTimeStr))
            logMsg = "".join(self.__Queue)
            with open(self.LogFilePath, "a", encoding="utf-8") as file:
                file.writelines(logMsg + "\n")
            self.__Queue.clear()
            self.RecordStartTime = self.RecordEndTime

        if printOut:
            ColorPrefix = self.LogLevelColorMap[logLevel.value][0]
            ColorSuffix = self.LogLevelColorMap[logLevel.value][1]
            print("{ColorPrefix}{msg}{ColorSuffix}".format(ColorPrefix = ColorPrefix, msg = msg, ColorSuffix = ColorSuffix), end = ("\n" if report else ""))


    def __GetLevelStr(self, logLevel: EnumLogLevel) -> str:
        match logLevel:
            case EnumLogLevel.Info:
                return "[I]"
            case EnumLogLevel.Debug:
                return "[D]"
            case EnumLogLevel.Warning:
                return "[W]"
            case EnumLogLevel.Error:
                return "[E]"
            case EnumLogLevel.Critical:
                return "[C]"
            case EnumLogLevel.Verbose:
                return "[V]"
            case _:
                return None


    def Info(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Info, report)


    def Debug(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Debug, report)


    def Warning(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Warning, report)


    def Error(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Error, report)


    def Critical(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Critical, report)


    def Verbose(self, msg: str, report: bool = True, printOut: bool = True):
        self.__AppendLog(msg, printOut, EnumLogLevel.Verbose, report)