atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/loggingw/reading.py

@@ -2,28 +2,37 @@ import os
 from typing import Literal, Union
 from pathlib import Path
 import datetime
+import re
 
 from ... import filesystem, datetimes
+from ...basics import booleans, list_of_classes
 from ...file_io import csvs
 
 
-class LogReaderTimeCouldntBeFoundInFileNameError(Exception):
-    pass
+def is_string_ends_with_ymd(s: str) -> bool:
+    date_tail_re = re.compile(r'(\d{4}-\d{2}-\d{2})$')
+
+    m = date_tail_re.search(s)
+    if not m:
+        return False
+    try:
+        datetime.datetime.strptime(m.group(1), "%Y-%m-%d")
+        return True
+    except ValueError:
+        return False
 
 
 def get_logs_paths(
-        log_files_directory_path: str = None,
-        log_file_path: str = None,
-        file_name_pattern: str = '*.*',
-        date_pattern: str = None,
+        log_file_path: str,
+        date_format: str = None,
         latest_only: bool = False,
-        previous_day_only: bool = False
-):
+        previous_day_only: bool = False,
+        yesterday_only: bool = False,
+        specific_date: str = None
+) -> list[filesystem.AtomicPath]:
     """
     This function gets the logs file paths from the directory. Supports rotating files to get the logs by time.
 
-    :param log_files_directory_path: Path to the log files. If specified, the function will get all the files from the
-        directory by the 'file_name_pattern'.
     :param log_file_path: Path to the log file. If specified, the function will get the file and all the rotated logs
         associated with this file. The 'file_name_pattern' will become the file name using the file name and extension.
 
@@ -35,112 +44,126 @@ def get_logs_paths(
 
         # The 'log_files_directory_path' will also be taken from the 'log_file_path':
         log_files_directory_path = 'C:/logs'
-    :param file_name_pattern: Pattern to match the log files names.
-        Default file_name_pattern will match all the files.
-    :param date_pattern: Pattern to match the date in the log file name.
+    :param date_format: date format string 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.
+
+        Example:
+        date_format = '%Y-%m-%d'
     :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.
+    :param yesterday_only: Boolean, if True, only the log file path from yesterday will be returned.
+        There's a difference between 'previous_day_only' and 'yesterday_only'.
+        'previous_day_only' will get the log file from the previous day in the list of files that were found.
+        Since that doesn't guarantee that the log file from the previous day is yesterday, we have 'yesterday_only'.
+    :param specific_date: Specific date to get the log file path.
+        If specified, the function will get the log file by the specific date.
+        Meaning that 'date_format' must be specified.
     """
 
-    if not log_files_directory_path and not log_file_path:
-        raise ValueError('Either "log_files_directory_path" or "log_file_path" must be specified.')
-    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.')
+    booleans.is_only_1_true_in_list(
+        booleans_list_of_tuples=[
+            (latest_only, 'latest_only'),
+            (previous_day_only, 'previous_day_only'),
+            (yesterday_only, 'yesterday_only'),
+            (specific_date, 'specific_date'),
+        ],
+        raise_if_all_false=False
+    )
 
-    if latest_only and previous_day_only:
-        raise ValueError('Both "latest_only" and "previous_day_only" cannot be True at the same time.')
+    if not date_format and specific_date:
+        raise ValueError('If "specific_date" is specified, "date_format" must be specified.')
 
-    # If log file path is specified, get the file_name_pattern from the file name.
-    if log_file_path:
-        # Build the file_name_pattern.
-        log_file_name: str = Path(log_file_path).stem
-        log_file_extension: str = Path(log_file_path).suffix
-        file_name_pattern = f'{log_file_name}*{log_file_extension}'
+    # Get the file_name_pattern from the file name. Build the file_name_pattern.
+    # For some reason if the file name will be '.zip', then the file stem will be '.zip' and the extension will be ''.
+    log_file_name: str = Path(log_file_path).stem
+    log_file_extension: str = Path(log_file_path).suffix
 
-        # Get the directory path from the file path.
-        log_files_directory_path = Path(log_file_path).parent
+    if is_string_ends_with_ymd(log_file_name):
+        raise ValueError(
+            f'The log file name cannot end with a date in the format YYYY-MM-DD: {log_file_name}')
 
