atomicshop 2.14.4__py3-none-any.whl → 2.14.5__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.14.4'
+__version__ = '2.14.5'

atomicshop/mitm/initialize_engines.py

@@ -83,8 +83,14 @@ class ModuleCategory:
 
         # Initiating logger for each engine by its name
         # initiate_logger(current_module.engine_name, log_file_extension)
-        loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-            logger_name=self.engine_name, directory_path=logs_path, disable_duplicate_ms=True)
+        loggingw.get_complex_logger(
+            logger_name=self.engine_name,
+            directory_path=logs_path,
+            add_stream=True,
+            add_timedfile=True,
+            formatter_streamhandler='DEFAULT',
+            formatter_filehandler='DEFAULT'
+        )
 
 
 # Assigning external class object by message domain received from client. If the domain is not in the list,

atomicshop/mitm/initialize_mitm_server.py

@@ -41,8 +41,15 @@ def initialize_mitm_server(config_static):
             config['certificates']['sni_server_certificate_from_server_socket_download_directory'])
 
     # Create a logger that will log messages to file, Initiate System logger.
-    system_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        "system", config['log']['logs_path'], disable_duplicate_ms=True)
+    logger_name = "system"
+    system_logger = loggingw.get_complex_logger(
+        logger_name=logger_name,
+        file_path=f'{config['log']['logs_path']}{os.sep}{logger_name}.txt',
+        add_stream=True,
+        add_timedfile=True,
+        formatter_streamhandler='DEFAULT',
+        formatter_filehandler='DEFAULT'
+    )
 
     # Writing first log.
     system_logger.info("======================================")
@@ -175,14 +182,24 @@ def initialize_mitm_server(config_static):
     config_static.CONFIG_EXTENDED['certificates']['domains_all_times'] = list(domains_engine_list_full)
 
     # Creating Statistics logger.
-    statistics_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        logger_name="statistics", directory_path=config['log']['logs_path'],
-        file_extension=config_static.CSV_EXTENSION, formatter_message_only=True, header=STATISTICS_HEADER
+    statistics_logger = loggingw.get_complex_logger(
+        logger_name="statistics",
+        directory_path=config['log']['logs_path'],
+        add_timedfile=True,
+        formatter_filehandler='MESSAGE',
+        file_type='csv',
+        header=STATISTICS_HEADER
     )
 
     network_logger_name = "network"
-    network_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-        logger_name=network_logger_name, directory_path=config['log']['logs_path'], disable_duplicate_ms=True)
+    network_logger = loggingw.get_complex_logger(
+        logger_name=network_logger_name,
+        directory_path=config['log']['logs_path'],
+        add_stream=True,
+        add_timedfile=True,
+        formatter_streamhandler='DEFAULT',
+        formatter_filehandler='DEFAULT'
+    )
     system_logger.info(f"Loaded network logger: {network_logger}")
 
     # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers

atomicshop/wrappers/loggingw/formatters.py

@@ -1,4 +1,5 @@
 import logging
+import time
 
 
 # Log formatter, means how the log will look inside the file
@@ -8,32 +9,9 @@ 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'
 
+DEFAULT_STREAM_FORMATTER: str = "%(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]',
@@ -56,7 +34,7 @@ FORMAT_ELEMENT_TO_HEADER: dict = {
 }
 
 DEFAULT_FORMATTER_TXT_FILE: str = \
-    "{asctime},{msecs:013.9f} | " \
+    "{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} : " \
@@ -64,7 +42,53 @@ DEFAULT_FORMATTER_TXT_FILE: str = \
     "{threadName} | {message}"
 
 DEFAULT_FORMATTER_CSV_FILE: str = \
-    '\"{asctime}.{msecs:010.6f}\",{levelname},{name},{filename},{lineno},{threadName},\"{message}\"'
+    '\"{asctime}\",{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
+
+
+
+
+
+        # if datefmt is None:
+        #     # Use the default behavior if no datefmt is provided
+        #     return super().formatTime(record, datefmt)
+        # elif '%f' in datefmt:
+        #     # Format the time up to seconds
+        #     base_time = time.strftime(datefmt.replace('%f', ''), ct)
+        #     # Calculate nanoseconds from the fractional part of the timestamp
+        #     nanoseconds = f'{record.created:.9f}'.split('.')[1]
+        #     # Return the formatted string with nanoseconds appended
+        #     return base_time + nanoseconds
+        # else:
+        #     # Use the provided datefmt if it doesn't include %f
+        #     return time.strftime(datefmt, ct)
 
 
 class FormatterProcessor:
