atomicshop 2.9.0__py3-none-any.whl → 2.9.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.9.0'
+__version__ = '2.9.1'

atomicshop/system_resource_monitor.py

@@ -6,7 +6,8 @@ from . import system_resources
 
 
 def run_check_system_resources(
-        interval, get_cpu, get_memory, get_disk_io, get_disk_used_percent, shared_results, queue=None):
+        interval, get_cpu, get_memory, get_disk_io_bytes, get_disk_files_count, get_disk_used_percent,
+        calculate_maximum_changed_disk_io, maximum_disk_io, shared_results, queue=None):
     """
     Continuously update the system resources in the shared results dictionary.
     This function runs in a separate process.
@@ -16,8 +17,20 @@ def run_check_system_resources(
         # Get the results of the system resources check function and store them in temporary results dictionary.
         results = system_resources.check_system_resources(
             interval=interval, get_cpu=get_cpu, get_memory=get_memory,
-            get_disk_io=get_disk_io,
+            get_disk_io_bytes=get_disk_io_bytes, get_disk_files_count=get_disk_files_count,
             get_disk_used_percent=get_disk_used_percent)
+
+        if calculate_maximum_changed_disk_io:
+            if results['disk_io_read'] > maximum_disk_io['read_bytes_per_sec']:
+                maximum_disk_io['read_bytes_per_sec'] = results['disk_io_read']
+            if results['disk_io_write'] > maximum_disk_io['write_bytes_per_sec']:
+                maximum_disk_io['write_bytes_per_sec'] = results['disk_io_write']
+            if results['disk_files_count_read'] > maximum_disk_io['read_files_count_per_sec']:
+                maximum_disk_io['read_files_count_per_sec'] = results['disk_files_count_read']
+            if results['disk_files_count_write'] > maximum_disk_io['write_files_count_per_sec']:
+                maximum_disk_io['write_files_count_per_sec'] = results['disk_files_count_write']
+            results['maximum_disk_io'] = maximum_disk_io
+
         # Update the shared results dictionary with the temporary results dictionary.
         # This is done in separate steps to avoid overwriting the special 'multiprocessing.Manager.dict' object.
         # So we update the shared results dictionary with the temporary results dictionary.
@@ -36,8 +49,10 @@ class SystemResourceMonitor:
             interval: float = 1,
             get_cpu: bool = True,
             get_memory: bool = True,
-            get_disk_io: bool = True,
+            get_disk_io_bytes: bool = True,
+            get_disk_files_count: bool = True,
             get_disk_used_percent: bool = True,
+            calculate_maximum_changed_disk_io: bool = False,
             use_queue: bool = False
     ):
         """
@@ -46,8 +61,11 @@ class SystemResourceMonitor:
             Default is 1 second.
         :param get_cpu: bool, get the CPU usage.
         :param get_memory: bool, get the memory usage.
-        :param get_disk_io: bool, get the disk I/O utilization.
+        :param get_disk_io_bytes: bool, get the disk I/O utilization of bytes.
+        :param get_disk_files_count: bool, get the disk files count in the interval.
         :param get_disk_used_percent: bool, get the disk used percentage.
+        :param calculate_maximum_changed_disk_io: bool, calculate the maximum changed disk I/O. This includes the
+            maximum changed disk I/O read and write in bytes/s and the maximum changed disk files count.
         :param use_queue: bool, use queue to store results.
             If you need ot get the queue, you can access it through the 'queue' attribute:
             SystemResourceMonitor.queue
@@ -84,15 +102,23 @@ class SystemResourceMonitor:
             print(results)
         """
         # Store parameters as instance attributes
-        self.interval = interval
-        self.get_cpu = get_cpu
-        self.get_memory = get_memory
-        self.get_disk_io = get_disk_io
-        self.get_disk_used_percent = get_disk_used_percent
+        self.interval: float = interval
+        self.get_cpu: bool = get_cpu
+        self.get_memory: bool = get_memory
+        self.get_disk_io_bytes: bool = get_disk_io_bytes
+        self.get_disk_files_count: bool = get_disk_files_count
+        self.get_disk_used_percent: bool = get_disk_used_percent
+        self.calculate_maximum_changed_disk_io: bool = calculate_maximum_changed_disk_io
 
         self.manager = multiprocessing.Manager()
         self.shared_results = self.manager.dict()
         self.process = None
+        self.maximum_disk_io: dict = {
+            'read_bytes_per_sec': 0,
+            'write_bytes_per_sec': 0,
+            'read_files_count_per_sec': 0,
+            'write_files_count_per_sec': 0
+        }
 
         if use_queue:
             self.queue = multiprocessing.Queue()
@@ -110,8 +136,9 @@ class SystemResourceMonitor:
 
         if self.process is None or not self.process.is_alive():
             self.process = multiprocessing.Process(target=run_check_system_resources, args=(
-                self.interval, self.get_cpu, self.get_memory, self.get_disk_io,
-                self.get_disk_used_percent, self.shared_results))
+                self.interval, self.get_cpu, self.get_memory, self.get_disk_io_bytes, self.get_disk_files_count,
+                self.get_disk_used_percent, self.calculate_maximum_changed_disk_io, self.maximum_disk_io,
+                self.shared_results, self.queue))
             self.process.start()
         else:
             print_api("Monitoring process is already running.", color='yellow', **print_kwargs)
@@ -137,12 +164,15 @@ class SystemResourceMonitor:
 SYSTEM_RESOURCES_MONITOR: Union[SystemResourceMonitor, None] = None
 
 
-def start_system_resources_monitoring(
+def start_monitoring(
         interval: float = 1,
         get_cpu: bool = True,
         get_memory: bool = True,
-        get_disk_io: bool = True,
+        get_disk_io_bytes: bool = True,
+        get_disk_files_count: bool = True,
         get_disk_used_percent: bool = True,
+        calculate_maximum_changed_disk_io: bool = False,
+        use_queue: bool = False,
         print_kwargs: dict = None
 ):
     """
