MapleX 3.1.3__tar.gz → 3.2.0__tar.gz

{maplex-3.1.3/src/MapleX.egg-info → maplex-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.1.3
+Version: 3.2.0
 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/
@@ -16,8 +16,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cryptography>=46.0.3
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: cryptography>=49.0.0
+Requires-Dist: pydantic>=2.13.4
 Dynamic: license-file
 
 # MapleX

{maplex-3.1.3 → maplex-3.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MapleX"
-version = "3.1.3"
+version = "3.2.0"
 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"
@@ -13,8 +13,8 @@ authors = [
     {name = "Ryuji Hazama"}
 ]
 dependencies = [
-    "cryptography>=46.0.3",
-    "pydantic>=2.12.5"
+    "cryptography>=49.0.0",
+    "pydantic>=2.13.4",
 ]
 classifiers = [
     "Programming Language :: Python :: 3.12",
@@ -41,4 +41,4 @@ Homepage = "https://github.com/Ryuji-Hazama"
 Repository = "https://github.com/Ryuji-Hazama/MapleTree"
 Issues = "https://github.com/Ryuji-Hazama/MapleTree/issues"
 YouTube = "https://www.youtube.com/@ryujihazama"
-Instagram = "https://www.instagram.com/ryujihazama/"
+Instagram = "https://www.instagram.com/ryujihazama/"

{maplex-3.1.3 → maplex-3.2.0}/readmes/LoggingBestPractice.md

@@ -101,7 +101,7 @@
 
 ### `NONE`
 
-    The `NONE` level is a special level in `MapleX` that not commonly exists in other logging libraries. It is used to bypass all the log level filters and always output the log, or suppress all other log levels if you set this in the logger configuration. This is useful for debugging in production environments, where you want to log a specific event, but don't want to log any other lower level events under the same logger configuration. For example, you can set the log level to `NONE` for a specific logger to always log suspicious events, while setting the log level to `WARNING` for other loggers to only log warnings and errors.
+    The `NONE` level is a special level in `MapleX` that not commonly exists in other logging libraries. It is used to bypass all the log level filters and always output the log, or suppress all other log levels if you set this in the logger configuration. This is useful for debugging in production environments, where you want to log a specific event, but don't want to log any other lower level events under the same logger configuration. For example, you can set the log level to `NONE` for a specific logger to always log suspicious events, while setting the log level to `WARN` for other loggers to only log warnings and errors.
 
 ## Conclusion
 

{maplex-3.1.3 → maplex-3.2.0}/readmes/README_Json.md

@@ -94,6 +94,10 @@ jsonInstance = MapleJson("jsonFile.json", fileEncoding="shift_jis")
 
     **There is no *redo*** in encryption. **DO NOT FORGET** your encryption key, or *you will lose your data FOREVER.*
 
+#### Disclaimers
+
+    This encryption is just a basic implementation using AES-128 (Fernet) and is intended for general use cases. It may not be suitable for highly sensitive data or scenarios requiring advanced security measures. If you need stronger security, consider using more robust encryption methods or libraries.
+
 ### Key
 
     A 32-byte byte-string key for encryption.
@@ -339,3 +343,7 @@ jsonFile.write(jsonData)
     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`.
+
+## Disclaimers for Encryption
+
+    The encryption provided by this library is just a basic implementation using AES-128 (Fernet) and is intended for general use cases. It may not be suitable for highly sensitive data or scenarios requiring advanced security measures. If you need stronger security, consider using more robust encryption methods or libraries.

maplex-3.2.0/readmes/README_Logger.md

@@ -0,0 +1,246 @@
+# Logger Class
+
+    Logger class is a logging object for Python applications. It outputs application logs to log files and to standard output.
+
+## Logger Initialization
+
+```python
+def __init__(
+    func: str = "",
+    workingDirectory: str | None = None,
+    cmdLogLevel: str | None = None,
+    fileLogLevel: str | None = None,
+    maxLogSize: float | None = None,
+    fileMode: Literal["append", "overwrite", "daily"] | None = None,
+    configFile: str = "config.json",
+    encoding: str | None = None,
+) -> None:
+```
+
+|Property|Required|Value|Version|
+|--------|--------|-----|-------|
+|**`func`**||Primary function name||
+|**`workingDirectory`**||Log file output directory||
+|**`cmdLogLevel`**||Terminal output log level||
+|**`fileLogLevel`**||Log file output log level||
+|**`maxLogSize`**||Log file max size (MB)||
+|**`fileMode`**||Logging file mode|`v3.0`|
+|**`configFile`**||Logger configuration file path|`v3.0`|
+|**`encoding`**||Log file encoding|`v3.0`|
+
+    The parameter overwrites the settings configured in `config.mpl`.
+
+## 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(__name__)
+```
+
+## 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.
+
+## Logging Methods
+
+```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, exception: Exception | None = None) -> None:
+def fatal(object: any, exception: Exception | None = None) -> None:
+```
+
+- You can use `exception` parameter to log the exception details along with a custom message in `error` and `fatal` methods in `v3.2.0` or later.
+
+    Each function outputs the log in each log level.
+
+## `ShowError` Function
+
+    This outputs the error logs and stuck trace.
+
+Function:
+
+```python
+def ShowError(
+    ex: Exception,
+    message: str | None = None,
+    fatal: bool = False
+)
+```
+
+|Property|Required|Value|
+|--------|--------|-----|
+|**`ex`**|\*|Exception|
+|**`message`**||Custom error message|
+|**`fatal`**||Show error as `FATAL`|
+
+- 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`).
+- If the configuration file does not exist, the instance auto-generates the file.
+- Instance uses the parameter values to auto-generate a configuration file, or uses the default value if it was not specified.
+
+Auto-generated configuration file (parameters not specified):
+
+```json
+{
+    "MapleLogger": {
+        "ConsoleLogLevel": "INFO",
+        "FileLogLevel": "INFO",
+        "MaxLogSize": 3,
+        "WorkingDirectory": "logs",
+        "FileEncoding": "utf-8",
+        "Formats": {
+            "Timestamp": {
+                "Format": "%F %X.%f",
+                "Digits": null
+            },
+            "ConsoleLogFormat": "[{level}]{func} {callerFunc}{callerLine}",
+            "FileLogFormat": "({pid}) {timestamp} [{level}]{func} {callerName}{callerFunc}({callerLine})",
+            "Separator": ": "
+        }
+    }
+}
+```
+
+|Key|Value|
+|---|-----|
+|**`ConsoleLogLevel`**|Console log level|
+|**`FileLogLevel`**|File log level|
+|**`MaxLogSize`**|Log file max size (MB)|
+|**`WorkingDirectory`**|Log file output path|
+|**`FileEncoding`**|Log file encoding|
+|**`Formats`**|Log format settings|
+|**`NameSpaces`**|Namespace specific log level settings|
+
+- To disable the log output, set the log level to `NONE`.
+- You can use a `float` number for the file max size (E.g., `2.5` for `2.5MB`)
+- You can also use a `str` for the file max size (E.g., `"3M"`)
+- You can set the timestamp format with the `Format` key in the `Timestamp` section of the `Formats` settings.
+  - The default format is `%F %X.%f`, which outputs the timestamp as `yyyy-MM-dd HH:mm:ss.fff`. You can use any valid Python datetime format string.
+- You can set the number of digits for the timestamp with the `Digits` key in the `Timestamp` section of the `Formats` settings.
+
+### Formats
+
+&nbsp;&nbsp;&nbsp;&nbsp;`v3.2.0` or later
+
+- You can set the log format for console and file output with the `ConsoleLogFormat` and `FileLogFormat` keys in the `Formats` settings.
+- Also, you can set the timestamp format with the `Format` key in the `Timestamp` section of the `Formats` settings.
+
+```json
+{
+    "MapleLogger": {
+        "Formats": {
+            "Timestamp": {
+                "Format": "%F %X.%f",
+                "Digits": -3
+            },
+            "ConsoleLogFormat": "[{level}]{func} {callerFunc}{callerLine}",
+            "FileLogFormat": "({pid}) {timestamp} [{level}]{func} {callerName}{callerFunc}({callerLine})",
+            "Separator": ": "
+        }
+    }
+}
+```
+
+|Key|Value|
+|---|-----|
+|**`Timestamp.Format`**|Timestamp format string|
+|**`Timestamp.Digits`**|Number of digits for the timestamp|
+|**`ConsoleLogFormat`**|Console log format string|
+|**`FileLogFormat`**|File log format string|
+|**`Separator`**|Separator string between prefix and message|
+
+- You can use standard Python datetime format strings for the `Timestamp.Format` key. For example, `%F %X.%f` outputs the timestamp as `yyyy-MM-dd HH:mm:ss.fff`.
+- You can set the number of digits for the timestamp with the `Timestamp.Digits` key.
+  - The default value is `null`, which outputs the full length of the timestamp.
+  - However, I recommend using `-3` to output the timestamp with milliseconds, which is the most common format for logging.
+  - You can use a negative number to specify the number of digits to output from the end of the timestamp. For example, `-3` cuts the last three digits of the timestamp, which outputs the timestamp as `yyyy-MM-dd HH:mm:ss.fff`.
+- You can use the following placeholders in the log format strings:
+
+`{pid}`: Process ID  
+`{timestamp}`: Timestamp  
+`{level}`: Log level  
+`{func}`: Function name  
+`{callerName}`: Caller function name  
+`{callerFunc}`: Caller function name (with module name)  
+`{callerLine}`: Caller line number
+
+### Namespace Specific Log Level Settings
+
+- You can set the log level for specific namespaces by adding a `NameSpaces` key in the configuration file.
+- The `NameSpaces` key is a list of dictionaries, where each dictionary contains a `NameSpace`, a `ConsoleLogLevel`, and a `FileLogLevel`.
+
+Example:
+
+```json
+{
+    "MapleLogger": {
+        "ConsoleLogLevel": "INFO",
+        "FileLogLevel": "INFO",
+        "NameSpaces": [
+            {
+                "NameSpace": "MyNamespace",
+                "ConsoleLogLevel": "DEBUG",
+                "FileLogLevel": "INFO"
+            }
+        ]
+    }
+}
+```
+
+- In this example, the log level for the `MyNamespace` namespace is set to `DEBUG` for console output and `INFO` for file output. All other namespaces will use the default log levels specified in the `ConsoleLogLevel` and `FileLogLevel` keys.
+- You can use this setting to control the log output for different parts of your application, allowing you to have more detailed logs for specific namespaces while keeping the overall log output at a higher level.

{maplex-3.1.3 → maplex-3.2.0/src/MapleX.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MapleX
-Version: 3.1.3
+Version: 3.2.0
 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/
@@ -16,8 +16,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cryptography>=46.0.3
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: cryptography>=49.0.0
+Requires-Dist: pydantic>=2.13.4
 Dynamic: license-file
 
 # MapleX

{maplex-3.1.3 → maplex-3.2.0}/src/MapleX.egg-info/SOURCES.txt

@@ -29,6 +29,10 @@ 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
+src/maplex/library/logger/consts/__init__.py
+src/maplex/library/logger/consts/config_keys.py
+src/maplex/library/logger/consts/defaults.py
+src/maplex/library/logger/consts/dict_keys.py
 tests/test_logger_unittest.py
 tests/test_maplejson_unittest.py
 tests/test_mapletree_unittest.py

maplex-3.2.0/src/MapleX.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=49.0.0
+pydantic>=2.13.4

{maplex-3.1.3 → maplex-3.2.0}/src/maplex/__init__.py

@@ -52,7 +52,7 @@ __all__ = [
     'winUnHide'
 ]
 
-__version__ = "3.1.3"
+__version__ = "3.2.0"
 __author__ = "Ryuji Hazama"
 __license__ = "MIT"
 

{maplex-3.1.3 → maplex-3.2.0}/src/maplex/library/logger/__init__.py

@@ -2,7 +2,7 @@
 Split mapleLogger.py into multiple files for better organization and maintainability.
 """
 
-from .config import LoggerConfig
+from .config import LoggerConfig, TimeStamp
 from .file_handler import FileHandler
 from .formatter import Formatter
 from .log_levels import LogLevel
@@ -14,6 +14,7 @@ __all__ = [
     "LoggerConfig",
     "LogLevel",
     "getConsoleColors",
+    "TimeStamp",
     "toLogLevel",
     "toLogSize",
     "isLogLevel"

{maplex-3.1.3 → maplex-3.2.0}/src/maplex/library/logger/config.py

@@ -21,6 +21,18 @@ from .utilities import *
 from library.logger.log_levels import LogLevel
 
 
+class TimeStamp(BaseModel):
+
+    timestampFormat: str | None = None
+    digits: int | None = None
+
+class Formats(BaseModel):
+
+    consoleFormat: str | None = None
+    fileFormat: str | None = None
+    separator: str | None = None
+    timestamp: TimeStamp | None = None
+
 class LoggerConfig(BaseModel):
 
     func: str | None = None
@@ -32,12 +44,10 @@ class LoggerConfig(BaseModel):
     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
-    consoleFormat: str = CONSOLE_FORMAT
-    fileFormat: str = FILE_FORMAT
+    formats: Formats | None = None
 
     logConfInstance: None = None
     logConf: dict[str, object] | None = None
@@ -51,9 +61,7 @@ class LoggerConfig(BaseModel):
         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"))
@@ -62,11 +70,13 @@ class LoggerConfig(BaseModel):
             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.setTimestampFormat(config.get(PARAM_TIMESTAMP, None))
+            self.setOutputFormat(config.get(CONSOLE_LOG_FORMAT, None), config.get(FILE_LOG_FORMAT, None), config.get(SEPARATOR, None))
             self.saveLogSettings(self.logConfInstance)
 
         except Exception as ex:
 
+            print(ex)
             print(f"{self.consoleColors.Red}Error: Failed to initialize logger config: {ex}{self.consoleColors.Reset}")
             raise ex
 
@@ -245,10 +255,26 @@ class LoggerConfig(BaseModel):
             print(f"{self.consoleColors.Red}Warning: Infinite log file size is not recommended. Using default value.{self.consoleColors.Reset}")
             self.maxLogSize = 3000000
 
+    def getLogLevel(self) -> None:
+
+        '''
+        Get LogLevel configuration from config file.
+        Set namespace specific LogLevel if available, otherwise set default LogLevel.
+        '''
+
+        namespaceSettings = self.logConf.get(NAME_SPACES, [])
+        thisNamespaceSettings = next((ns for ns in namespaceSettings if ns.get(NAME_SPACE) == self.callerName), None)
+
+        if thisNamespaceSettings is not None:
+
+            self.consoleLogLevel = thisNamespaceSettings.get(CONSOLE_LOG_LEVEL, None)
+            self.fileLogLevel = thisNamespaceSettings.get(FILE_LOG_LEVEL, None)
+
     def setOutputLogLevels(self, cmdLogLevel: object, fileLogLevel: object) -> None:
 
-        self.consoleLogLevel = self.__setLogLevel(CONSOLE_LOG_LEVEL, cmdLogLevel)
-        self.fileLogLevel = self.__setLogLevel(FILE_LOG_LEVEL, fileLogLevel)
+        self.getLogLevel()
+        self.consoleLogLevel = self.__setLogLevel(CONSOLE_LOG_LEVEL, cmdLogLevel if self.consoleLogLevel is None else self.consoleLogLevel)
+        self.fileLogLevel = self.__setLogLevel(FILE_LOG_LEVEL, fileLogLevel if self.fileLogLevel is None else self.fileLogLevel)
 
     def __setLogLevel(self, fileOrConsole, loglevel: object) -> LogLevel:
 
@@ -260,7 +286,7 @@ class LoggerConfig(BaseModel):
         
         else:
 
-            tempLogLevel = self.logConf.get(fileOrConsole, "INFO")
+            tempLogLevel = self.logConf.get(fileOrConsole, None)
 
             if tempLogLevel is None:
 
@@ -293,24 +319,107 @@ class LoggerConfig(BaseModel):
 
             self.encoding = fileEncoding
 
-    def setTimestampFormat(self, timestampFormat: str) -> None:
+    def setTimestampFormat(self, timestampFormat: dict) -> 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 self.formats is None:
+
+            self.formats = Formats()
+
+        if self.formats.timestamp is None:
+
+            self.formats.timestamp = TimeStamp()
+
         if timestampFormat is not None:
 
-            self.timestampFormat = timestampFormat
+            self.formats.timestamp.timestampFormat = timestampFormat.get(FORMAT, None)
+            self.formats.timestamp.digits = timestampFormat.get(DIGITS, 3)
 
         else:
 
-            configTimestampFormat = self.logConf.get(TIMESTAMP_FORMAT, None)
+            timestampSettings = self.logConf.get(FORMATS, {}).get(TIMESTAMP, {})
+            configTimestampFormat = timestampSettings.get(FORMAT, None)
+            configTimestampDigits = timestampSettings.get(DIGITS, None)
 
             if configTimestampFormat is None:
 
-                configTimestampFormat = "%F %X.%f"
-                self.logConf[TIMESTAMP_FORMAT] = configTimestampFormat
+                configTimestampFormat = TIMESTAMP_FORMAT
+                timestampSettings[FORMAT] = configTimestampFormat
+                self.logConf.setdefault(FORMATS, {})[TIMESTAMP] = timestampSettings
+
+            if configTimestampDigits is None:
+
+                configTimestampDigits = MILLISECOND_DIGITS
+                timestampSettings[DIGITS] = configTimestampDigits
+                self.logConf.setdefault(FORMATS, {})[TIMESTAMP] = timestampSettings
+
+            if "TimestampFormat" in self.logConf:
+
+                # Show warning if old config key is used
+                print(f"{self.consoleColors.Yellow}Warning: 'TimestampFormat' key in config file is deprecated. Please use 'Formats.Timestamp' instead.{self.consoleColors.Reset}\nMore details: https://github.com/Ryuji-Hazama/MapleTree/blob/main/readmes/README_Logger.md#settings")
+
+            self.formats.timestamp.timestampFormat = configTimestampFormat
+            self.formats.timestamp.digits = configTimestampDigits
+
+    def setOutputFormat(self, consoleFormat: str, fileFormat: str, separator: str | None = None) -> None:
+
+        """Set output format for console and file logs. Default is "[{level}]{func} {callerFunc}{callerLine}" for console and "({pid}) {timestamp} [{level}]{func} {callerName}{callerFunc}({callerLine})" for file. You can set this in config file with keys "ConsoleLogFormat" and "FileLogFormat"."""
+
+        if self.formats is None:
+
+            self.formats = Formats()
+
+        # Console format
+
+        if consoleFormat is not None:
+
+            self.formats.consoleFormat = consoleFormat
+
+        else:
+
+            self.formats.consoleFormat = self.logConf.get(FORMATS, {}).get(CONSOLE_LOG_FORMAT, None)
+
+            if self.formats.consoleFormat is None:
+
+                self.formats.consoleFormat = CONSOLE_FORMAT
+                formatConf = self.logConf.get(FORMATS, {})
+                formatConf[CONSOLE_LOG_FORMAT] = CONSOLE_FORMAT
+                self.logConf[FORMATS] = formatConf
+
+        # File format
+
+        if fileFormat is not None:
+
+            self.formats.fileFormat = fileFormat
+
+        else:
+
+            self.formats.fileFormat = self.logConf.get(FORMATS, {}).get(FILE_LOG_FORMAT, None)
+
+            if self.formats.fileFormat is None:
+
+                self.formats.fileFormat = FILE_FORMAT
+                formatConf = self.logConf.get(FORMATS, {})
+                formatConf[FILE_LOG_FORMAT] = FILE_FORMAT
+                self.logConf[FORMATS] = formatConf
+
+        # Message separator
+
+        if separator is not None:
+
+            self.formats.separator = separator
+
+        else:
+
+            self.formats.separator = self.logConf.get(FORMATS, {}).get(SEPARATOR, None)
+
+            if self.formats.separator is None:
 
-            self.timestampFormat = configTimestampFormat
+                self.formats.separator = DEFAULT_SEPARATOR
+                formatConf = self.logConf.get(FORMATS, {})
+                formatConf[SEPARATOR] = DEFAULT_SEPARATOR
+                self.logConf[FORMATS] = formatConf
 
     def saveLogSettings(self, logConfInstance: MapleJson | None) -> None:
 
@@ -348,12 +457,12 @@ class LoggerConfig(BaseModel):
             MAX_LOG_SIZE: self.maxLogSize,
             FILE_MODE: "daily" if self.logfile and "log_" in self.logfile else "append",
             FILE_ENCODING: self.encoding,
-            TIMESTAMP_FORMAT: self.timestampFormat,
+            TIMESTAMP: self.formats.timestamp if self.formats.timestamp else None,
             GET_LOGGER: bool(self.func),
             CONSOLE_ALIGN_WIDTH: self.consoleAlignWidth,
             FILE_ALIGN_WIDTH: self.fileAlignWidth,
-            CONSOLE_FORMAT: self.consoleFormat,
-            FILE_FORMAT: self.fileFormat,
+            PARAM_CONSOLE_FORMAT: self.formats.consoleFormat,
+            PARAM_FILE_FORMAT: self.formats.fileFormat,
             PROCESS_ID: self.pid
         }
 

maplex-3.2.0/src/maplex/library/logger/consts/__init__.py

@@ -0,0 +1,45 @@
+from .config_keys import *
+from .defaults import *
+from .dict_keys import *
+
+__all__ = [
+    "CONFIG_KEY",
+    "CONSOLE",
+    "FILE",
+    "CONSOLE_LOG_LEVEL",
+    "FILE_LOG_LEVEL",
+    "MAX_LOG_SIZE",
+    "FILE_MODE",
+    "WORKING_DIRECTORY",
+    "FILE_ENCODING",
+    "FORMATS",
+    "TIMESTAMP",
+    "FORMAT",
+    "DIGITS",
+    "ALIGN_WIDTH",
+    "CONSOLE_LOG_FORMAT",
+    "FILE_LOG_FORMAT",
+    "SEPARATOR",
+    "NAME_SPACES",
+    "NAME_SPACE",
+    # Dictionary keys for internal use
+    "GET_LOGGER",
+    "FUNC",
+    "CONFIG_FILE",
+    "CONSOLE_ALIGN_WIDTH",
+    "FILE_ALIGN_WIDTH",
+    "CALLER_NAME",
+    "PROCESS_ID",
+    "PARAM_TIMESTAMP",
+    "PARAM_FORMATS",
+    "PARAM_CONSOLE_FORMAT",
+    "PARAM_FILE_FORMAT",
+    # Default values
+    "FILE_FORMAT",
+    "CONSOLE_FORMAT",
+    "DEFAULT_SEPARATOR",
+    "TIMESTAMP_FORMAT",
+    "MILLISECOND_DIGITS",
+    "FILE_MODE_OVERWRITE",
+    "FILE_MODE_DAILY",
+]

maplex-3.2.0/src/maplex/library/logger/consts/config_keys.py

@@ -0,0 +1,21 @@
+CONFIG_KEY = "MapleLogger"
+CONSOLE = "Console"
+FILE = "File"
+CONSOLE_LOG_LEVEL = "ConsoleLogLevel"
+FILE_LOG_LEVEL = "FileLogLevel"
+MAX_LOG_SIZE = "MaxLogSize"
+FILE_MODE = "FileMode"
+WORKING_DIRECTORY = "WorkingDirectory"
+FILE_ENCODING = "FileEncoding"
+
+FORMATS = "Formats"
+CONSOLE_LOG_FORMAT = "ConsoleLogFormat"
+FILE_LOG_FORMAT = "FileLogFormat"
+SEPARATOR = "Separator"
+TIMESTAMP = "Timestamp"
+FORMAT = "Format"
+DIGITS = "Digits"
+
+ALIGN_WIDTH = "AlignWidth"
+NAME_SPACES = "NameSpaces"
+NAME_SPACE = "NameSpace"

maplex-3.2.0/src/maplex/library/logger/consts/defaults.py

@@ -0,0 +1,7 @@
+FILE_FORMAT = '({pid}) {timestamp} [{level}]{func} {callerName}{callerFunc}({callerLine})'
+CONSOLE_FORMAT = '[{level}]{func} {callerFunc}{callerLine}'
+DEFAULT_SEPARATOR = ': '
+TIMESTAMP_FORMAT = "%F %X.%f"
+MILLISECOND_DIGITS = None
+FILE_MODE_OVERWRITE = 'overwrite'
+FILE_MODE_DAILY = 'daily'

maplex-3.2.0/src/maplex/library/logger/consts/dict_keys.py

@@ -0,0 +1,11 @@
+CONFIG_FILE = "configFile"
+FUNC = "func"
+GET_LOGGER = "getLogger"
+CONSOLE_ALIGN_WIDTH = "consoleAlignWidth"
+FILE_ALIGN_WIDTH = "fileAlignWidth"
+CALLER_NAME = "CallerName"
+PROCESS_ID = "pid"
+PARAM_TIMESTAMP = "timestamp"
+PARAM_FORMATS = "formats"
+PARAM_CONSOLE_FORMAT = "consoleFormat"
+PARAM_FILE_FORMAT = "fileFormat"

{maplex-3.1.3 → maplex-3.2.0}/src/maplex/library/logger/formatter.py

@@ -7,6 +7,7 @@ from datetime import datetime
 import inspect
 import os
 
+from .config import TimeStamp
 from .consts import *
 from .log_levels import *
 from .utilities import *
@@ -29,8 +30,10 @@ class Formatter:
         self.consoleColors = getConsoleColors()
         self.logLevel = LogLevel
         self.config = config
-        self.consoleFormat = config.get(CONSOLE_FORMAT, CONSOLE_FORMAT)
-        self.fileFormat = config.get(FILE_FORMAT, FILE_FORMAT)
+        self.consoleFormat = config.get(PARAM_CONSOLE_FORMAT, CONSOLE_FORMAT)
+        self.fileFormat = config.get(PARAM_FILE_FORMAT, FILE_FORMAT)
+        self.timestampFormat = self.config.get(TIMESTAMP, TimeStamp()).timestampFormat or TIMESTAMP_FORMAT
+        self.timestampDigits = config.get(TIMESTAMP, TimeStamp()).digits or MILLISECOND_DIGITS
         self.pid = os.getpid()
         self.COLOR_CODE_LENGTH = 5
         self.COLOR_CODE_RESET_LENGTH = 4
@@ -69,7 +72,7 @@ class Formatter:
 
         return colorCodeLength
 
-    def __getCurrentTimestamp(self, timestampFormat: str) -> str:
+    def __getCurrentTimestamp(self) -> str:
 
         """
         Get the current timestamp formatted according to the specified format string.
@@ -78,7 +81,7 @@ class Formatter:
         :return: The current timestamp as a formatted string.
         """
 
-        return datetime.now().strftime(timestampFormat)
+        return datetime.now().strftime(self.timestampFormat)[:self.timestampDigits]
 
     def __getLogLevelColor(self, logLevel: LogLevel) -> str:
 
@@ -142,7 +145,7 @@ class Formatter:
 
         if '{timestamp}' in consoleFormat:
 
-            timestamp = self.__getCurrentTimestamp(self.config.get(TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S'))
+            timestamp = self.__getCurrentTimestamp()
             consoleFormat = consoleFormat.replace('{timestamp}', timestamp)
 
         if '{level}' in consoleFormat:
@@ -193,7 +196,7 @@ class Formatter:
 
         if '{timestamp}' in fileFormat:
 
-            timestamp = self.__getCurrentTimestamp(self.config.get(TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S'))
+            timestamp = self.__getCurrentTimestamp()
             fileFormat = fileFormat.replace('{timestamp}', timestamp)
 
         if '{level}' in fileFormat:

{maplex-3.1.3 → maplex-3.2.0}/src/maplex/mapleLogger.py

@@ -28,7 +28,7 @@ class Logger:
             fileMode: Literal["append", "overwrite", "daily"] | None = None,
             configFile: str = "config.json",
             encoding: str | None = None,
-            timestampFormat: str | None = None,
+            timestamp: TimeStamp | None = None,
             **kwargs
         ) -> None:
 
@@ -48,7 +48,7 @@ class Logger:
                 "fileMode": fileMode,
                 "configFile": configFile,
                 "encoding": encoding,
-                "timestampFormat": timestampFormat,
+                "timestamp": timestamp,
                 "getLogger": kwargs.get("getLogger", False),
                 "consoleAlignWidth": kwargs.get("consoleAlignWidth", 16),
                 "fileAlignWidth": kwargs.get("fileAlignWidth", 4)
@@ -166,7 +166,7 @@ class Logger:
 
             if loglevel >= self.config.consoleLogLevel:
                 consolePrefix = self.formatter.format_console(loglevel, callerDepth)
-                print(f"{consolePrefix}: {message}")
+                print(f"{consolePrefix}{self.config.formats.separator}{message}")
         
             if loglevel >= self.config.fileLogLevel:
 
@@ -177,7 +177,7 @@ class Logger:
                     try:
 
                         with open(self.config.logfile, "a", encoding=self.config.encoding) as f:
-                            print(f"{prefixString}: {message}", file=f)
+                            print(f"{prefixString}{self.config.formats.separator}{message}", file=f)
 
                         break
 
@@ -235,21 +235,33 @@ class Logger:
     ################################
     # Error
 
-    def error(self, object: any):
+    def error(self, object: any, exception: Exception | None = None):
 
         '''Error log'''
 
-        self.logWriter(self.LogLevel.ERROR, object, callerDepth=self.DEFAULT_CALLER_DEPTH)
+        if exception is None:
+
+            self.logWriter(self.LogLevel.ERROR, object, callerDepth=self.DEFAULT_CALLER_DEPTH)
+
+        else:
+
+            self.ShowError(exception, message=f"{object}", fatal=False, additionalCallerDepth=1)
 
     #
     ################################
     # Fatal
 
-    def fatal(self, object: any):
+    def fatal(self, object: any, exception: Exception | None = None):
 
         '''Fatal log'''
 
-        self.logWriter(self.LogLevel.FATAL, object, callerDepth=self.DEFAULT_CALLER_DEPTH)
+        if exception is None:
+
+            self.logWriter(self.LogLevel.FATAL, object, callerDepth=self.DEFAULT_CALLER_DEPTH)
+
+        else:
+
+            self.ShowError(exception, message=f"{object}", fatal=True, additionalCallerDepth=1)
 
     #
     ################################
@@ -265,7 +277,7 @@ class Logger:
     ################################
     # Error messages
 
-    def ShowError(self, ex: Exception, message: str | None = None, fatal: bool = False):
+    def ShowError(self, ex: Exception, message: str | None = None, fatal: bool = False, additionalCallerDepth: int = 0) -> None:
 
         '''Show and log error'''
 
@@ -279,9 +291,9 @@ class Logger:
 
         if message is not None:
 
-            self.logWriter(logLevel, message, callerDepth=self.DEFAULT_CALLER_DEPTH)
+            self.logWriter(logLevel, message, callerDepth=self.DEFAULT_CALLER_DEPTH + additionalCallerDepth)
 
-        self.logWriter(logLevel, f"{ex}\n{traceback.format_exc()}", callerDepth=self.DEFAULT_CALLER_DEPTH)
+        self.logWriter(logLevel, f"{ex}\n{traceback.format_exc()}", callerDepth=self.DEFAULT_CALLER_DEPTH + additionalCallerDepth)
 
     #
     ################################
@@ -377,9 +389,9 @@ ToDo list:
 
 * Logger *
 
-- Add option to set date format
-- Add set* functions
 - Configure log format in config file
+- Configure mili sec digits
+- Add set* functions
 
 """
 """ * * * * * * * * * * * * * """

maplex-3.1.3/readmes/README_Logger.md

@@ -1,158 +0,0 @@
-# Logger Class
-
-    Logger class is a logging object for Python applications. It outputs application logs to log files and to standard output.
-
-## Logger Initialization
-
-```python
-def __init__(
-    func: str = "",
-    workingDirectory: str | None = None,
-    cmdLogLevel: str | None = None,
-    fileLogLevel: str | None = None,
-    maxLogSize: float | None = None,
-    fileMode: Literal["append", "overwrite", "daily"] | None = None,
-    configFile: str = "config.json",
-    encoding: str | None = None,
-) -> None:
-```
-
-|Property|Required|Value|Version|
-|--------|--------|-----|-------|
-|**`func`**||Primary function name||
-|**`workingDirectory`**||Log file output directory||
-|**`cmdLogLevel`**||Terminal output log level||
-|**`fileLogLevel`**||Log file output log level||
-|**`maxLogSize`**||Log file max size (MB)||
-|**`fileMode`**||Logging file mode|`v3.0`|
-|**`configFile`**||Logger configuration file path|`v3.0`|
-|**`encoding`**||Log file encoding|`v3.0`|
-
-    The parameter overwrites the settings configured in `config.mpl`.
-
-## 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(__name__)
-```
-
-## 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.
-
-## Logging Methods
-
-```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:
-```
-
-    Each function outputs the log in each log level.
-
-## `ShowError` Function
-
-    This outputs the error logs and stuck trace.
-
-Function:
-
-```python
-def ShowError(
-    ex: Exception,
-    message: str | None = None,
-    fatal: bool = False
-)
-```
-
-|Property|Required|Value|
-|--------|--------|-----|
-|**`ex`**|\*|Exception|
-|**`message`**||Custom error message|
-|**`fatal`**||Show error as `FATAL`|
-
-- 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`).
-- If the configuration file does not exist, the instance auto-generates the file.
-- Instance uses the parameter values to auto-generate a configuration file, or uses the default value if it was not specified.
-
-Auto-generated configuration file (parameters not specified):
-
-```json
-{
-    "MapleLogger": {
-        "ConsoleLogLevel": "INFO",
-        "FileLogLevel": "INFO",
-        "MaxLogSize": 3.0,
-        "WorkingDirectory": "/path/to/output/logs",
-        "FileEncoding": "utf-8"
-    }
-}
-```
-
-|Key|Value|
-|---|-----|
-|**`ConsoleLogLevel`**|Console log level|
-|**`FileLogLevel`**|File log level|
-|**`MaxLogSize`**|Log file max size (MB)|
-|**`WorkingDirectory`**|Log file output path|
-|**`FileEncoding`**|Log file encoding|
-
-- To disable the log output, set the log level to `NONE`.
-- You can use a `float` number for the file max size (E.g., `2.5` for `2.5MB`)
-- You can also use a `str` for the file max size (E.g., `"3M"`)

maplex-3.1.3/src/MapleX.egg-info/requires.txt

@@ -1,2 +0,0 @@
-cryptography>=46.0.3
-pydantic>=2.12.5