@@ -150,7 +174,11 @@ class FormatterProcessor:
 
 
 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 +188,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 +201,8 @@ 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)

atomicshop/wrappers/loggingw/handlers.py

@@ -2,6 +2,11 @@ import logging
 from logging.handlers import TimedRotatingFileHandler, QueueListener, QueueHandler
 import re
 import os
+from pathlib import Path
+
+
+DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
+DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
 
 
 class TimedRotatingFileHandlerWithHeader(TimedRotatingFileHandler):
@@ -150,7 +155,20 @@ def get_handler_name(handler: logging.Handler) -> str:
     return handler.get_name()
 
 
-def change_rotated_filename(file_handler: logging.Handler, file_extension: str):
+def change_rotated_filename(
+        file_handler: logging.Handler,
+        date_format_string: str = None,
+        date_regex_pattern: str = None
+):
+    """
+    Function to change the way TimedRotatingFileHandler managing the rotating filename.
+
+    :param file_handler: FileHandler to change the rotating filename for.
+    :param date_format_string: Date format string to use for the rotated log filename.
+        If None, the default 'DEFAULT_DATE_STRING_FORMAT' will be used.
+    :param date_regex_pattern: Regex pattern to match the rotated log filenames.
+        If None, the default 'DEFAULT_DATE_REGEX_PATTERN' will be used.
+    """
     # Changing the way TimedRotatingFileHandler managing the rotating filename
     # Default file suffix is only "Year_Month_Day" with addition of the dot (".") character to the
     # "file name + extension" that you provide it. Example: log file name:
@@ -170,18 +188,40 @@ def change_rotated_filename(file_handler: logging.Handler, file_extension: str):
     # file_handler.extMatch = re.compile(r"^\d{4}_\d{2}_\d{2}" + re.escape(log_file_extension) + r"$")
     # file_handler.extMatch = re.compile(r"^\d{4}_\d{2}_\d{2}.txt$")
 
-    # Set variables that are responsible for setting TimedRotatingFileHandler filename on rotation.
-    # Log files time format, need only date
-    format_date_log_filename: str = "%Y_%m_%d"
-    # Log file suffix.
-    logfile_suffix: str = "_" + format_date_log_filename + file_extension
-    # Regex object to match the TimedRotatingFileHandler file name suffix.
-    # "re.escape" is used to "escape" strings in regex and use them as is.
-    logfile_regex_suffix = re.compile(r"^\d{4}_\d{2}_\d{2}" + re.escape(file_extension) + r"$")
+    # Update the namer function to format the rotated filename correctly
+    def namer(name):
+        # Currently the 'name' is full file path + '.' + logfile_suffix.
+        # Example: 'C:\\path\\to\\file.log._2021_12_24'
+        # Get the parent directory of the file: C:\path\to
+        parent_dir: str = str(Path(name).parent)
+        # Get the base filename without the extension: file.log
+        filename: str = Path(name).stem
+        # Get the date part of the filename: _2021_12_24
+        date_part: str = str(Path(name).suffix).replace(".", "")
+        # Get the file extension: log
+        file_extension: str = Path(filename).suffix
+        # Get the file name without the extension: file
+        file_stem: str = Path(filename).stem
+
+        return f"{parent_dir}{os.sep}{file_stem}{date_part}{file_extension}"
+
+    # Construct the new suffix without the file extension
+    if date_format_string is None:
+        logfile_suffix = f"_{DEFAULT_DATE_STRING_FORMAT}"
+    else:
+        logfile_suffix = f"_{date_format_string}"
+
+    # Regex pattern to match the rotated log filenames
+    if date_regex_pattern is None:
+        logfile_regex_suffix = re.compile(DEFAULT_DATE_REGEX_PATTERN)
+    else:
+        logfile_regex_suffix = re.compile(date_regex_pattern)
 
-    # Changing the setting that we set above
+    # Update the handler's suffix to include the date format
     file_handler.suffix = logfile_suffix
