atomicshop 2.2.9__py3-none-any.whl → 2.3.0__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.2.9'
+__version__ = '2.3.0'

atomicshop/basics/bytes_arrays.py

@@ -1,4 +1,3 @@
-# v1.0.0
 def get_single_byte_from_byte_string(byte_string, index: int):
     """
     Function extracts single byte as byte from byte string object.
@@ -18,3 +17,37 @@ def get_single_byte_from_byte_string(byte_string, index: int):
     """
 
     return byte_string[index:index+1]
+
+
+def convert_sequence_of_bytes_to_sequence_of_strings(byte_sequence: bytes) -> list[str]:
+    """
+    Convert sequence of bytes to sequence of strings.
+    :param byte_sequence: bytes, sequence of bytes.
+    :return: list of strings.
+    """
+
+    result: list[str] = list()
+    for byte_index, single_byte in enumerate(byte_sequence):
+        # Convert byte to string character.
+        string_from_byte = chr(single_byte)
+
+        # Check if string is alphanumeric.
+        if string_from_byte.isalnum():
+            # Append string to result.
+            result.append(string_from_byte)
+        # If string is not alphanumeric, it means that it is something like '\x04'.
+        # So, we need to output '04'. We need to remove the '\x' from the string.
+        # The problem is that the string doesn't contain 4 characters, but 1.
+        # len(string_from_byte) returns 1.
+        # So, we can't remove '\x' from the string, since it is the character '\x04' in the table.
+        # We will convert it to printable string with repr() function.
+        # repr() function returns string with quotes, so we need to remove them with [1:-1].
+        else:
+            printable_string = repr(string_from_byte)[1:-1]
+            # Remove '\x' from the string.
+            printable_string = printable_string.replace('\\x', '')
+            result.append(printable_string)
+
+        # single_byte_string = byte_sequence[byte_index:byte_index+1]
+
+    return result

atomicshop/basics/dicts.py

@@ -118,3 +118,38 @@ def merge(dict1, dict2) -> dict:
 def find_key_by_value(input_dict, value):
     # This will return set of keys. If non found, will return empty set.
     return {k for k, v in input_dict.items() if v == value}
+
+
+def sort_by_values(input_dict: dict, reverse: bool = False) -> dict:
+    """
+    The function will sort a dictionary by its values.
+    Example:
+        # Define dictionary.
+        test = {
+            'key1': '1',
+            'key2': '2',
+            'key3': '8',
+            'key4': '37',
+            'key5': '5',
+            'key6': '23'
+        }
+
+        # Sort dictionary.
+        sorted_dict = sort_by_values(test, reverse=True)
+
+        # Result:
+        # {
+        #     'key4': '37',
+        #     'key6': '23',
+        #     'key3': '8',
+        #     'key5': '5',
+        #     'key2': '2',
+        #     'key1': '1'
+        # }
+
+    :param input_dict: dict, the dictionary to sort.
+    :param reverse: bool, if True, the dictionary will be sorted in reverse order.
+    :return: dict, the sorted dictionary.
+    """
+
+    return dict(sorted(input_dict.items(), key=lambda item: item[1], reverse=reverse))

atomicshop/basics/dicts_nested.py