-    # Get all the log file paths by the file_name_pattern.
-    logs_files: list = filesystem.get_file_paths_from_directory(
+    if not log_file_extension and '.' in log_file_name:
+        log_file_name, log_file_extension = log_file_name.rsplit('.')
+        log_file_extension = f'.{log_file_extension}'
+
+    file_name_pattern: str = f'{log_file_name}*{log_file_extension}'
+
+    # Get the directory path from the file path.
+    log_files_directory_path: str = str(Path(log_file_path).parent)
+
+    # Get all the log file paths by the file_name_pattern and the date_format string.
+    logs_files: list[filesystem.AtomicPath] = filesystem.get_paths_from_directory(
         log_files_directory_path,
+        get_file=True,
         file_name_check_pattern=file_name_pattern,
         add_last_modified_time=True,
-        sort_by_last_modified_time=True)
+        sort_by_last_modified_time=True,
+        datetime_format=date_format
+    )
+
+    # The above will not include the latest log file if it is not rotated yet.
+    # noinspection PyTypeChecker
+    last_log_file_atomic_path: filesystem.AtomicPath = None
+    if os.path.isfile(log_file_path):
+        last_log_file_atomic_path = filesystem.AtomicPath(log_file_path)
+        last_log_file_atomic_path.update(update_last_modified=True)
+
+    if logs_files and last_log_file_atomic_path and date_format:
+        # The problem here is the file name that doesn't contain the date string in the name.
+        # If it is regular log rotation, then there will be one file that doesn't have the date string in the name.
+        # If the function used to get the previous day log, then there will be no file that doesn't have the date
+        # string.
+
+        # Get the latest timestamp from the files with dates.
+        latest_datetime_float: float = 0
+        for file_index, single_file in enumerate(logs_files):
+            if single_file.datetime_float > latest_datetime_float:
+                latest_datetime_float = single_file.datetime_float
+
+        # We will add one day to the latest date that we found and assign to the latest file in rotation
+        # which is without the datetime string.
+        latest_datetime_float += 86400
+        last_log_file_atomic_path.datetime_float = latest_datetime_float
+        last_log_file_atomic_path.datetime_datetime = datetime.datetime.fromtimestamp(latest_datetime_float)
+        last_log_file_atomic_path.datetime_string = (
+            last_log_file_atomic_path.datetime_datetime.strftime(date_format))
+        last_log_file_atomic_path.datetime_format = date_format
+
+        # Add the last log file to the list.
+        logs_files.append(last_log_file_atomic_path)
+
+        # Sort the files by the last modified time.
+        logs_files = list_of_classes.sort_by_attributes(logs_files, ['datetime_float'])
+    elif last_log_file_atomic_path and logs_files and not date_format:
+        logs_files.append(last_log_file_atomic_path)
+    elif last_log_file_atomic_path and not logs_files:
+        logs_files = [last_log_file_atomic_path]
 
-    # Get the datetime object from the first file name by the date pattern.
-    first_date_string = None
     if logs_files:
-        first_file_name: str = Path(logs_files[0]['file_path']).name
-        first_datetime_object, first_date_string, first_timestamp_float = (
-            datetimes.get_datetime_from_complex_string_by_pattern(first_file_name, date_pattern))
-
-    # The problem here is the file name that doesn't contain the date string in the name.
-    # If it is regular log rotation, then there will be one file that doesn't have the date string in the name.
-    # If the function used to get the previous day log, then there will be no file that doesn't have the date string.
-    if len(logs_files) > 1 or (len(logs_files) == 1 and first_date_string):
-        if date_pattern:
-            latest_timestamp: float = 0
-            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.
-                datetime_object, date_string, timestamp_float = (
-                    datetimes.get_datetime_from_complex_string_by_pattern(current_file_name, date_pattern))
-
-                # 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 and timestamp_float > latest_timestamp:
-                    latest_timestamp = timestamp_float
-
-            # Check timestamps, if more than 1 file is None, then the function that gets the date from the file name
-            # didn't work properly, probably because of the string datetime format or the filenames.
-            none_timestamps = [single_file['last_modified'] for single_file in logs_files].count(None)
-            if none_timestamps > 1:
-                raise LogReaderTimeCouldntBeFoundInFileNameError(
-                    'The date pattern could not be found in the file name. Check the date pattern and the file names.')
-
-            # Now, there should be a file that doesn't have the string date pattern in the file name.
-            # We will add one day to the latest date that we found and assign to that file path.
-            for file_index, single_file in enumerate(logs_files):
-                if single_file['last_modified'] is None:
-                    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.
-            logs_files = sorted(logs_files, key=lambda x: x['last_modified'], reverse=False)
-
         if latest_only:
             logs_files = [logs_files[-1]]
