atomicshop 2.14.4__py3-none-any.whl → 2.14.6__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.6'

atomicshop/datetimes.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 import time
 import random
 import re
+from typing import Union
 
 
 class MonthToNumber:
@@ -47,6 +48,28 @@ class MonthToNumber:
         'דצמבר': '12'}
 
 
+# Mapping of datetime format specifiers to regex patterns
+DATE_TIME_STRING_FORMAT_SPECIFIERS_TO_REGEX: dict = {
+    '%Y': r'\d{4}',   # Year with century
+    '%m': r'\d{2}',   # Month as a zero-padded decimal number
+    '%d': r'\d{2}',   # Day of the month as a zero-padded decimal number
+    '%H': r'\d{2}',   # Hour (24-hour clock) as a zero-padded decimal number
+    '%I': r'\d{2}',   # Hour (12-hour clock) as a zero-padded decimal number
+    '%M': r'\d{2}',   # Minute as a zero-padded decimal number
+    '%S': r'\d{2}',   # Second as a zero-padded decimal number
+    '%f': r'\d{6}',   # Microsecond as a decimal number, zero-padded on the left
+    '%j': r'\d{3}',   # Day of the year as a zero-padded decimal number
+    '%U': r'\d{2}',   # Week number of the year (Sunday as the first day of the week)
+    '%W': r'\d{2}',   # Week number of the year (Monday as the first day of the week)
+    '%w': r'\d',      # Weekday as a decimal number (0 = Sunday, 6 = Saturday)
+    '%y': r'\d{2}',   # Year without century
+    '%p': r'(AM|PM)',   # AM or PM
+    '%z': r'[+-]\d{4}',  # UTC offset in the form ±HHMM
+    '%Z': r'[A-Z]+',     # Time zone name
+    '%%': r'%'           # Literal '%'
+}
+
+
 def get_datetime_from_complex_string_by_pattern(complex_string: str, date_pattern: str) -> tuple[datetime, str, float]:
     """
     Function will get datetime object from a complex string by pattern.
@@ -71,6 +94,49 @@ def get_datetime_from_complex_string_by_pattern(complex_string: str, date_patter
         raise ValueError("No valid date found in the string")
 
 
+def datetime_format_to_regex(format_str: str) -> str:
+    """
+    Convert a datetime format string to a regex pattern.
+
+    :param format_str: The datetime format string to convert.
+    :return: The regex pattern that matches the format string.
+
+    Example:
+    datetime_format_to_regex("%Y-%m-%d")
+
+    Output:
+    '^\\d{4}-\\d{2}-\\d{2}$'
+    """
+
+    # Escape all non-format characters
+    escaped_format_str = re.escape(format_str)
+
+    # Replace escaped format specifiers with their regex equivalents
+    for specifier, regex in DATE_TIME_STRING_FORMAT_SPECIFIERS_TO_REGEX.items():
+        escaped_format_str = escaped_format_str.replace(re.escape(specifier), regex)
+
+    # Return the full regex pattern with start and end anchors
+    return f"^{escaped_format_str}$"
+
+
+def extract_datetime_format_from_string(complex_string: str) -> Union[str, None]:
+    """
+    Extract the datetime format from the suffix used in TimedRotatingFileHandler.
+
+    Args:
+    - suffix: The suffix string from the handler.
+
+    Returns:
+    - The datetime format string, or None if it cannot be determined.
+    """
+    # Regular expression to match datetime format components in the suffix
+    datetime_format_regex = r"%[a-zA-Z]"
+    matches = re.findall(datetime_format_regex, complex_string)
+    if matches:
+        return "".join(matches)
+    return None
+
+
 def convert_single_digit_to_zero_padded(string: str):
     """
     Function will check if string is a single character digit and will add zero in front of it.

atomicshop/mitm/config_editor.py

