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

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/wrappers/loggingw/reading.py

@@ -1,6 +1,7 @@
 import os
 from typing import Literal, Union
 from pathlib import Path
+import datetime
 
 from ... import filesystem, datetimes
 from ...file_io import csvs
@@ -11,7 +12,6 @@ def get_logs_paths(
         log_file_path: str = None,
         file_name_pattern: str = '*.*',
         date_pattern: str = None,
-        log_type: Literal['csv'] = 'csv',
         latest_only: bool = False,
         previous_day_only: bool = False
 ):
@@ -36,7 +36,6 @@ def get_logs_paths(
     :param date_pattern: Pattern to match the date in the log file name.
         If specified, the function will get the log file by the date pattern.
         If not specified, the function will get the file date by file last modified time.
-    :param log_type: Type of log to get.
     :param latest_only: Boolean, if True, only the latest log file path will be returned.
     :param previous_day_only: Boolean, if True, only the log file path from the previous day will be returned.
     """
@@ -46,9 +45,6 @@ def get_logs_paths(
     elif log_files_directory_path and log_file_path:
         raise ValueError('Both "log_files_directory_path" and "log_file_path" cannot be specified at the same time.')
 
-    if log_type != 'csv':
-        raise ValueError('Only "csv" log type is supported.')
-
     if latest_only and previous_day_only:
         raise ValueError('Both "latest_only" and "previous_day_only" cannot be True at the same time.')
 
@@ -75,16 +71,22 @@ def get_logs_paths(
             for file_index, single_file in enumerate(logs_files):
                 # Get file name from current loop file path.
                 current_file_name: str = Path(single_file['file_path']).name
+                logs_files[file_index]['file_name'] = current_file_name
+
                 # Get the datetime object from the file name by the date pattern.
                 try:
-                    datetime_object = datetimes.get_datetime_from_complex_string_by_pattern(
+                    datetime_object, date_string, timestamp_float = datetimes.get_datetime_from_complex_string_by_pattern(
                         current_file_name, date_pattern)
-                    timestamp_float = datetime_object.timestamp()
                 # ValueError will be raised if the date pattern does not match the file name.
                 except ValueError:
                     timestamp_float = 0
+                    datetime_object = None
+                    date_string = None
+
                 # Update the last modified time to the dictionary.
                 logs_files[file_index]['last_modified'] = timestamp_float
+                logs_files[file_index]['datetime'] = datetime_object
+                logs_files[file_index]['date_string'] = date_string
 
                 if timestamp_float > latest_timestamp:
                     latest_timestamp = timestamp_float
@@ -95,6 +97,8 @@ def get_logs_paths(
                 if single_file['last_modified'] == 0:
                     latest_timestamp += 86400
                     logs_files[file_index]['last_modified'] = latest_timestamp
+                    logs_files[file_index]['datetime'] = datetime.datetime.fromtimestamp(latest_timestamp)
+                    logs_files[file_index]['date_string'] = logs_files[file_index]['datetime'].strftime(date_pattern)
                     break
 
             # Sort the files by the last modified time.
@@ -117,7 +121,7 @@ def get_logs_paths(
     return logs_files
 
 
-def get_logs(
+def get_all_log_files_into_list(
         log_files_directory_path: str = None,
         log_file_path: str = None,
         file_name_pattern: str = '*.*',
@@ -127,9 +131,10 @@ def get_logs(
         remove_logs: bool = False,
         move_to_path: str = None,
         print_kwargs: dict = None
-):
+) -> list:
     """
-    This function gets the logs from the log files. Supports rotating files to get the logs by time.
+    This function gets the logs contents from the log files. Supports rotating files to get the logs by time.
+    All the contents will be merged into one list.
 
     :param log_files_directory_path: Path to the log files. Check the 'get_logs_paths' function for more details.
     :param log_file_path: Path to the log file. Check the 'get_logs_paths' function for more details.
@@ -144,8 +149,9 @@ def get_logs(
         'all' - Each CSV file has a header. Get the header from each file.
     :param remove_logs: Boolean, if True, the logs will be removed after getting them.
     :param move_to_path: Path to move the logs to.
-
     :param print_kwargs: Keyword arguments dict for 'print_api' function.
+
+    :return: List of dictionaries with the logs content.
     """
 
     if not print_kwargs:
@@ -162,8 +168,7 @@ def get_logs(
         log_files_directory_path=log_files_directory_path,
         log_file_path=log_file_path,
         file_name_pattern=file_name_pattern,
-        date_pattern=date_pattern,
-        log_type=log_type)
+        date_pattern=date_pattern)
 
     # Read all the logs.
     logs_content: list = list()
@@ -294,8 +299,7 @@ class LogReader:
         # If the existing logs file count is 0, it means that this is the first check. We need to get the current count.
         if self._existing_logs_file_count == 0:
             self._existing_logs_file_count = len(get_logs_paths(
-                log_file_path=self.log_file_path,
-                log_type='csv'
+                log_file_path=self.log_file_path
             ))
 
             # If the count is still 0, then there are no logs to read.
@@ -311,7 +315,6 @@ class LogReader:
         latest_statistics_file_path_object = get_logs_paths(
             log_file_path=self.log_file_path,
             date_pattern=self.date_pattern,
-            log_type='csv',
             latest_only=True
         )
 
@@ -327,7 +330,6 @@ class LogReader:
             previous_day_statistics_file_path = get_logs_paths(
                 log_file_path=self.log_file_path,
                 date_pattern=self.date_pattern,
-                log_type='csv',
                 previous_day_only=True
             )[0]['file_path']
         # If you get IndexError, it means that there are no previous day logs to read.
@@ -336,8 +338,7 @@ class LogReader:
 
         # Count all the rotated files.
         current_log_files_count: int = len(get_logs_paths(
-            log_file_path=self.log_file_path,
-            log_type='csv'
+            log_file_path=self.log_file_path
         ))
 
         # If the count of the log files is greater than the existing logs file count, it means that the rotation

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

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