@@ -150,10 +180,22 @@ def start_system_resources_monitoring(
     :param interval: float, interval in seconds.
     :param get_cpu: bool, get CPU usage.
     :param get_memory: bool, get memory usage.
-    :param get_disk_io: bool, get TOTAL disk I/O utilization in bytes/s.
+    :param get_disk_io_bytes: bool, get TOTAL disk I/O utilization in bytes/s.
+    :param get_disk_files_count: bool, get TOTAL disk files count.
     :param get_disk_used_percent: bool, get TOTAL disk used percentage.
+    :param calculate_maximum_changed_disk_io: bool, calculate the maximum changed disk I/O. This includes the
+        maximum changed disk I/O read and write in bytes/s and the maximum changed disk files count.
+    :param use_queue: bool, use queue to store results.
+        Usage Example:
+        system_resources.start_monitoring(use_queue=True)
+        queue = system_resources.get_monitoring_queue()
+        while True:
+            if not queue.empty():
+                results = queue.get()
+                print(results)
+
     :param print_kwargs: dict, print kwargs.
-    :return: SystemResourceMonitor
+    :return:
     """
 
     # if print_kwargs is None:
@@ -166,15 +208,18 @@ def start_system_resources_monitoring(
             interval=interval,
             get_cpu=get_cpu,
             get_memory=get_memory,
-            get_disk_io=get_disk_io,
-            get_disk_used_percent=get_disk_used_percent
+            get_disk_io_bytes=get_disk_io_bytes,
+            get_disk_files_count=get_disk_files_count,
+            get_disk_used_percent=get_disk_used_percent,
+            calculate_maximum_changed_disk_io=calculate_maximum_changed_disk_io,
+            use_queue=use_queue
         )
         SYSTEM_RESOURCES_MONITOR.start()
     else:
         print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
 
 
-def stop_system_resources_monitoring():
+def stop_monitoring():
     """
     Stop monitoring system resources.
     :return: None
@@ -184,7 +229,7 @@ def stop_system_resources_monitoring():
         SYSTEM_RESOURCES_MONITOR.stop()
 
 
-def get_system_resources_monitoring_instance() -> SystemResourceMonitor:
+def get_monitoring_instance() -> SystemResourceMonitor:
     """
     Get the system resources monitoring instance.
     :return: SystemResourceMonitor
@@ -193,16 +238,16 @@ def get_system_resources_monitoring_instance() -> SystemResourceMonitor:
     return SYSTEM_RESOURCES_MONITOR
 
 
-def get_system_resources_monitoring_result():
+def get_result():
     """
     Get system resources monitoring result.
 
     Usage Example:
-    system_resources.start_system_resources_monitoring()
+    system_resources.start_monitoring()
 
     while True:
         time.sleep(1)
-        result = system_resources.get_system_resources_monitoring_result()
+        result = system_resources.get_result()
 
         if result:
             print(
@@ -217,4 +262,37 @@ def get_system_resources_monitoring_result():
     if SYSTEM_RESOURCES_MONITOR is not None:
         return SYSTEM_RESOURCES_MONITOR.get_latest_results()
     else:
-        return {}
+        raise RuntimeError("System resources monitoring is not running.")
+
+
+def get_result_by_queue():
+    """
+    Get system resources monitoring result by queue.
+
+    Usage Example:
+    system_resources.start_system_resources_monitoring()
+
+    while True:
+        result = system_resources.get_result_by_queue()
+        print(result)
+
+    :return: dict
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    if SYSTEM_RESOURCES_MONITOR is not None:
+        if not SYSTEM_RESOURCES_MONITOR.queue.empty():
+            return SYSTEM_RESOURCES_MONITOR.queue.get()
+    else:
+        raise RuntimeError("System resources monitoring is not running.")
+
+
+def get_monitoring_queue() -> Union[multiprocessing.Queue, None]:
+    """
+    Get the monitoring queue.
+    :return: multiprocessing.Queue
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    if SYSTEM_RESOURCES_MONITOR is not None:
+        return SYSTEM_RESOURCES_MONITOR.queue
+    else:
+        raise RuntimeError("System resources monitoring is not running.")

atomicshop/system_resources.py

@@ -1,18 +1,20 @@
 import os
-import shutil
-import tempfile
 import time
+import tempfile
+import shutil
 import threading
 
 from .print_api import print_api
 from .wrappers.psutilw import cpus, memories, disks
+from . import system_resource_monitor
 
 
 def check_system_resources(
         interval: float = 1,
         get_cpu: bool = True,
         get_memory: bool = True,
-        get_disk_io: bool = True,
+        get_disk_io_bytes: bool = True,
+        get_disk_files_count: bool = False,
         get_disk_used_percent: bool = True
 ):
     """
@@ -20,7 +22,8 @@ def check_system_resources(
     :param interval: float, interval in seconds.
     :param get_cpu: bool, get CPU usage.
     :param get_memory: bool, get memory usage.
-    :param get_disk_io: bool, get TOTAL disk I/O utilization in bytes/s.
+    :param get_disk_io_bytes: bool, get TOTAL disk I/O utilization in bytes/s.
+    :param get_disk_files_count: bool, get TOTAL disk files count.
     :param get_disk_used_percent: bool, get TOTAL disk used percentage.
     :return:
     """
@@ -31,6 +34,8 @@ def check_system_resources(
         'memory_usage': None,
         'disk_io_write': None,
         'disk_io_read': None,
+        'disk_files_count_read': None,
+        'disk_files_count_write': None,
         'disk_used_percent': None
     }
 
@@ -40,21 +45,30 @@ def check_system_resources(
     def set_memory_usage():
         result['memory_usage'] = memories.get_memory_usage()
 
-    def set_disk_io_utilization():
-        aggregated_disk_io_utilization = disks.get_disk_io_utilization(interval=interval)['aggregated']
+    def set_disk_io_bytes_change():
+        aggregated_disk_io_utilization = (
+            disks.get_disk_io(interval=interval, aggregated=True, io_change_bytes=True))['aggregated']
         result['disk_io_read'] = aggregated_disk_io_utilization['read_change_per_sec']
         result['disk_io_write'] = aggregated_disk_io_utilization['write_change_per_sec']
 
+    def set_disk_files_count():
+        aggregated_disk_files_count = (
+            disks.get_disk_io(interval=interval, aggregated=True, io_file_count=True))['aggregated']
+        result['disk_files_count_read'] = aggregated_disk_files_count['read_file_count_per_sec']
+        result['disk_files_count_write'] = aggregated_disk_files_count['write_file_count_per_sec']
+
     def set_disk_used_percent():
-        result['disk_used_percent'] = disks.get_disk_usage()['total'].percent
+        result['disk_used_percent'] = disks.get_disk_usage()['aggregated'].percent
 
     # Create threads for each system resource check.
     if get_cpu:
         threads.append(threading.Thread(target=set_cpu_usage))
     if get_memory:
         threads.append(threading.Thread(target=set_memory_usage))
-    if get_disk_io:
-        threads.append(threading.Thread(target=set_disk_io_utilization))
+    if get_disk_io_bytes:
+        threads.append(threading.Thread(target=set_disk_io_bytes_change))
+    if get_disk_files_count:
+        threads.append(threading.Thread(target=set_disk_files_count))
     if get_disk_used_percent:
         threads.append(threading.Thread(target=set_disk_used_percent))
 
@@ -85,17 +99,44 @@ def wait_for_resource_availability(cpu_percent_max: int = 80, memory_percent_max
         time.sleep(wait_time)  # Wait for 'wait_time' seconds before checking again
 
 
-def test_disk_speed(file_size_bytes, file_count, remove_file_after_each_copy: bool = True, target_directory=None):
+def test_disk_speed_with_monitoring(
+        file_settings: list[dict],
+        remove_file_after_each_copy: bool = False,
+        target_directory=None,
+        read_full_file: bool = False,
+        monitoring: bool = True,
+        print_kwargs: dict = None
+):
     """
-    Tests disk write and read speeds by generating files in a 'source' directory, copying them to a 'dest' directory
-    within the target directory, and optionally removing them after each copy. Now also returns the total execution time.
+    Generates files and performs write and read operations in the specified target directory,
+    while monitoring disk I/O speeds in a separate thread. Returns the maximum read and write rates,
+    and the total operation time.
+
+    :param file_settings: list of dicts, of file settings. Each dict will contain:
+        'size': int, size of each file in bytes.
+        'count': int, number of files to generate and copy.
 
-    :param file_size_bytes: Size of each file in bytes.
-    :param file_count: Number of files to generate and copy.
+        Example:
+        file_setting = [
+            {'size': 100000000, 'count': 100},
+            {'size': 500000000, 'count': 50}
+        ]
+
+        This will generate 100 files of 100 MB each, and 50 files of 500 MB each.
     :param remove_file_after_each_copy: Whether to remove the file after copying to target directory.
     :param target_directory: Directory where files will be copied. Uses a temporary directory if None.
-    :return: Tuple of peak write speed, peak read speed, and total execution time in seconds.
+    :param read_full_file: Whether to read the full file after copying, or read in chunks.
+    :param monitoring: Whether to skip monitoring disk I/O speeds.
+    :return: A tuple containing the total operation time in seconds and maximum_io_changes.
     """
+
+    max_io_changes: dict = {}
+
+    if monitoring:
+        system_resource_monitor.start_monitoring(
+            interval=1, get_cpu=False, get_memory=False, get_disk_io_bytes=True, get_disk_used_percent=False,
+            get_disk_files_count=True, calculate_maximum_changed_disk_io=True, use_queue=True)
+
     if target_directory is None:
         target_directory = tempfile.mkdtemp()
     else:
@@ -106,48 +147,44 @@ def test_disk_speed(file_size_bytes, file_count, remove_file_after_each_copy: bo
     os.makedirs(source_directory, exist_ok=True)
     os.makedirs(dest_directory, exist_ok=True)
 
-    write_speeds = []
-    read_speeds = []
-    created_files = []  # Keep track of all created files for cleanup
-
     overall_start_time = time.time()  # Start timing the entire operation
 
-    for i in range(file_count):
-        # Generate file in source directory
-        src_file_path = os.path.join(source_directory, f"tempfile_{i}")
-        with open(src_file_path, "wb") as file:
-            file.write(os.urandom(file_size_bytes))
-        created_files.append(src_file_path)  # Add the file for cleanup
-
-        # Measure write speed
-        start_time = time.time()
-        shutil.copy(src_file_path, dest_directory)
-        end_time = time.time()
-        write_speeds.append(file_size_bytes / (end_time - start_time))
-
-        target_file_path = os.path.join(dest_directory, os.path.basename(src_file_path))
-
-        # Measure read speed
-        with open(target_file_path, "rb") as file:
-            start_time = time.time()
-            while file.read(1024 * 1024):  # Read in chunks of 1 MB
-                pass
-            end_time = time.time()
-        read_speeds.append(file_size_bytes / (end_time - start_time))
-
-        if remove_file_after_each_copy:
-            os.remove(target_file_path)
-            os.remove(src_file_path)
+    for file_setting in file_settings:
+        for i in range(file_setting['count']):
+            # Generate file in source directory
+            src_file_path = os.path.join(source_directory, f"tempfile_{i}")
+            with open(src_file_path, "wb") as file:
+                file.write(os.urandom(file_setting['size']))
 
-    overall_end_time = time.time()
+            # Measure write speed.
+            shutil.copy(src_file_path, dest_directory)
+
+            target_file_path = os.path.join(dest_directory, os.path.basename(src_file_path))
+            print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
 
-    # Calculate peak speeds in Bytes/s and total execution time
-    peak_write_speed = max(write_speeds)
-    peak_read_speed = max(read_speeds)
+            # Measure read speed.
+            with open(target_file_path, "rb") as file:
+                if read_full_file:
+                    file.read()
+                else:
+                    while file.read(1024 * 1024):  # Read in chunks of 1 MB
+                        pass
+
+            if remove_file_after_each_copy:
+                os.remove(target_file_path)
+                os.remove(src_file_path)
+
+    overall_end_time = time.time()
     total_execution_time = overall_end_time - overall_start_time
+    print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
 
     # Cleanup. Remove all created files and directories.
     shutil.rmtree(source_directory)
     shutil.rmtree(dest_directory)
 
-    return peak_write_speed, peak_read_speed, total_execution_time
+    if monitoring:
+        # Stop the I/O monitoring.
+        max_io_changes = system_resource_monitor.get_result()['maximum_disk_io']
+        system_resource_monitor.stop_monitoring()
+
+    return total_execution_time, max_io_changes

atomicshop/wrappers/psutilw/disks.py

@@ -1,19 +1,16 @@
-import os
 import time
-import tempfile
-import shutil
-import threading
 
 import psutil
 
-from ... import system_resources
 
-
-def get_disk_io_utilization(
+def get_disk_io(
         interval: float = 1,
         disk_list: list = None,
         aggregated: bool = True,
-        separated: bool = False
+        separated: bool = False,
+        io_change_bytes: bool = False,
+        io_file_count: bool = False,
+        io_busy_time: bool = False,
 ) -> dict:
     """
     Get disk utilization based on disk I/O changes, allowing for both aggregated and separated values.
@@ -25,122 +22,142 @@ def get_disk_io_utilization(
     :param disk_list: List of disks to measure. If None, measure all disks. Affects only when separated is True.
     :param aggregated: Boolean indicating whether to return aggregated utilization.
     :param separated: Boolean indicating whether to return separate utilizations for each disk.
-    :return: Disk utilization data.
-    """
-
-    io_start_aggregated = None
-    io_end_aggregated = None
-
-    io_start_separated = psutil.disk_io_counters(perdisk=True)
-    if aggregated:
-        io_start_aggregated = psutil.disk_io_counters(perdisk=False)
-    time.sleep(interval)
-    io_end_separated = psutil.disk_io_counters(perdisk=True)
-    if aggregated:
-        io_end_aggregated = psutil.disk_io_counters(perdisk=False)
-
-    io_change = {}
-    if separated:
-        for disk in io_start_separated.keys():
-            if disk_list is None or disk in disk_list:
-                read_change = io_end_separated[disk].read_bytes - io_start_separated[disk].read_bytes
-                write_change = io_end_separated[disk].write_bytes - io_start_separated[disk].write_bytes
-                read_change_per_sec = read_change / interval
-                write_change_per_sec = write_change / interval
-                io_change[disk] = {
-                    'read_change_bytes': read_change,
-                    'write_change_bytes': write_change,
-                    'read_change_per_sec': read_change_per_sec,
-                    'write_change_per_sec': write_change_per_sec,
-                }
-
-    if aggregated:
-        if not io_start_aggregated or not io_end_aggregated:
-            raise ValueError('Aggregated disk I/O counters are not available.')
-        total_read_change = io_end_aggregated.read_bytes - io_start_aggregated.read_bytes
-        total_write_change = io_end_aggregated.write_bytes - io_start_aggregated.write_bytes
-        total_read_change_per_sec = total_read_change / interval
-        total_write_change_per_sec = total_write_change / interval
-        io_change['aggregated'] = {
-            'read_change_bytes': total_read_change,
-            'write_change_bytes': total_write_change,
-            'read_change_per_sec': total_read_change_per_sec,
-            'write_change_per_sec': total_write_change_per_sec,
+    :param io_change_bytes: Boolean indicating whether to return I/O change in bytes. Returned dictionary:
+        {
+            'read_change_bytes': int,
+            'write_change_bytes': int,
+            'read_change_per_sec': float,
+            'write_change_per_sec': float
         }
-
-    return io_change
-
-
-def _get_disk_busy_time(
-        interval: float = 1,
-        disk_list: list = None,
-        aggregated: bool = True,
-        separated: bool = False
-) -> dict:
+    :param io_file_count: Boolean indicating whether to return I/O file count. Returned dictionary:
+        {
+            'read_file_count': int,
+            'write_file_count': int,
+            'read_file_count_per_sec': float,
+            'write_file_count_per_sec': float
+        }
+    :param io_busy_time: Boolean indicating whether to return I/O busy time.
+        !!! For some reason on Windows it gets the count of files read or written and not the time in ms.
+        Returned dictionary:
+        {
+            'read_time_ms': int,
+            'write_time_ms': int,
+            'read_time_per_sec': float,
+            'write_time_per_sec': float,
+            'busy_time': int,
+            'busy_time_per_sec': float,
+            'busy_time_percent': float
+        }
+    :return: Disk utilization data.
     """
-    !!! For some reason on Windows it gets the count of files read or written and not the time in ms.
 
-    Get disk busy time, allowing for both aggregated and separated values.
-    Windows: because 'psutil.disk_io_counters' before using this function, you may need to execute the following
-    command in the command prompt:
-        diskperf -y
+    if not aggregated and not separated:
+        raise ValueError('At least one of aggregated or separated must be True.')
 
-    :param interval: Sampling interval in seconds to measure I/O changes.
-    :param disk_list: List of disks to measure. If None, measure all disks. Affects only when separated is True.
-    :param aggregated: Boolean indicating whether to return aggregated utilization.
-    :param separated: Boolean indicating whether to return separate utilizations for each disk.
-    :return: Disk utilization data.
-    """
+    if not io_change_bytes and not io_file_count and not io_busy_time:
+        raise ValueError('At least one of io_change_bytes, io_file_count, or io_busy_time must be True.')
 
     io_start_aggregated = None
     io_end_aggregated = None
 
-    io_start_separated = psutil.disk_io_counters(perdisk=True)
+    if separated:
+        io_start_separated = psutil.disk_io_counters(perdisk=True)
     if aggregated:
         io_start_aggregated = psutil.disk_io_counters(perdisk=False)
+
     time.sleep(interval)
-    io_end_separated = psutil.disk_io_counters(perdisk=True)
+
+    if separated:
+        io_end_separated = psutil.disk_io_counters(perdisk=True)
     if aggregated:
         io_end_aggregated = psutil.disk_io_counters(perdisk=False)
 
-    busy_time = {}
+    io_change = {}
     if separated:
         for disk in io_start_separated.keys():
             if disk_list is None or disk in disk_list:
-                read_time = io_end_separated[disk].read_time - io_start_separated[disk].read_time
-                write_time = io_end_separated[disk].write_time - io_start_separated[disk].write_time
-                read_time_per_sec = read_time / interval
-                write_time_per_sec = write_time / interval
-                busy_time[disk] = {
-                    'read_time_ms': read_time,
-                    'write_time_ms': write_time,
-                    'read_time_per_sec': read_time_per_sec,
-                    'write_time_per_sec': write_time_per_sec,
-                    'busy_time': read_time + write_time,
-                    'busy_time_per_sec': read_time_per_sec + write_time_per_sec,
-                    'busy_time_percent': (read_time + write_time) / interval
-                }
+                io_change[disk] = {}
+                if io_change_bytes:
+                    read_change = io_end_separated[disk].read_bytes - io_start_separated[disk].read_bytes
+                    write_change = io_end_separated[disk].write_bytes - io_start_separated[disk].write_bytes
+                    read_change_per_sec = read_change / interval
+                    write_change_per_sec = write_change / interval
+                    io_change[disk].update({
+                        'read_change_bytes': read_change,
+                        'write_change_bytes': write_change,
+                        'read_change_per_sec': read_change_per_sec,
+                        'write_change_per_sec': write_change_per_sec,
+                    })
+                if io_file_count:
+                    read_count = io_end_separated[disk].read_count - io_start_separated[disk].read_count
+                    write_count = io_end_separated[disk].write_count - io_start_separated[disk].write_count
+                    read_count_per_sec = read_count / interval
+                    write_count_per_sec = write_count / interval
+                    io_change[disk].update({
+                        'read_file_count': read_count,
+                        'write_file_count': write_count,
+                        'read_file_count_per_sec': read_count_per_sec,
+                        'write_file_count_per_sec': write_count_per_sec,
+                    })
+                if io_busy_time:
+                    read_time = io_end_separated[disk].read_time - io_start_separated[disk].read_time
+                    write_time = io_end_separated[disk].write_time - io_start_separated[disk].write_time
+                    read_time_per_sec = read_time / interval
+                    write_time_per_sec = write_time / interval
+                    io_change[disk].update({
+                        'read_time_ms': read_time,
+                        'write_time_ms': write_time,
+                        'read_time_per_sec': read_time_per_sec,
+                        'write_time_per_sec': write_time_per_sec,
+                        'busy_time': read_time + write_time,
+                        'busy_time_per_sec': read_time_per_sec + write_time_per_sec,
+                        'busy_time_percent': (read_time + write_time) / interval
+                    })
 
     if aggregated:
         if not io_start_aggregated or not io_end_aggregated:
             raise ValueError('Aggregated disk I/O counters are not available.')
-        # total_read_time = io_end_aggregated.read_time - io_start_aggregated.read_time
-        # total_write_time = io_end_aggregated.write_time - io_start_aggregated.write_time
-        total_read_time = io_end_aggregated.read_time
-        total_write_time = io_end_aggregated.write_time
-        total_read_time_per_sec = total_read_time / interval
-        total_write_time_per_sec = total_write_time / interval
-        busy_time['aggregated'] = {
-            'read_time_ms': total_read_time,
-            'write_time_ms': total_write_time,
-            'read_time_per_sec': total_read_time_per_sec,
-            'write_time_per_sec': total_write_time_per_sec,
-            'busy_time': total_read_time + total_write_time,
-            'busy_time_per_sec': total_read_time_per_sec + total_write_time_per_sec,
-            'busy_time_percent': (total_read_time + total_write_time) / interval
-        }
 
-    return busy_time
+        io_change['aggregated'] = {}
+
+        if io_change_bytes:
+            total_read_change = io_end_aggregated.read_bytes - io_start_aggregated.read_bytes
+            total_write_change = io_end_aggregated.write_bytes - io_start_aggregated.write_bytes
+            total_read_change_per_sec = total_read_change / interval
+            total_write_change_per_sec = total_write_change / interval
+            io_change['aggregated'] = {
+                'read_change_bytes': total_read_change,
+                'write_change_bytes': total_write_change,
+                'read_change_per_sec': total_read_change_per_sec,
+                'write_change_per_sec': total_write_change_per_sec,
+            }
+        if io_file_count:
+            total_read_count = io_end_aggregated.read_count - io_start_aggregated.read_count
+            total_write_count = io_end_aggregated.write_count - io_start_aggregated.write_count
+            total_read_count_per_sec = total_read_count / interval
+            total_write_count_per_sec = total_write_count / interval
+            io_change['aggregated'].update({
+                'read_file_count': total_read_count,
+                'write_file_count': total_write_count,
+                'read_file_count_per_sec': total_read_count_per_sec,
+                'write_file_count_per_sec': total_write_count_per_sec,
+            })
+        if io_busy_time:
+            total_read_time = io_end_aggregated.read_time - io_start_aggregated.read_time
+            total_write_time = io_end_aggregated.write_time - io_start_aggregated.write_time
+            total_read_time_per_sec = total_read_time / interval
+            total_write_time_per_sec = total_write_time / interval
+            io_change['aggregated'].update({
+                'read_time_ms': total_read_time,
+                'write_time_ms': total_write_time,
+                'read_time_per_sec': total_read_time_per_sec,
+                'write_time_per_sec': total_write_time_per_sec,
+                'busy_time': total_read_time + total_write_time,
+                'busy_time_per_sec': total_read_time_per_sec + total_write_time_per_sec,
+                'busy_time_percent': (total_read_time + total_write_time) / interval
+            })
+
+    return io_change
 
 
 def get_disk_usage(disk_list: list = None) -> dict:
@@ -160,89 +177,6 @@ def get_disk_usage(disk_list: list = None) -> dict:
                 disk_usage[disk.device] = str(e)
 
     # Get total disk usage.
-    disk_usage['total'] = psutil.disk_usage('/')
+    disk_usage['aggregated'] = psutil.disk_usage('/')
 
     return disk_usage
-
-
-def test_disk_speed_with_monitoring(
-        file_size_bytes: int, file_count: int, remove_file_after_each_copy: bool = False, target_directory=None):
-    """
-    Generates files and performs write and read operations in the specified target directory,
-    while monitoring disk I/O speeds in a separate thread. Returns the maximum read and write rates,
-    and the total operation time.
-
-    :param file_size_bytes: Size of each file in bytes.
-    :param file_count: Number of files to generate and copy.
-    :param remove_file_after_each_copy: Whether to remove the file after copying to target directory.
-    :param target_directory: Directory where files will be copied. Uses a temporary directory if None.
-    :return: A tuple containing the maximum write speed, maximum read speed, and total operation time in seconds.
-    """
-    io_speeds = {'write_speed': [], 'read_speed': []}
-    stop_thread = False
-
-    def io_monitor():
-        """
-        Monitors disk I/O speed by checking psutil disk_io_counters every second and calculates the speed.
-        This function is intended to run in a separate thread.
-        """
-
-        while not stop_thread:
-            result = system_resources.check_system_resources(
-                interval=1, get_disk_io=True, get_cpu=False, get_memory=False, get_disk_used_percent=False)
-
-            io_speeds['write_speed'].append(result['disk_io_write'])
-            io_speeds['read_speed'].append(result['disk_io_read'])
-
-    # Start the I/O monitoring thread
-    monitor_thread = threading.Thread(target=io_monitor)
-    monitor_thread.start()
-
-    if target_directory is None:
-        target_directory = tempfile.mkdtemp()
-    else:
-        os.makedirs(target_directory, exist_ok=True)
-
-    source_directory = os.path.join(target_directory, 'source')
-    dest_directory = os.path.join(target_directory, 'dest')
-    os.makedirs(source_directory, exist_ok=True)
-    os.makedirs(dest_directory, exist_ok=True)
-
-    write_speeds = []
-    read_speeds = []
-    created_files = []  # Keep track of all created files for cleanup
-
-    overall_start_time = time.time()  # Start timing the entire operation
-
-    for i in range(file_count):
-        # Generate file in source directory
-        src_file_path = os.path.join(source_directory, f"tempfile_{i}")
-        with open(src_file_path, "wb") as file:
-            file.write(os.urandom(file_size_bytes))
-        created_files.append(src_file_path)  # Add the file for cleanup
-
-        shutil.copy(src_file_path, dest_directory)
-        target_file_path = os.path.join(dest_directory, os.path.basename(src_file_path))
-
-        # Measure read speed
-        with open(target_file_path, "rb") as file:
-            start_time = time.time()
-            while file.read(1024 * 1024):  # Read in chunks of 1 MB
-                pass
-            end_time = time.time()
-        read_speeds.append(file_size_bytes / (end_time - start_time))
-
-        if remove_file_after_each_copy:
-            os.remove(target_file_path)
-            os.remove(src_file_path)
-
-    overall_end_time = time.time()
-
-    stop_thread = True
-    monitor_thread.join()
-
-    # Determine maximum speeds
-    max_write_speed = max(io_speeds['write_speed']) if io_speeds['write_speed'] else 0
-    max_read_speed = max(io_speeds['read_speed']) if io_speeds['read_speed'] else 0
-
-    return max_write_speed, max_read_speed, total_operation_time

{atomicshop-2.9.0.dist-info → atomicshop-2.9.1.dist-info}/METADATA

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

{atomicshop-2.9.0.dist-info → atomicshop-2.9.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=IbBAx01GvuncS_hxpSRIAExpJW75V-EhMbbVnwzyzVo,122
+atomicshop/__init__.py,sha256=6KyCPoNOFCE-qMHSsE5D6KYM2ED2PeS6vsl4SuxrWGU,122
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
 atomicshop/appointment_management.py,sha256=N3wVGJgrqJfsj_lqiRfaL3FxMEe57by5Stzanh189mk,7263
@@ -36,8 +36,8 @@ 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_resource_monitor.py,sha256=SF376RE952sYbZJxVqHt32Bek0zMFxBVDocbUfon6-E,7538
-atomicshop/system_resources.py,sha256=y5SjM87k3h4mffvBHn6P4DqNiMmLjtdgUb6gkZU_p0U,5882
+atomicshop/system_resource_monitor.py,sha256=1LgMKCawatUiLAXkbm31vdmTu2cEE8Y1UhsESJWUslE,11289
+atomicshop/system_resources.py,sha256=w4F1si9mJNS26UeHiFm68UwrfEb618QRNekb6Git_C8,7523
 atomicshop/tempfiles.py,sha256=uq1ve2WlWehZ3NOTXJnpBBMt6HyCdBufqedF0HyzA6k,2517
 atomicshop/timer.py,sha256=KxBBgVM8po6pUJDW8TgY1UXj0iiDmRmL5XDCq0VHAfU,1670
 atomicshop/urls.py,sha256=CQl1j1kjEVDlAuYJqYD9XxPF1SUSgrmG8PjlcXNEKsQ,597
@@ -205,7 +205,7 @@ atomicshop/wrappers/playwrightw/mouse.py,sha256=-2FZbQtjgH7tdXWld6ZPGqlKFUdf5in0
 atomicshop/wrappers/playwrightw/scenarios.py,sha256=Wz7aVYfG7K4fuSe_TUAc1jhFXVq5jYvZKbDtvqUiONc,5236
 atomicshop/wrappers/playwrightw/waits.py,sha256=308fdOu6YDqQ7K7xywj7R27sSmFanPBQqpZyBC-NFmo,7015
 atomicshop/wrappers/psutilw/cpus.py,sha256=w6LPBMINqS-T_X8vzdYkLS2Wzuve28Ydp_GafTCngrc,236
-atomicshop/wrappers/psutilw/disks.py,sha256=AfeQIi-ugZIzAd7dmkMwFku1rb6Yl0Uzt8dFYvJMRnI,10490
+atomicshop/wrappers/psutilw/disks.py,sha256=7Ly6QlKI36lYw2AeUn8MlQsYMRTvDz-O9Kp-PRq_ym4,8463
 atomicshop/wrappers/psutilw/memories.py,sha256=wpdKEkQ9Wty_r7ZJKkfli7wIHMXdQOMlmDlzmc_0FWo,161
 atomicshop/wrappers/psutilw/psutilw.py,sha256=W9PSEZmrm_Ct_-6oKqAcbgbyF21CwcIbbHOkVqgMiow,20866
 atomicshop/wrappers/psycopgw/psycopgw.py,sha256=XJvVf0oAUjCHkrYfKeFuGCpfn0Oxj3u4SbKMKA1508E,7118
@@ -226,8 +226,8 @@ atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5ey
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=aXBwlEIJhFT0-c4i8iNlFx2It9VpCEpsv--5Oqcpxao,11624
 atomicshop/wrappers/socketw/ssl_base.py,sha256=k4V3gwkbq10MvOH4btU4onLX2GNOsSfUAdcHmL1rpVE,2274
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=t3dtDEfN47CfYVi0CW6Kc2QHTEeZVyYhc57IYYh5nmA,826
-atomicshop-2.9.0.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.9.0.dist-info/METADATA,sha256=6vLhMQYgyIHS0NE4S8s-m8cpEaK4gm-8chZ9LnUpZgk,10369
-atomicshop-2.9.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-atomicshop-2.9.0.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.9.0.dist-info/RECORD,,
+atomicshop-2.9.1.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.9.1.dist-info/METADATA,sha256=1u71oL74BRp4FmrfREViR7QCTlEwf4m1MC870Dv2RSM,10369
+atomicshop-2.9.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+atomicshop-2.9.1.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.9.1.dist-info/RECORD,,