atomicshop 2.14.8__py3-none-any.whl → 2.14.9__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.8'
+__version__ = '2.14.9'

atomicshop/wrappers/loggingw/filters.py

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

atomicshop/wrappers/loggingw/handlers.py

@@ -1,6 +1,5 @@
 import logging
 from logging.handlers import TimedRotatingFileHandler, QueueListener, QueueHandler
-from logging import FileHandler
 import time
 import re
 import os
@@ -10,66 +9,15 @@ from typing import Literal, Union
 import threading
 from datetime import datetime
 
-from . import loggers, formatters
+from . import loggers, formatters, filters
 from ... import datetimes, filesystem
 
 
-DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
+"""
 # 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):
-        self._last_rotated_date = datetime.now().date()
-        super().doRollover()
-
-
-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.
-
-    :param header: string, Header to write to the log file.
-        Example: "time,host,error"
-    """
-    def __init__(self, *args, **kwargs):
-        self.header = kwargs.pop('header', None)
-        super().__init__(*args, **kwargs)
-
-    def doRollover(self):
-        super().doRollover()
-        self._write_header()
-
-    def _write_header(self):
-        if self.header:
-            with open(self.baseFilename, 'a') as f:
-                f.write(self.header + '\n')
-
-    def emit(self, record):
-        if not os.path.exists(self.baseFilename) or os.path.getsize(self.baseFilename) == 0:
-            self._write_header()
-        super().emit(record)
+DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
+DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
+"""
 
 
 def _process_formatter_attribute(
@@ -134,6 +82,48 @@ def add_stream_handler(
     loggers.set_propagation(logger)
 
 
+# Function to start the interval-based rotation check
+def _start_interval_rotation(handler):
+    def check_rotation():
+        while True:
+            next_rollover = _calculate_next_rollover()
+            while datetime.now() < next_rollover:
+                time.sleep(0.1)
+
+                # Check if the next_rollover has changed (indicating a rollover by an event)
+                if _calculate_next_rollover() != next_rollover:
+                    next_rollover = _calculate_next_rollover()
+                    break
+
+            # Perform manual rollover if needed
+            if datetime.now() >= next_rollover:
+                _rotate_log()
+
+    def _calculate_next_rollover():
+        return datetime.fromtimestamp(handler.rolloverAt)
+
+    # Function to rotate logs
+    def _rotate_log():
+        handler.doRollover()
+
+    rotation_thread = threading.Thread(target=check_rotation)
+    rotation_thread.daemon = True
+    rotation_thread.start()
+
+
+def _wrap_do_rollover(handler, header):
+    original_do_rollover = handler.doRollover
+
+    def new_do_rollover():
+        original_do_rollover()
+        # After rollover, write the header
+        if header:
+            with open(handler.baseFilename, 'a') as f:
+                f.write(header + '\n')
+
+    handler.doRollover = new_do_rollover
+
+
 def add_timedfilehandler_with_queuehandler(
         logger: logging.Logger,
         file_path: str,
@@ -147,6 +137,10 @@ def add_timedfilehandler_with_queuehandler(
             str,
             None] = None,
         formatter_use_nanoseconds: bool = False,
+        rotate_at_rollover_time: bool = True,
+        rotation_date_format: str = None,
+        rotation_callback_namer_function: callable = None,
+        rotation_use_default_callback_namer_function: bool = True,
         when: str = 'midnight',
         interval: int = 1,
         delay: bool = True,
@@ -159,10 +153,6 @@ def add_timedfilehandler_with_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
@@ -173,15 +163,8 @@ def add_timedfilehandler_with_queuehandler(
 
     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)
+    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)
 
@@ -196,7 +179,23 @@ def add_timedfilehandler_with_queuehandler(
         set_formatter(file_handler, logging_formatter)
 
     # This function will change the suffix behavior of the rotated file name.
-    change_rotated_filename(file_handler)
+    change_rotated_filename(
+        file_handler=file_handler, date_format_string=rotation_date_format,
+        callback_namer_function=rotation_callback_namer_function,
+        use_default_callback_namer_function=rotation_use_default_callback_namer_function
+    )
+
+    # If header is set, we'll add the filter to the handler that will create the header on file rotation.
+    if header:
+        # Filter is added to write header on logger startup.
+        add_filter_to_handler(file_handler, filters.HeaderFilter(header, file_handler.baseFilename))
+        # Wrap the doRollover method to write the header after each rotation, since adding the filter
+        # will only write the header on log file creation.
+        _wrap_do_rollover(file_handler, header)
+
+    # Start the interval-based rotation forcing.
+    if rotate_at_rollover_time:
+        _start_interval_rotation(file_handler)
 
     queue_handler = start_queue_listener_for_file_handler_and_get_queue_handler(file_handler)
     loggers.set_logging_level(queue_handler, logging_level)
@@ -243,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
-) -> ForceAtTimeRotationTimedRotatingFileHandler:
+) -> TimedRotatingFileHandler:
     """
     Function to get a TimedRotatingFileHandler.
     This handler will output messages to a file, rotating the log file at certain timed intervals.