@@ -0,0 +1,37 @@
+import configparser
+
+
+class CategoryNotFoundInConfigError(Exception):
+    pass
+
+
+def edit_property(category: str, category_property: str, value: str, config_file_path: str) -> None:
+    """
+    Edit a property in the config file.
+
+    :param category: str, Category in the config file.
+    :param category_property: str, Property in the category.
+    :param value: str, Value to set to the property.
+    :param config_file_path: str, Path to the config file.
+
+    :return: None.
+
+    -----------
+
+    Config Example:
+    [category]
+    category_property = value
+    """
+    config = configparser.ConfigParser()
+    config.read(config_file_path)
+
+    if category not in config:
+        raise CategoryNotFoundInConfigError(f"Category '{category}' not found in the config file.")
+
+    # Change the value of the property if it is different from the current value.
+    current_value = config[category][category_property]
+    if current_value != value:
+        config[category][category_property] = value
+
+        with open(config_file_path, "w") as configfile:
+            config.write(configfile)

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.create_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

@@ -1,5 +1,7 @@
 import os
+import sys
 import threading
+import time
 
 # Importing atomicshop package to get the version of the package.
 import atomicshop
@@ -10,7 +12,8 @@ from .connection_thread_worker import thread_worker_main
 from .. import filesystem, queues
 from ..python_functions import get_current_python_version_string, check_python_version_compliance
 from ..wrappers.socketw.socket_wrapper import SocketWrapper
-from ..wrappers.socketw.dns_server import DnsServer
+from ..wrappers.socketw import dns_server
+from ..wrappers.psutilw import networks
 from ..basics import dicts_nested
 from ..wrappers.loggingw import loggingw
 from ..print_api import print_api
@@ -41,8 +44,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.create_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 +185,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.create_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.create_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
@@ -194,19 +214,41 @@ def initialize_mitm_server(config_static):
 
     # === Initialize DNS module ====================================================================================
     if config['dns']['enable_dns_server']:
+        # Check if the DNS server port is in use.
+        port_in_use = networks.get_processes_using_port_list([config['dns']['listening_port']])
+        if port_in_use:
+            for port, process_info in port_in_use.items():
+                message = f"Port [{port}] is already in use by process: {process_info}"
+                print_api(message, error_type=True, logger_method='critical', logger=system_logger)
+
+            # Wait for the message to be printed and saved to file.
+            time.sleep(1)
+            sys.exit(1)
+
         # before executing TCP sockets and after executing 'network' logger.
-        dns_server = DnsServer(config)
+        dns_server_instance = dns_server.DnsServer(config)
         # Passing the engine domain list to DNS server to work with.
         # 'list' function re-initializes the current list, or else it will be the same instance object.
-        dns_server.domain_list = list(domains_engine_list_full)
+        dns_server_instance.domain_list = list(domains_engine_list_full)
 
-        dns_server.request_domain_queue = domain_queue
+        dns_server_instance.request_domain_queue = domain_queue
         # Initiate the thread.
-        threading.Thread(target=dns_server.start).start()
+        dns_thread = threading.Thread(target=dns_server_instance.start)
+        dns_thread.daemon = True
+        dns_thread.start()
 
     # === EOF Initialize DNS module ================================================================================
     # === Initialize TCP Server ====================================================================================
     if config['tcp']['enable_tcp_server']:
+        port_in_use = networks.get_processes_using_port_list(config['tcp']['listening_port_list'])
+        if port_in_use:
+            for port, process_info in port_in_use.items():
+                print_api(f"Port [{port}] is already in use by process: {process_info}", logger=system_logger,
+                          error_type=True, logger_method='critical')
+            # Wait for the message to be printed and saved to file.
+            time.sleep(1)
+            sys.exit(1)
+
         socket_wrapper = SocketWrapper(
             config=dicts_nested.merge(config, config_static.CONFIG_EXTENDED), logger=listener_logger,
             statistics_logger=statistics_logger)

atomicshop/print_api.py

@@ -99,15 +99,16 @@ def print_api(
             # If 'logger.error' should be outputted to console, and 'color' wasn't selected, then set color to 'yellow'.
             if logger_method == 'error' and not color:
                 color = 'yellow'
-                error_type = True
             # If 'logger.critical' should be outputted to console, and 'color' wasn't selected, then set color to 'red'.
             elif logger_method == 'critical' and not color:
                 color = 'red'
-                error_type = True
 
             if color:
                 message = get_colors_basic_dict(color) + message + ColorsBasic.END
 
+        if logger_method == 'error' or logger_method == 'critical':
+            error_type = True
+
         # If exception was raised and 'stderr=True'.
         if sys.exc_info()[0] is not None and stderr:
             # If 'traceback' is set to 'True', we'll output traceback of exception.

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)