MapleX 3.0.0.dev4__tar.gz → 3.0.1__tar.gz

{maplex-3.0.0.dev4/src/MapleX.egg-info → maplex-3.0.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.0.0.dev4
+Version: 3.0.1
 Summary: A Python library for simple logging, json file operations, Maple file format operations, and console color utilities.
-Author: RyujiHazama
+Author: Ryuji Hazama
 Project-URL: PyPI, https://pypi.org/project/MapleX/
 Project-URL: Homepage, https://github.com/Ryuji-Hazama
 Project-URL: Repository, https://github.com/Ryuji-Hazama/MapleTree
@@ -78,7 +78,7 @@ Also outputs to the log file:
 
 [More details](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/README_Logger.md)
 
-[Logging Tips](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingTips.md)
+[Logging Best Practice](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingBestPractice.md)
 
 ## MapleJson
 
@@ -185,11 +185,6 @@ All datas after "\nEOF\n" will be ignored
 - `--upgrade` option for upgrade from older version.
 - `--break-system-package` option for Python on Linux OS outside the `venv`. ***This might brak the system Python package dependencies.***
 
-### Manual Installation
-
-1. Download `./dist/maplex-<version>-py3-none-any.whl`
-2. Run `[python[3] -m] pip install /path/to/downloaded/maplex-<version>-py3-none-any.whl [--break-system-packages]`
-
 ### Build the Package by Yourself
 
 &nbsp;&nbsp;&nbsp;&nbsp;Run `python[3] -m build`  

{maplex-3.0.0.dev4 → maplex-3.0.1}/README.md

@@ -56,7 +56,7 @@ Also outputs to the log file:
 
 [More details](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/README_Logger.md)
 
-[Logging Tips](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingTips.md)
+[Logging Best Practice](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingBestPractice.md)
 
 ## MapleJson
 
@@ -163,11 +163,6 @@ All datas after "\nEOF\n" will be ignored
 - `--upgrade` option for upgrade from older version.
 - `--break-system-package` option for Python on Linux OS outside the `venv`. ***This might brak the system Python package dependencies.***
 
-### Manual Installation
-
-1. Download `./dist/maplex-<version>-py3-none-any.whl`
-2. Run `[python[3] -m] pip install /path/to/downloaded/maplex-<version>-py3-none-any.whl [--break-system-packages]`
-
 ### Build the Package by Yourself
 
 &nbsp;&nbsp;&nbsp;&nbsp;Run `python[3] -m build`  

{maplex-3.0.0.dev4 → maplex-3.0.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MapleX"
-version = "3.0.0.dev4"
+version = "3.0.1"
 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"
 license-files = ["LICENSE"]
 authors = [
-    {name = "RyujiHazama"}
+    {name = "Ryuji Hazama"}
 ]
 dependencies = [
     "cryptography>=46.0.3",

maplex-3.0.1/readmes/LoggingBestPractice.md

@@ -0,0 +1,20 @@
+# Logging Best Practice
+
+## What Is "Logging"
+
+### The flight recorder of the application
+
+    When you are developing an application, you might experience that your application is crashing silently. Then you will insert a bunch of `print()` lines to determine where the application failed, and what was causing the error. That is a log, and those outputs are showing the exact path of your process, and help you understand what is working correctly, why, and where your code failed after the application halts.
+
+    However, those logs are disappearing when you close the output terminal, or the terminal was automatically closed by the application. That is why you need to output logs to a file like a flight recorder in a black box.
+
+### Four W's of Logging
+
+    Every time the event occurs, the logger should capture the "Four W's" to get the details of the event.
+
+- **When** — When the event occured.
+- **Whrere** — Where the event happened.
+- **What** — What was the event.
+- **Weight** — How seriouc is the event?
+
+### Logging vs `print()`

maplex-3.0.1/readmes/README_Json.md

@@ -0,0 +1,321 @@
+# MapleJson Class
+
+    MapleJson class is a class library to manage the JSON formatted files.
+
+- You can read a JSON file as a `dict` data.
+- You can write the `dict` data into a file as a JSON formatted string
+- You can save the data as an encrypted data string.
+- You can decrypt the encrypted data.
+
+## Class Initialization
+
+```python
+
+def __init__(
+    filePath: str,
+    fileEncoding: str = 'utf-8',
+    indent: int = 4,
+    ensure_ascii: bool = False,
+    encrypt: bool = False,
+    key: bytes = None
+) -> None:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`filePath`**|\*|JSON file path|3.0.0|
+|**`fileEncoding`**||File encoding|3.0.0|
+|**`indent`**||Indent size for save as a JSON file|3.0.0|
+|**`ensureAscii`**||Ensure ASCII flag when save to a file|3.0.0|
+|**`encrypt`**||Encryption flag|3.0.0|
+|**`key`**|(\*)|Encryption key (32 bytes)|3.0.0|
+
+    Initialize the class with a file path.
+
+### File encoding
+
+    You can set a specific file character encoding. Default: `UTF-8`
+
+    E.g.: If you are using `Shift_JIS` (Japanese system), you should initialize the class like the example below:
+
+```python
+from maplex import MapleJson
+
+jsonInstance = MapleJson("jsonFile.json", fileEncoding="shift_jis")
+```
+
+### Indent size
+
+    You can set the block indent size with `indent` parameter. Default: `4`
+
+    If you set `indent=2`, the file will be save like the example below:
+
+```json
+{
+  "Data": {
+    "Key": "Value",
+  }
+}
+```
+
+### Ensure ASCII
+
+    You can set the flag to ensure ASCII encoding.
+
+    If you don't set the parameter (Default: `False`), the file contents after saving are look like the example below:
+
+```json
+{
+    "data": {
+        "japanese": "値",
+        "russian": "значение",
+        "english": "value"
+    }
+}
+```
+
+    But, if you set `ensureAscii=True`, the file contents after saving will be changed like:
+
+```json
+{
+    "data": {
+        "japanese": "\u5024",
+        "russian": "\u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435",
+        "english": "value"
+    }
+}
+```
+
+### Encrypt
+
+    If you set `encrypt=True`, set the [encryption key](#key), and save data to a file using the `MapleJson` class, the file will be encrypted with AES-128 (using Fernet).
+
+    The encrypted file can be read using the `MapleJson` class, and it is also necessary to set `encrypt=True` and use the same key.
+
+    **There is no *redo*** in encryption. **DO NOT FORGET** your encryption key, or *you will lose your data FOREVER.*
+
+### Key
+
+    A 32-byte byte-string key for encryption.
+
+    If you set `encrypt=True` when initializing the class, you must also set the key.
+
+    Encryption example:
+
+```python
+from maplex import MapleJson
+
+key = b'Yj6wIw5VR3Z-4nXXdWTZAhwU6j2SIgSQNl7QbYgDyCA='
+jsonData = MapleJson("sampleFile.json", encrypt=True, key=key)
+
+sampleData = {
+    "setting1": True,
+    "setting2": "value2",
+    "setting3": 12345
+}
+
+jsonData.write(sampleData)
+```
+
+    Inside the `sampleFile.json` will be:
+
+```text
+gAAAAABph_yYxWIyHpS1HImudFoWQQ5WTh2VsPxO4dcXGbYujR62dW1wpZDUf1cZJF-jGzDfTLGHi6e4ihQJRTvNibgIm3sRFLJUyRClRUBSsd1mMmZ0YzFk_ZuinaNSLox3RILZwIMCCE0XbWjw_vs5x_gCKXJQdtEYZ3bSWcSyYBHBAqh3OxA=
+```
+
+    The you can read the data with:
+
+```python
+from maplex import MapleJson
+
+# Set the same key that was used in encryption
+key = b'Yj6wIw5VR3Z-4nXXdWTZAhwU6j2SIgSQNl7QbYgDyCA='
+jsonData = MapleJson("sampleFile.json", encrypt=True, key=key)
+dictFromJson = jsonData.read()
+
+print(dictFromJson)
+```
+
+    The console output will be:
+
+```text
+{'setting1': True, 'setting2': 'value2', 'setting3': 12345}
+```
+
+    **DO NOT FORGET YOUR ENCRYPTION KEY**,  or you will lose your data *FOREVER.* There is no redo in encryption.
+
+## Functions
+
+### `read()`
+
+```python
+def read(
+    *keys: str
+) -> dict | None:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`*keys`**||Dict keys|3.0.0|
+
+    This function reads a JSON file, which is specified at the class instance, and returns the data as a `dict` object.
+
+    While the data in the `sampleFile.json` is:
+
+```json
+{
+    "settings": {
+        "setting1": True,
+        "setting2": "value2",
+        "setting3": 12345
+    },
+    "data": {
+        "data1": "value1",
+        "data2": 67890
+    }
+}
+```
+
+    Read with:
+
+```python
+from maplex import MapleJson
+
+jsonFile = MapleJson("sampleFile.json")
+jsonData = jsonFile.read()
+
+print(jsonData)
+```
+
+    The output will be:
+
+```text
+{'settings': {'setting1': True, 'setting2': 'value2', 'setting3': 12345}, 'data': {'data1': 'value1', 'data2': 67890}}
+```
+
+    If you provide the key(s) in the parameter, the function returns the object of the key, and returns `None` if the key does not exist.
+
+```python
+from maplex import MapleJson
+
+jsonFile = MapleJson("sampleFile.json")
+jsonData = jsonFile.read("data")
+
+print(jsonData)
+```
+
+    This outputs:
+
+```text
+{'data1': 'value1', 'data2': 67890}
+```
+
+### `write()`
+
+```python
+def write(
+    data: dict
+) -> None:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`data`**|\*|Dict object to save|3.0.0|
+
+    This function saves the `dict` object to a file in JSON format.
+
+    This overwrites the existing file and creates a new file if the file does not exist.
+
+```python
+from maplex import MapleJson
+
+jsonFile = MapleJson("sampleFile")
+jsonData = {"data1": True, "data2": "value2", "data3": 12345}
+jsonFile.write(jsonData)
+```
+
+    This creates a file that contains the following data:
+
+```json
+{
+    "data1": True,
+    "data2": "value2",
+    "data3": 12345
+}
+```
+
+    The function **overwrites the entire file** with the provided data. So you should be careful, especially when reading with the key(s) and saving their data.
+
+    While the data in the `sampleFile.json` is:
+
+```json
+{
+    "settings": {
+        "setting1": True,
+        "setting2": "value2",
+        "setting3": 12345
+    },
+    "data": {
+        "data1": "value1",
+        "data2": 67890
+    }
+}
+```
+
+```python
+from maplex import MapleJson
+
+jsonFile = MapleJson("sampleFile.json")
+jsonData = jsonFile.read("settings")
+jsonFile.write(jsonData)
+```
+
+    This code changes the file contents like the sample below:
+
+```json
+{
+    "setting1": True,
+    "setting2": "value2",
+    "setting3": 12345
+}
+```
+
+### `generateKey()`
+
+```python
+def generateKey(
+    setAsCurrent: bool = False
+) -> bytes:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`setAsCurrent`**||Using the generated key as a current encryption key|3.0.0|
+
+    The function returns the randomly generated encryption byte-string key.
+
+- If you set `setAsCurrent=False`, nothing will be changed in the instance state.
+- If you set `setAsCurrent=True` while the encryption state was set as `True`, the instance encryption key is overwritten by the newly generated key.
+- If you set `setAsCurrent=True` while the encryption state was set as `False`, the instance encryption state is changed to `True` and the newly generated key is set as an encryption key.
+
+    E.g. Encrypt a json file:
+
+```python
+from maplex import MapleJson
+
+jsonFile = MapleJson("sampleFile.json")
+jsonData = jsonFile.read()
+key = jsonFile.generateKey(True)
+# YOU MUST SAVE THE KEY in the safe storage.
+jsonFile.write(jsonData)
+```
+
+    The code will encrypt the `sampleFile.json` with AES-128 encryption with the randomly generated key.
+
+    **There is no *redo*** in encryption. **DO NOT FORGET** your encryption key, or *you will lose your data FOREVER.*
+
+## Getters and Setters
+
+    Every class parameter has its own getter and setter functions, and you can set, change, or get those values after initializing the class.
+
+- You need to set the encryption key when you set the encryption to `True`.

{maplex-3.0.0.dev4 → maplex-3.0.1}/readmes/README_Logger.md

@@ -30,37 +30,50 @@ def __init__(
 
     The parameter overwrites the settings configured in `config.mpl`.
 
-## Usage
+## Functions
+
+### `getLogger()`
+
+```python
+def getLogger(
+    name = "",
+    **kwargs
+) -> maplex.Logger:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`name`**||Primary funcion name|`v3.0`|
+|**`**kwargs`**||Other parameters|`v3.0`|
+
+    This get or creates a Logger instance.
+
+    If you already have a Logger class instance with the same name, the function returns the existing instance, and you can save your resources on the machine.
 
 ```python
 from maplex
 
-logger = maplex.getLogger("FunctionName")
-logger.info("Hello there!")
+logger = maplex.getLogger(__name__)
 ```
 
-This outputs:
+## Getters and Setters
 
-```console
-[INFO ][FunctionName] <module>(4) Hello there!
-```
+&nbsp;&nbsp;&nbsp;&nbsp;Every class parameter has its own getter and setter functions, and you can set, change, or get those values after initializing the class.
 
-File output will be:  `AppLog.log`
+## Logging Methods
 
-```log
-(PsNo) yyyy-MM-dd HH:mm:ss.fff [INFO ][FunctionName] <module>(4) Hello there!
+```python
+def trace(object: any) -> None:
+def debug(object: any) -> None:
+def info(object: any) -> None:
+def warn(object: any) -> None:
+def error(object: any) -> None:
+def fatal(object: any) -> None:
 ```
 
-### Log Level
-
-- `TRACE`
-- `DEBUG`
-- `INFO`
-- `WARN`
-- `ERROR`
-- `FATAL`
+&nbsp;&nbsp;&nbsp;&nbsp;Each function outputs the log in each log level.
 
-### ShowError function
+## `ShowError` Function
 
 &nbsp;&nbsp;&nbsp;&nbsp;This outputs the error logs and stuck trace.
 
@@ -82,6 +95,36 @@ def ShowError(
 
 - If `fatal=True`, it outputs log as a `FATAL` log level.
 
+## Usage
+
+```python
+from maplex
+
+logger = maplex.getLogger("FunctionName")
+logger.info("Hello there!")
+```
+
+This outputs:
+
+```console
+[INFO ][FunctionName] <module>(4) Hello there!
+```
+
+File output will be:  `AppLog.log`
+
+```log
+(PsNo) yyyy-MM-dd HH:mm:ss.fff [INFO ][FunctionName] <module>(4) Hello there!
+```
+
+### Log Level
+
+- `TRACE`
+- `DEBUG`
+- `INFO`
+- `WARN`
+- `ERROR`
+- `FATAL`
+
 ## Settings
 
 - You can configure log settings with a JSON formatted file (default: `config.json`).

{maplex-3.0.0.dev4 → maplex-3.0.1/src/MapleX.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.0.0.dev4
+Version: 3.0.1
 Summary: A Python library for simple logging, json file operations, Maple file format operations, and console color utilities.
-Author: RyujiHazama
+Author: Ryuji Hazama
 Project-URL: PyPI, https://pypi.org/project/MapleX/
 Project-URL: Homepage, https://github.com/Ryuji-Hazama
 Project-URL: Repository, https://github.com/Ryuji-Hazama/MapleTree
@@ -78,7 +78,7 @@ Also outputs to the log file:
 
 [More details](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/README_Logger.md)
 
-[Logging Tips](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingTips.md)
+[Logging Best Practice](https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/LoggingBestPractice.md)
 
 ## MapleJson
 
@@ -185,11 +185,6 @@ All datas after "\nEOF\n" will be ignored
 - `--upgrade` option for upgrade from older version.
 - `--break-system-package` option for Python on Linux OS outside the `venv`. ***This might brak the system Python package dependencies.***
 
-### Manual Installation
-
-1. Download `./dist/maplex-<version>-py3-none-any.whl`
-2. Run `[python[3] -m] pip install /path/to/downloaded/maplex-<version>-py3-none-any.whl [--break-system-packages]`
-
 ### Build the Package by Yourself
 
 &nbsp;&nbsp;&nbsp;&nbsp;Run `python[3] -m build`  

{maplex-3.0.0.dev4 → maplex-3.0.1}/src/MapleX.egg-info/SOURCES.txt

@@ -4,7 +4,7 @@ README.md
 logErrorOutputSample.png
 logOutputSample.png
 pyproject.toml
-readmes/LoggingTips.md
+readmes/LoggingBestPractice.md
 readmes/README_ConsoleColors.md
 readmes/README_Exceptions.md
 readmes/README_Json.md

{maplex-3.0.0.dev4 → maplex-3.0.1}/src/maplex/__init__.py

@@ -4,7 +4,7 @@ Logger: A simple logging utility for tracking events and debugging.
 """
 
 from .mapleColors import ConsoleColors
-from .json import MapleJson
+from .json import MapleJson, getMapleJson
 from .mapleLogger import Logger, getLogger, getDailyLogger
 from .mapleExceptions import (
     InvalidMapleFileFormatException,
@@ -27,6 +27,7 @@ from .utils import winHide, winUnHide
 __all__ = [
     'ConsoleColors',
     'getDailyLogger',
+    'getMapleJson',
     'getLogger',
     'InvalidMapleFileFormatException',
     'KeyEmptyException',
@@ -48,6 +49,6 @@ __all__ = [
     'winUnHide'
 ]
 
-__version__ = "3.0.0.dev4"
+__version__ = "3.0.1"
 __author__ = "Ryuji Hazama"
 __license__ = "MIT"

{maplex-3.0.0.dev4 → maplex-3.0.1}/src/maplex/json.py

@@ -63,7 +63,7 @@ class MapleJson:
 
         return self.encrypt
     
-    def setEncryption(self, encrypt: bool, key=None) -> None:
+    def setEncryption(self, encrypt: bool, key: bytes | None = None) -> None:
 
         self.encrypt = encrypt
 
@@ -74,7 +74,7 @@ class MapleJson:
         self.key = key
         self.fernet = Fernet(key) if encrypt and key else None
 
-    def getKey(self) -> bytes:
+    def getKey(self) -> bytes | None:
 
         return self.key
 
@@ -87,7 +87,7 @@ class MapleJson:
     #####################
     # Basic File Operations
 
-    def read(self, *keys) -> dict | None:
+    def read(self, *keys: str) -> dict | None:
 
         try:
 
@@ -158,7 +158,6 @@ class MapleJson:
     #####################
     # Utility Methods
 
-    #
     #####################
     # Generate Encryption Key
 
@@ -180,4 +179,27 @@ class MapleJson:
             self.fernet = Fernet(key)
             self.encrypt = True
 
-        return key
+        return key
+
+_json: dict[str, MapleJson] = {}
+
+# Get or create a MapleJson instance
+
+def getMapleJson(filePath: str,
+                  fileEncoding: str = 'utf-8',
+                  indent: int = 4,
+                  ensureAscii: bool = False,
+                  encrypt: bool = False,
+                  key: bytes = None
+                  ) -> MapleJson:
+
+    if filePath not in _json:
+
+        _json[filePath] = MapleJson(filePath,
+                                    fileEncoding,
+                                    indent,
+                                    ensureAscii,
+                                    encrypt,
+                                    key)
+
+    return _json[filePath]

{maplex-3.0.0.dev4 → maplex-3.0.1}/src/maplex/mapleLogger.py

@@ -37,6 +37,9 @@ class Logger:
         self.consoleColors = ConsoleColors()
         self.fileMode = "append" if fileMode is None else fileMode
         self.encoding = encoding
+        self.timestampFormat = "%F %X.%f" # Timestamp format for logs (set this in config in future)
+        self.consoleAlignWidth = 16 # Width for function name alignment in logs (set this in config in future)
+        self.fileAlignWidth = 4 # Width for function name alignment in logs (set this in config in future)
 
         try:
 
@@ -53,6 +56,7 @@ class Logger:
             self.__checkOutputDirectory(workingDirectory)
             self.__setLogFileName(self.fileMode)
             self.__setFuncName(kwargs.get("getLogger", False), func)
+            self.__setAlignWidth(self.consoleAlignWidth, self.fileAlignWidth)
             self.__setLogFileSize(maxLogSize)
             self.__setOutputLogLevels(cmdLogLevel, fileLogLevel)
             self.__setFileEncoding(encoding)
@@ -210,6 +214,26 @@ class Logger:
             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: any) -> None:
 
         self.maxLogSize = 0
@@ -551,16 +575,26 @@ class Logger:
             # 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}")
+                consolePrefix = f"[{col}{loglevel.name:5}{Reset}]{Green}{self.func}{Reset} {bBlack}{callerFunc}({callerLine}){Reset}"
+                colorLength = len(col) + len(Reset) + len(Green) + len(Reset) + len(bBlack) + len(Reset)
+                consolePrefixLength = len(consolePrefix) - colorLength
+                consoleAlignWidth = self.consoleAlignWidth * (consolePrefixLength // self.consoleAlignWidth + (1 if consolePrefixLength % self.consoleAlignWidth != 0 else 0))
+                consoleAlignWidth += colorLength
+                print(f"{consolePrefix:<{consoleAlignWidth}}: {message}")
         
             if loglevel >= self.fileLogLevel:
 
+                timeStamp = datetime.now().strftime(self.timestampFormat)[:-3]
+                prefixString = f"({self.pid}) {timeStamp} [{loglevel.name:5}]{self.func} {self.callerName}{callerFunc}({callerLine})"
+                prefixLength = len(prefixString)
+                alignWidth = self.fileAlignWidth * (prefixLength // self.fileAlignWidth + (1 if prefixLength % self.fileAlignWidth != 0 else 0))
+
                 for i in range(3):
 
                     try:
 
                         with open(self.logfile, "a", encoding=self.encoding) as f:
-                            print(f"({self.pid}) {f"{datetime.now():%F %X.%f}"[:-3]} [{loglevel.name:5}]{self.func} {self.callerName}{callerFunc}({callerLine}) {message}", file=f)
+                            print(f"{prefixString:<{alignWidth}}: {message}", file=f)
 
                         break
 
@@ -703,8 +737,7 @@ class Logger:
 
             self.logWriter(logLevel, message, callerDepth=2)
 
-        self.logWriter(logLevel, ex, callerDepth=2)
-        self.logWriter(logLevel, traceback.format_exc(), callerDepth=2)
+        self.logWriter(logLevel, f"{ex}\n{traceback.format_exc()}", callerDepth=2)
 
     #
     ################################

maplex-3.0.0.dev4/readmes/LoggingTips.md

@@ -1 +0,0 @@
-# Logging Tips

maplex-3.0.0.dev4/readmes/README_Json.md

@@ -1,93 +0,0 @@
-# MapleJson Class
-
-    MapleJson class is a class library to manage the JSON formatted files.
-
-- You can read a JSON file as a `dict` data.
-- You can write the `dict` data into a file as a JSON formatted string
-- You can save the data as an encrypted data string.
-- You can decrypt the encrypted data.
-
-## Class Initialization
-
-```python
-
-def __init__(
-    filePath: str,
-    fileEncoding: str = 'utf-8',
-    indent: int = 4,
-    ensure_ascii: bool = False,
-    encrypt: bool = False,
-    key: bytes = None
-) -> None:
-```
-
-|Property|Required|Value|Version|
-|--------|--------|-----|-------|
-|**filePath**|\*|JSON file path|3.0.0|
-|**fileEncoding**||File encoding|3.0.0|
-|**indent**||Indent size for save as a JSON file|3.0.0|
-|**ensureAscii**||Ensure ASCII flag when save to a file|3.0.0|
-|**encrypt**||Encryption flag|3.0.0|
-|**key**|(\*)|Encryption key|3.0.0|
-
-    Initialize the class with a file path.
-
-### File encoding
-
-    You can set a specific file character encoding. Default: `UTF-8`
-
-    E.g.: If you are using `Shift_JIS` (Japanese system), you should initialize the class like the example below:
-
-```python
-from maplex import MapleJson
-
-jsonInstance = MapleJson("jsonFile.json", fileEncoding="shift_jis")
-```
-
-### Indent size
-
-    You can set the block indent size with `indent` parameter. Default: `4`
-
-    If you set `indent=2`, the file will be save like the example below:
-
-```json
-{
-  "Data": {
-    "Key": "Value",
-  }
-}
-```
-
-### Ensure ASCII
-
-    You can set the flag to ensure ASCII encoding.
-
-    If you don't set the parameter (Default: `False`), the file contents after saving are look like the example below:
-
-```json
-{
-    "data": {
-        "japanese": "値",
-        "russian": "значение",
-        "english": "value"
-    }
-}
-```
-
-    But, if you set `ensureAscii=True`, the file contents after saving will be changed like:
-
-```json
-{
-    "data": {
-        "japanese": "\u5024",
-        "russian": "\u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435",
-        "english": "value"
-    }
-}
-```
-
-### Encrypt
-
-### Key
-
-## Functions