atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/loggingw/consts.py

@@ -0,0 +1,49 @@
+DEFAULT_ROTATING_SUFFIXES_FROM_WHEN: dict = {
+    'midnight': '%Y-%m-%d',
+    'S': '%Y-%m-%d_%H-%M-%S',
+    'M': '%Y-%m-%d_%H-%M',
+    'H': '%Y-%m-%d_%H',
+    'D': '%Y-%m-%d',
+    'W0': '%Y-%m-%d',
+    'W1': '%Y-%m-%d',
+    'W2': '%Y-%m-%d',
+    'W3': '%Y-%m-%d',
+    'W4': '%Y-%m-%d',
+    'W5': '%Y-%m-%d',
+    'W6': '%Y-%m-%d'
+}
+
+
+DEFAULT_STREAM_FORMATTER: str = "%(asctime)s | %(levelname)s | %(threadName)s | %(name)s | %(message)s"
+DEFAULT_MESSAGE_FORMATTER: str = "%(message)s"
+
+FORMAT_ELEMENT_TO_HEADER: dict = {
+    'asctime': 'Event Time [Y-M-D H:M:S]',
+    'created': 'Created',
+    'filename': "ModuleFileName            ",
+    'funcName': 'Function',
+    'levelname': 'Log Level',
+    'levelno': 'Level Number',
+    'lineno': 'Line ',
+    'module': 'Module',
+    'msecs': '[MS.mS]',
+    'message': 'Message',
+    'name': 'Logger Name                     ',
+    'pathname': 'Path',
+    'process': 'Process',
+    'processName': 'Process Name',
+    'relativeCreated': 'Relative Created',
+    'thread': 'Thread',
+    'threadName': 'Thread Name'
+}
+
+DEFAULT_FORMATTER_TXT_FILE: str = \
+    "{asctime} | " \
+    "{levelname:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['levelname'])}" + "s} | " \
+    "{name:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['name'])}" + "s} | " \
+    "{filename:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['filename'])}" + "s} : " \
+    "{lineno:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['lineno'])}" + "d} | " \
+    "{threadName} | {message}"
+
+DEFAULT_FORMATTER_CSV_FILE: str = \
+    '\"{asctime}\",{levelname},{name},{filename},{lineno},{threadName},\"{message}\"'

atomicshop/wrappers/loggingw/filters.py

@@ -0,0 +1,102 @@
+import logging
+import threading
+import os
+
+
+from ...basics import ansi_escape_codes
+
+
+class HeaderFilter(logging.Filter):
+    """
+    A logging.Filter that writes a header to a log file if the file is empty (
+    i.e., no log records have been written, i.e.2, on file rotation).
+    """
+
+    # noinspection PyPep8Naming
+    def __init__(self, header, baseFilename):
+        super().__init__()
+        self.header = header
+        self.baseFilename = baseFilename
+        self._write_header_if_needed()
+
+    def _write_header_if_needed(self):
+        if not os.path.exists(self.baseFilename) or os.path.getsize(self.baseFilename) == 0:
+            self._write_header()
+
+    def _write_header(self):
+        if self.header:
+            with open(self.baseFilename, 'a') as f:
+                f.write(self.header + '\n')
+
+    def filter(self, record):
+        self._write_header_if_needed()
+        return True
+
+
+class ThreadColorLogFilter(logging.Filter):
+    """
+    A logging.Filter that adds color to log records based on the thread that emitted the log record.
+    """
+    def __init__(self, color: str, thread_id):
+        super().__init__()
+        self.color = color
+        self.thread_id = thread_id
+
+    def filter(self, record):
+        if threading.get_ident() == self.thread_id:
+            record.msg = (
+                    ansi_escape_codes.get_colors_basic_dict(self.color) + record.msg +
+                    ansi_escape_codes.ColorsBasic.END)
+        return True
+
+
+"""
+A logging.Filter in Python's logging module is an object that provides a way to perform fine-grained 
+filtering of log records. 
+It allows you to control which log records are passed through and which are filtered out, 
+based on specific criteria you define.
+
+Basic Concepts of logging.Filter
+Purpose: Filters are used to allow or deny log records from being processed further. 
+This can be based on various criteria, such as the level of the log record, the source logger, or custom attributes.
+Implementation: Filters are typically subclasses of logging.Filter, 
+but they can also be any callable that accepts a log record and returns a boolean value.
+
+How logging.Filter Works
+When a log record is emitted, it is passed through any filters attached to the logger or the handler. 
+If the filter returns True, the log record is processed. If the filter returns False, the log record is ignored.
+
+Example of logging.Filter
+Here’s a simple example to demonstrate the use of logging.Filter:
+
+Create a Filter: Subclass logging.Filter and override the filter method.
+import logging
+
+class MyFilter(logging.Filter):
+    def filter(self, record):
+        # Example: Allow only log records with a level of WARNING or higher
+        return record.levelno >= logging.WARNING
+
+Attach the Filter to a Handler or Logger:
+# Create a logger
+logger = logging.getLogger('my_logger')
+logger.setLevel(logging.DEBUG)
+
+# Create a console handler
+console_handler = logging.StreamHandler()
+
+# Create an instance of the custom filter
+my_filter = MyFilter()
+
+# Add the filter to the handler
+console_handler.addFilter(my_filter)
+
+# Add the handler to the logger
+logger.addHandler(console_handler)
+
+# Log some messages
+logger.debug('This is a debug message')    # Will be filtered out
+logger.info('This is an info message')     # Will be filtered out
+logger.warning('This is a warning message') # Will be displayed
+logger.error('This is an error message')   # Will be displayed
+"""

