atomicshop 2.5.16__py3-none-any.whl → 2.6.1__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.5.16'
+__version__ = '2.6.1'

atomicshop/basics/enums.py

@@ -32,10 +32,10 @@ def __comparison_usage_example(
         main folder.
 
     Usage:
-        from atomicshop.filesystem import get_file_paths_and_relative_directories, ComparisonOperator
+        from atomicshop.filesystem import get_file_paths_from_directory, ComparisonOperator
 
         # 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_from_directory(
             directory_fullpath=some_directory_path,
             file_name_check_tuple=(config_file_name, ComparisonOperator.EQ))
     """

atomicshop/basics/multiprocesses.py

@@ -1,5 +1,8 @@
 import multiprocessing
 import queue
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+from ..import system_resources
 
 
 def process_wrap_queue(function_reference, *args, **kwargs):
@@ -28,3 +31,333 @@ def process_wrap_queue(function_reference, *args, **kwargs):
     process_object.join()
 
     return queue_object.get()
+
+
+class MultiProcessorRecursive:
+    def __init__(
+            self,
+            process_function,
+            input_list: list,
+            max_workers: int = None,
+            cpu_percent_max: int = 80,
+            memory_percent_max: int = 80,
+            wait_time: float = 5
+    ):
+        """
+        MultiProcessor class. Used to execute functions in parallel. The result of each execution is feeded back
+            to the provided function. Making it sort of recursive execution.
+        :param process_function: function, function to execute on the input list.
+        :param input_list: list, list of inputs to process.
+        :param max_workers: integer, number of workers to execute functions in parallel. Default is None, which
+            is the number of CPUs.
+        :param cpu_percent_max: integer, maximum CPU percentage. Above that usage, we will wait before starting new
+            execution.
+        :param memory_percent_max: integer, maximum memory percentage. Above that usage, we will wait, before starting
+            new execution.
+        :param wait_time: float, time to wait if the CPU or memory usage is above the maximum percentage.
+
+        Usage:
+            def unpack_file(file_path):
+                # Process the file at file_path and unpack it.
+                # Return a list of new file paths that were extracted from the provided path.
+                return [new_file_path1, new_file_path2]  # Example return value
+
+            # List of file paths to process
+            file_paths = ["path1", "path2", "path3"]
+
+            # Create an instance of MultiProcessor
+            # Note: unpacking.unpack_file is passed without parentheses
+            processor = MultiProcessor(
+                process_function=unpack_file,
+                input_list=file_paths,
+                max_workers=4,  # Number of parallel workers
+                cpu_percent_max=80,  # Max CPU usage percentage
+                memory_percent_max=80,  # Max memory usage percentage
+                wait_time=5  # Time to wait if resources are overused
+            )
+
+            # Run the processing
+            processor.run_process()
+        """
+
+        self.process_function = process_function
+        self.input_list: list = input_list
+        self.max_workers: int = max_workers
+        self.cpu_percent_max: int = cpu_percent_max
+        self.memory_percent_max: int = memory_percent_max
+        self.wait_time: float = wait_time
+
+    def run_process(self):
+        with multiprocessing.Pool(processes=self.max_workers) as pool:
+            # Keep track of the async results
+            async_results = []
+
+            while self.input_list:
+                new_input_list = []
+                for item in self.input_list:
+                    # Check system resources before processing each item
+                    system_resources.wait_for_resource_availability(
+                        cpu_percent_max=self.cpu_percent_max,
+                        memory_percent_max=self.memory_percent_max,
+                        wait_time=self.wait_time)
+
+                    # Process the item
+                    async_result = pool.apply_async(self.process_function, (item,))
+                    async_results.append(async_result)
+
+                # Reset input_list for next round of processing
+                self.input_list = []
+
+                # Collect results as they complete
+                for async_result in async_results:
+                    try:
+                        result = async_result.get()
+                        # Assuming process_function returns a list, extend new_input_list
+                        new_input_list.extend(result)
+                    except Exception as e:
+                        print(f"An error occurred: {e}")
+
+                # Update the input_list for the next iteration
+                self.input_list = new_input_list
+                # Clear the async_results for the next iteration
+                async_results.clear()
+
+
+class _MultiProcessorTest:
+    def __init__(self, worker_count: int = 8, initialize_at_start: bool = True):
+        """
+        MultiProcessor class. Used to execute functions in parallel.
+        :param worker_count: integer, number of workers to execute functions in parallel.
+        :param initialize_at_start: boolean, if True, the workers will be initialized at the start of the class.
+
+        Usage:
+            # Example functions
+            def my_function1(x):
+                return x * x
+
+            def my_callback(result):
+                print(f"Result received: {result}")
+
+            # Usage example
+            if __name__ == "__main__":
+                processor = MultiProcessor()
+
+                # Adding tasks with callback (asynchronous)
+                for i in range(5):
+                    processor.add_task(my_function1, i, callback=my_callback)
+
+                # Adding a task and waiting for the result (synchronous)
+                result = processor.add_task(my_function1, 10, wait=True)
+                print(f"Synchronous result: {result}")
+
+                # Shutdown and wait for all tasks to complete
+                processor.shutdown()
+        """
+
+        self.worker_count: int = worker_count
+        self.task_queue = multiprocessing.Queue()
+        self.result_queue = multiprocessing.Queue()
+        self.workers: list = list()
+
+        if initialize_at_start:
+            self._init_workers()
+
+    def _worker(self):
+        while True:
+            task = self.task_queue.get()
+            if task is None:  # Termination signal
+                break
+            func, args, kwargs, callback, return_result = task
+            try:
+                result = func(*args, **kwargs)
+                if callback:
+                    callback(result)
+                if return_result:
+                    self.result_queue.put(result)
+            except Exception as e:
+                if callback:
+                    callback(e)
+                if return_result:
+                    self.result_queue.put(e)
+
+    def _init_workers(self):
+        for _ in range(self.worker_count):
+            p = multiprocessing.Process(target=self._worker)
+            p.start()
+            self.workers.append(p)
+
+    def add_task(self, func, *args, callback=None, wait=False, **kwargs):
+        """
+        Add a task to the queue.
+        :param func: reference, function to execute.
+        :param args: arguments for the function.
+        :param callback: reference, function to execute after the task is completed. The result of the task will be
+            passed to the callback function.
+        :param wait: boolean, if True, the function will wait for the task to complete and return the result.
+        :param kwargs: keyword arguments for the function.
+        :return:
+        """
+        if wait:
+            self.task_queue.put((func, args, kwargs, None, True))
+            return self.result_queue.get()
+        else:
+            self.task_queue.put((func, args, kwargs, callback, False))
+            return None
+
+    def shutdown(self):
+        # Signal workers to exit
+        for _ in self.workers:
+            self.task_queue.put(None)
+
+        # Wait for all workers to finish
+        for p in self.workers:
+            p.join()
+
+
+class _MultiConcuratorTest:
+    def __init__(self, max_workers: int = 2, initialize_at_start: bool = False):
+        """
+        MultiConcurator class. Used to execute functions in parallel with the ProcessPoolExecutor.
+
+        :param max_workers: integer, number of workers to execute functions in parallel.
+        :param initialize_at_start: boolean, if True, the workers will be initialized at the start of the class.
+
+        Usage 1:
+            if __name__ == "__main__":
+            concurator = MultiConcurator(max_workers=4, initialize_at_start=True)
+
+            # ... add tasks to concurator ...
+
+            concurator.wait_for_completion()
+
+            # Continuously get and process results
+            for result in concurator.get_results():
+                print(result)
+
+            concurator.shutdown()
+
+        Usage 2:
+            # Basic Usage - Executing Functions in Parallel
+            This example shows how to execute a simple function in parallel.
+
+            def square(number):
+                return number * number
+
+            if __name__ == "__main__":
+                concurator = MultiConcurator(max_workers=4, initialize_at_start=True)
+
+                # Submit tasks
+                for num in range(10):
+                    concurator.add_to_queue(square, num)
+
+                # Wait for completion and handle results
+                concurator.wait_for_completion()
+
+                # Retrieve results
+                while not concurator.queue.empty():
+                    result = concurator.queue.get()
+                    print(result)
+
+                concurator.shutdown()
+
+        Usage 3:
+            # Handling Results with a Callback Function
+            # This example demonstrates handling the results of each task using a callback function.
+
+            def multiply(x, y):
+                return x * y
+
+            def handle_result(result):
+                print(f"Result: {result}")
+
+            if __name__ == "__main__":
+                concurator = MultiConcurator(max_workers=4, initialize_at_start=True)
+
+                for i in range(5):
+                    concurator.add_to_queue(multiply, i, i+1)
+
+                concurator.wait_for_completion(handle_result)
+                concurator.shutdown()
+
+        Usage 4:
+            # Dynamically Initializing the Executor
+            # This example shows how to initialize the executor dynamically and process tasks.
+
+            def compute_power(base, exponent):
+                return base ** exponent
+
+            if __name__ == "__main__":
+                concurator = MultiConcurator(max_workers=3)
+
+                # Initialize executor when needed
+                concurator.init_executor()
+
+                for i in range(1, 5):
+                    concurator.add_to_queue(compute_power, i, 2)
+
+                concurator.wait_for_completion()
+                while not concurator.queue.empty():
+                    print(concurator.queue.get())
+
+                concurator.shutdown()
+
+        Usage 5:
+            # Handling Exceptions in Tasks
+            # This example demonstrates how you can handle exceptions that might occur in the tasks.
+
+            def risky_division(x, y):
+                if y == 0:
+                    raise ValueError("Cannot divide by zero")
+                return x / y
+
+            def handle_result(result):
+                if isinstance(result, Exception):
+                    print(f"Error occurred: {result}")
+                else:
+                    print(f"Result: {result}")
+
+            if __name__ == "__main__":
+                concurator = MultiConcurator(max_workers=4, initialize_at_start=True)
+
+                concurator.add_to_queue(risky_division, 10, 2)
+                concurator.add_to_queue(risky_division, 10, 0)  # This will raise an exception
+
+                concurator.wait_for_completion(handle_result)
+                concurator.shutdown()
+        """
+
+        self.executor = None
+        self.max_workers: int = max_workers
+        self.futures: list = list()
+        self.queue = multiprocessing.Queue()
+
+        if initialize_at_start:
+            self.init_executor()
+
+    def init_executor(self):
+        if self.executor is None:
+            self.executor = ProcessPoolExecutor(max_workers=self.max_workers)
+
+    def add_to_queue(self, func, *args, **kwargs):
+        if self.executor is None:
+            raise RuntimeError("Executor has not been initialized. Call init_executor() first.")
+        future = self.executor.submit(func, *args, **kwargs)
+        self.futures.append(future)
+        return future
+
+    def wait_for_completion(self, handle_result=None):
+        for future in as_completed(self.futures):
+            result = future.result()
+            if handle_result:
+                handle_result(result)
+            else:
+                self.queue.put(result)
+
+    def get_results(self):
+        while not self.queue.empty():
+            yield self.queue.get()
+
+    def shutdown(self):
+        if self.executor is not None:
+            self.executor.shutdown()
+            self.executor = None

atomicshop/basics/numbers.py

@@ -5,3 +5,16 @@ def is_divisible(n, k):
         return True
     else:
         return False
+
+
+def find_highest_number(numbers: list[float, int, str]):
+    """
+    Takes a list of numbers (float or integers) and returns the highest one.
+
+    :param numbers: List of floats or integers.
+    :return: The highest number in the list.
+    """
+    if not numbers:
+        raise ValueError('The list of numbers is empty.')
+
+    return max(numbers)

atomicshop/file_io/docxs.py

@@ -2,7 +2,6 @@ from docx import Document
 from docx.opc.exceptions import PackageNotFoundError
 
 from .. import filesystem, config_init
-from . import file_io
 from ..print_api import print_api
 
 
@@ -67,12 +66,13 @@ def search_for_hyperlink_in_files(directory_path: str, hyperlink: str, relative_
         raise NotADirectoryError(f"Directory doesn't exist: {directory_path}")
 
     # Get all the docx files in the specified directory.
-    files = filesystem.get_file_paths_and_relative_directories(
-        directory_path, file_name_check_pattern="*.docx", relative_file_name_as_directory=True)
+    files = filesystem.get_file_paths_from_directory(
+        directory_path, file_name_check_pattern="*.docx",
+        add_relative_directory=True, relative_file_name_as_directory=True)
 
     found_in_files: list = list()
     for file_path in files:
-        hyperlinks = get_hyperlinks(file_path['path'])
+        hyperlinks = get_hyperlinks(file_path['file_path'])
         if hyperlink in hyperlinks:
             found_in_files.append(file_path)
 

atomicshop/filesystem.py

@@ -381,7 +381,7 @@ def move_files_from_folder_to_folder(source_directory: str, target_directory: st
         # Move each item to the destination directory
         shutil.move(source_item, destination_item)
     # # Get all file names without full paths in source folder.
-    # file_list_in_source: list = get_file_paths_and_relative_directories(source_directory)
+    # file_list_in_source: list = get_file_paths_from_directory(source_directory)
     #
     # # Iterate through all the files.
     # for file_path in file_list_in_source:
@@ -438,10 +438,11 @@ def get_file_names_from_directory(directory_path: str) -> list:
     return file_list
 
 
-def get_file_paths_and_relative_directories(
-        directory_fullpath: str,
+def get_file_paths_from_directory(
+        directory_path: str,
         recursive: bool = True,
         file_name_check_pattern: str = '*',
+        add_relative_directory: bool = False,
         relative_file_name_as_directory: bool = False,
         add_last_modified_time: bool = False,
         sort_by_last_modified_time: bool = False
@@ -453,13 +454,18 @@ def get_file_paths_and_relative_directories(
     If 'file_name_check_tuple' specified, the function will return only list of files that answer to the input
     of that tuple.
 
-    :param directory_fullpath: string to full path to directory on the filesystem to scan.
+    :param directory_path: string to full path to directory on the filesystem to scan.
     :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 add_relative_directory: boolean, if
+        'True', then the function will add relative directory to the output list.
+            In this case the output list will contain dictionaries with keys 'path' and 'relative_dir'.
+        'False', then the function will not add relative directory to the output list.
+            And the output list will contain only full file paths.
     :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
@@ -477,33 +483,43 @@ def get_file_paths_and_relative_directories(
         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_result['path'] = os.path.join(dirpath, file)
+        file_path: str = os.path.join(dirpath, file)
 
-        # if 'relative_file_name_as_directory' was passed.
-        if relative_file_name_as_directory:
-            # Output the path with filename.
-            file_result['relative_dir'] = _get_relative_output_path_from_input_path(directory_fullpath, dirpath, file)
-        # if 'relative_file_name_as_directory' wasn't passed.
+        if not add_relative_directory and not add_last_modified_time:
+            file_result: str = file_path
         else:
-            # Output the path without filename.
-            file_result['relative_dir'] = _get_relative_output_path_from_input_path(directory_fullpath, dirpath)
-
-        # Remove separator from the beginning if exists.
-        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'])
+            file_result: dict = dict()
+
+            # Get full file path of the file.
+            file_result['file_path'] = file_path
+
+            if add_relative_directory:
+                # if 'relative_file_name_as_directory' was passed.
+                if relative_file_name_as_directory:
+                    # Output the path with filename.
+                    file_result['relative_dir'] = _get_relative_output_path_from_input_path(
+                        directory_path, dirpath, file)
+                # if 'relative_file_name_as_directory' wasn't passed.
+                else:
+                    # Output the path without filename.
+                    file_result['relative_dir'] = _get_relative_output_path_from_input_path(directory_path, dirpath)
+
+                # Remove separator from the beginning if exists.
+                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'])
 
         object_list.append(file_result)
 
     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".')
+    if relative_file_name_as_directory and not add_relative_directory:
+        raise ValueError('Parameter "relative_file_name_as_directory" cannot be "True" if parameter '
+                         '"add_relative_directory" is not "True".')
 
     # === Function main ================
     # Define locals.
@@ -511,7 +527,7 @@ def get_file_paths_and_relative_directories(
 
     # "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):
+    for dirpath, subdirs, files in os.walk(directory_path):
         # Iterate through all the file names that were found in the folder.
         for file in files:
             # If 'file_name_check_pattern' was passed.
@@ -674,7 +690,7 @@ def get_file_hashes_from_directory(directory_path: str, recursive: bool = False,
     """
 
     # Get all the files.
