MapleX 2.0.0__py3-none-any.whl

maplex/__init__.py

@@ -0,0 +1,41 @@
+"""
+MapleTree: A Python library for building and managing hierarchical data structures with ease.
+Logger: A simple logging utility for tracking events and debugging.
+"""
+
+from .mapleColors import ConsoleColors
+from .mapleLogger import Logger
+from .mapleExceptions import (
+    InvalidMapleFileFormatException,
+    KeyEmptyException,
+    MapleDataNotFoundException,
+    MapleException,
+    MapleFileEmptyException,
+    MapleFileLockedException,
+    MapleHeaderNotFoundException,
+    MapleTagNotFoundException,
+    NotAMapleFileException
+)
+from .mapleTreeEditor import MapleTree
+from .utils import winHide, winUnHide
+
+__all__ = [
+    'ConsoleColors',
+    'InvalidMapleFileFormatException',
+    'KeyEmptyException',
+    'MapleDataNotFoundException',
+    'MapleException',
+    'MapleFileEmptyException',
+    'MapleFileLockedException',
+    'MapleHeaderNotFoundException',
+    'MapleTagNotFoundException',
+    'NotAMapleFileException',
+    'MapleTree',
+    'Logger',
+    'winHide',
+    'winUnHide'
+]
+
+__version__ = "2.0.0"
+__author__ = "Ryuji Hazama"
+__license__ = "MIT"

maplex/mapleColors.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+
+##################################
+# Console output colors BaseModel
+
+class ConsoleColors(BaseModel):
+
+    # Standard colors
+
+    Black: str = "\033[30m"
+    Red: str = "\033[31m"
+    Green: str = "\033[32m"
+    Yellow: str = "\033[33m"
+    Blue: str = "\033[34m"
+    Magenta: str = "\033[35m"
+    LightBlue: str = "\033[36m"
+    White: str = "\033[37m"
+
+    # Background colors
+
+    bgBlack: str = "\033[40m"
+    bgRed: str = "\033[41m"
+    bgGreen: str = "\033[42m"
+    bgYellow: str = "\033[43m"
+    bgBlue: str = "\033[44m"
+    bgMagenta: str = "\033[45m"
+    bgLightBlue: str = "\033[46m"
+    bgWhite: str = "\033[47m"
+
+    # Bright colors
+
+    bBlack: str = "\033[90m"
+    bRed: str = "\033[91m"
+    bGreen: str = "\033[92m"
+    bYellow: str = "\033[93m"
+    bBlue: str = "\033[94m"
+    bMagenta: str = "\033[95m"
+    bLightBlue: str = "\033[96m"
+    bWhite: str = "\033[97m"
+
+    # Other formats
+
+    Bold: str = "\033[1m"
+    Underline: str = "\033[4m"
+    Reversed: str = "\033[7m"
+    Reset: str = "\033[0m"

maplex/mapleExceptions.py

@@ -0,0 +1,105 @@
+################################
+# Exception classes
+
+class MapleException(Exception):
+
+    """Basic exception for all exception inside the Maple tree."""
+
+class MapleFileNotFoundException(MapleException):
+
+    def __init__(self, mapleFile: str = "", message: str = "Maple file not found"):
+
+        self.message = f"{message}: {mapleFile}"
+        super().__init__(self.message)
+
+class KeyEmptyException(MapleException):
+
+    def __init__(self, mapleFile: str = "", message: str | None = None):
+
+        if message is None:
+
+            self.message = "File encryption toggle was set as \"True\", but the encryption key was not set.\n" \
+                           "Please set key(bytes) value or encryption toggle to \"False\"."
+            
+        else:
+
+            self.message = message
+
+        super().__init__(mapleFile, self.message)
+
+class MapleFileLockedException(MapleException):
+
+    def __init__(self, mapleFile: str = "", message: str = "Maple file has been locked by other instance"):
+
+        self.message = f"{message}: {mapleFile}"
+        super().__init__(self.message)
+
+class MapleDataNotFoundException(MapleException):
+
+    def __init__(self, fileName: str = "", message: str = "Data not found"):
+
+        self.message = f"{message}: {fileName}"
+        super().__init__(self.message)
+
+class MapleHeaderNotFoundException(MapleDataNotFoundException):
+
+    def __init__(self, fileName = "", header: str = "", preHeader: str = "", message = ""):
+
+        if header != "":
+
+            self.message = f"Header [{header}] not found"
+
+        else:
+
+            self.message = "Header not found"
+
+        if preHeader != "":
+
+            self.message = f"{self.message} in [{preHeader}]"
+
+        if message != "":
+
+            self.message = message
+
+        super().__init__(fileName, self.message)
+
+class MapleTagNotFoundException(MapleDataNotFoundException):
+
+    def __init__(self, fileName = "", tag: str = "", header: str = "", message = ""):
+
+        if tag != "":
+
+            self.message = f"Tag [{tag}] not found"
+
+        else:
+
+            self.message = "Tag not found"
+
+        if header != "":
+
+            self.message = f"{self.message} in [{header}]"
+
+        if message != "":
+
+            self.message = message
+
+        super().__init__(self.message, fileName)
+
+class NotAMapleFileException(MapleException):
+
+    def __init__(self, filePath: str = "", message: str = "The file is not a Maple file"):
+
+        self.message = f"{message}: {filePath}"
+        super().__init__(self.message)
+
+class InvalidMapleFileFormatException(NotAMapleFileException):
+
+    def __init__(self, mapleFile = "", message = "Invalid Maple file format"):
+
+        self.message = f"[{message}: {mapleFile}]"
+        super().__init__(self.message)
+
+class MapleFileEmptyException(InvalidMapleFileFormatException):
+
+    def __init__(self, mapleFile="", message="File is empty"):
+        super().__init__(mapleFile, message)

