MapleX 2.2.0.dev2__py3-none-any.whl → 3.0.0.dev2__py3-none-any.whl

maplex/__init__.py

@@ -4,17 +4,21 @@ Logger: A simple logging utility for tracking events and debugging.
 """
 
 from .mapleColors import ConsoleColors
-from .mapleLogger import Logger
+from .mapleJson import MapleJson
+from .mapleLogger import Logger, getLogger
 from .mapleExceptions import (
     InvalidMapleFileFormatException,
     KeyEmptyException,
     MapleDataNotFoundException,
     MapleException,
+    MapleEncryptionNotEnabledException,
     MapleFileEmptyException,
     MapleFileLockedException,
     MapleFileNotFoundException,
     MapleHeaderNotFoundException,
+    MapleSyntaxException,
     MapleTagNotFoundException,
+    MapleTypeException,
     NotAMapleFileException
 )
 from .mapleTreeEditor import MapleTree
@@ -22,15 +26,20 @@ from .utils import winHide, winUnHide
 
 __all__ = [
     'ConsoleColors',
+    'getLogger',
     'InvalidMapleFileFormatException',
     'KeyEmptyException',
     'MapleDataNotFoundException',
+    'MapleEncryptionNotEnabledException',
     'MapleException',
     'MapleFileEmptyException',
     'MapleFileLockedException',
     'MapleFileNotFoundException',
     'MapleHeaderNotFoundException',
+    'MapleJson',
+    'MapleSyntaxException',
     'MapleTagNotFoundException',
+    'MapleTypeException',
     'NotAMapleFileException',
     'MapleTree',
     'Logger',
@@ -38,6 +47,6 @@ __all__ = [
     'winUnHide'
 ]
 
-__version__ = "2.0.0"
+__version__ = "3.0.0.dev2"
 __author__ = "Ryuji Hazama"
 __license__ = "MIT"

maplex/mapleColors.py

@@ -41,6 +41,7 @@ class ConsoleColors(BaseModel):
     # Other formats
 
     Bold: str = "\033[1m"
+    Italic: str = "\033[3m"
     Underline: str = "\033[4m"
     Reversed: str = "\033[7m"
     Reset: str = "\033[0m"

maplex/mapleExceptions.py

@@ -54,6 +54,13 @@ class MapleDataNotFoundException(MapleException):
 
         super().__init__(self.message)
 
+class MapleEncryptionNotEnabledException(MapleException):
+
+    def __init__(self, mapleFile: str = "", message: str = "File encryption is not enabled"):
+
+        self.message = f"{message}: {mapleFile}"
+        super().__init__(self.message)
+
 class MapleHeaderNotFoundException(MapleDataNotFoundException):
 
     def __init__(self, fileName = "", header: str = "", preHeader: str = "", message = ""):
@@ -137,3 +144,31 @@ class MapleTypeException(MapleSyntaxException):
             self.message = message
 
         super().__init__(self.message)
+
+class MapleValueException(MapleException):
+
+    def __init__(self, message: str = "Maple value error"):
+
+        self.message = message
+        super().__init__(self.message)
+
+class MapleLoggerException(MapleException):
+
+    def __init__(self, message: str = "Maple logger error"):
+
+        self.message = message
+        super().__init__(self.message)
+
+class MapleInvalidLoggerLevelException(MapleLoggerException):
+
+    def __init__(self, loggerLevel: str = "", message: str = ""):
+
+        if message == "":
+
+            self.message = f"Invalid logger level [{loggerLevel}]"
+
+        else:
+
+            self.message = f"{message}: Caused by invalid logger level [{loggerLevel}]"
+
+        super().__init__(self.message)

maplex/mapleJson.py

@@ -0,0 +1,162 @@
+import json
+import os
+import base64
+from cryptography.fernet import Fernet
+from . import mapleExceptions as mExc
+
+class MapleJson:
+
+    def __init__(self, filePath: str, fileEncoding: str = 'utf-8', indent: int = 4, ensure_ascii: bool = True, encrypt: bool = False, key: bytes = None):
+
+        self.filePath = filePath
+        self.fileEncoding = fileEncoding
+        self.indent = indent
+        self.ensure_ascii = ensure_ascii
+        self.encrypt = encrypt
+        self.key = key
+        self.fernet = Fernet(key) if encrypt and key else None
+
+    #
+    #####################
+    # Getter / Setter
+
+    def getFilePath(self) -> str:
+
+        return self.filePath
+    
+    def setFilePath(self, filePath: str) -> None:
+
+        self.filePath = filePath
+
+    def getFileEncoding(self) -> str:
+
+        return self.fileEncoding
+    
+    def setFileEncoding(self, fileEncoding: str) -> None:
+
+        self.fileEncoding = fileEncoding
+
+    def getIndent(self) -> int:
+
+        return self.indent
+    
+    def setIndent(self, indent: int) -> None:
+
+        self.indent = indent
+
+    def getEnsureAscii(self) -> bool:
+
+        return self.ensure_ascii
+    
+    def setEnsureAscii(self, ensure_ascii: bool) -> None:
+
+        self.ensure_ascii = ensure_ascii
+
+    def isEncrypted(self) -> bool:
+
+        return self.encrypt
+    
+    def setEncryption(self, encrypt: bool, key=None) -> None:
+
+        self.encrypt = encrypt
+
+        if encrypt and not key:
+
+            raise mExc.KeyEmptyException(self.filePath)
+
+        self.key = key
+        self.fernet = Fernet(key) if encrypt and key else None
+
+    def getKey(self) -> bytes:
+
+        return self.key
+
+    def setKey(self, key: bytes) -> None:
+
+        self.key = key
+        self.fernet = Fernet(key) if self.encrypt and key else None
+
+    #
+    #####################
+    # Basic File Operations
+
+    def read(self) -> dict:
+
+        try:
+
+            with open(self.filePath, 'rb') as file:
+
+                data = file.read()
+
+                if self.encrypt and self.fernet:
+
+                    decryptedData = self.fernet.decrypt(data)
+                    return json.loads(decryptedData.decode(self.fileEncoding))
+
+                else:
+
+                    return json.loads(data.decode(self.fileEncoding))
+
+        except FileNotFoundError:
+
+            raise mExc.MapleFileNotFoundException(self.filePath)
+        
+        except Exception as e:
+
+            raise mExc.MapleException(f"Error reading JSON file: {e}")
+        
+    def write(self, data: dict) -> None:
+
+        try:
+
+            if type(data) is not dict:
+
+                raise mExc.MapleTypeException(self.filePath, "Data to write must be a dictionary")
+
+            jsonData = json.dumps(data, indent=self.indent, ensure_ascii=self.ensure_ascii).encode(self.fileEncoding)
+
+            if self.encrypt and self.fernet:
+
+                encryptedData = self.fernet.encrypt(jsonData)
+
+                with open(self.filePath, 'wb') as file:
+
+                    file.write(encryptedData)
+
+            else:
+
+                with open(self.filePath, 'wb') as file:
+
+                    file.write(jsonData)
+
+        except Exception as e:
+
+            raise mExc.MapleException(f"Error writing JSON file: {e}")
+
+    #
+    #####################
+    # Utility Methods
+
+    #
+    #####################
+    # Generate Encryption Key
+
+    def generateKey(self, setAsCurrent: bool = False) -> bytes:
+
+        """
+        Generates a new Fernet encryption key.
+        Args:
+            setAsCurrent (bool): If True, sets the generated key as the current key for the instance.
+        Returns:
+            bytes: The generated encryption key.
+        """
+
+        key = Fernet.generate_key()
+
+        if setAsCurrent:
+
+            self.key = key
+            self.fernet = Fernet(key)
+            self.encrypt = True
+
+        return key