-    file_paths_list = get_file_paths_and_relative_directories(directory_path, recursive=recursive)
+    file_paths_list = get_file_paths_from_directory(directory_path, recursive=recursive)
 
     # Create a list of dictionaries, each dictionary is a file with its hash.
     files: list = list()

atomicshop/mitm/initialize_mitm_server.py

@@ -6,7 +6,6 @@ from atomicshop.print_api import print_api
 from .import_config import ImportConfig
 from .initialize_engines import ModuleCategory
 from .connection_thread_worker import thread_worker_main
-from ..filesystem import get_file_paths_and_relative_directories
 from .. import filesystem, queues
 from ..python_functions import get_current_python_version_string, check_python_version_compliance
 from ..wrappers.socketw.socket_wrapper import SocketWrapper
@@ -104,8 +103,8 @@ 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(
-        directory_fullpath=config_static.ENGINES_DIRECTORY_PATH,
+    engine_config_path_list = filesystem.get_file_paths_from_directory(
+        directory_path=config_static.ENGINES_DIRECTORY_PATH,
         file_name_check_pattern=config_static.ENGINE_CONFIG_FILE_NAME)
 
     # Iterate through all the 'engine_config.ini' file paths.
@@ -114,7 +113,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['path'])
+        current_module.fill_engine_fields_from_config(engine_config_path)
         current_module.initialize_engine(logs_path=config['log']['logs_path'],
                                          logger=system_logger)
 