-    file_handler.namer = lambda name: name.replace(file_extension + ".", "") + file_extension
+
+    file_handler.namer = namer
+    # Update the handler's extMatch regex to match the new filename format
     file_handler.extMatch = logfile_regex_suffix
 
 

atomicshop/wrappers/loggingw/loggingw.py

@@ -1,80 +1,34 @@
-import os
 import logging
+import os
 import queue
+from typing import Literal, Union
 
 from . import loggers, handlers, formatters
 
 
-def get_logger_with_level(logger_name: str, logging_level="DEBUG") -> logging.Logger:
-    """
-    Function to get a logger and set logging level.
-
-    :param logger_name: Name of the logger.
-    :param logging_level: 'int' or 'str', Logging level to set to the logger.
-        None: if None, the logger level will not be set.
-    :return: Logger.
-    """
-
-    # Get the logger.
-    logger: logging.Logger = loggers.get_logger(logger_name)
-    # Set the logger level if it is not None.
-    if logging_level:
-        loggers.set_logging_level(logger, logging_level)
-
-    return logger
-
-
-def get_logger_with_stream_handler(
-        logger_name: str, logging_level="DEBUG",
-        formatter: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
-) -> logging.Logger:
-    """
-    Function to get a logger and add StreamHandler to it.
-
-    :param logger_name: Name of the logger.
-    :param logging_level: 'int' or 'str', Logging level to set to the logger.
-        None: if None, the logger level will not be set.
-    :param formatter: Formatter to use for StreamHandler. It is template of how a message will look like.
-    :return: Logger.
-    """
-
-    # Get the logger.
-    logger: logging.Logger = loggers.get_logger(logger_name)
-    # Set the logger level if it is not None.
-    if logging_level:
-        loggers.set_logging_level(logger, logging_level)
-    # Add StreamHandler to the logger.
-    add_stream_handler(logger, logging_level, formatter)
-
-    return logger
-
-
-def get_logger_with_timedfilehandler(
+def get_complex_logger(
         logger_name: str,
-        directory_path, file_name: str = None, file_extension: str = '.txt',
-        logging_level="DEBUG", formatter='default',
-        formatter_message_only: bool = False, disable_duplicate_ms: bool = False,
-        when: str = "midnight", interval: int = 1, delay: bool = True, encoding=None
-) -> logging.Logger:
-    logger = get_logger_with_level(logger_name, logging_level)
-    add_timedfilehandler_with_queuehandler(
-        logger, directory_path, file_name, file_extension, logging_level, formatter,
-        formatter_message_only, disable_duplicate_ms, when, interval, delay, encoding
-    )
-
-    return logger
-
-
-def get_logger_with_stream_handler_and_timedfilehandler(
-        logger_name: str,
-        directory_path,
-        file_name: str = None,
-        file_extension: str = '.txt',
+        file_path: str = None,
+        directory_path: str = None,
+        add_stream: bool = False,
+        add_timedfile: bool = False,
+        file_type: Literal[
+            'txt',
+            'csv',
+            'json'] = 'txt',
         logging_level="DEBUG",
-        formatter_filehandler='default',
-        formatter_streamhandler: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s",
-        formatter_message_only: bool = False,
-        disable_duplicate_ms: bool = False,
+        formatter_streamhandler: Union[
+            Literal[
+                'MESSAGE',
+                'DEFAULT'],
+            None] = None,
+        formatter_filehandler: Union[
+            Literal[
+                'MESSAGE',
+                'DEFAULT',],
+            None] = None,
+        formatter_streamhandler_use_nanoseconds: bool = True,
+        formatter_filehandler_use_nanoseconds: bool = True,
         when: str = "midnight",
         interval: int = 1,
         delay: bool = True,
@@ -85,26 +39,35 @@ def get_logger_with_stream_handler_and_timedfilehandler(
     Function to get a logger and add StreamHandler and TimedRotatingFileHandler to it.
 
     :param logger_name: Name of the logger.
-    :param directory_path: string, Path to the directory where the log file will be created.
-    :param file_name: string, Name of the log file without file extension, since we add it through separate argument.
-        If not provided, logger name will be used.
-    :param file_extension: string, Extension of the log file. Default is '.txt'.
-        '.txt': Text file.
-        '.csv': CSV file.
-        '.json': JSON file.
+    :param file_path: full path to the log file. If you don't want to use the file, set it to None.
+        You can set the directory_path only and then the 'logger_name' will be used as the file name with the
+        'file_type' as the file extension.
+    :param directory_path: full path to the directory where the log file will be saved.
+    :param add_stream: bool, If set to True, StreamHandler will be added to the logger.
+    :param add_timedfile: bool, If set to True, TimedRotatingFileHandler will be added to the logger.
+    :param file_type: string, file type of the log file. Default is 'txt'.
+        'txt': Text file.
+        'csv': CSV file.
+        'json': JSON file.
     :param logging_level: str or int, Logging level for the handler, that will use the logger while initiated.
+    :param formatter_streamhandler: string, Formatter to use for StreamHandler. It is template of how a message will
+        look like.
+        None: No formatter will be used.
+        'DEFAULT': Default formatter will be used:
+            "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
+        'MESSAGE': Formatter will be used only for the 'message' part.
     :param formatter_filehandler: string, Formatter to use for handler. It is template of how a message will look like.
         None: No formatter will be used.
-        'default': Default formatter will be used for each file extension:
-            .txt: "%(asctime)s | %(levelname)s | %(threadName)s | %(name)s | %(message)s"
-            .csv: "%(asctime)s,%(levelname)s,%(threadName)s,%(name)s,%(message)s"
-            .json: '{"time": "%(asctime)s", "level": "%(levelname)s", "thread": "%(threadName)s",
+        'DEFAULT': Default formatter will be used for each file extension:
+            txt: "%(asctime)s | %(levelname)s | %(threadName)s | %(name)s | %(message)s"
+            csv: "%(asctime)s,%(levelname)s,%(threadName)s,%(name)s,%(message)s"
+            json: '{"time": "%(asctime)s", "level": "%(levelname)s", "thread": "%(threadName)s",
                 "logger": "%(name)s", "message": "%(message)s"}'
-    :param formatter_streamhandler: string, Formatter to use for StreamHandler. It is template of how a message will
-        look like.
-    :param formatter_message_only: bool, If set to True, formatter will be used only for the 'message' part.
-    :param disable_duplicate_ms: bool, If set to True, duplicate milliseconds will be removed from formatter
-        'asctime' element.
+        'MESSAGE': Formatter will be used only for the 'message' part.
+    :param formatter_streamhandler_use_nanoseconds: bool, If set to True, the nanoseconds will be used
+        in the formatter in case you provide 'asctime' element.
+    :param formatter_filehandler_use_nanoseconds: bool, If set to True, the nanoseconds will be used
+        in the formatter in case you provide 'asctime' element.
     :param when: string, When to rotate the log file. Default is 'midnight'.
         [when="midnight"] is set to rotate the filename at midnight. This means that the current file name will be
         added Yesterday's date to the end of the file and today's file will continue to write at the same
@@ -119,6 +82,7 @@ def get_logger_with_stream_handler_and_timedfilehandler(
     :param encoding: string, Encoding to use for the log file. Default is None.
     :param header: string, Header to write to the log file.
         Example: "time,host,error"
+        Useful for 'csv' file type format.
 
     :return: Logger.
 
@@ -130,11 +94,41 @@ def get_logger_with_stream_handler_and_timedfilehandler(
 
     def main():
         header: str = "time,host,error"
-        output_directory: str = "D:\\logs"
+        output_log_file: str = "D:\\logs\\log_file.csv"
+
+        error_logger = loggingw.get_complex_logger(
+            logger_name=f'{self.__class__.__name__}_CSV',
+            file_path=output_log_file,
+            add_timedfile=True,
+            file_type='csv',
+            formatter_filehandler='MESSAGE',
+            header=header
+        )
+
+        error_logger.info(error_message)
+
+
+    if __name__ == "__main__":
+        main()
+
+    ------------------------------
+
+    Example to use StreamHandler to output to console and TimedRotatingFileHandler to write to file:
+    from atomicshop.wrappers.loggingw import loggingw
+
 
-        error_logger = loggingw.get_logger_with_stream_handler_and_timedfilehandler(
-            logger_name="errors", directory_path=output_directory,
-            file_extension=".csv", formatter_message_only=True, header=header
+    def main():
+        header: str = "time,host,error"
+        output_log_file: str = "D:\\logs\\log_file.txt"
+
+        error_logger = loggingw.get_complex_logger(
+            logger_name=f'{self.__class__.__name__}',
+            file_path=output_log_file,
+            add_stream=True,
+            add_timedfile=True,
+            file_type='txt',
+            formatter_streamhandler='DEFAULT',
+            formatter_filehandler='DEFAULT'
         )
 
         error_logger.info(f"{datetime.now()},host1,/path/to/file,error message")
@@ -143,32 +137,93 @@ def get_logger_with_stream_handler_and_timedfilehandler(
     if __name__ == "__main__":
         main()
     """
+
+    if not directory_path and not file_path:
+        raise ValueError("You need to provide 'directory_path' or 'file_path'.")
+    if directory_path and file_path:
+        raise ValueError("You can't provide both 'directory_path' and 'file_path'.")
+
+    if directory_path:
+        if directory_path.endswith(os.sep):
+            directory_path = directory_path[:-1]
+
+        file_path = f"{directory_path}{os.sep}{logger_name}.{file_type}"
+
     logger = get_logger_with_level(logger_name, logging_level)
-    add_stream_handler(logger, logging_level, formatter_streamhandler, formatter_message_only)
-    add_timedfilehandler_with_queuehandler(
-        logger, directory_path, file_name, file_extension, logging_level, formatter_filehandler,
-        formatter_message_only, disable_duplicate_ms, when, interval, delay, encoding, header
-    )
+
+    if add_stream:
+        add_stream_handler(
+            logger=logger, logging_level=logging_level, formatter=formatter_streamhandler,
+            formatter_use_nanoseconds=formatter_streamhandler_use_nanoseconds)
+
+    if add_timedfile:
+        add_timedfilehandler_with_queuehandler(
+            logger=logger, file_path=file_path, logging_level=logging_level, formatter=formatter_filehandler,
+            formatter_use_nanoseconds=formatter_filehandler_use_nanoseconds, file_type=file_type,
+            when=when, interval=interval, delay=delay, encoding=encoding, header=header)
+
+    return logger
+
+
+def get_logger_with_level(
+        logger_name: str,
+        logging_level="DEBUG"
+) -> logging.Logger:
+    """
+    Function to get a logger and set logging level.
+
+    :param logger_name: Name of the logger.
+    :param logging_level: 'int' or 'str', Logging level to set to the logger.
+        None: if None, the logger level will not be set.
+    :return: Logger.
+    """
+
+    # Get the logger.
+    logger: logging.Logger = loggers.get_logger(logger_name)
+    # Set the logger level if it is not None.
+    if logging_level:
+        loggers.set_logging_level(logger, logging_level)
 
     return logger
 
 
+def _process_formatter_attribute(
+        formatter: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            None],
+        file_type: Union[
+            Literal['txt', 'csv', 'json'],
+            None] = None
+):
+    """
+    Function to process the formatter attribute.
+    """
+
+    if formatter == 'DEFAULT' and file_type is None:
+        return formatters.DEFAULT_STREAM_FORMATTER
+    elif formatter == 'DEFAULT' and file_type == 'txt':
+        return formatters.DEFAULT_FORMATTER_TXT_FILE
+    elif formatter == 'DEFAULT' and file_type == 'csv':
+        return formatters.DEFAULT_FORMATTER_CSV_FILE
+    elif formatter == 'DEFAULT' and file_type == 'json':
+        return formatters.DEFAULT_MESSAGE_FORMATTER
+    elif formatter == 'MESSAGE':
+        return formatters.DEFAULT_MESSAGE_FORMATTER
+    else:
+        return formatter
+
+
 def add_stream_handler(
-        logger: logging.Logger, logging_level: str = "DEBUG",
-        formatter: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s",
-        formatter_message_only: bool = False
+        logger: logging.Logger,
+        logging_level: str = "DEBUG",
+        formatter: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            None] = None,
+        formatter_use_nanoseconds: bool = False
 ):
     """
     Function to add StreamHandler to logger.
     Stream formatter will output messages to the console.
-
-    :param logger: Logger to add the handler to.
-    :param logging_level: Logging level for the handler, that will use the logger while initiated.
-    :param formatter: Formatter to use for StreamHandler. It is template of how a message will look like.
-        None: No formatter will be used.
-        'default': Default formatter will be used:
-            "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
-    :param formatter_message_only: bool, If set to True, formatter will be used only for the 'message' part.
     """
 
     # Getting the StreamHandler.
@@ -177,12 +232,12 @@ def add_stream_handler(
     loggers.set_logging_level(stream_handler, logging_level)
 
     # If formatter_message_only is set to True, then formatter will be used only for the 'message' part.
-    if formatter_message_only:
-        formatter = "%(message)s"
+    formatter = _process_formatter_attribute(formatter)
 
     # If formatter was provided, then it will be used.
     if formatter:
-        logging_formatter = formatters.get_logging_formatter_from_string(formatter)
+        logging_formatter = formatters.get_logging_formatter_from_string(
+            formatter=formatter, use_nanoseconds=formatter_use_nanoseconds)
         handlers.set_formatter(stream_handler, logging_formatter)
 
     # Adding the handler to the main logger
@@ -194,13 +249,16 @@ def add_stream_handler(
 
 def add_timedfilehandler_with_queuehandler(
         logger: logging.Logger,
-        directory_path: str,
-        file_name_no_extension: str = None,
-        file_extension: str = '.txt',
+        file_path: str,
+        file_type: Literal[
+            'txt',
+            'csv',
+            'json'] = 'txt',
         logging_level="DEBUG",
-        formatter='default',
-        formatter_message_only: bool = False,
-        disable_duplicate_ms: bool = False,
+        formatter: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            None] = None,
+        formatter_use_nanoseconds: bool = False,
         when: str = 'midnight',
         interval: int = 1,
         delay: bool = True,
@@ -211,45 +269,11 @@ def add_timedfilehandler_with_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 logger: Logger to add the handler to.
-    :param directory_path: string, Path to the directory where the log file will be created.
-    :param file_name_no_extension: string, Name of the log file without file extension, since we add it through
-        separate argument. If not provided, logger name will be used.
-    :param file_extension: string, Extension of the log file. Default is '.txt'.
-    :param logging_level: str or int, Logging level for the handler, that will use the logger while initiated.
-    :param formatter: string, Formatter to use for handler. It is template of how a message will look like.
-        None: No formatter will be used.
-        'default': Default formatter will be used for each file extension:
-            .txt: "%(asctime)s | %(levelname)s | %(threadName)s | %(name)s | %(message)s"
-            .csv: "%(asctime)s,%(levelname)s,%(threadName)s,%(name)s,%(message)s"
-            .json: '{"time": "%(asctime)s", "level": "%(levelname)s", "thread": "%(threadName)s",
-                "logger": "%(name)s", "message": "%(message)s"}'
-    :param formatter_message_only: bool, If set to True, formatter will be used only for the 'message' part.
-    :param disable_duplicate_ms: bool, If set to True, duplicate milliseconds will be removed from formatter
-        'asctime' element.
-    :param when: string, When to rotate the log file. Default is 'midnight'.
-        [when="midnight"] is set to rotate the filename at midnight. This means that the current file name will be
-        added Yesterday's date to the end of the file and today's file will continue to write at the same
-        filename. Also, if the script finished working on 25.11.2021, the name of the log file will be "test.log"
-        If you run the script again on 28.11.2021, the logging module will take the last modification date of
-        the file "test.log" and assign a date to it: test.log.2021_11_25
-        The log filename of 28.11.2021 will be called "test.log" again.
-    :param interval: int, Interval to rotate the log file. Default is 1.
-        If 'when="midnight"' and 'interval=1', then the log file will be rotated every midnight.
-        If 'when="midnight"' and 'interval=2', then the log file will be rotated every 2nd midnights.
-    :param delay: bool, If set to True, the log file will be created only if there's something to write.
-    :param encoding: string, Encoding to use for the log file. Default is None.
-    :param header: string, Header to write to the log file.
-        Example: "time,host,error"
     """
 
     # If file name wasn't provided we will use the logger name instead.
-    if not file_name_no_extension:
-        file_name_no_extension = logger.name
-
-    # Set log file path.
-    log_file_path = f'{directory_path}{os.sep}{file_name_no_extension}{file_extension}'
+    # if not file_name_no_extension:
+    #     file_name_no_extension = logger.name
 
     # Setting the TimedRotatingFileHandler, without adding it to the logger.
     # It will be added to the QueueListener, which will use the TimedRotatingFileHandler to write logs.
@@ -259,41 +283,30 @@ def add_timedfilehandler_with_queuehandler(
     # 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.
 
-    if file_extension == ".csv":
+    if file_type == "csv":
         # If file extension is CSV, we'll set the header to the file.
         # This is needed since the CSV file will be rotated, and we'll need to set the header each time.
         # We'll use the custom TimedRotatingFileHandlerWithHeader class.
         file_handler = handlers.get_timed_rotating_file_handler_with_header(
-            log_file_path, when=when, interval=interval, delay=delay, encoding=encoding, header=header)
+            file_path, when=when, interval=interval, delay=delay, encoding=encoding, header=header)
     else:
         file_handler = handlers.get_timed_rotating_file_handler(
-            log_file_path, when=when, interval=interval, delay=delay, encoding=encoding)
+            file_path, when=when, interval=interval, delay=delay, encoding=encoding)
 
     loggers.set_logging_level(file_handler, logging_level)
 
-    if formatter == "default":
-        # Create file formatter based on extension
-        if file_extension == ".txt":
-            formatter = formatters.DEFAULT_FORMATTER_TXT_FILE
-        elif file_extension == ".csv":
-            formatter = formatters.DEFAULT_FORMATTER_CSV_FILE
-        elif file_extension == ".json":
-            formatter = "%(message)s"
-
-    # If 'formatter_message_only' is set to 'True', we'll use the formatter only for the message part.
-    if formatter_message_only:
-        formatter = "%(message)s"
+    formatter = _process_formatter_attribute(formatter, file_type=file_type)
 
     # If formatter was passed to the function we'll add it to handler.
     if formatter:
         # Convert string to Formatter object. Moved to newer styling of python 3: style='{'
         logging_formatter = formatters.get_logging_formatter_from_string(
-            formatter, disable_duplicate_ms=disable_duplicate_ms)
+            formatter=formatter, use_nanoseconds=formatter_use_nanoseconds)
         # Setting the formatter in file handler.
         handlers.set_formatter(file_handler, logging_formatter)
 
     # This function will change the suffix behavior of the rotated file name.
-    handlers.change_rotated_filename(file_handler, file_extension)
+    handlers.change_rotated_filename(file_handler)
 
     queue_handler = start_queue_listener_for_file_handler_and_get_queue_handler(file_handler)
     loggers.set_logging_level(queue_handler, logging_level)

{atomicshop-2.14.4.dist-info → atomicshop-2.14.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.14.4
+Version: 2.14.5
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License

{atomicshop-2.14.4.dist-info → atomicshop-2.14.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=tunTjRW84u7Nao5t0Z6ZWFYrQDUW_zun_a86yEIubts,123
+atomicshop/__init__.py,sha256=hgaCf3sGJGnktr5gfFAzZxI1NReX4ILvEOdMvHiDI40,123
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_create_pdf_demo.py,sha256=Yi-PGZuMg0RKvQmLqVeLIZYadqEZwUm-4A9JxBl_vYA,3713
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
@@ -122,8 +122,8 @@ atomicshop/mains/installs/pycharm.py,sha256=uYTfME7hOeNkAsOZxDDPj2hDqmkxrFqVV6Nv
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/connection_thread_worker.py,sha256=PQ8bwOgrPudYP5oPnSi_DWaKXOi038M8TMImlLkxuPI,20486
 atomicshop/mitm/import_config.py,sha256=_V-IVJ7a1L6E-VOR4CDfZj-S1odbsIlBe13ij0NlpqY,7974
-atomicshop/mitm/initialize_engines.py,sha256=UGdT5DKYNri3MNOxESP7oeSxYiUDrVilJ4jic_nwdew,8055
-atomicshop/mitm/initialize_mitm_server.py,sha256=5JGkyvAvz1sJVeRGMJWSQiQ-VOdrU-NJn633oxQe0cw,13143
+atomicshop/mitm/initialize_engines.py,sha256=jiuA9BPLiUKG_7kE9FMCLrhf5W4LnPoYgc9FfV3AKRs,8175
+atomicshop/mitm/initialize_mitm_server.py,sha256=avC1lfS65dCdJ3cfF3olGIKycnz3ChlzCuXFmhah0Uk,13418
 atomicshop/mitm/message.py,sha256=u2U2f2SOHdBNU-6r1Ik2W14ai2EOwxUV4wVfGZA098k,1732
 atomicshop/mitm/shared_functions.py,sha256=PaK_sbnEA5zo9k2ktEOKLmvo-6wRUunxzSNRr41uXIQ,1924
 atomicshop/mitm/statistic_analyzer.py,sha256=ctsf-MBIUvG4-R0K4gFQyi_b42-VCq-5s7hgO9jMOes,38415
@@ -233,10 +233,10 @@ atomicshop/wrappers/factw/rest/statistics.py,sha256=vznwzKP1gEF7uXz3HsuV66BU9wrp
 atomicshop/wrappers/factw/rest/status.py,sha256=4O3xS1poafwyUiLDkhyx4oMMe4PBwABuRPpOMnMKgIU,641
 atomicshop/wrappers/fibratusw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/fibratusw/install.py,sha256=PLVymDe0HuOvU0r2lje8BkQAgtiOWEeRO7n-1zKuL7A,3287
-atomicshop/wrappers/loggingw/formatters.py,sha256=mUtcJJfmhLNrwUVYShXTmdu40dBaJu4TS8FiuTXI7ys,7189
-atomicshop/wrappers/loggingw/handlers.py,sha256=2A_3Qy1B0RvVWZmQocAB6CmpqlXoKJ-yi6iBWG2jNLo,8274
+atomicshop/wrappers/loggingw/formatters.py,sha256=808R7K3e3ZJD2BXfqI6UMOyXGrCgt9SYh2Uv7sL_1KQ,7432
+atomicshop/wrappers/loggingw/handlers.py,sha256=MzoVWE_WX2OZZ5nD9eJpEBK-SW9XJVkm1Hl_9B3gM8E,9769
 atomicshop/wrappers/loggingw/loggers.py,sha256=DHOOTAtqkwn1xgvLHSkOiBm6yFGNuQy1kvbhG-TDog8,2374
-atomicshop/wrappers/loggingw/loggingw.py,sha256=m6YySEedP3_4Ik1S_uGMxETSbmRkmMYmAZxhHBlXSlo,16616
+atomicshop/wrappers/loggingw/loggingw.py,sha256=JPNSglpuN7ryXsmUHLMCnJRsjvRPV3Q64CN3OgSEFsU,14863
 atomicshop/wrappers/loggingw/reading.py,sha256=wse-38zUDHB3HUB28R8Ah_Ig3Wxt2tChapKtu-yyy2E,17036
 atomicshop/wrappers/nodejsw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/nodejsw/install_nodejs.py,sha256=QZg-R2iTQt7kFb8wNtnTmwraSGwvUs34JIasdbNa7ZU,5154
@@ -281,8 +281,8 @@ atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5ey
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=aXBwlEIJhFT0-c4i8iNlFx2It9VpCEpsv--5Oqcpxao,11624
 atomicshop/wrappers/socketw/ssl_base.py,sha256=k4V3gwkbq10MvOH4btU4onLX2GNOsSfUAdcHmL1rpVE,2274
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=t3dtDEfN47CfYVi0CW6Kc2QHTEeZVyYhc57IYYh5nmA,826
-atomicshop-2.14.4.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.14.4.dist-info/METADATA,sha256=fjxtj_SzmyjVK6o_Z08jX-lLJoz7m_vYNPvn0fCoFYU,10478
-atomicshop-2.14.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.14.4.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.14.4.dist-info/RECORD,,
+atomicshop-2.14.5.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.14.5.dist-info/METADATA,sha256=gY_7i-PXmCnygtkJYX2xDi6Jl9jH8AeVRnaBhR2SsCk,10478
+atomicshop-2.14.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.14.5.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.14.5.dist-info/RECORD,,