maplex/mapleLogger.py

@@ -0,0 +1,375 @@
+import datetime
+import inspect
+import os
+from os import path, getpid
+import sys
+import traceback
+from enum import IntEnum
+from .mapleTreeEditor import MapleTree
+from .mapleColors import ConsoleColors
+
+class Logger:
+
+    def __init__(self, func: str = "", workingDirectory: str | None = None, cmdLogLevel: str | None = None, fileLogLevel: str | None = None, maxLogSize: float | None = None):
+
+        """
+        Set a negative value to maxLogSize for an infinite log file size.
+        """
+
+        self.intMaxValue = 4294967295
+        self.consoleLogLevel = -1
+        self.fileLogLevel = -1
+        self.func = func
+        self.CWD = os.getcwd()
+        self.consoleColors = ConsoleColors()
+        
+        # Check the OS (Windows cannot change the console color)
+
+        systemId = sys.platform
+
+        if systemId.startswith("win"):
+
+            self.consoleColors = ConsoleColors(Black="", Red="", Green="", Yellow="", Blue="", Magenta="", LightBlue="", White="",
+                                               bgBlack="", bgRed="", bgGreen="", bgYellow="", bgBlue="", bgMagenta="", bgLightBlue="", bgWhite="",
+                                               bBlack="", bRed="", bGreen="", bYellow="", bBlue="", bMagenta="", bLightBlue="", bWhite="",
+                                               Bold="", Underline="", Reversed="", Reset="")
+
+        #
+        ############################
+        # Check config file
+        
+        configFile = path.join(self.CWD, "config.mpl")
+
+        try:
+
+            if not path.isfile(configFile):
+
+                f = open(configFile, "w")
+                f.write("MAPLE\n"
+                        "H *LOG_SETTINGS\n"
+                        "    CMD INFO\n"
+                        "    FLE INFO\n"
+                        "    MAX 3\n"
+                        "    OUT logs\n"
+                        "    CMT TRACE, DEBUG, INFO, WARN, ERROR, FATAL\n"
+                        "E\nEOF")
+                f.close()
+                
+            maple = MapleTree(configFile)
+
+        except:
+
+            maple = None
+        #
+        ############################
+        # Check output directory
+        
+        if workingDirectory is not None:
+
+            self.CWD = workingDirectory
+
+        elif maple:
+
+            self.CWD = maple.readMapleTag("OUT", "*LOG_SETTINGS")
+
+        if self.CWD in {"", None}:
+
+            self.CWD = path.join(os.getcwd(), "logs")
+
+        elif not path.isabs(self.CWD):
+
+            self.CWD = path.join(os.getcwd(), self.CWD)
+
+        self.logfile = path.join(self.CWD, f"log_{datetime.datetime.now():%Y%m%d}.log")
+
+        #
+        ############################
+        # Check log directory
+
+        if not path.isdir(path.join(self.CWD)):
+            os.makedirs(path.join(self.CWD))
+
+        #
+        ############################
+        # Set max log file size
+
+        self.maxLogSize = 0
+
+        if maxLogSize is not None:
+
+            self.maxLogSize = maxLogSize * 1000000
+
+        elif maple is not None:
+
+            try:
+
+                logSizeStr = maple.readMapleTag("MAX", "*LOG_SETTINGS")
+
+                if logSizeStr != "":
+
+                    self.maxLogSize = float(logSizeStr) * 1000000
+
+            except:
+
+                pass
+
+        if self.maxLogSize == 0:
+
+            self.maxLogSize = 3000000
+
+        #
+        ############################
+        # Set output log levels
+
+        self.consoleLogLevel = -1
+        self.fileLogLevel = -1
+
+        # Console log level
+
+        if cmdLogLevel is not None:
+
+            self.consoleLogLevel = self.isLogLevel(cmdLogLevel)
+
+        if self.consoleLogLevel == -1 and maple is not None:
+
+            strLogLevel = maple.readMapleTag("CMD", "*LOG_SETTINGS")
+
+            if strLogLevel is not None:
+
+                self.consoleLogLevel = self.isLogLevel(strLogLevel)
+
+        if self.consoleLogLevel == -1:
+
+            self.consoleLogLevel = self.LogLevel.INFO
+
+        # File log level
+
+        if fileLogLevel is not None:
+
+            self.fileLogLevel = self.isLogLevel(fileLogLevel)
+
+        if self.fileLogLevel == -1 and maple is not None:
+
+            strLogLevel = maple.readMapleTag("FLE", "*LOG_SETTINGS")
+
+            if strLogLevel is not None:
+
+                self.fileLogLevel = self.isLogLevel(strLogLevel)
+
+        if self.fileLogLevel == -1:
+
+            self.fileLogLevel = self.LogLevel.INFO
+
+    #
+    #####################
+    # Set log level enum
+
+    class LogLevel(IntEnum):
+
+        TRACE = 0
+        DEBUG = 1
+        INFO = 2
+        WARN = 3
+        ERROR = 4
+        FATAL = 5
+
+    #
+    ################
+    # Check log level
+
+    def isLogLevel(self, lLStr: str) -> LogLevel:
+
+        for lLevel in self.LogLevel:
+            if lLStr == lLevel.name:
+                return lLevel
+
+        return -1
+
+    #
+    #################################
+    # Logger
+
+    def logWriter(self, loglevel: LogLevel, message: any):
+
+        """
+        Output log to log file and console.
+        """
+
+        ''' - - - - - - -*
+        *                *
+        * Logging Object *
+        *                *
+        * - - - - - - -'''
+
+        # Console colors
+
+        bBlack = self.consoleColors.bBlack
+        Red = self.consoleColors.Red
+        bRed = self.consoleColors.bRed
+        Green = self.consoleColors.Green
+        bLightBlue = self.consoleColors.bLightBlue
+        Bold = self.consoleColors.Bold
+        Reset = self.consoleColors.Reset
+
+        f = open(self.logfile, "a")
+
+        # Get caller informations
+
+        callerFunc = inspect.stack()[1].function
+        callerLine = inspect.stack()[1].lineno
+
+        try:
+
+            # Set console color
+
+            match loglevel:
+
+                case self.LogLevel.TRACE:
+
+                    col = bBlack
+
+                case self.LogLevel.DEBUG:
+
+                    col = Green
+
+                case self.LogLevel.INFO:
+
+                    col = bLightBlue
+
+                case self.LogLevel.WARN:
+
+                    col = bRed
+
+                case self.LogLevel.ERROR:
+
+                    col = Red
+
+                case self.LogLevel.FATAL:
+
+                    col = Bold + Red
+
+                case _:
+
+                    col = ""
+
+            # Export to console and log file
+
+            if loglevel >= self.consoleLogLevel:
+                print(f"[{col}{loglevel.name:5}{Reset}]{Green}[{self.func}]{Reset} {bBlack}{callerFunc}({callerLine}){Reset} {message}")
+        
+            if loglevel >= self.fileLogLevel:
+                print(f"({getpid()}) {f"{datetime.datetime.now():%F %X.%f}"[:-3]} [{loglevel.name:5}][{self.func}] {callerFunc}({callerLine}) {message}", file=f)
+
+        except Exception as ex:
+
+            # If faled to export, print error info to console
+
+            print(f"{Red}[ERROR] {ex}{Reset}")
+
+        finally:
+            f.close()
+
+        if self.maxLogSize > 0:
+
+            # Check file size
+
+            try:
+
+                if path.getsize(self.logfile) > self.maxLogSize:
+
+                    i = 0
+                    logCopyFile = f"{self.logfile}{i}.log"
+
+                    while path.isfile(logCopyFile):
+
+                        i += 1
+                        logCopyFile = f"{self.logfile}{i}.log"
+
+                    os.rename(self.logfile, logCopyFile)
+
+            except Exception as ex:
+
+                print(f"{Red}[ERROR] {ex}{Reset}")
+
+    #
+    ################################
+    # Trace
+
+    def Trace(self, object: any):
+
+        '''Trace log'''
+
+        self.logWriter(self.LogLevel.TRACE, object)
+
+    #
+    ################################
+    # Debug
+
+    def Debug(self, object: any):
+
+        '''Debug log'''
+
+        self.logWriter(self.LogLevel.DEBUG, object)
+
+    #
+    ################################
+    # Info
+
+    def Info(self, object: any):
+
+        '''Info log'''
+
+        self.logWriter(self.LogLevel.INFO, object)
+
+    #
+    ################################
+    # Warn
+
+    def Warn(self, object: any):
+
+        '''Warn log'''
+
+        self.logWriter(self.LogLevel.WARN, object)
+
+    #
+    ################################
+    # Error
+
+    def Error(self, object: any):
+
+        '''Error log'''
+
+        self.logWriter(self.LogLevel.ERROR, object)
+
+    #
+    ################################
+    # Fatal
+
+    def Fatal(self, object: any):
+
+        '''Fatal log'''
+
+        self.logWriter(self.LogLevel.FATAL, object)
+
+    #
+    ################################
+    # Error messages
+
+    def ShowError(self, ex: Exception, message: str | None = None, fatal: bool = False):
+
+        '''Show and log error'''
+
+        if fatal:
+
+            logLevel = self.LogLevel.FATAL
+
+        else:
+
+            logLevel = self.LogLevel.ERROR
+
+        if message is not None:
+
+            self.logWriter(logLevel, message)
+
+        self.logWriter(logLevel, ex)
+        self.logWriter(logLevel, traceback.format_exc())