atomicshop/system_resources.py

@@ -0,0 +1,26 @@
+import psutil
+import time
+
+from .print_api import print_api
+
+
+def check_system_resources():
+    cpu_usage = psutil.cpu_percent(interval=0.1)
+    memory_usage = psutil.virtual_memory().percent
+    return cpu_usage, memory_usage
+
+
+def wait_for_resource_availability(cpu_percent_max: int = 80, memory_percent_max: int = 80, wait_time: float = 5):
+    """
+    Wait for system resources to be available.
+    :param cpu_percent_max: int, maximum CPU percentage. Above that usage, we will wait.
+    :param memory_percent_max: int, maximum memory percentage. Above that usage, we will wait.
+    :param wait_time: float, time to wait between checks.
+    :return: None
+    """
+    while True:
+        cpu, memory = check_system_resources()
+        if cpu < cpu_percent_max and memory < memory_percent_max:
+            break
+        print_api(f"Waiting for resources to be available... CPU: {cpu}%, Memory: {memory}%", color='yellow')
+        time.sleep(wait_time)  # Wait for 'wait_time' seconds before checking again

atomicshop/wrappers/loggingw/loggingw.py

@@ -231,3 +231,21 @@ def start_queue_listener_for_file_handler_and_get_queue_handler(file_handler):
     handlers.start_queue_listener_for_file_handler(file_handler, queue_object)
 
     return handlers.get_queue_handler(queue_object)
