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

atomicshop/wrappers/loggingw/consts.py

@@ -14,7 +14,7 @@ DEFAULT_ROTATING_SUFFIXES_FROM_WHEN: dict = {
 }
 
 
-DEFAULT_STREAM_FORMATTER: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
+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 = {

atomicshop/wrappers/loggingw/filters.py

@@ -1,12 +1,18 @@
 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
@@ -27,6 +33,23 @@ class HeaderFilter(logging.Filter):
         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. 

atomicshop/wrappers/loggingw/formatters.py

@@ -155,3 +155,15 @@ def get_logging_formatter_from_string(
         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

atomicshop/wrappers/loggingw/handlers.py

@@ -8,12 +8,14 @@ import queue
 from typing import Literal, Union
 import threading
 from datetime import datetime
+import contextlib
+import multiprocessing
 
 from . import loggers, formatters, filters, consts
 from ... import datetimes, filesystem
 
 
-"""
+r"""
 # Not used, only for the reference:
 DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
 DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
@@ -47,17 +49,16 @@ def _process_formatter_attribute(
         return formatter
 
 
-def add_stream_handler(
-        logger: logging.Logger,
+def get_stream_handler_extended(
         logging_level: str = "DEBUG",
         formatter: Union[
             Literal['DEFAULT', 'MESSAGE'],
             str,
             None] = None,
         formatter_use_nanoseconds: bool = False
-):
+) -> logging.StreamHandler:
     """
-    Function to add StreamHandler to logger.
+    Function to get StreamHandler with extended configuration.
     Stream formatter will output messages to the console.
     """
 
@@ -75,36 +76,47 @@ def add_stream_handler(
             formatter=formatter, use_nanoseconds=formatter_use_nanoseconds)
         set_formatter(stream_handler, logging_formatter)
 
-    # Adding the handler to the main logger
-    loggers.add_handler(logger, stream_handler)
-
-    # Disable propagation from the 'root' logger, so we will not see the messages twice.
-    loggers.set_propagation(logger)
+    return stream_handler
 
 
 # Function to start the interval-based rotation check
 def _start_interval_rotation(handler):
+    # def check_rotation():
+    #     while True:
+    #         next_rollover = _calculate_next_rollover()
+    #         while datetime.now() < next_rollover:
+    #             time.sleep(0.1)
+    #
+    #             # Check if the next_rollover has changed (indicating a rollover by an event)
+    #             if _calculate_next_rollover() != next_rollover:
+    #                 next_rollover = _calculate_next_rollover()
+    #                 break
+    #
+    #         # Perform manual rollover if needed
+    #         if datetime.now() >= next_rollover:
+    #             handler.doRollover()
+    #
+    #         # handler.doRollover()
+    #
+    # def _calculate_next_rollover():
+    #     return datetime.fromtimestamp(handler.rolloverAt)
     def check_rotation():
-        while True:
-            next_rollover = _calculate_next_rollover()
-            while datetime.now() < next_rollover:
-                time.sleep(0.1)
+        last_rollover_at = handler.rolloverAt  # Initial rollover time
 
-                # Check if the next_rollover has changed (indicating a rollover by an event)
-                if _calculate_next_rollover() != next_rollover:
-                    next_rollover = _calculate_next_rollover()
-                    break
+        while True:
+            current_time = datetime.now()
+            next_rollover = datetime.fromtimestamp(handler.rolloverAt)
 
-            # Perform manual rollover if needed
-            if datetime.now() >= next_rollover:
-                _rotate_log()
+            # Check if the rollover time has passed and it hasn't been handled yet
+            if current_time >= next_rollover and handler.rolloverAt == last_rollover_at:
+                # Perform manual rollover
+                handler.doRollover()
 
-    def _calculate_next_rollover():
-        return datetime.fromtimestamp(handler.rolloverAt)
+                # Update last_rollover_at to the new rolloverAt
+                last_rollover_at = handler.rolloverAt
 
-    # Function to rotate logs
-    def _rotate_log():
-        handler.doRollover()
+            # Sleep for a short interval before checking again
+            time.sleep(0.1)
 
     rotation_thread = threading.Thread(target=check_rotation)
     rotation_thread.daemon = True
@@ -124,8 +136,80 @@ def _wrap_do_rollover(handler, header):
     handler.doRollover = new_do_rollover
 
 
-def add_timedfilehandler_with_queuehandler(
-        logger: logging.Logger,
+def get_queue_handler_and_start_queue_listener_for_file_handler(file_handler):
+    """
+    Function to create QueueHandler and start QueueListener for the FileHandler.
+    The QueueListener, which will get the logs from the queue and use the FileHandler to write them to the
+    file.
+    The QueueHandler will put the logs to the queue.
+
+    :param file_handler: FileHandler object.
+    :return: QueueHandler object.
+    """
+
+    # Create the Queue between threads. "-1" means that there can infinite number of items that can be
+    # put in the Queue. if integer is bigger than 0, it means that this will be the maximum
+    # number of items.
+    queue_object = queue.Queue(-1)
+
+    # Create QueueListener, which will get the logs from the queue and use the FileHandler to write them to the file.
+    start_queue_listener_for_handlers((file_handler,), queue_object)
+
+    # Get the QueueHandler, which will put the logs to the queue.
+    queue_handler = get_queue_handler(queue_object)
+
+    return queue_handler
+
+
+# BASE FUNCTIONS =======================================================================================================
+
+
+def get_stream_handler() -> logging.StreamHandler:
+    """
+    Function to get a StreamHandler.
+    This handler that will output messages to the console.
+
+    :return: StreamHandler.
+    """
+
+    return logging.StreamHandler()
+
+
+# noinspection PyPep8Naming
+def get_timed_rotating_file_handler(
+        log_file_path: str,
+        when: str = "midnight",
+        interval: int = 1,
+        backupCount: int = 0,
+        delay: bool = False,
+        encoding=None
+) -> TimedRotatingFileHandler:
+    """
+    Function to get a TimedRotatingFileHandler.
+    This handler will output messages to a file, rotating the log file at certain timed intervals.
+
+    :param log_file_path: Path to the log file.
+    :param when: When to rotate the log file. Possible values:
+        "S" - Seconds
+        "M" - Minutes
+        "H" - Hours
+        "D" - Days
+        "midnight" - Roll over at midnight
+    :param interval: Interval to rotate the log file.
+    :param backupCount: int, Number of backup files to keep. Default is 0.
+        If backupCount is > 0, when rollover is done, no more than backupCount files are kept, the oldest are deleted.
+        If backupCount is == 0, all the backup files will be kept.
+    :param delay: bool, If set to True, the log file will be created only if there's something to write.
+    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
+    :return: TimedRotatingFileHandler.
+    """
+
+    return TimedRotatingFileHandler(
+        filename=log_file_path, when=when, interval=interval, backupCount=backupCount, delay=delay, encoding=encoding)
+
+
+# noinspection PyPep8Naming
+def get_timed_rotating_file_handler_extended(
         file_path: str,
         file_type: Literal[
             'txt',
@@ -141,38 +225,63 @@ def add_timedfilehandler_with_queuehandler(
         rotation_date_format: str = None,
         rotation_callback_namer_function: callable = None,
         rotation_use_default_callback_namer_function: bool = True,
+        use_internal_queue_listener: bool = False,
         when: str = 'midnight',
         interval: int = 1,
         delay: bool = True,
+        backupCount: int = 0,
         encoding=None,
         header: str = None
-):
+) -> Union[TimedRotatingFileHandler, logging.handlers.QueueHandler]:
     """
-    Function to add TimedRotatingFileHandler and QueueHandler to logger.
-    TimedRotatingFileHandler will output messages to the file through QueueHandler.
-    This is needed, since TimedRotatingFileHandler is not thread-safe, though official docs say it is.
+    :param file_path: Path to the log file.
+    :param file_type: Type of the file. Possible values: 'txt', 'csv', 'json'.
+    :param logging_level: Logging level for the handler.
+    :param formatter: Formatter for the handler.
+    :param formatter_use_nanoseconds: If set to True, the formatter will use nanoseconds.
+    :param rotate_at_rollover_time: If set to True, the handler will rotate the log file at the rollover time.
+    :param rotation_date_format: Date format string to set to the handler's suffix.
+    :param rotation_callback_namer_function: Callback function to change the filename on rotation.
+    :param rotation_use_default_callback_namer_function: If set to True, the default callback namer function will be used
+        and the filename will be changed on rotation instead of using the default like this:
+        'file.log.2021-12-24' -> 'file_2021-12-24.log'.
+    :param use_internal_queue_listener: If set to True, the handler will use internal QueueListener to write logs.
+    :param when: When to rotate the log file. Possible values:
+        "S" - Seconds
+        "M" - Minutes
+        "H" - Hours
+        "D" - Days
+        "midnight" - Roll over at midnight
+    :param use_internal_queue_listener: If set to True, the handler will use internal QueueListener to write logs.
+        Function to add TimedRotatingFileHandler and QueueHandler to logger.
+        TimedRotatingFileHandler will output messages to the file through QueueHandler.
+        This is needed, since TimedRotatingFileHandler is not thread-safe, though official docs say it is.
+    :param interval: Interval to rotate the log file.
+    :param delay: If set to True, the log file will be created only if there's something to write.
+    :param backupCount: Number of backup files to keep. Default is 0.
+        If backupCount is > 0, when rollover is done, no more than backupCount files are kept, the oldest are deleted.
+        If backupCount is == 0, all the backup files will be kept.
+    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
+    :param header: Header to write to the log file.
+    :return: TimedRotatingFileHandler or QueueHandler (if, use_internal_queue_listener is set to True).
     """
 
-    # Setting the TimedRotatingFileHandler, without adding it to the logger.
-    # It will be added to the QueueListener, which will use the TimedRotatingFileHandler to write logs.
-    # This is needed since there's a bug in TimedRotatingFileHandler, which won't let it be used with
-    # threads the same way it would be used for multiprocess.
-
     # Creating file handler with log filename. At this stage the log file is created and locked by the handler,
     # Unless we use "delay=True" to tell the class to write the file only if there's something to write.
 
     filesystem.create_directory(os.path.dirname(file_path))
 
     file_handler = get_timed_rotating_file_handler(
-        file_path, when=when, interval=interval, delay=delay, encoding=encoding)
+        file_path, when=when, interval=interval, delay=delay, backupCount=backupCount, encoding=encoding)
 
     loggers.set_logging_level(file_handler, logging_level)
 
     formatter = _process_formatter_attribute(formatter, file_type=file_type)
 
     # If formatter was passed to the function we'll add it to handler.
+    # noinspection GrazieInspection
     if formatter:
-        # Convert string to Formatter object. Moved to newer styling of python 3: style='{'
+        # Convert string to Formatter object. Moved to newer styling of python 3: style='{'.
         logging_formatter = formatters.get_logging_formatter_from_string(
             formatter=formatter, use_nanoseconds=formatter_use_nanoseconds)
         # Setting the formatter in file handler.
@@ -197,86 +306,36 @@ def add_timedfilehandler_with_queuehandler(
     if rotate_at_rollover_time:
         _start_interval_rotation(file_handler)
 
-    queue_handler = start_queue_listener_for_file_handler_and_get_queue_handler(file_handler)
-    loggers.set_logging_level(queue_handler, logging_level)
-
-    # Add the QueueHandler to the logger.
-    loggers.add_handler(logger, queue_handler)
-
-    # Disable propagation from the 'root' logger, so we will not see the messages twice.
-    loggers.set_propagation(logger)
-
-
-def start_queue_listener_for_file_handler_and_get_queue_handler(file_handler):
-    """
-    Function to start QueueListener, which will put the logs from FileHandler to the Queue.
-    QueueHandler will get the logs from the Queue and put them to the file that was set in the FileHandler.
-
-    :param file_handler: FileHandler object.
-    :return: QueueHandler object.
-    """
-
-    # Create the Queue between threads. "-1" means that there can infinite number of items that can be
-    # put in the Queue. if integer is bigger than 0, it means that this will be the maximum
-    # number of items.
-    queue_object = queue.Queue(-1)
-    # Create QueueListener, which will put the logs from FileHandler to the Queue and put the logs to the queue.
-    start_queue_listener_for_file_handler(file_handler, queue_object)
-
-    return get_queue_handler(queue_object)
-
-
-# BASE FUNCTIONS =======================================================================================================
-
-
-def get_stream_handler() -> logging.StreamHandler:
-    """
-    Function to get a StreamHandler.
-    This handler that will output messages to the console.
-
-    :return: StreamHandler.
-    """
-
-    return logging.StreamHandler()
-
-
-def get_timed_rotating_file_handler(
-        log_file_path: str, when: str = "midnight", interval: int = 1, delay: bool = False, encoding=None
-) -> TimedRotatingFileHandler:
-    """
-    Function to get a TimedRotatingFileHandler.
-    This handler will output messages to a file, rotating the log file at certain timed intervals.
-
-    :param log_file_path: Path to the log file.
-    :param when: When to rotate the log file. Possible values:
-        "S" - Seconds
-        "M" - Minutes
-        "H" - Hours
-        "D" - Days
-        "midnight" - Roll over at midnight
-    :param interval: Interval to rotate the log file.
-    :param delay: bool, If set to True, the log file will be created only if there's something to write.
-    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
-    :return: TimedRotatingFileHandler.
-    """
+    # Setting the TimedRotatingFileHandler, without adding it to the logger.
+    # It will be added to the QueueListener, which will use the TimedRotatingFileHandler to write logs.
+    # This is needed since there's a bug in TimedRotatingFileHandler, which won't let it be used with
+    # threads the same way it would be used for multiprocess.
 
-    return TimedRotatingFileHandler(
-        filename=log_file_path, when=when, interval=interval, delay=delay, encoding=encoding)
+    # If internal queue listener is set to True, we'll start the QueueListener for the FileHandler.
+    if use_internal_queue_listener:
+        queue_handler = get_queue_handler_and_start_queue_listener_for_file_handler(file_handler)
+        loggers.set_logging_level(queue_handler, logging_level)
+        return queue_handler
+    else:
+        return file_handler
 
 
-def start_queue_listener_for_file_handler(
-        file_handler: logging.FileHandler, queue_object) -> logging.handlers.QueueListener:
+def start_queue_listener_for_handlers(
+        handlers: tuple[logging.Handler],
+        queue_object: Union[queue.Queue, multiprocessing.Queue]
+) -> logging.handlers.QueueListener:
     """
     Function to get a QueueListener for the FileHandler.
     This handler get the messages from the FileHandler and put them in the Queue.
 
-    :param file_handler: FileHandler to get the messages from.
+    :param handlers: Tuple of handlers to put in the QueueListener.
+        For example, it can be (stream_handler, file_handler).
     :param queue_object: Queue object to put the messages in.
     :return: QueueListener.
     """
 
     # Create the QueueListener based on TimedRotatingFileHandler
-    queue_listener = QueueListener(queue_object, file_handler)
+    queue_listener: logging.handlers.QueueListener = QueueListener(queue_object, *handlers)
     # Start the QueueListener. Each logger will have its own instance of the Queue
     queue_listener.start()
 
@@ -296,6 +355,25 @@ def get_queue_handler(queue_object) -> logging.handlers.QueueHandler:
     return QueueHandler(queue_object)
 
 
+def get_queue_handler_extended(
+        queue_object: Union[
+            queue.Queue,
+            multiprocessing.Queue],
+        logging_level: str = "DEBUG"):
+    """
+    Function to get the QueueHandler.
+    QueueHandler of the logger will pass the logs to the Queue and the opposite QueueListener will write them
+    from the Queue to the file that was set in the FileHandler.
+    """
+
+    # Getting the QueueHandler.
+    queue_handler = get_queue_handler(queue_object)
+    # Setting log level for the handler, that will use the logger while initiated.
+    loggers.set_logging_level(queue_handler, logging_level)
+
+    return queue_handler
+
+
 def set_formatter(handler: logging.Handler, logging_formatter: logging.Formatter):
     """
     Function to set the formatter for the handler.
@@ -445,3 +523,32 @@ def add_filter_to_handler(handler: logging.Handler, filter_object: logging.Filte
     """
 
     handler.addFilter(filter_object)
+
+
+def get_formatter_string(handler: logging.Handler) -> str:
+    """
+    Function to get the formatter string from the handler.
+    :param handler: Handler to get the formatter from.
+    :return: Formatter string.
+    """
+
+    return formatters.get_formatter_string(handler.formatter)
+
+
+@contextlib.contextmanager
+def temporary_change_formatter(handler: logging.Handler, formatter_string: str):
+    """
+    Context manager to temporarily change the formatter of the handler.
+
+    Example:
+        with temporary_change_formatter(handler, formatter_string):
+            # Do something with the temporary formatter.
+            pass
+    """
+    original_formatter = handler.formatter
+
+    try:
+        handler.setFormatter(logging.Formatter(formatter_string))
+        yield
+    finally:
+        handler.setFormatter(original_formatter)

atomicshop/wrappers/loggingw/loggers.py

@@ -14,6 +14,25 @@ import logging
 """
 
 
+def is_logger_exists(
+        logger_name: str
+) -> bool:
+    """
+    Function to check if the logger exists.
+    :param logger_name: str, Name of the logger.
+    :return: bool, True if the logger exists, False otherwise.
+    """
+    return logger_name in logging.Logger.manager.loggerDict
+
+
+def get_all_existing_loggers_names() -> list:
+    """
+    Function to get all existing loggers names.
+    :return: list, List of all existing loggers names.
+    """
+    return list(logging.Logger.manager.loggerDict.keys())
+
+
 def get_logger(logger_name: str) -> logging.Logger:
     """
     Function to get a logger.