-
-        if previous_day_only:
-            # Check if there is a previous day log file.
+        elif previous_day_only:
             if len(logs_files) == 1:
                 logs_files = []
             else:
                 logs_files = [logs_files[-2]]
-    # If there is only one file, meaning it is the current day log.
-    # If the 'previous_day_only' is True, then there are no previous day logs to output.
-    elif len(logs_files) == 1 and previous_day_only:
-        logs_files = []
+        elif yesterday_only:
+            # Get yesterday's date.
+            yesterday_date_string = (datetime.datetime.now() - datetime.timedelta(days=1)).strftime(date_format)
+            # Check if there is a yesterday log file.
+            logs_files = [single_file
+                          for single_file in logs_files if single_file.datetime_string == yesterday_date_string]
+        elif specific_date:
+            # Check if there is a specific date log file.
+            logs_files = [single_file for single_file in logs_files if single_file.datetime_string == specific_date]
 
     return logs_files
 
 
 def get_all_log_files_into_list(
-        log_files_directory_path: str = None,
         log_file_path: str = None,
-        file_name_pattern: str = '*.*',
-        date_pattern: str = None,
+        date_format: str = None,
         log_type: Literal['csv'] = 'csv',
         header_type_of_files: Literal['first', 'all'] = 'first',
         remove_logs: bool = False,
@@ -151,13 +174,13 @@ def get_all_log_files_into_list(
     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.
-    :param file_name_pattern: Pattern to match the log files names.
-        Default file_name_pattern will match all the files.
-    :param date_pattern: Pattern to match the date in the log file name.
+    :param date_format: date format string 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.
+
+        Example:
+        date_format = '%Y-%m-%d'
     :param log_type: Type of log to get.
     :param header_type_of_files: Type of header to get from the files.
         'first' - Only the first file has a header for CSV. This header will be used for the rest of the files.
@@ -180,10 +203,8 @@ def get_all_log_files_into_list(
 
     # Get all the log file paths by the file_name_pattern.
     logs_files: list = get_logs_paths(
-        log_files_directory_path=log_files_directory_path,
         log_file_path=log_file_path,
-        file_name_pattern=file_name_pattern,
-        date_pattern=date_pattern)
+        date_format=date_format)
 
     # Read all the logs.
     logs_content: list = list()
@@ -191,13 +212,13 @@ def get_all_log_files_into_list(
     for single_file in logs_files:
         if log_type == 'csv':
             if header_type_of_files == 'all':
-                csv_content, _ = csvs.read_csv_to_list_of_dicts_by_header(single_file['file_path'], **print_kwargs)
+                csv_content, _ = csvs.read_csv_to_list_of_dicts_by_header(single_file.path, **print_kwargs)
                 logs_content.extend(csv_content)
             elif header_type_of_files == 'first':
                 # The function gets empty header to read it from the CSV file, the returns the header that it read.
                 # Then each time the header is fed once again to the function.
                 csv_content, header = csvs.read_csv_to_list_of_dicts_by_header(
-                    single_file['file_path'], header=header, **print_kwargs)
+                    single_file.path, header=header, **print_kwargs)
                 # Any way the first file will be read with header.
                 logs_content.extend(csv_content)
 
@@ -208,7 +229,7 @@ def get_all_log_files_into_list(
     if remove_logs:
         # Remove the statistics files.
         for single_file in logs_files:
-            filesystem.remove_file(single_file['file_path'])
+            filesystem.remove_file(single_file.path)
 
     if move_to_path:
         # Get formatted time stamp for file name.
@@ -221,9 +242,7 @@ def get_all_log_files_into_list(
         filesystem.create_directory(move_to_path_with_timestamp)
         # Move the statistics files.
         for single_file in logs_files:
-            single_file_name = filesystem.get_file_name(single_file['file_path'])
-            move_to_path_with_file = f'{move_to_path_with_timestamp}{os.sep}{single_file_name}'
-            filesystem.move_file(single_file['file_path'], move_to_path_with_file)
+            filesystem.move_file(single_file.path, move_to_path_with_timestamp)
 
     return logs_content
 
@@ -263,22 +282,25 @@ class LogReader:
     def __init__(
             self,
             log_file_path: str,
-            date_pattern: str = None,
+            date_format: str = None,
             log_type: Literal['csv'] = 'csv',
             get_previous_file: bool = False,
             header: list = None
     ):
         """
         :param log_file_path: Path to the log file.
-        :param date_pattern: Pattern to match the date in the log file name.
+        :param date_format: date format string 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.
+
+            Example:
+            date_format = '%Y-%m-%d'
         :param log_type: Type of log to get.
         :param get_previous_file: Boolean, if True, the function will get the previous log file.
             For example, your log is set to rotate every Midnight.
-            Meaning, once the day will change, the function will get the log file from the previous day in the third entry
-            of the return tuple. This happens only once each 24 hours. Not from the time the function was called, but from
-            the time the day changed.
+            Meaning, once the day will change, the function will get the log file from the previous day in the
+            third entry of the return tuple. This happens only once each 24 hours. Not from the time
+            the function was called, but from the time the day changed.
         :param header: List of strings that will be the header of the CSV file. Default is 'None'.
             None: the header from the CSV file will be used. The first row of the CSV file will be the header.
                 Meaning, that the first line will be skipped and the second line will be the first row of the content.
@@ -287,7 +309,7 @@ class LogReader:
         """
 
         self.log_file_path: str = log_file_path
-        self.date_pattern: str = date_pattern
+        self.date_format: str = date_format
         self.log_type: Literal['csv'] = log_type
         self.get_previous_file: bool = get_previous_file
         self.header: list = header
@@ -329,7 +351,7 @@ class LogReader:
         # Get the latest statistics file path.
         latest_statistics_file_path_object = get_logs_paths(
             log_file_path=self.log_file_path,
-            date_pattern=self.date_pattern,
+            date_format=self.date_format,
             latest_only=True
         )
 
@@ -337,16 +359,16 @@ class LogReader:
         # if not latest_statistics_file_path_object:
         #     return [], [], self.header
 
-        latest_statistics_file_path: str = latest_statistics_file_path_object[0]['file_path']
+        latest_statistics_file_path: str = latest_statistics_file_path_object[0].path
 
         # Get the previous day statistics file path.
         previous_day_statistics_file_path: Union[str, None] = None
         try:
             previous_day_statistics_file_path = get_logs_paths(
                 log_file_path=self.log_file_path,
-                date_pattern=self.date_pattern,
+                date_format=self.date_format,
                 previous_day_only=True
-            )[0]['file_path']
+            )[0].path
         # If you get IndexError, it means that there are no previous day logs to read.
         except IndexError:
             pass

atomicshop/wrappers/mongodbw/mongo_infra.py

@@ -0,0 +1,31 @@
+from pymongo import MongoClient
+import pymongo.errors
+
+
+MONGODB_DEFAULT_URI: str = 'mongodb://localhost:27017/'
+
+
+class MongoDBNoConnectionError(Exception):
+    pass
+
+
+def test_connection(
+        uri: str = MONGODB_DEFAULT_URI,
+        raise_exception: bool = False
+) -> bool:
+    """
+    Test the connection to the MongoDB server.
+
+    :param uri: str, URI to the MongoDB server.
+    :param raise_exception: bool, True to raise an exception if the connection fails, False otherwise (just return
+    False).
+    :return: bool, True if the connection is successful, False otherwise.
+    """
+    try:
+        client = MongoClient(uri)
+        client.admin.command('ping')
+        return True
+    except pymongo.errors.ServerSelectionTimeoutError:
+        if raise_exception:
+            raise MongoDBNoConnectionError(f"Could not connect to the MongoDB server on: ")
+        return False