MapleX 3.0.1__tar.gz → 3.1.0.dev1__tar.gz

{maplex-3.0.1/src/MapleX.egg-info → maplex-3.1.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.0.1
+Version: 3.1.0.dev1
 Summary: A Python library for simple logging, json file operations, Maple file format operations, and console color utilities.
 Author: Ryuji Hazama
 Project-URL: PyPI, https://pypi.org/project/MapleX/

{maplex-3.0.1 → maplex-3.1.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MapleX"
-version = "3.0.1"
+version = "3.1.0.dev1"
 description = """A Python library for simple logging, json file operations, Maple file format operations, and console color utilities."""
 keywords = ["logging", "logger", "json", "file operations", "maple file format", "console colors"]
 readme = "README.md"

{maplex-3.0.1 → maplex-3.1.0.dev1/src/MapleX.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.0.1
+Version: 3.1.0.dev1
 Summary: A Python library for simple logging, json file operations, Maple file format operations, and console color utilities.
 Author: Ryuji Hazama
 Project-URL: PyPI, https://pypi.org/project/MapleX/

{maplex-3.0.1 → maplex-3.1.0.dev1}/src/MapleX.egg-info/SOURCES.txt

@@ -22,6 +22,13 @@ src/maplex/mapleExceptions.py
 src/maplex/mapleLogger.py
 src/maplex/mapleTreeEditor.py
 src/maplex/utils.py
+src/maplex/library/logger/__init__.py
+src/maplex/library/logger/config.py
+src/maplex/library/logger/consts.py
+src/maplex/library/logger/file_handler.py
+src/maplex/library/logger/formatter.py
+src/maplex/library/logger/log_levels.py
+src/maplex/library/logger/utilities.py
 tests/test_logger_unittest.py
 tests/test_maplejson_unittest.py
 tests/test_mapletree_unittest.py

{maplex-3.0.1 → maplex-3.1.0.dev1}/src/maplex/__init__.py

@@ -49,6 +49,18 @@ __all__ = [
     'winUnHide'
 ]
 
-__version__ = "3.0.1"
+__version__ = "3.1.0.dev1"
 __author__ = "Ryuji Hazama"
-__license__ = "MIT"
+__license__ = "MIT"
+
+
+""" * * * * * * * * * * * * * """
+"""
+ToDo list:
+
+* MapleX *
+
+- Restructure MapleX to be more modular and maintainable
+
+"""
+""" * * * * * * * * * * * * * """

{maplex-3.0.1 → maplex-3.1.0.dev1}/src/maplex/json.py

@@ -1,3 +1,4 @@
+import datetime
 import json
 import os
 import base64
@@ -6,6 +7,10 @@ from . import mapleExceptions as mExc
 
 class MapleJson:
 
+    """
+    MapleJson is a utility class for handling JSON files with optional encryption support. It provides methods to read and write JSON data, as well as manage encryption keys.
+    """
+
     def __init__(self,
                  filePath: str,
                  fileEncoding: str = 'utf-8',
@@ -15,6 +20,17 @@ class MapleJson:
                  key: bytes = None
                  ) -> None:
 
+        """
+        Initialize a MapleJson instance.
+
+        :param filePath: Path to the JSON file.
+        :param fileEncoding: Encoding of the JSON file.
+        :param indent: Indentation level for JSON formatting.
+        :param ensureAscii: Whether to ensure ASCII characters in JSON.
+        :param encrypt: Whether to encrypt the JSON file.
+        :param key: Encryption key for the JSON file.
+        """
+
         self.filePath = filePath
         self.fileEncoding = fileEncoding
         self.indent = indent
@@ -87,7 +103,7 @@ class MapleJson:
     #####################
     # Basic File Operations
 
-    def read(self, *keys: str) -> dict | None:
+    def read(self, *keys: str) -> object | None:
 
         try:
 
@@ -125,16 +141,52 @@ class MapleJson:
         except Exception as e:
 
             raise mExc.MapleException(f"Error reading JSON file: {e}")
+
+    def readOrDefault(self, default: object, *keys: str) -> object:
+
+        result = self.read(*keys)
+        return result if result is not None else default
         
-    def write(self, data: dict) -> None:
+    def write(self, data: object, *keys: str) -> None:
 
         try:
 
-            if type(data) is not dict:
+            if len(keys) > 0:
+
+                # Read existing data to preserve other keys
+
+                existingData = self.read() or {}
+
+                # Navigate to the correct location in the nested structure
+
+                currentLevel = existingData
+
+                for i, jsonKey in enumerate(keys):
+
+                    if i == len(keys) - 1:
+
+                        currentLevel[jsonKey] = data
+
+                    else:
+
+                        if jsonKey not in currentLevel or not isinstance(currentLevel[jsonKey], dict):
+
+                            currentLevel[jsonKey] = {}
+
+                        currentLevel = currentLevel[jsonKey]
+
+                dataToWrite = existingData
 
-                raise mExc.MapleTypeException(self.filePath, "Data to write must be a dictionary")
+            else:
+
+                dataToWrite = data
 
-            jsonData = json.dumps(data, indent=self.indent, ensure_ascii=self.ensureAscii).encode(self.fileEncoding)
+            jsonData = json.dumps(
+                dataToWrite,
+                indent=self.indent,
+                ensure_ascii=self.ensureAscii,
+                default=self.datetimeSerializer
+            ).encode(self.fileEncoding)
 
             if self.encrypt and self.fernet:
 
@@ -181,6 +233,30 @@ class MapleJson:
 
         return key
 
+    def datetimeSerializer(self, obj: object) -> str:
+
+        if isinstance(obj, (datetime.datetime, datetime.date)):
+
+            return obj.isoformat()
+
+        raise TypeError(f"Type {type(obj)} not serializable")
+
+    def datetimeDeserializer(self, obj: str) -> datetime.datetime | datetime.date | str:
+
+        try:
+
+            return datetime.datetime.fromisoformat(obj)
+
+        except ValueError:
+
+            try:
+
+                return datetime.date.fromisoformat(obj)
+
+            except ValueError:
+
+                return obj
+
 _json: dict[str, MapleJson] = {}
 
 # Get or create a MapleJson instance
@@ -202,4 +278,13 @@ def getMapleJson(filePath: str,
                                     encrypt,
                                     key)
 
-    return _json[filePath]
+    return _json[filePath]
+
+""" * * * * * * * * * * * * * """
+"""
+ToDo list:
+
+* Json *
+
+"""
+""" * * * * * * * * * * * * * """

maplex-3.1.0.dev1/src/maplex/library/logger/__init__.py

@@ -0,0 +1,16 @@
+"""
+Split mapleLogger.py into multiple files for better organization and maintainability.
+"""
+
+from .config import LoggerConfig
+from .log_levels import LogLevel
+from .utilities import *
+
+__all__ = [
+    "LoggerConfig",
+    "LogLevel",
+    "getConsoleColors",
+    "toLogLevel",
+    "toLogSize",
+    "isLogLevel"
+]

maplex-3.1.0.dev1/src/maplex/library/logger/config.py

@@ -0,0 +1,344 @@
+"""
+Move configu helper functions to a separate file to avoid circular imports and improve code organization
+"""
+
+from datetime import datetime
+import inspect
+from typing import Literal
+import os
+from os import path
+from pydantic import BaseModel
+
+from src.maplex.mapleColors import ConsoleColors
+from src.maplex.mapleExceptions import *
+from src.maplex.json import MapleJson
+from .consts import *
+from .utilities import *
+from src.maplex.library.logger.log_levels import LogLevel
+
+
+class LoggerConfig(BaseModel):
+
+    func: str | None = None
+    callerName: str | None = None
+    workingDirectory: str | None = None
+    consoleLogLevel: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "NONE"] | None = None
+    fileLogLevel: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "NONE"] | None = None
+    maxLogSize: int | None = None
+    fileMode: Literal["append", "overwrite", "daily"] | None = None
+    configFile: str = "config.json"
+    encoding: str | None = None
+    timestampFormat: str | None = None
+    getLogger: bool | None = None
+    consoleAlignWidth: int | None = None
+    fileAlignWidth: int | None = None
+
+    logConfInstance: None = None
+    logConf: dict[str, object] | None = None
+    logfile: str | None = None
+    pid: int = os.getpid()
+
+    consoleColors: ConsoleColors | None = None
+
+    def __init__(self, config: dict[str, object]) -> None:
+
+        try:
+
+            super().__init__(**config)
+            self.consoleColors = getConsoleColors()
+
+            self.logConfInstance = self.checkConfigFile(config.get(CONFIG_FILE, self.configFile))
+            self.checkOutputDirectory(config.get(WORKING_DIRECTORY, None))
+            self.setLogFileName(config.get(FILE_MODE, "append"))
+            self.setFuncName(config.get(GET_LOGGER, False), config.get(FUNC, None))
+            self.setAlignWidth(config.get(CONSOLE_ALIGN_WIDTH, None), config.get(FILE_ALIGN_WIDTH, None))
+            self.setLogFileSize(config.get(MAX_LOG_SIZE, None))
+            self.setOutputLogLevels(config.get(CONSOLE_LOG_LEVEL, None), config.get(FILE_LOG_LEVEL, None))
+            self.setFileEncoding(config.get(FILE_ENCODING, None))
+            self.setTimestampFormat(config.get(TIMESTAMP_FORMAT, None))
+            self.saveLogSettings(self.logConfInstance)
+
+        except Exception as ex:
+
+            print(f"{self.consoleColors.Red}Error: Failed to initialize logger config: {ex}{self.consoleColors.Reset}")
+            raise ex
+
+    
+    def checkConfigFile(self, configFile: str) -> MapleJson | None:
+    
+        # Set config file path
+        
+        self.configFile = self.checkFilePath(configFile)
+
+        # Try to read config file
+
+        try:
+
+            logConfInstance = MapleJson(self.configFile)
+
+            if path.isfile(self.configFile):
+
+                confJson = logConfInstance.read()
+
+            else:
+
+                confJson = {}
+
+        except Exception as ex:
+
+            print(f"{self.consoleColors.Red}Warning: Failed to read logger config file: {ex}{self.consoleColors.Reset}")
+            confJson = {}
+            logConfInstance = None
+
+        # Read configuration
+
+        logConf = confJson.get(CONFIG_KEY, None)
+
+        if logConf is None:
+
+            logConf = {}
+            logConf[CONSOLE_LOG_LEVEL] = "INFO"
+            logConf[FILE_LOG_LEVEL] = "INFO"
+            logConf[MAX_LOG_SIZE] = 3
+            logConf[WORKING_DIRECTORY] = "logs"
+
+        self.logConf = logConf
+        return logConfInstance
+
+    def checkFilePath(self, filePath: str) -> str:
+
+        '''Check and return absolute file path'''
+
+        if path.isabs(filePath):
+
+            return filePath
+
+        else:
+
+            return path.join(os.getcwd(), filePath)
+
+    def checkOutputDirectory(self, outputDir: str) -> None:
+
+        '''Check and set output directory'''
+
+        # Check parameter and config file
+
+        if outputDir is not None:
+
+            self.workingDirectory = outputDir
+
+        else:
+
+            self.workingDirectory = self.logConf.get(WORKING_DIRECTORY, None)
+
+        # Set absolute path
+
+        if self.workingDirectory in {"", None}:
+
+            self.workingDirectory = path.join(os.getcwd(), "logs")
+            self.logConf[WORKING_DIRECTORY] = self.workingDirectory
+
+        elif not path.isabs(self.workingDirectory):
+
+            self.workingDirectory = path.join(os.getcwd(), self.workingDirectory)
+
+        # Check if directory exists
+
+        if not path.isdir(self.workingDirectory):
+
+            os.makedirs(self.workingDirectory)
+
+    def setLogFileName(self, fileMode: str) -> None:
+
+        '''Set log file name'''
+
+        if fileMode == "daily":
+
+            self.logfile = path.join(self.workingDirectory, f"log_{datetime.now():%Y%m%d}.log")
+        
+        else:
+
+            self.logfile = path.join(self.workingDirectory, "AppLog.log")
+
+    def setFuncName(self, isGetLogger: bool, func: str | None = None) -> None:
+
+        if isGetLogger:
+
+            caller = inspect.stack()[3].frame.f_globals.get("__name__", "")
+
+        else:
+
+            caller = inspect.stack()[2].frame.f_globals.get("__name__", "")
+
+        if func in {None, ""}:
+
+            self.func = ""
+            self.callerName = ""
+        
+        elif func != caller:
+
+            self.func = f"[{func}]"
+            self.callerName = ""
+
+        else:
+
+            self.func = ""
+            self.callerName = f"{caller}."
+
+    def setAlignWidth(self, consoleAlignWidth: int | None = None, fileAlignWidth: int | None = None) -> None:
+
+        '''Set function name alignment width'''
+
+        if consoleAlignWidth is not None and type(consoleAlignWidth) is int and consoleAlignWidth > 0:
+
+            self.consoleAlignWidth = consoleAlignWidth
+
+        else:
+
+            self.consoleAlignWidth = 16
+
+        if fileAlignWidth is not None and type(fileAlignWidth) is int and fileAlignWidth > 0:
+
+            self.fileAlignWidth = fileAlignWidth
+
+        else:
+
+            self.fileAlignWidth = 4
+
+    def setLogFileSize(self, maxLogSize: object) -> None:
+
+        self.maxLogSize = 0
+
+        if maxLogSize is not None:
+
+            self.setMaxLogSize(maxLogSize)
+
+        else:
+
+            try:
+
+                logSize = self.logConf.get(MAX_LOG_SIZE, None)
+
+                if logSize is not None:
+
+                    self.setMaxLogSize(logSize)
+
+                else:
+
+                    self.maxLogSize = 3000000
+                    self.logConf[MAX_LOG_SIZE] = 3
+
+            except MapleLoggerException as ex:
+
+                print(f"{self.consoleColors.Red}Warning: Invalid MaxLogSize value provided. Using default value.{self.consoleColors.Reset}")
+                self.maxLogSize = 3000000
+
+        if self.maxLogSize == 0:
+
+            print(f"{self.consoleColors.Red}Warning: Infinite log file size is not recommended. Using default value.{self.consoleColors.Reset}")
+            self.maxLogSize = 3000000
+
+    def setOutputLogLevels(self, cmdLogLevel: object, fileLogLevel: object) -> None:
+
+        self.consoleLogLevel = self.__setLogLevel(CONSOLE_LOG_LEVEL, cmdLogLevel)
+        self.fileLogLevel = self.__setLogLevel(FILE_LOG_LEVEL, fileLogLevel)
+
+    def __setLogLevel(self, fileOrConsole, loglevel: object) -> LogLevel:
+
+        '''Set log level'''
+
+        if loglevel is not None:
+
+            tempLogLevel = loglevel
+        
+        else:
+
+            tempLogLevel = self.logConf.get(fileOrConsole, "INFO")
+
+            if tempLogLevel is None:
+
+                tempLogLevel = "INFO"
+                self.logConf[fileOrConsole] = tempLogLevel
+
+        try:
+
+            return toLogLevel(tempLogLevel)
+
+        except MapleInvalidLoggerLevelException as ex:
+
+            print(f"{self.consoleColors.Red}Warning: Invalid {fileOrConsole} provided: [{tempLogLevel}]. Using default value.{self.consoleColors.Reset}")
+            return self.LogLevel.INFO
+
+    def setFileEncoding(self, encoding: str) -> None:
+
+        if encoding is not None:
+
+            self.encoding = encoding
+
+        else:
+
+            fileEncoding = self.logConf.get(FILE_ENCODING, None)
+
+            if fileEncoding is None:
+
+                fileEncoding = "utf-8"
+                self.logConf[FILE_ENCODING] = fileEncoding
+
+            self.encoding = fileEncoding
+
+    def setTimestampFormat(self, timestampFormat: str) -> None:
+
+        """Set timestamp format for logs. Default is "%F %X.%f" (e.g. 2024-06-01 12:34:56.789). You can set this in config file with key "TimestampFormat"."""
+
+        if timestampFormat is not None:
+
+            self.timestampFormat = timestampFormat
+
+        else:
+
+            configTimestampFormat = self.logConf.get(TIMESTAMP_FORMAT, None)
+
+            if configTimestampFormat is None:
+
+                configTimestampFormat = "%F %X.%f"
+                self.logConf[TIMESTAMP_FORMAT] = configTimestampFormat
+
+            self.timestampFormat = configTimestampFormat
+
+    def saveLogSettings(self, logConfInstance: MapleJson | None) -> None:
+
+        """ Save current log settings to config file """
+
+        if logConfInstance is not None:
+
+            try:
+
+                confJson = logConfInstance.read()
+
+            except Exception:
+
+                confJson = {}
+            
+            try:
+
+                confJson[CONFIG_KEY] = self.logConf
+                logConfInstance.write(confJson)
+
+            except Exception as ex:
+
+                print(f"{self.consoleColors.Red}Warning: Failed to write logger config file: {ex}{self.consoleColors.Reset}")
+
+    ###########################
+    # Seters and getters
+
+    def setMaxLogSize(self, maxLogSize: object) -> None:
+
+        '''Set max log size'''
+
+        try:
+
+            self.maxLogSize = toLogSize(maxLogSize)
+
+        except MapleLoggerException as ex:
+
+            raise MapleLoggerException("Invalid max log size. Log size must be an integer, float or string.") from ex

maplex-3.1.0.dev1/src/maplex/library/logger/consts.py

@@ -0,0 +1,17 @@
+
+CONFIG_KEY = "MapleLogger"
+FUNC = "func"
+CONSOLE = "Console"
+FILE = "File"
+CONSOLE_LOG_LEVEL = "ConsoleLogLevel"
+FILE_LOG_LEVEL = "FileLogLevel"
+MAX_LOG_SIZE = "MaxLogSize"
+FILE_MODE = "FileMode"
+CONFIG_FILE = "configFile"
+WORKING_DIRECTORY = "WorkingDirectory"
+FILE_ENCODING = "FileEncoding"
+TIMESTAMP_FORMAT = "TimestampFormat"
+ALIGN_WIDTH = "AlignWidth"
+GET_LOGGER = "getLogger"
+CONSOLE_ALIGN_WIDTH = "consoleAlignWidth"
+FILE_ALIGN_WIDTH = "fileAlignWidth"

maplex-3.1.0.dev1/src/maplex/library/logger/file_handler.py

@@ -0,0 +1,3 @@
+"""
+File handler for logging.
+"""

maplex-3.1.0.dev1/src/maplex/library/logger/formatter.py

@@ -0,0 +1,4 @@
+"""
+Logger formatter module for MapleLogger.
+Format log messages based on the specified format string and log level.
+"""

maplex-3.1.0.dev1/src/maplex/library/logger/log_levels.py

@@ -0,0 +1,15 @@
+from enum import IntEnum
+
+"""
+LogLevel Enum for MapleLogger
+"""
+
+class LogLevel(IntEnum):
+
+    TRACE = 0
+    DEBUG = 1
+    INFO = 2
+    WARN = 3
+    ERROR = 4
+    FATAL = 5
+    NONE = 6