@@ -261,32 +260,10 @@ def get_timed_rotating_file_handler(
     :return: TimedRotatingFileHandler.
     """
 
-    return ForceAtTimeRotationTimedRotatingFileHandler(
+    return TimedRotatingFileHandler(
         filename=log_file_path, when=when, interval=interval, delay=delay, encoding=encoding)
 
 
-def get_timed_rotating_file_handler_with_header(
-        log_file_path: str, when: str = "midnight", interval: int = 1, delay: bool = False, encoding=None,
-        header: str = None) -> TimedRotatingFileHandlerWithHeader:
-    """
-    Function to get a TimedRotatingFileHandler with header.
-    This handler will output messages to a file, rotating the log file at certain timed intervals.
-    It will write a header to the log file each time there is a file rotation.
-
-    :param log_file_path: Path to the log file.
-    :param when: When to rotate the log file. Possible
-    :param interval: Interval to rotate the log file.
-    :param delay: bool, If set to True, the log file will be created only if there's something to write.
-    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
-    :param header: Header to write to the log file.
-        Example: "time,host,error"
-    :return: TimedRotatingFileHandlerWithHeader.
-    """
-
-    return TimedRotatingFileHandlerWithHeader(
-        filename=log_file_path, when=when, interval=interval, delay=delay, encoding=encoding, header=header)
-
-
 def start_queue_listener_for_file_handler(
         file_handler: logging.FileHandler, queue_object) -> logging.handlers.QueueListener:
     """
@@ -351,72 +328,74 @@ def get_handler_name(handler: logging.Handler) -> str:
 
 def change_rotated_filename(
         file_handler: logging.Handler,
-        date_format_string: str = None
+        date_format_string: str = None,
+        callback_namer_function: callable = None,
+        use_default_callback_namer_function: bool = True
 ):
     """
     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_format_string: Date format string to set to the handler's suffix.
+    :param callback_namer_function: Callback function to change the filename on rotation.
+    :param use_default_callback_namer_function: If set to True, the default callback namer function will be used
+        and the filename will be changed on rotation instead of using the default like this:
+        'file.log.2021-12-24' -> 'file_2021-12-24.log'.
+
+    ---------------------
+
+    At this point, 'file_handler.suffix' is already '%Y-%m-%d' if 'when' is set to 'midnight'.
+    You can change it if you wish (example: '%Y_%m_%d'), the method is described below.
     """
-    # 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:
-    # test.log
-    # After file is rotated at midnight, by default the old filename will be:
-    # test.log.2021_12_24
-    # And the log file of 25th, now will be "test.log".
-    # So, Changing the file suffix to include the extension to the suffix, so it will be:
-    # test.log.2021_12_24.log
-    # file_handler.suffix = logfile_suffix
-    # file_handler.suffix = "_%Y_%m_%d.txt"
-    # This step will remove the created ".log." above before the suffix and the filename will look like:
-    # test.2021_12_24.log
-    # file_handler.namer = lambda name: name.replace(log_file_extension + ".", "") + log_file_extension
-    # file_handler.namer = lambda name: name.replace(".txt.", "") + log_file_extension
-    # This will recompile the string to tell the handler the length of the suffix parts
-    # 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$")
 
     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'
+        # 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
+        # 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}"
+        return f"{parent_dir}{os.sep}{file_stem}_{date_part}{file_extension}"
+
+    def change_file_handler_suffix():
+        # 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)
 
-    if date_format_string is None:
-        date_format_string = DEFAULT_DATE_STRING_FORMAT
+        # Regex pattern to match the rotated log filenames
+        logfile_regex_suffix = re.compile(date_regex_pattern)
 
-    # Construct the new suffix without the file extension
-    logfile_suffix = f"_{date_format_string}"
+        # Update the handler's suffix to include the date format
+        file_handler.suffix = 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)
+        # Update the handler's extMatch regex to match the new filename format
+        file_handler.extMatch = logfile_regex_suffix
 
