atomicshop 2.14.5__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.5'
+__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,7 +83,7 @@ class ModuleCategory:
 
         # Initiating logger for each engine by its name
         # initiate_logger(current_module.engine_name, log_file_extension)
-        loggingw.get_complex_logger(
+        loggingw.create_logger(
             logger_name=self.engine_name,
             directory_path=logs_path,
             add_stream=True,

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
@@ -42,7 +45,7 @@ def initialize_mitm_server(config_static):
 
     # Create a logger that will log messages to file, Initiate System logger.
     logger_name = "system"
-    system_logger = loggingw.get_complex_logger(
+    system_logger = loggingw.create_logger(
         logger_name=logger_name,
         file_path=f'{config['log']['logs_path']}{os.sep}{logger_name}.txt',
         add_stream=True,
@@ -182,7 +185,7 @@ 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_complex_logger(
+    statistics_logger = loggingw.create_logger(
         logger_name="statistics",
         directory_path=config['log']['logs_path'],
         add_timedfile=True,
@@ -192,7 +195,7 @@ def initialize_mitm_server(config_static):
     )
 
     network_logger_name = "network"
-    network_logger = loggingw.get_complex_logger(
+    network_logger = loggingw.create_logger(
         logger_name=network_logger_name,
         directory_path=config['log']['logs_path'],
         add_stream=True,
@@ -211,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/handlers.py

@@ -1,15 +1,50 @@
 import logging
 from logging.handlers import TimedRotatingFileHandler, QueueListener, QueueHandler
+from logging import FileHandler
+import time
 import re
 import os
 from pathlib import Path
+import queue
+from typing import Literal, Union
+import threading
+from datetime import datetime
+
+from . import loggers, formatters
+from ... import datetimes, filesystem
 
 
 DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
-DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
+# Not used, only for the reference:
+# _DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
+
+
+class ForceAtTimeRotationTimedRotatingFileHandler(TimedRotatingFileHandler):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._last_rotated_date = None
+        self._start_rotation_check()
+
+    def _start_rotation_check(self):
+        self._rotation_thread = threading.Thread(target=self._check_for_rotation)
+        self._rotation_thread.daemon = True
+        self._rotation_thread.start()
+
+    def _check_for_rotation(self):
+        while True:
+            now = datetime.now()
+            current_date = now.date()
+            # Check if it's midnight and the logs haven't been rotated today
+            if now.hour == 0 and now.minute == 0 and current_date != self._last_rotated_date:
+                self._last_rotated_date = current_date
+                self.doRollover()
+            time.sleep(0.1)
+
+    def doRollover(self):
+        super().doRollover()
 
 
-class TimedRotatingFileHandlerWithHeader(TimedRotatingFileHandler):
+class TimedRotatingFileHandlerWithHeader(ForceAtTimeRotationTimedRotatingFileHandler):
     """
     Custom TimedRotatingFileHandler that writes a header to the log file each time there is a file rotation.
     Useful for writing CSV files.
@@ -36,6 +71,164 @@ class TimedRotatingFileHandlerWithHeader(TimedRotatingFileHandler):
         super().emit(record)
 
 
+def _process_formatter_attribute(
+        formatter: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            str,
+            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: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            str,
+            None] = None,
+        formatter_use_nanoseconds: bool = False
+):
+    """
+    Function to add StreamHandler to logger.
+    Stream formatter will output messages to the console.
+    """
+
+    # Getting the StreamHandler.
+    stream_handler = get_stream_handler()
+    # Setting log level for the handler, that will use the logger while initiated.
+    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.
+    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=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)
+
+
+def add_timedfilehandler_with_queuehandler(
+        logger: logging.Logger,
+        file_path: str,
+        file_type: Literal[
+            'txt',
+            'csv',
+            'json'] = 'txt',
+        logging_level="DEBUG",
+        formatter: Union[
+            Literal['DEFAULT', 'MESSAGE'],
+            str,
+            None] = None,
+        formatter_use_nanoseconds: bool = False,
+        when: str = 'midnight',
+        interval: int = 1,
+        delay: bool = True,
+        encoding=None,
+        header: str = None
+):
+    """
+    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.
+    """
+
+    # 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
+
+    # 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))
+
+    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 = get_timed_rotating_file_handler_with_header(
+            file_path, when=when, interval=interval, delay=delay, encoding=encoding, header=header)
+    else:
+        file_handler = get_timed_rotating_file_handler(
+            file_path, when=when, interval=interval, delay=delay, 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.
+    if formatter:
+        # 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.
+        set_formatter(file_handler, logging_formatter)
+
+    # This function will change the suffix behavior of the rotated file name.
+    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)
+
+    # 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.
@@ -49,7 +242,7 @@ def get_stream_handler() -> logging.StreamHandler:
 
 def get_timed_rotating_file_handler(
         log_file_path: str, when: str = "midnight", interval: int = 1, delay: bool = False, encoding=None
-) -> logging.handlers.TimedRotatingFileHandler:
+) -> ForceAtTimeRotationTimedRotatingFileHandler:
     """
     Function to get a TimedRotatingFileHandler.
     This handler will output messages to a file, rotating the log file at certain timed intervals.
@@ -67,7 +260,7 @@ def get_timed_rotating_file_handler(
     :return: TimedRotatingFileHandler.
     """
 
-    return TimedRotatingFileHandler(
+    return ForceAtTimeRotationTimedRotatingFileHandler(
         filename=log_file_path, when=when, interval=interval, delay=delay, encoding=encoding)
 
 
@@ -157,8 +350,7 @@ def get_handler_name(handler: logging.Handler) -> str:
 
 def change_rotated_filename(
         file_handler: logging.Handler,
-        date_format_string: str = None,
-        date_regex_pattern: str = None
+        date_format_string: str = None
 ):
     """
     Function to change the way TimedRotatingFileHandler managing the rotating filename.
@@ -166,8 +358,6 @@ def change_rotated_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
@@ -188,8 +378,10 @@ def change_rotated_filename(
     # 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$")
 
-    # Update the namer function to format the rotated filename correctly
-    def namer(name):
+    def callback_namer(name):
+        """
+        Callback function to change the filename of the rotated log file on file rotation.
+        """
         # 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
@@ -205,22 +397,23 @@ def change_rotated_filename(
 
         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}"
+        date_format_string = DEFAULT_DATE_STRING_FORMAT
+
+    # Construct the new suffix without the file extension
+    logfile_suffix = f"_{date_format_string}"
+
+    # Get regex pattern from string format.
+    # Example: '%Y_%m_%d' -> r'\d{4}_\d{2}_\d{2}'
+    date_regex_pattern = datetimes.datetime_format_to_regex(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)
+    logfile_regex_suffix = re.compile(date_regex_pattern)
 
     # Update the handler's suffix to include the date format
     file_handler.suffix = logfile_suffix
 
-    file_handler.namer = namer
+    file_handler.namer = callback_namer
     # Update the handler's extMatch regex to match the new filename format
     file_handler.extMatch = logfile_regex_suffix
 
@@ -242,3 +435,23 @@ def has_handlers(logger: logging.Logger) -> bool:
         return False
     else:
         return True
+
+
+def extract_datetime_format_from_file_handler(file_handler: FileHandler) -> Union[str, None]:
+    """
+    Extract the datetime string formats from all TimedRotatingFileHandlers in the logger.
+
+    Args:
+    - logger: The logger instance.
+
+    Returns:
+    - A list of datetime string formats used by the handlers.
+    """
+    # Extract the suffix
+    suffix = getattr(file_handler, 'suffix', None)
+    if suffix:
+        datetime_format = datetimes.extract_datetime_format_from_string(suffix)
+        if datetime_format:
+            return datetime_format
+
+        return None

atomicshop/wrappers/loggingw/loggingw.py

@@ -1,12 +1,11 @@
 import logging
 import os
-import queue
 from typing import Literal, Union
 
 from . import loggers, handlers, formatters
 
 
-def get_complex_logger(
+def create_logger(
         logger_name: str,
         file_path: str = None,
         directory_path: str = None,
@@ -18,20 +17,18 @@ def get_complex_logger(
             'json'] = 'txt',
         logging_level="DEBUG",
         formatter_streamhandler: Union[
-            Literal[
-                'MESSAGE',
-                'DEFAULT'],
+            Literal['MESSAGE', 'DEFAULT'],
+            str,
             None] = None,
         formatter_filehandler: Union[
-            Literal[
-                'MESSAGE',
-                'DEFAULT',],
+            Literal['MESSAGE', 'DEFAULT'],
+            str,
             None] = None,
         formatter_streamhandler_use_nanoseconds: bool = True,
         formatter_filehandler_use_nanoseconds: bool = True,
         when: str = "midnight",
         interval: int = 1,
-        delay: bool = True,
+        delay: bool = False,
         encoding=None,
         header: str = None
 ) -> logging.Logger:
@@ -56,6 +53,7 @@ def get_complex_logger(
         'DEFAULT': Default formatter will be used:
             "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
         'MESSAGE': Formatter will be used only for the 'message' part.
+        string: Custom formatter, regular syntax for logging.Formatter.
     :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:
@@ -64,6 +62,7 @@ def get_complex_logger(
             json: '{"time": "%(asctime)s", "level": "%(levelname)s", "thread": "%(threadName)s",
                 "logger": "%(name)s", "message": "%(message)s"}'
         'MESSAGE': Formatter will be used only for the 'message' part.
+        string: Custom formatter, regular syntax for logging.Formatter.
     :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
@@ -96,7 +95,7 @@ def get_complex_logger(
         header: str = "time,host,error"
         output_log_file: str = "D:\\logs\\log_file.csv"
 
-        error_logger = loggingw.get_complex_logger(
+        error_logger = loggingw.create_logger(
             logger_name=f'{self.__class__.__name__}_CSV',
             file_path=output_log_file,
             add_timedfile=True,
@@ -121,7 +120,7 @@ def get_complex_logger(
         header: str = "time,host,error"
         output_log_file: str = "D:\\logs\\log_file.txt"
 
-        error_logger = loggingw.get_complex_logger(
+        error_logger = loggingw.create_logger(
             logger_name=f'{self.__class__.__name__}',
             file_path=output_log_file,
             add_stream=True,
@@ -152,12 +151,12 @@ def get_complex_logger(
     logger = get_logger_with_level(logger_name, logging_level)
 
     if add_stream:
-        add_stream_handler(
+        handlers.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(
+        handlers.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)
@@ -187,156 +186,6 @@ def get_logger_with_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: 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.
-    """
-
-    # Getting the StreamHandler.
-    stream_handler = handlers.get_stream_handler()
-    # Setting log level for the handler, that will use the logger while initiated.
-    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.
-    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=formatter, use_nanoseconds=formatter_use_nanoseconds)
-        handlers.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)
-
-
-def add_timedfilehandler_with_queuehandler(
-        logger: logging.Logger,
-        file_path: str,
-        file_type: Literal[
-            'txt',
-            'csv',
-            'json'] = 'txt',
-        logging_level="DEBUG",
-        formatter: Union[
-            Literal['DEFAULT', 'MESSAGE'],
-            None] = None,
-        formatter_use_nanoseconds: bool = False,
-        when: str = 'midnight',
-        interval: int = 1,
-        delay: bool = True,
-        encoding=None,
-        header: str = None
-):
-    """
-    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.
-    """
-
-    # 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
-
-    # 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.
-
-    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(
-            file_path, when=when, interval=interval, delay=delay, encoding=encoding, header=header)
-    else:
-        file_handler = handlers.get_timed_rotating_file_handler(
-            file_path, when=when, interval=interval, delay=delay, 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.
-    if formatter:
-        # 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.
-        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)
-
-    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.
-    handlers.start_queue_listener_for_file_handler(file_handler, queue_object)
-
-    return handlers.get_queue_handler(queue_object)
-
-
 def disable_default_logger():
     """
     Function to disable default logger.
@@ -353,3 +202,22 @@ def disable_default_logger():
 
     # Disabling the default logger in Python
     logging.disable(logging.CRITICAL)
+
+
+def get_datetime_format_string_from_logger_file_handlers(logger: logging.Logger) -> list:
+    """
+    Function to get datetime format string from the logger's file handlers.
+    This is useful when you want to know the datetime format string that is used on file rotation.
+    :param logger: Logger to get the datetime format string from.
+    :return: List of datetime format strings.
+    """
+
+    datetime_format_strings = []
+
+    for handler in logger.handlers:
+        if isinstance(handler, logging.FileHandler):
+            date_time_format_string = handlers.extract_datetime_format_from_file_handler(handler)
+            if date_time_format_string:
+                datetime_format_strings.append(date_time_format_string)
+
+    return datetime_format_strings

atomicshop/wrappers/loggingw/reading.py

@@ -75,8 +75,8 @@ def get_logs_paths(
 
                 # Get the datetime object from the file name by the date pattern.
                 try:
-                    datetime_object, date_string, timestamp_float = datetimes.get_datetime_from_complex_string_by_pattern(
-                        current_file_name, date_pattern)
+                    datetime_object, date_string, timestamp_float = (
+                        datetimes.get_datetime_from_complex_string_by_pattern(current_file_name, date_pattern))
                 # ValueError will be raised if the date pattern does not match the file name.
                 except ValueError:
                     timestamp_float = 0

atomicshop/wrappers/psutilw/networks.py

@@ -0,0 +1,40 @@
+from typing import Union
+import shlex
+
+import psutil
+
+
+def get_process_using_port(port: int) -> Union[dict, None]:
+    """
+    Function to find the process using the port.
+    :param port: Port number.
+    :return: dict['pid', 'name', 'cmdline'] or None.
+    """
+    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+        try:
+            connections = proc.connections(kind='inet')
+            for conn in connections:
+                if conn.laddr.port == port:
+                    return {
+                        'pid': proc.info['pid'],
+                        'name': proc.info['name'],
+                        'cmdline': shlex.join(proc.info['cmdline'])
+                    }
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            pass
+    return None
+
+
+def get_processes_using_port_list(ports: list) -> Union[dict, None]:
+    """
+    Function to find the process using the port.
+    :param ports: List of port numbers.
+    :return: dict[port: {'pid', 'name', 'cmdline'}] or None.
+    """
+    port_process_map = {}
+    for port in ports:
+        process_info = get_process_using_port(port)
+        if process_info:
+            port_process_map[port] = process_info
+
+    return port_process_map

atomicshop/wrappers/socketw/dns_server.py

@@ -6,11 +6,16 @@ import socket
 
 from ...print_api import print_api
 from ..loggingw import loggingw
+from ..psutilw import networks
 
 import dnslib
 from dnslib import DNSRecord, DNSHeader, RR, A
 
 
+class DnsPortInUseError(Exception):
+    pass
+
+
 class DnsServer:
     """
     DnsServer class is responsible to handle DNS Requests on port 53 based on configuration and send DNS Response back.
@@ -56,8 +61,12 @@ class DnsServer:
 
         # Logger that logs all the DNS Requests and responses in DNS format. These entries will not present in
         # network log of TCP Server module.
-        self.dns_full_logger = loggingw.get_logger_with_timedfilehandler(
-            logger_name="dns", directory_path=self.config['log']['logs_path'], disable_duplicate_ms=True)
+        self.dns_full_logger = loggingw.create_logger(
+            logger_name="dns",
+            directory_path=self.config['log']['logs_path'],
+            add_timedfile=True,
+            formatter_filehandler='DEFAULT'
+        )
 
     def thread_worker_empty_dns_cache(self, function_sleep_time: int):
         """
@@ -78,6 +87,11 @@ class DnsServer:
         :return: None.
         """
 
+        port_in_use = networks.get_processes_using_port_list([self.config['dns']['listening_port']])
+        if port_in_use:
+            for port, process_info in port_in_use.items():
+                raise DnsPortInUseError(f"Port [{port}] is already in use by process: {process_info}")
+
         self.logger.info("DNS Server Module Started.")
 
         # Define objects for global usage

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

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

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

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=hgaCf3sGJGnktr5gfFAzZxI1NReX4ILvEOdMvHiDI40,123
+atomicshop/__init__.py,sha256=hybMlQ9qVeOgdPaVMdVvrp-rXkVt1Ifm1_zQ95KG2kM,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
@@ -8,7 +8,7 @@ atomicshop/command_line_processing.py,sha256=u5yT9Ger_cu7ni5ID0VFlRbVD46ARHeNC9t
 atomicshop/config_init.py,sha256=z2RXD_mw9nQlAOpuGry1h9QT-2LhNscXgGAktN3dCVQ,2497
 atomicshop/console_output.py,sha256=AOSJjrRryE97PAGtgDL03IBtWSi02aNol8noDnW3k6M,4667
 atomicshop/console_user_response.py,sha256=31HIy9QGXa7f-GVR8MzJauQ79E_ZqAeagF3Ks4GGdDU,3234
-atomicshop/datetimes.py,sha256=wZ75JS6Aq5kTQrCSrjCwBrT-KPO7Xu9_BRWKrY8uU3c,15645
+atomicshop/datetimes.py,sha256=Rmn-Ag36xRI1xbyoMs2fe1PB5hzb_UHEIwRVPppz0M0,18278
 atomicshop/diff_check.py,sha256=RJvzJhyYAZyRPKVDk1dS7UwZCx0kq__WDZ6N0rNfZUY,27110
 atomicshop/dns.py,sha256=h4uZKoz4wbBlLOOduL1GtRcTm-YpiPnGOEGxUm7hhOI,2140
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
@@ -26,7 +26,7 @@ atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,
 atomicshop/on_exit.py,sha256=Wf1iy2e0b0Zu7oRxrct3VkLdQ_x9B32-z_JerKTt9Z0,5493
 atomicshop/pbtkmultifile_argparse.py,sha256=aEk8nhvoQVu-xyfZosK3ma17CwIgOjzO1erXXdjwtS4,4574
 atomicshop/permissions.py,sha256=P6tiUKV-Gw-c3ePEVsst9bqWaHJbB4ZlJB4xbDYVpEs,4436
-atomicshop/print_api.py,sha256=DhbCQd0MWZZ5GYEk4oTu1opRFC-b31g1VWZgTGewG2Y,11568
+atomicshop/print_api.py,sha256=j0bZ9b2rFKCcr0TVx1ARraVKeEs6JaaSgIlBdndy1nI,11600
 atomicshop/process.py,sha256=U2gyRl0bw2138y-rOMABMVptRvAL81ZfX1JyfxJI_Oo,15973
 atomicshop/python_file_patcher.py,sha256=kd3rBWvTcosLEk-7TycNdfKW9fZbe161iVwmH4niUo0,5515
 atomicshop/python_functions.py,sha256=zJg4ogUwECxrDD7xdDN5JikIUctITM5lsyabr_ZNsRw,4435
@@ -120,10 +120,11 @@ atomicshop/file_io/xlsxs.py,sha256=v_dyg9GD4LqgWi6wA1QuWRZ8zG4ZwB6Dz52ytdcmmmI,2
 atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,2104
 atomicshop/mains/installs/pycharm.py,sha256=uYTfME7hOeNkAsOZxDDPj2hDqmkxrFqVV6Nv6xnYNVk,141
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+atomicshop/mitm/config_editor.py,sha256=9ZwD6NGqgsr1f85NyFwWwM7FDut2vGQ4xari3vS9UT0,1130
 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=jiuA9BPLiUKG_7kE9FMCLrhf5W4LnPoYgc9FfV3AKRs,8175
-atomicshop/mitm/initialize_mitm_server.py,sha256=avC1lfS65dCdJ3cfF3olGIKycnz3ChlzCuXFmhah0Uk,13418
+atomicshop/mitm/initialize_engines.py,sha256=YnXPK1UKrmULnfL4zLo2LOpKWq-aGKzc9p3n8tfcYCM,8170
+atomicshop/mitm/initialize_mitm_server.py,sha256=0xjHleUFecU8nyhzf5z8On-nZtL26A80prH4GHSqNc8,14611
 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
@@ -234,10 +235,10 @@ atomicshop/wrappers/factw/rest/status.py,sha256=4O3xS1poafwyUiLDkhyx4oMMe4PBwABu
 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=808R7K3e3ZJD2BXfqI6UMOyXGrCgt9SYh2Uv7sL_1KQ,7432
-atomicshop/wrappers/loggingw/handlers.py,sha256=MzoVWE_WX2OZZ5nD9eJpEBK-SW9XJVkm1Hl_9B3gM8E,9769
+atomicshop/wrappers/loggingw/handlers.py,sha256=0n4Bqr9yQ7GiQOBYtSVFtCFBeEUfcvkaAFYgWY1E3Tg,18014
 atomicshop/wrappers/loggingw/loggers.py,sha256=DHOOTAtqkwn1xgvLHSkOiBm6yFGNuQy1kvbhG-TDog8,2374
-atomicshop/wrappers/loggingw/loggingw.py,sha256=JPNSglpuN7ryXsmUHLMCnJRsjvRPV3Q64CN3OgSEFsU,14863
-atomicshop/wrappers/loggingw/reading.py,sha256=wse-38zUDHB3HUB28R8Ah_Ig3Wxt2tChapKtu-yyy2E,17036
+atomicshop/wrappers/loggingw/loggingw.py,sha256=irzlIYXTcCpSVjmb6NU6GJGCIy3V48ZVKNvKOlH70CU,9417
+atomicshop/wrappers/loggingw/reading.py,sha256=yh7uNPxEdn6KsxSKrYny2C57XdI25F5gaByz77CO_pw,17038
 atomicshop/wrappers/nodejsw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/nodejsw/install_nodejs.py,sha256=QZg-R2iTQt7kFb8wNtnTmwraSGwvUs34JIasdbNa7ZU,5154
 atomicshop/wrappers/playwrightw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -253,6 +254,7 @@ atomicshop/wrappers/playwrightw/waits.py,sha256=308fdOu6YDqQ7K7xywj7R27sSmFanPBQ
 atomicshop/wrappers/psutilw/cpus.py,sha256=w6LPBMINqS-T_X8vzdYkLS2Wzuve28Ydp_GafTCngrc,236
 atomicshop/wrappers/psutilw/disks.py,sha256=3ZSVoommKH1TWo37j_83frB-NqXF4Nf5q5mBCX8G4jE,9221
 atomicshop/wrappers/psutilw/memories.py,sha256=_S0aL8iaoIHebd1vOFrY_T9aROM5Jx2D5CvDh_4j0Vc,528
+atomicshop/wrappers/psutilw/networks.py,sha256=Q2EtyemncDhDsNYZREME0nOIxM-jQqIktFN3i5HtSog,1294
 atomicshop/wrappers/psutilw/psutilw.py,sha256=q3EwgprqyrR4zLCjl4l5DHFOQoukEvQMIPjNB504oQ0,21262
 atomicshop/wrappers/psycopgw/psycopgw.py,sha256=XJvVf0oAUjCHkrYfKeFuGCpfn0Oxj3u4SbKMKA1508E,7118
 atomicshop/wrappers/pywin32w/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -270,7 +272,7 @@ atomicshop/wrappers/socketw/accepter.py,sha256=HQC1EyZmyUtVEfFbaBkHCE-VZp6RWyd9m
 atomicshop/wrappers/socketw/base.py,sha256=1vvg8EhRGvnxdrRAm1VJSLCXkm2SZDHRjdpTuhkH3Mg,1844
 atomicshop/wrappers/socketw/certificator.py,sha256=SxCKFyBlwzs4uohugfBokOYQpZJyH8KY46m87Q23n6w,9017
 atomicshop/wrappers/socketw/creator.py,sha256=C-l57G854HAtWJonVbgfQge290-Dg0Ov4aurJAWIKls,11199
-atomicshop/wrappers/socketw/dns_server.py,sha256=laMR_opplvytVTvVcztNoDChZGMCDR31fDQejrCNaEI,42032
+atomicshop/wrappers/socketw/dns_server.py,sha256=u4RSDIK4UR1aKOulwSGscchxYa7pTlPxMO-StHuBMag,42464
 atomicshop/wrappers/socketw/exception_wrapper.py,sha256=_YDnzyEcUnV6VISU3bk-UPdnsMvHjKJBHwxLMTsxQu8,8495
 atomicshop/wrappers/socketw/get_process.py,sha256=APw_oOXsuR5KljYesd4J8MuzR-kaw2ez3MN3oD_h9Qc,5226
 atomicshop/wrappers/socketw/receiver.py,sha256=m8hXKOa8dqEQGUdcbYjshH8-j0CsMGRkge2ifYKhaAw,9050
@@ -281,8 +283,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.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,,
+atomicshop-2.14.6.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.14.6.dist-info/METADATA,sha256=GxNk1sCw7qnOT6BX5QRiy9KCqX1KQfwt4lU0ESSxaos,10478
+atomicshop-2.14.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.14.6.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.14.6.dist-info/RECORD,,