+
+
+def disable_default_logger():
+    """
+    Function to disable default logger.
+    """
+
+    # # Get the default logger.
+    # logger = logging.getLogger()
+    # # Remove all handlers from the logger.
+    # logger.handlers.clear()
+    # # Set the logger level to 'NOTSET'.
+    # logger.setLevel(logging.NOTSET)
+    # # Disable propagation from the 'root' logger, so we will not see the messages twice.
+    # loggers.set_propagation(logger)
+
+    # Disabling the default logger in Python
+    logging.disable(logging.CRITICAL)

atomicshop/wrappers/loggingw/reading.py

@@ -2,7 +2,6 @@ import os
 from typing import Literal
 
 from ... import filesystem, datetimes
-from ...basics import list_of_dicts
 from ...file_io import csvs
 
 
@@ -37,7 +36,7 @@ def get_logs(
     if remove_logs and move_to_path:
         raise ValueError('Both "remove_logs" and "move_to_path" cannot be True/specified at the same time.')
 
-    logs_files: list = filesystem.get_file_paths_and_relative_directories(
+    logs_files: list = filesystem.get_file_paths_from_directory(
         path, file_name_check_pattern=pattern,
         add_last_modified_time=True, sort_by_last_modified_time=True)
 
@@ -47,12 +46,12 @@ def get_logs(
     for single_file in logs_files:
         if log_type == 'csv':
             if header_type_of_files == 'all':
-                csv_content, _ = csvs.read_csv_to_list(single_file['path'], **print_kwargs)
+                csv_content, _ = csvs.read_csv_to_list(single_file['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(single_file['path'], header=header, **print_kwargs)
+                csv_content, header = csvs.read_csv_to_list(single_file['file_path'], header=header, **print_kwargs)
                 # Any way the first file will be read with header.
                 logs_content.extend(csv_content)
 
@@ -63,7 +62,7 @@ def get_logs(
     if remove_logs:
         # Remove the statistics files.
         for single_file in logs_files:
-            filesystem.remove_file(single_file['path'])
+            filesystem.remove_file(single_file['file_path'])
 
     if move_to_path:
         # Get formatted time stamp for file name.
@@ -76,8 +75,8 @@ def get_logs(
         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['path'])
+            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['path'], move_to_path_with_file)
+            filesystem.move_file(single_file['file_path'], move_to_path_with_file)
 
     return logs_content

atomicshop/wrappers/socketw/socket_server_tester.py

@@ -3,7 +3,7 @@ import threading
 from .socket_client import SocketClient
 from ..configparserw import ConfigParserWrapper
 from ..loggingw import loggingw
-from ...filesystem import get_file_paths_and_relative_directories
+from ...filesystem import get_file_paths_from_directory
 from ...file_io import jsons, file_io
 
 
@@ -57,14 +57,14 @@ def execute_test(config_static):
     loggingw.get_logger_with_stream_handler("network")
 
     # Get all the files in requests folder recursively.
-    request_file_list = get_file_paths_and_relative_directories(config['requests_directory'])
+    request_file_list = get_file_paths_from_directory(config['requests_directory'])
     print(f"Found request files: {len(request_file_list)}")
 
     # Get contents of all request files to list of contents.
     requests_bytes_list: list = list()
     for request_file_path in request_file_list:
         if config['request_type'] == 'json':
-            request_file_content = jsons.read_json_file(request_file_path['path'])
+            request_file_content = jsons.read_json_file(request_file_path)
 
             # If imported json is regular and not combined json.
             if isinstance(request_file_content, dict):
@@ -79,13 +79,13 @@ def execute_test(config_static):
                     requests_bytes_list.extend(
                         get_key_values_from_json(json_dict, config['request_json_hex_key_list']))
         elif config['request_type'] == 'string':
-            request_file_content = file_io.read_file(request_file_path['path'])
+            request_file_content = file_io.read_file(request_file_path)
             # Convert string content to bytes and append to list.
             requests_bytes_list.append(request_file_content.encode())
             print(f"Extracted 1 request.")
         elif config['request_type'] == 'binary':
             # The content is already in bytes, so just appending.
-            requests_bytes_list.append(file_io.read_file(request_file_path['path'], 'rb'))
+            requests_bytes_list.append(file_io.read_file(request_file_path, 'rb'))
             print(f"Extracted 1 request.")
 
     print(f"Finished parsing. Parsed requests: {len(requests_bytes_list)}")

{atomicshop-2.5.16.dist-info → atomicshop-2.6.1.dist-info}/METADATA

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

{atomicshop-2.5.16.dist-info → atomicshop-2.6.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=ayLlabN9C1kOn1T8udiljMqhA2XOEFO5ihTvhBJ00kA,123
+atomicshop/__init__.py,sha256=eEODmu-TVbN7jQzj-QW2WqUEroxwfWlIzr-UPTPbi2E,122
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/appointment_management.py,sha256=N3wVGJgrqJfsj_lqiRfaL3FxMEe57by5Stzanh189mk,7263
 atomicshop/archiver.py,sha256=QuDKx6bJEM29u-7r2tsizXEEGJmPuv0Xm91JQOpg__8,7152
@@ -12,7 +12,7 @@ atomicshop/diff_check.py,sha256=RON9cSTgy3jAnwUmAUkOyfF6bgrBKOq9Sbgyl3RYodw,1235
 atomicshop/dns.py,sha256=bNZOo5jVPzq7OT2qCPukXoK3zb1oOsyaelUwQEyK1SA,2500
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
-atomicshop/filesystem.py,sha256=NCf36h9AefZoT6v0o09089ITMo8qaH-DHZCJ4BafKok,29945
+atomicshop/filesystem.py,sha256=82osUMOas8DqUtR7mpcRWAqdx5JTRJ3e-o1VxetSXZg,30923
 atomicshop/functions.py,sha256=VqLjxAxhaxUr-Ad8P1cw9bZGdZpbtqfCaXQyHf3CM9g,509
 atomicshop/hashing.py,sha256=k_HXR7FnPUzLUKk8EiewJ_gLFBlWncZluiBwzplFMWs,3548
 atomicshop/http_parse.py,sha256=nrf2rZcprLqtW8HVrV7TCZ1iTBcWRRy-mXIlAOzcaJs,9703
@@ -34,6 +34,7 @@ atomicshop/sound.py,sha256=KSzWRF8dkpEVXmFidIv-Eftc3kET-hQzQOxZRE7rMto,24297
 atomicshop/speech_recognize.py,sha256=55-dIjgkpF93mvJnJuxSFuft5H5eRvGNlUj9BeIOZxk,5903
 atomicshop/ssh_remote.py,sha256=Sas3nrQv8ardxR51t59xZZsYm8nvUcA7tMSqEDViRLk,17155
 atomicshop/sys_functions.py,sha256=MTBxRve5bh58SPvhX3gMiGqHlSBuI_rdNN1NnnBBWqI,906
+atomicshop/system_resources.py,sha256=CMJfhDv6dI9K3IejpyKu-6qRlfeTphaOCd2RaLxXDyg,1034
 atomicshop/tempfiles.py,sha256=uq1ve2WlWehZ3NOTXJnpBBMt6HyCdBufqedF0HyzA6k,2517
 atomicshop/timer.py,sha256=KxBBgVM8po6pUJDW8TgY1UXj0iiDmRmL5XDCq0VHAfU,1670
 atomicshop/urls.py,sha256=CQl1j1kjEVDlAuYJqYD9XxPF1SUSgrmG8PjlcXNEKsQ,597
@@ -65,15 +66,15 @@ atomicshop/basics/bytes_arrays.py,sha256=M0o9OOx7TRcI2JQZSKpVLeBu5Q9jEaAwu7rE9_F
 atomicshop/basics/classes.py,sha256=sgzsYpI8MhauNvfB_mmznROpyPbfgbqaneTTEWE7g9s,7336
 atomicshop/basics/dicts.py,sha256=4DdkeVTzqr1Kh66vvIkzw4lz910SV0HMsEAGc7w5gug,8274
 atomicshop/basics/dicts_nested.py,sha256=StYxYnYPa0SEJr1lmEwAv5zfERWWqoULeyG8e0zRAwE,4107
-atomicshop/basics/enums.py,sha256=fY7a9oOKy9TWc-_ExbRK5UyGndU6uquj8yBxtnvYNtk,3567
+atomicshop/basics/enums.py,sha256=CeV8MfqWHihK7vvV6Mbzq7rD9JykeQfrJeFdLVzfHI4,3547
 atomicshop/basics/exceptions.py,sha256=-1Gu8bHA3hrf11mmeaPuVE73jWV3EOyRgh2vSpWfveg,504
 atomicshop/basics/guids.py,sha256=iRx5n18ATZWhpo748BwEjuLWLsu9y3OwF5-Adp-Dtik,403
 atomicshop/basics/hexs.py,sha256=i8CTG-J0TGGa25yFSbWEvpVyHFnof_qSWUrmXY-ylKM,1054
 atomicshop/basics/isinstancing.py,sha256=fQ35xfqbguQz2BUn-3a4KVGskhTcIn8JjRtxV2rFcRQ,876
 atomicshop/basics/list_of_dicts.py,sha256=fu0H6dUD9uUo2kl7FYIrWzOQMwCmg7qRxGnFM5S319E,5716
 atomicshop/basics/lists.py,sha256=ZyTjHyvkta-4_xCG1P-LFMENELmgAYlDdPq4hMRAOR8,2545
-atomicshop/basics/multiprocesses.py,sha256=GVeyF-r9Q6SAjpJ46eqkZQ4QUli554n-CAIE_W8pij8,958
-atomicshop/basics/numbers.py,sha256=FRjAH1Thk3z3ayxq0Ik6Wh93ELDRk1geyDYTv8amZBE,165
+atomicshop/basics/multiprocesses.py,sha256=4Bq5fzONuvCLfmwP11u9TKWGerTJv0zlwuHVKFhV6ms,13778
+atomicshop/basics/numbers.py,sha256=II-jP8MG0IYvmjT9_BLEai65xzDJ0LTHK2eFVSrgVqo,527
 atomicshop/basics/randoms.py,sha256=DmYLtnIhDK29tAQrGP1Nt-A-v8WC7WIEB8Edi-nk3N4,282
 atomicshop/basics/strings.py,sha256=uhl-5cqZ3qLK7M38lOEDSGCAkG3xmeLoEU3V0oCgMxU,14358
 atomicshop/basics/threads.py,sha256=xvgdDJdmgN0wmmARoZ-H7Kvl1GOcEbvgaeGL4M3Hcx8,2819
@@ -84,7 +85,7 @@ atomicshop/etw/dns_trace.py,sha256=ZbEf1gptnUnJwaRURUW9ENDwC9Q41Zl6NtxgMNELJcg,5
 atomicshop/etw/etw.py,sha256=xVJNbfCq4KgRfsDnul6CrIdAMl9xRBixZ-hUyqiB2g4,2403
 atomicshop/file_io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/file_io/csvs.py,sha256=4R4Kij8FmxNwXFjDtlF_A0flAk0Hj5nZKlEnqC5VxgQ,3125
-atomicshop/file_io/docxs.py,sha256=2lue7_eAz0fI8X3vCn34lHarU5xGSm4-Yqr0PeUPt84,4359
+atomicshop/file_io/docxs.py,sha256=3IFtaurVhvntcuCL59bpFlzGyKxvDmVUjUQTHWluOMY,4369
 atomicshop/file_io/file_io.py,sha256=s39zU5PRG-lqWFx6HNlZRLWMQJzpgIL0mkVyXdk8Jw4,7884
 atomicshop/file_io/jsons.py,sha256=4xCnC6MfajLouXUFl2aVXUPvftQVf2eS5DgydPZHF_c,4170
 atomicshop/file_io/tomls.py,sha256=oa0Wm8yMkPRXKN9jgBuTnKbioSOee4mABW5IMUFCYyU,3041
@@ -94,7 +95,7 @@ atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/connection_thread_worker.py,sha256=7f7T3t6ltndzb3125DgyRTzsD-oAbAfewDIhpNEeHRY,20630
 atomicshop/mitm/import_config.py,sha256=BPZ62ozMUaUKn7Crt6dhzvUgD3dSKd17kMfbJNObvlI,7486
 atomicshop/mitm/initialize_engines.py,sha256=qCtIjaR-sCbcliKKX_I65O6e4fqc-zDHELGglnL92cw,7687
-atomicshop/mitm/initialize_mitm_server.py,sha256=jM2djtClin-4Z7B6uq1D-XddmPZQT2Iu2_nn4EuT3iI,11307
+atomicshop/mitm/initialize_mitm_server.py,sha256=8Rwq4OzA4VKpzWNhxn8-CkCY_UdPIK64J4UrtD7oE3M,11230
 atomicshop/mitm/message.py,sha256=u2U2f2SOHdBNU-6r1Ik2W14ai2EOwxUV4wVfGZA098k,1732
 atomicshop/mitm/shared_functions.py,sha256=NeHABBlY-tmQRooWGVl2jZQx1wSTKJtEqG7mMvF2Jqo,4268
 atomicshop/mitm/statistic_analyzer.py,sha256=1g5l6X-NbnHvh_TREJRumTDWgE4ixUNJ8pKGneKcf4Y,23524
@@ -162,8 +163,8 @@ atomicshop/wrappers/loggingw/checks.py,sha256=AGFsTsLxHQd1yAraa5popqLaGO9VM0KpcP
 atomicshop/wrappers/loggingw/formatters.py,sha256=mUtcJJfmhLNrwUVYShXTmdu40dBaJu4TS8FiuTXI7ys,7189
 atomicshop/wrappers/loggingw/handlers.py,sha256=qm5Fbu8eDmlstMduUe5nKUlJU5IazFkSnQizz8Qt2os,5479
 atomicshop/wrappers/loggingw/loggers.py,sha256=DHOOTAtqkwn1xgvLHSkOiBm6yFGNuQy1kvbhG-TDog8,2374
-atomicshop/wrappers/loggingw/loggingw.py,sha256=30uaJOJhPJExYptEmwc5HWScI2RbnDlNgybOsxW7klc,11609
-atomicshop/wrappers/loggingw/reading.py,sha256=cHco0EG8bEB6fJ7JxkFdV_d8J-voYRBCUzS-qVqv4aU,3697
+atomicshop/wrappers/loggingw/loggingw.py,sha256=v9WAseZXB50LluT9rIUcRvvevg2nLVKPgz3dbGejfV0,12151
+atomicshop/wrappers/loggingw/reading.py,sha256=xs7L6Jo-vedrhCVP7m-cJo0VhWmoSoK86avR4Tm0kG4,3675
 atomicshop/wrappers/playwrightw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/playwrightw/_tryouts.py,sha256=l1BLkFsiIMNlgv7nfZd1XGEvXQkIQkIcg48__9OaC00,4920
 atomicshop/wrappers/playwrightw/base.py,sha256=zwHfbFZV7qqpmReJg5lEpKtOO23DRxEd61ZdoLBU_9Q,9833
@@ -188,12 +189,12 @@ atomicshop/wrappers/socketw/receiver.py,sha256=m8hXKOa8dqEQGUdcbYjshH8-j0CsMGRkg
 atomicshop/wrappers/socketw/sender.py,sha256=hHpBLc0LCfOIUErq2mc0ATfp0tDDQ5XhcYT4hRAZARU,3680
 atomicshop/wrappers/socketw/sni.py,sha256=GIm5uUJCh5i-pjY4FhSkoK4oo9uL_fFq1Mbr6PKXpBg,10014
 atomicshop/wrappers/socketw/socket_client.py,sha256=X3Bo83EVZwDwrSIji7UOT9UGYutn-pfBTQcls_Jd7N8,20235
-atomicshop/wrappers/socketw/socket_server_tester.py,sha256=VfNthyBvgI5tL9v3Qprh4CcRP0sqKnif-a7f0gev4lY,6335
+atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5eyTx0UGBOJi74viowtpU5Jvs,6291
 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.5.16.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.5.16.dist-info/METADATA,sha256=02N26vDhqG2L4xhGjWCiug9P7OXAs6WlvUbzN9q6h7k,10268
-atomicshop-2.5.16.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-atomicshop-2.5.16.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.5.16.dist-info/RECORD,,
+atomicshop-2.6.1.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.6.1.dist-info/METADATA,sha256=-WYBRbrqQqP3mICJe8ZuRix8y3SMBURo6A7wAD7Dbc4,10267
+atomicshop-2.6.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+atomicshop-2.6.1.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.6.1.dist-info/RECORD,,

{atomicshop-2.5.16.dist-info → atomicshop-2.6.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any