@@ -70,3 +70,33 @@ def find_key_by_value(input_dict: dict, string1: str, string2: str = str(), key_
                 final_key_list.append(temp_list)
 
     return final_key_list
+
+
+def find_key_of_last_nest(input_dict: dict) -> list:
+    """
+    Returns list of keys of the last nest in the dictionary.
+    :param input_dict: dict, the dictionary to search.
+    :return: list of keys in order.
+    """
+
+    for key, value in input_dict.items():
+        if isinstance(value, dict):
+            return [key] + find_key_of_last_nest(value)
+        elif isinstance(value, list):
+            return [key] + find_key_of_last_nest(value[0])
+        else:
+            return [key]
+
+
+def find_key_of_last_dict(input_dict: dict) -> list:
+    """
+    Returns list of keys of the last dictionary in the dict.
+    :param input_dict: dict, the dictionary to search.
+    :return: list of keys in order.
+    """
+
+    for key, value in input_dict.items():
+        if isinstance(value, dict):
+            return [key] + find_key_of_last_dict(value)
+        else:
+            return []

atomicshop/basics/enums.py

@@ -0,0 +1,70 @@
+from enum import Enum
+import os
+
+
+class ComparisonOperator(Enum):
+    """
+    Enum class that was created for 'scan_directory_and_return_list' function.
+    Specifically for 'file_name_check_tuple[1]' - second entry.
+    """
+    EQ = '__eq__'
+    CONTAINS = '__contains__'
+
+
+def __comparison_usage_example(
+        directory_fullpath: str,
+        file_name_check_tuple: tuple = tuple()):
+    """
+    The function receives a filesystem directory as string, scans it recursively for files and returns list of
+    full paths to that file (including).
+    If 'file_name_check_tuple' specified, the function will return only list of files that answer to the input
+    of that tuple.
+    Recursive.
+
+    :param directory_fullpath: string to full path to directory on the filesystem to scan.
+    :param file_name_check_tuple: tuple that should contain 2 entries:
+        file_name_check_tuple[0]: string that will contain part of file name to check or full file name with extension.
+        file_name_check_tuple[1]: 'ComparisonOperator' object to test against found file name with extension.
+            'ComparisonOperator.EQ' will check for specific file name (eg: 'config_file.ini').
+            'ComparisonOperator.CONTAINS' will check if file name contains part of the string (eg: 'config')(eg: '.ini')
+
+    :return: list of all found filenames with full file paths, list with relative folders to file excluding the
+        main folder.
+
+    Usage:
+        from atomicshop.filesystem import get_file_paths_and_relative_directories, ComparisonOperator
+
+        # Get full paths of all the 'engine_config.ini' files.
+        engine_config_path_list = get_file_paths_and_relative_directories(
+            directory_fullpath=some_directory_path,
+            file_name_check_tuple=(config_file_name, ComparisonOperator.EQ))
+    """
+
+    # Type checking.
+    if file_name_check_tuple:
+        if not isinstance(file_name_check_tuple[1], ComparisonOperator):
+            raise TypeError(f'Second entry of tuple "file_name_check_tuple" is not of "ComparisonOperator" type.')
+
+    # "Walk" over all the directories and subdirectories - make list of full file paths inside the directory
+    # recursively.
+    for dirpath, subdirs, files in os.walk(directory_fullpath):
+        # Iterate through all the file names that were found in the folder.
+        for file in files:
+            # If 'file_name_check_tuple' was passed.
+            if file_name_check_tuple:
+                # Get separate variables from the tuple.
+                # 'check_string' is a string that will be checked against 'file' iteration, which also a string.
+                # 'comparison_operator' is 'ComparisonOperator' Enum object, that contains the string method
+                # operator that will be used against the 'check_string'.
+                check_string, comparison_operator = file_name_check_tuple
+                # 'getattr' adds the string comparison method to the 'file' string. Example:
+                # file.__eq__
+                # 'comparison_operator' is the Enum class representation and '.value' method is the string
+                # representation of '__eq__'.
+                # and after that comes the check string to check against:
+                # file.__eq__(check_string)
+                if getattr(file, comparison_operator.value)(check_string):
+                    return
+            # If 'file_name_check_tuple' wasn't passed, then get all the files.
+            else:
+                return

atomicshop/basics/strings.py

@@ -159,11 +159,16 @@ def match_pattern_against_string(pattern: str, check_string: str, prefix_suffix:
     # Replace the wildcard string '*' with regex wildcard string '.+'.
     # In regex '.' is a wildcard, but only for 1 character, if you need more than 1 character you should add '+'.
     pattern_re = pattern.replace(wildcard_str, wildcard_re)
+    pattern_no_wildcard = pattern.replace(wildcard_str, '')
 
     # Search for pattern, if found, return 'True'.
     if search_pattern(pattern_re):
         return True
 
+    # 'regex' doesn't think that '.*' is a match for 'test', so we'll check for this case separately.
+    if search_pattern(pattern_no_wildcard):
+        return True
+
     # If it wasn't found in previous check,
     # then we'll continue checking without prefix and suffix if 'prefix_suffix' is 'True'.
     if prefix_suffix:
@@ -268,6 +273,14 @@ def is_numeric_only(string: str) -> bool:
     return string.isdigit()
 
 
+def is_alphabetic_only(string: str) -> bool:
+    """
+    Function to check if string contains only alphabetic characters.
+    """
+
+    return string.isalpha()
+
+
 def replace_words_with_values_from_dict(
         sentence: str, dictionary: dict, contains: bool = False, case_insensitive: bool = False) -> str:
     """
@@ -305,3 +318,40 @@ def replace_words_with_values_from_dict(
     joined_sentence: str = ' '.join(sentence_parts)
 
     return joined_sentence
+
+
+def multiple_splits_by_delimiters(full_string: str, delimiters: list) -> list[str]:
+    """
+    Function splits the string by multiple delimiters.
+    :param full_string: string, to split.
+    :param delimiters: list, of delimiters.
+    :return: list of strings.
+    """
+
+    # Base case: no more delimiters, return the string itself in a list.
+    if not delimiters:
+        return [full_string]
+
+    # Take the first delimiter.
+    delimiter = delimiters[0]
+    # Split the string on the current delimiter.
+    split_strings = full_string.split(delimiter)
+    # Get the remaining delimiters.
+    remaining_delimiters = delimiters[1:]
+
+    result = []
+    for substring in split_strings:
+        # Recursively call the whole function with each substring and the remaining delimiters.
+        result.extend(multiple_splits_by_delimiters(substring, remaining_delimiters))
+    return result
+
+
+def check_if_suffix_is_in_string(string: str, suffix: str) -> bool:
+    """
+    Function checks if 'suffix' is in the end of 'string'.
+    :param string: string, to check.
+    :param suffix: string, to check.
+    :return: boolean.
+    """
+
+    return string.endswith(suffix)

atomicshop/datetimes.py

@@ -183,6 +183,42 @@ def create_date_range_for_year_month(
     return create_date_range(first_date, last_date)
 
 
+def get_difference_between_dates_in_days(first_datetime, reference_datetime) -> int:
+    """
+    Get the difference between two dates in days.
+    The first day is '0'.
+
+    :param first_datetime: datetime.datetime object.
+    :param reference_datetime: datetime.datetime object.
+
+    :return: integer, the difference between the two dates in days.
+    """
+
+    # Get the difference between the two dates.
+    difference = reference_datetime - first_datetime
+
+    # Get the difference in days.
+    return difference.days
+
+
+def get_difference_between_dates_in_hours(first_datetime, reference_datetime) -> int:
+    """
+    Get the difference between two dates in hours.
+    The first hour is '0'.
+
+    :param first_datetime: datetime.datetime object.
+    :param reference_datetime: datetime.datetime object.
+
+    :return: integer, the difference between the two dates in hours.
+    """
+
+    # Get the difference between the two dates.
+    difference = first_datetime - reference_datetime
+
+    # Get the difference in hours.
+    return difference.days * 24 + difference.seconds // (60 * 60)
+
+
 def get_seconds_random(minimum_seconds, maximum_seconds):
     return random.randint(minimum_seconds, maximum_seconds)
 

atomicshop/domains.py

@@ -56,11 +56,16 @@ def get_registered_domain(domain: str) -> str:
     :return: string of main registered domain with tld only.
     """
     # Extract all the parts from domain with 'tldextract'.
-    extracted_domain_parts = tldextract.TLDExtract(suffix_list_urls=str())(domain)
+    # By default, TLD Extract will use the online database, to use the offline database empty Sequence[str] must be
+    # passed to 'suffix_list_urls' option.
+    # Empty sequence in TLDExtract itself is defined as '()'.
+    # extracted_domain_parts = tldextract.TLDExtract(suffix_list_urls=str())(domain)
+    extracted_domain_parts = tldextract.TLDExtract(suffix_list_urls=())(domain)
 
     # If 'suffix' is empty, it means that the tld is not in 'tldextract' offline database or there is no tld at all,
     # for example: some-domain-without-tld
     if not extracted_domain_parts.suffix:
         return domain
     else:
-        return f'{extracted_domain_parts.registered_domain}.{extracted_domain_parts.suffix}'
+        # return f'{extracted_domain_parts.registered_domain}.{extracted_domain_parts.suffix}'
+        return extracted_domain_parts.registered_domain

atomicshop/file_io/jsons.py

@@ -1,4 +1,3 @@
-# v1.0.4 - 21.03.2023 18:10
 import json
 
 from .file_io import read_file_decorator, write_file_decorator

atomicshop/file_io/tomls.py

@@ -0,0 +1,24 @@
+import tomllib
+
+from .file_io import read_file_decorator
+
+
+@read_file_decorator
+def read_toml_file(file_path: str,
+                   file_mode: str = 'rb',
+                   encoding=None,
+                   file_object=None,
+                   **kwargs) -> dict:
+    """
+    Read the toml file and return its content as dictionary.
+
+    :param file_path: String with full file path to file.
+    :param file_mode: string, file reading mode. Examples: 'r', 'rb'. Default is 'r'.
+    :param encoding: string, encoding of the file. Default is 'None'.
+    :param file_object: file object of the 'open()' function in the decorator. Decorator executes the 'with open()'
+        statement and passes to this function. That's why the default is 'None', since we get it from the decorator.
+    :return: dict.
+    """
+
+    # Read the file to variable
+    return tomllib.load(file_object)

atomicshop/file_io/xlsxs.py

@@ -0,0 +1,58 @@
+import pandas
+
+from .file_io import write_file_decorator
+
+
+@write_file_decorator
+def write_xlsx(
+        spread_sheets: dict,
+        file_path: str,
+        file_mode: str = 'w',
+        index: bool = False,
+        file_object=None,
+        **kwargs
+) -> None:
+    """
+    Write data to xlsx file. Including several spreadsheets if specified.
+
+    :param file_path: string, full path to the file to write.
+    :param spread_sheets: dict. Each dict is a spreadsheet. The keys are the names of the sheets and the
+        values are the dicts to write to the sheets.
+
+        Example:
+            spread_sheets = {
+                'sheet1': {
+                    'col1': [1, 2, 3],
+                    'col2': [4, 5, 6]
+                },
+                'sheet2': {
+                    'col1': [7, 8, 9],
+                    'col2': [10, 11, 12]
+                }
+            }
+    :param file_mode: string, file writing mode. Examples: 'x', 'w', 'wb'.
+    :param index: boolean, if True, the index of the data frame will be written to the file on the left-most column.
+        The index meaning that each row will have a number, starting from 0.
+    :param file_object: file object of the 'open()' function in the decorator. Decorator executes the 'with open()'
+        statement and passes to this function. That's why the default is 'None', since we get it from the decorator.
+    :return:
+    """
+
+    # Create dict of data frames.
+    spread_sheets = {sheet_name: pandas.DataFrame(sheet_data) for sheet_name, sheet_data in spread_sheets.items()}
+
+    # Save the file.
+    with pandas.ExcelWriter(file_path, engine='openpyxl') as writer:
+        for sheet_name, sheet_data in spread_sheets.items():
+            sheet_data.to_excel(writer, sheet_name=sheet_name, index=index)
+
+    # # Create the writer object.
+    # writer = pandas.ExcelWriter(file_path, engine='xlsxwriter')
+    #
+    # # Iterate through the spreadsheets.
+    # for sheet_name, sheet_data in spread_sheets.items():
+    #     # Write the sheet.
+    #     sheet_data.to_excel(writer, sheet_name=sheet_name)
+    #
+    # # Save the file.
+    # writer.save()

atomicshop/filesystem.py

@@ -3,10 +3,9 @@ import pathlib
 from pathlib import Path, PurePath, PureWindowsPath
 import glob
 import shutil
-from enum import Enum
 
 from .print_api import print_api
-from .basics import strings
+from .basics import strings, list_of_dicts
 
 
 def get_working_directory() -> str:
@@ -258,33 +257,35 @@ def get_file_names_from_directory(directory_path: str) -> list:
     return file_list
 
 
-class ComparisonOperator(Enum):
-    """
-    Enum class that was created for 'scan_directory_and_return_list' function.
-    Specifically for 'file_name_check_tuple[1]' - second entry.
-    """
-    EQ = '__eq__'
-    CONTAINS = '__contains__'
-
-
-def get_file_paths_and_relative_directories(directory_fullpath: str,
-                                            file_name_check_tuple: tuple = tuple(),
-                                            relative_file_name_as_directory: bool = False):
+def get_file_paths_and_relative_directories(
+        directory_fullpath: str,
+        recursive: bool = True,
+        file_name_check_pattern: str = '*',
+        relative_file_name_as_directory: bool = False,
+        add_last_modified_time: bool = False,
+        sort_by_last_modified_time: bool = False
+):
     """
+    Recursive, by option.
     The function receives a filesystem directory as string, scans it recursively for files and returns list of
     full paths to that file (including).
     If 'file_name_check_tuple' specified, the function will return only list of files that answer to the input
     of that tuple.
-    Recursive.
 
     :param directory_fullpath: string to full path to directory on the filesystem to scan.
-    :param file_name_check_tuple: tuple that should contain 2 entries:
-        file_name_check_tuple[0]: string that will contain part of file name to check or full file name with extension.
-        file_name_check_tuple[1]: 'ComparisonOperator' object to test against found file name with extension.
-            'ComparisonOperator.EQ' will check for specific file name (eg: 'config_file.ini').
-            'ComparisonOperator.CONTAINS' will check if file name contains part of the string (eg: 'config')(eg: '.ini')
+    :param recursive: boolean.
+        'True', then the function will scan recursively in subdirectories.
+        'False', then the function will scan only in the directory that was passed.
+    :param file_name_check_pattern: string, if specified, the function will return only files that match the pattern.
+        The string can contain part of file name to check or full file name with extension.
+        Can contain wildcards.
     :param relative_file_name_as_directory: boolean that will set if 'relative_directory_list' should contain
         file name with extension for each entry.
+    :param add_last_modified_time: boolean, if 'True', then the function will add last modified time of the file
+        to the output list.
+    :param sort_by_last_modified_time: boolean, if 'True', then the function will sort the output list by last
+        modified time of the file.
+
     :return: list of all found filenames with full file paths, list with relative folders to file excluding the
         main folder.
     """
@@ -294,59 +295,57 @@ def get_file_paths_and_relative_directories(directory_fullpath: str,
         Function gets the full file path, adds it to the found 'object_list' and gets the relative path to that
         file, against the main path to directory that was passed to the parent function.
         """
+
+        file_result: dict = dict()
+
         # Get full file path of the file.
-        file_path = os.path.join(dirpath, file)
-        object_list.append(file_path)
+        file_result['path'] = os.path.join(dirpath, file)
 
         # if 'relative_file_name_as_directory' was passed.
         if relative_file_name_as_directory:
             # Output the path with filename.
-            relative_directory = _get_relative_output_path_from_input_path(directory_fullpath, dirpath, file)
+            file_result['relative_dir'] = _get_relative_output_path_from_input_path(directory_fullpath, dirpath, file)
         # if 'relative_file_name_as_directory' wasn't passed.
         else:
             # Output the path without filename.
-            relative_directory = _get_relative_output_path_from_input_path(directory_fullpath, dirpath)
+            file_result['relative_dir'] = _get_relative_output_path_from_input_path(directory_fullpath, dirpath)
 
         # Remove separator from the beginning if exists.
-        relative_directory = relative_directory.removeprefix(os.sep)
+        file_result['relative_dir'] = file_result['relative_dir'].removeprefix(os.sep)
+
+        # If 'add_last_modified_time' was passed.
+        if add_last_modified_time:
+            # Get last modified time of the file.
+            file_result['last_modified'] = get_file_modified_time(file_result['path'])
 
-        relative_paths_list.append(relative_directory)
+        object_list.append(file_result)
 
-    # Type checking.
-    if file_name_check_tuple:
-        if not isinstance(file_name_check_tuple[1], ComparisonOperator):
-            raise TypeError(f'Second entry of tuple "file_name_check_tuple" is not of "ComparisonOperator" type.')
+    if sort_by_last_modified_time and not add_last_modified_time:
+        raise ValueError('Parameter "sort_by_last_modified_time" cannot be "True" if parameter '
+                         '"add_last_modified_time" is not "True".')
 
     # === Function main ================
     # Define locals.
     object_list: list = list()
-    relative_paths_list: list = list()
 
     # "Walk" over all the directories and subdirectories - make list of full file paths inside the directory
     # recursively.
     for dirpath, subdirs, files in os.walk(directory_fullpath):
         # Iterate through all the file names that were found in the folder.
         for file in files:
-            # If 'file_name_check_tuple' was passed.
-            if file_name_check_tuple:
-                # Get separate variables from the tuple.
-                # 'check_string' is a string that will be checked against 'file' iteration, which also a string.
-                # 'comparison_operator' is 'ComparisonOperator' Enum object, that contains the string method
-                # operator that will be used against the 'check_string'.
-                check_string, comparison_operator = file_name_check_tuple
-                # 'getattr' adds the string comparison method to the 'file' string. Example:
-                # file.__eq__
-                # 'comparison_operator' is the Enum class representation and '.value' method is the string
-                # representation of '__eq__'.
-                # and after that comes the check string to check against:
-                # file.__eq__(check_string)
-                if getattr(file, comparison_operator.value)(check_string):
-                    get_file()
-            # If 'file_name_check_tuple' wasn't passed, then get all the files.
-            else:
+            # If 'file_name_check_pattern' was passed.
+            if strings.match_pattern_against_string(file_name_check_pattern, file):
                 get_file()
 
-    return object_list, relative_paths_list
+        if not recursive:
+            break
+
+    # If 'sort_by_last_modified_time' was passed.
+    if sort_by_last_modified_time:
+        # Sort the list by last modified time.
+        object_list = list_of_dicts.sort_by_keys(object_list, key_list=['last_modified'])
+
+    return object_list
 
 
 def _get_relative_output_path_from_input_path(main_directory: str, file_directory: str, file_name: str = str()):
@@ -434,3 +433,32 @@ def get_files_and_folders(directory_path: str, string_contains: str = str()):
     """
     files_folders_list: list = glob.glob(f'{directory_path}{os.sep}*{string_contains}')
     return files_folders_list
+
+
+def get_file_modified_time(file_path: str) -> float:
+    """
+    The function returns the time of last modification of the file in seconds since the epoch.
+
+    :param file_path: string, full path to file.
+    :return: float, time of last modification of the file in seconds since the epoch.
+    """
+    return os.path.getmtime(file_path)
+
+
+def change_last_modified_date_of_file(file_path: str, new_date: float) -> None:
+    """
+    The function changes the last modified date of the file.
+
+    Example:
+    import os
+    import time
+    file_path = "C:\\Users\\file.txt"
+    new_timestamp = time.mktime(time.strptime('2023-10-03 12:00:00', '%Y-%m-%d %H:%M:%S'))
+    os.utime(file_path, (new_timestamp, new_timestamp))
+
+    :param file_path: string, full path to file.
+    :param new_date: float, time of last modification of the file in seconds since the epoch.
+    :return: None.
+    """
+
+    os.utime(file_path, (new_date, new_date))

atomicshop/mitm/initialize_mitm_server.py

@@ -104,7 +104,7 @@ def initialize_mitm_server(config_static):
     system_logger.info("Importing engine modules.")
 
     # Get full paths of all the 'engine_config.ini' files.
-    engine_config_path_list, _ = get_file_paths_and_relative_directories(
+    engine_config_path_list = get_file_paths_and_relative_directories(
         directory_fullpath=config_static.ENGINES_DIRECTORY_PATH,
         file_name_check_tuple=(config_static.ENGINE_CONFIG_FILE_NAME, ComparisonOperator.EQ))
 
@@ -114,7 +114,7 @@ def initialize_mitm_server(config_static):
     for engine_config_path in engine_config_path_list:
         # Initialize engine.
         current_module = ModuleCategory(config_static.WORKING_DIRECTORY)
-        current_module.fill_engine_fields_from_config(engine_config_path)
+        current_module.fill_engine_fields_from_config(engine_config_path['path'])
         current_module.initialize_engine(logs_path=config['log']['logs_path'],
                                          logger=system_logger)