atomicshop/wrappers/loggingw/formatters.py

@@ -1,4 +1,7 @@
 import logging
+import time
+
+from . import consts
 
 
 # Log formatter, means how the log will look inside the file
@@ -8,63 +11,33 @@ import logging
 
 # ".40" truncating the string to only 40 characters. Example: %(message).250s
 
-# Adding '%(asctime)s.%(msecs)06f' will print milliseconds as well as nanoseconds:
-# 2022-02-17 15:15:51,913.335562
-# If you don't use custom 'datefmt' in your 'setFormatter' function,
-# it will print duplicate milliseconds:
-# 2022-02-17 15:15:51,913.913.335562
-# The setting should be like:
-# file_handler.setFormatter(logging.Formatter(log_formatter_file, datefmt='%Y-%m-%d,%H:%M:%S'))
-# 's' stands for string. 'd' stands for digits, a.k.a. 'int'. 'f' stands for float.
-
-# Old tryouts:
-#   log_formatter_file: str = f"%(asctime)s.%(msecs)06f | " \
-#   log_formatter_file: str = f"%(asctime)s.%(msecs) | " \
-#                           f"%(levelname)-{len(log_header_level)}s | " \
-#                           f"%(name)-{len(log_header_logger)}s | " \
-#                           f"%(filename)-{len(log_header_script)}s : " \
-#                           f"%(lineno)-{len(log_header_line)}d | " \
-#                           "%(threadName)s: %(message)s"
-#   log_formatter_file: str = "{asctime}.{msecs:0<3.0f} | " \
-#   log_formatter_file: str = "{asctime}.{msecs:0>3.0f}.{msecs:0>.6f} | " \
-
-# Old tryouts for reference:
-#   file_formatter = logging.Formatter(log_formatter_file, style='{')
-#   file_formatter.default_time_format = '%Y-%m-%d %H:%M:%S'
-#   file_formatter.default_msec_format = '%s,%03d'
-#   file_formatter.default_msec_format = '%s,%03f'
-
-
-FORMAT_ELEMENT_TO_HEADER: dict = {
-    'asctime': 'Event Time [Y-M-D H:M:S]',
-    'created': 'Created',
-    'filename': "ModuleFileName            ",
-    'funcName': 'Function',
-    'levelname': 'Log Level',
-    'levelno': 'Level Number',
-    'lineno': 'Line ',
-    'module': 'Module',
-    'msecs': '[MS.mS]',
-    'message': 'Message',
-    'name': 'Logger Name                     ',
-    'pathname': 'Path',
-    'process': 'Process',
-    'processName': 'Process Name',
-    'relativeCreated': 'Relative Created',
-    'thread': 'Thread',
-    'threadName': 'Thread Name'
-}
-
-DEFAULT_FORMATTER_TXT_FILE: str = \
-    "{asctime},{msecs:013.9f} | " \
-    "{levelname:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['levelname'])}" + "s} | " \
-    "{name:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['name'])}" + "s} | " \
-    "{filename:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['filename'])}" + "s} : " \
-    "{lineno:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['lineno'])}" + "d} | " \
-    "{threadName} | {message}"
-
-DEFAULT_FORMATTER_CSV_FILE: str = \
-    '\"{asctime}.{msecs:010.6f}\",{levelname},{name},{filename},{lineno},{threadName},\"{message}\"'
+
+class NanosecondsFormatter(logging.Formatter):
+    def __init__(self, fmt=None, datefmt=None, style='%', use_nanoseconds=False):
+        super().__init__(fmt, datefmt, style)
+        self.use_nanoseconds = use_nanoseconds
+
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)
+
+        if datefmt:
+            # Remove unsupported %f from datefmt if present
+            if '%f' in datefmt:
+                datefmt = datefmt.replace('%f', '')
+                self.use_nanoseconds = True
+        else:
+            # Default time format if datefmt is not provided
+            datefmt = '%Y-%m-%d %H:%M:%S'
+
+        s = time.strftime(datefmt, ct)
+
+        if self.use_nanoseconds:
+            # Calculate nanoseconds from the fractional part of the timestamp
+            nanoseconds = f'{record.created:.9f}'.split('.')[1]
+            # Return the formatted string with nanoseconds appended
+            return f'{s}.{nanoseconds}'
+        else:
+            return s
 
 
 class FormatterProcessor:
@@ -144,13 +117,17 @@ class FormatterProcessor:
         # Iterate through all the elements and get the header list.
         header_dict: dict = dict()
         for element in self.list_of_elements:
-            header_dict.update({element: FORMAT_ELEMENT_TO_HEADER[element]})
+            header_dict.update({element: consts.FORMAT_ELEMENT_TO_HEADER[element]})
 
         return header_dict
 
 
 def get_logging_formatter_from_string(
-        formatter: str, style=None, datefmt=None, disable_duplicate_ms: bool = False) -> logging.Formatter:
+        formatter: str,
+        style=None,
+        datefmt=None,
+        use_nanoseconds: bool = False
+) -> logging.Formatter:
     """
     Function to get the logging formatter from the string.
 
@@ -160,12 +137,12 @@ def get_logging_formatter_from_string(
         '%': will use the '%' style.
         '{': will use the '{' style.
     :param datefmt: string, date format of 'asctime' element. Default is None.
-    :param disable_duplicate_ms: bool, if True, will disable the duplicate milliseconds in the 'asctime' element.
-        Example: If we're using '%(asctime)s.%(msecs)06f' msecs value in our time stamp, we need to use custom
-            'datefmt' to get rid of the additional duplicate milliseconds:
-            Instead of '2022-02-17 15:15:51,913.913.335562' print '2022-02-17 15:15:51,913.335562'
-            The problem with this method is that milliseconds aren't adjusted to 3 digits with zeroes (like 1 = 001).
-            We can use the regular strftime format: datefmt='%Y-%m-%d,%H:%M:%S:%f'
+        We use custom formatter that can process the date format with nanoseconds:
+        '%Y-%m-%d %H:%M:%S.%f' -> '2021-01-01 00:00:00.000000000'
+    :param use_nanoseconds: bool, if set to True, the formatter will use nanoseconds instead of milliseconds.
+        This will print 'asctime' in the following format: '2021-01-01 00:00:00.000000000', instead of
+        '2021-01-01 00:00:00.000'.
+
     :return: logging.Formatter, formatter.
     """
 
@@ -173,10 +150,20 @@ def get_logging_formatter_from_string(
     if not style:
         style = FormatterProcessor(formatter).get_style()['style']
 
-    # The regular 'datefmt' is '%Y-%m-%d,%H:%M:%S:%f'. If we want to use it with milliseconds 'msecs' element,
-    # we need to disable the duplicate milliseconds.
-    if disable_duplicate_ms:
-        datefmt = '%Y-%m-%d,%H:%M:%S'
-
     # Create the logging formatter.
-    return logging.Formatter(formatter, style=style, datefmt=datefmt)
+    if use_nanoseconds or '%f' in datefmt:
+        return NanosecondsFormatter(formatter, style=style, datefmt=datefmt, use_nanoseconds=use_nanoseconds)
+    else:
+        return logging.Formatter(formatter, style=style, datefmt=datefmt)
+
+
+def get_formatter_string(formatter) -> str:
+    """
+    Function to get the formatter string from the 'logging.Formatter'.
+
+    :param formatter: logging.Formatter, formatter to convert to string.
+    :return: str, formatter string.
+    """
+
+    # noinspection PyProtectedMember
+    return formatter._fmt