-    # Regex pattern to match the rotated log filenames
-    logfile_regex_suffix = re.compile(date_regex_pattern)
+    if use_default_callback_namer_function and callback_namer_function:
+        raise ValueError("You can't use both default and custom callback namer function.")
+    elif not use_default_callback_namer_function and not callback_namer_function:
+        raise ValueError(
+            "You need to provide a 'callback_namer_function' or our 'use_default_callback_namer_function'.")
 
-    # Update the handler's suffix to include the date format
-    file_handler.suffix = logfile_suffix
+    if date_format_string:
+        change_file_handler_suffix()
 
-    file_handler.namer = callback_namer
-    # Update the handler's extMatch regex to match the new filename format
-    file_handler.extMatch = logfile_regex_suffix
+    # Set the callback function to change the filename on rotation.
+    if use_default_callback_namer_function:
+        file_handler.namer = callback_namer
+
+    if callback_namer_function:
+        file_handler.namer = callback_namer_function
 
 
 def has_handlers(logger: logging.Logger) -> bool:
@@ -438,7 +417,7 @@ def has_handlers(logger: logging.Logger) -> bool:
         return True
 
 
-def extract_datetime_format_from_file_handler(file_handler: FileHandler) -> Union[str, None]:
+def extract_datetime_format_from_file_handler(file_handler: logging.FileHandler) -> Union[str, None]:
     """
     Extract the datetime string formats from all TimedRotatingFileHandlers in the logger.
 
@@ -456,3 +435,13 @@ def extract_datetime_format_from_file_handler(file_handler: FileHandler) -> Unio
             return datetime_format
 
         return None
+
+
+def add_filter_to_handler(handler: logging.Handler, filter_object: logging.Filter):
+    """
+    Function to add a filter to the handler.
+    :param handler: Handler to add the filter to.
+    :param filter_object: Filter object to add to the handler.
+    """
+
+    handler.addFilter(filter_object)

atomicshop/wrappers/loggingw/loggingw.py

@@ -2,7 +2,7 @@ import logging
 import os
 from typing import Literal, Union
 
-from . import loggers, handlers, formatters
+from . import loggers, handlers
 
 
 def create_logger(
@@ -26,6 +26,10 @@ def create_logger(
             None] = None,
         formatter_streamhandler_use_nanoseconds: bool = True,
         formatter_filehandler_use_nanoseconds: bool = True,
+        filehandler_rotate_at_rollover_time: bool = True,
+        filehandler_rotation_date_format: str = None,
+        filehandler_rotation_callback_namer_function: callable = None,
+        filehandler_rotation_use_default_namer_function: bool = True,
         when: str = "midnight",
         interval: int = 1,
         delay: bool = False,
@@ -67,6 +71,20 @@ def create_logger(
         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 filehandler_rotate_at_rollover_time: bool,
+        If set to True, the log file will be rotated at the rollover time, even if there's nothing to write.
+        If set to False, the log file will be rotated after 'when' time, but only when event occurs.
+    :param filehandler_rotation_date_format: string, Date format to use for the log file rotation.
+        Example for 'when="midnight"': the default date format is '%Y-%m-%d', resulting in filename on rotation like:
+            "test.log.2021-11-25"
+            If you want to change the date format to '%Y_%m_%d', the filename will be:
+            "test.log.2021_11_25"
+    :param filehandler_rotation_callback_namer_function: callable, Callback function to use for the log file naming
+        on rotation. If set to None, logging module default function will be used. With "when='midnight'",
+        and filename: "test.log" this will name the file on rotation similar to: "test.log.2021-11-25".
+    :param filehandler_rotation_use_default_namer_function: bool, If set to True, the default namer function will be
+        used for the log file naming on rotation. With "when='midnight'" and filename: "test.log",
+        this will name the file on rotation similar to: "test_2021-11-25.log".
     :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
@@ -159,6 +177,10 @@ def create_logger(
         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,
+            rotate_at_rollover_time=filehandler_rotate_at_rollover_time,
+            rotation_date_format=filehandler_rotation_date_format,
+            rotation_callback_namer_function=filehandler_rotation_callback_namer_function,
+            rotation_use_default_callback_namer_function=filehandler_rotation_use_default_namer_function,
             when=when, interval=interval, delay=delay, encoding=encoding, header=header)
 
     return logger

{atomicshop-2.14.8.dist-info → atomicshop-2.14.9.dist-info}/METADATA

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

{atomicshop-2.14.8.dist-info → atomicshop-2.14.9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=gZdXspcvPZo8Qcm-5yJOZLVwsJp8kFqubdBUfmwcABs,123
+atomicshop/__init__.py,sha256=DBF3vx08oq-VNJ9rHPgRbBVXDm9QZq_mn99gKX4ERy0,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
@@ -234,10 +234,11 @@ 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/filters.py,sha256=CMs5PAMb68zxJgBcQobaOFDG5kLJBOVYnoBHjDgksO8,2859
 atomicshop/wrappers/loggingw/formatters.py,sha256=808R7K3e3ZJD2BXfqI6UMOyXGrCgt9SYh2Uv7sL_1KQ,7432
-atomicshop/wrappers/loggingw/handlers.py,sha256=ofm7pEhD0aPGOGc9QAJT8S00FVD30X5g06KZntoOLc0,18071
+atomicshop/wrappers/loggingw/handlers.py,sha256=bv3oCm_P0JdXaJKYjhyfFNMNong6Nc9LE4JGFxLN2As,16940
 atomicshop/wrappers/loggingw/loggers.py,sha256=DHOOTAtqkwn1xgvLHSkOiBm6yFGNuQy1kvbhG-TDog8,2374
-atomicshop/wrappers/loggingw/loggingw.py,sha256=irzlIYXTcCpSVjmb6NU6GJGCIy3V48ZVKNvKOlH70CU,9417
+atomicshop/wrappers/loggingw/loggingw.py,sha256=lo4OZPXCbYZi3GqpaaJSs9SOGFfqD2EgHzzTK7f5IR4,11275
 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
@@ -283,8 +284,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.8.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.14.8.dist-info/METADATA,sha256=tcSG898X9bqGNFLcBWRjXFgnEP1s4aRQWPXVIqH8Sz4,10478
-atomicshop-2.14.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.14.8.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.14.8.dist-info/RECORD,,
+atomicshop-2.14.9.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.14.9.dist-info/METADATA,sha256=TL4CY4-kaxRLWK4vD8N1GxSUsFCHwBesZSZB3nAz7OU,10478
+atomicshop-2.14.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.14.9.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.14.9.dist-info/RECORD,,