atomicshop 2.8.1__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.8.1'
+__version__ = '2.9.1'

atomicshop/print_api.py

@@ -39,6 +39,8 @@ def print_api(
 
         Then, in the function, you can use it like this:
             print_api(message, **print_kwargs)
+            # If 'print_kwargs' is 'None'.
+            print_api(message, **(print_kwargs or {}))
             print_api(message, print_kwargs=print_kwargs)
             print_api(message, print_kwargs={'logger': self.logger})
 

atomicshop/system_resource_monitor.py

@@ -0,0 +1,298 @@
+from typing import Union
+import multiprocessing
+
+from .print_api import print_api
+from . import system_resources
+
+
+def run_check_system_resources(
+        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.
+    """
+
+    while True:
+        # 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_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.
+        shared_results.update(results)
+
+        if queue is not None:
+            queue.put(results)
+
+
+class SystemResourceMonitor:
+    """
+    A class to monitor system resources in a separate process.
+    """
+    def __init__(
+            self,
+            interval: float = 1,
+            get_cpu: bool = True,
+            get_memory: 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
+    ):
+        """
+        Initialize the system resource monitor.
+        :param interval: float, the interval in seconds to check the system resources.
+            Default is 1 second.
+        :param get_cpu: bool, get the CPU usage.
+        :param get_memory: bool, get the memory usage.
+        :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
+
+            Example:
+            system_resource_monitor = SystemResourceMonitor()
+            your_queue = system_resource_monitor.queue
+
+            while True:
+                if not your_queue.empty():
+                    results = your_queue.get()
+                    print(results)
+
+        ================
+
+        Usage Example with queue:
+        system_resource_monitor = SystemResourceMonitor(use_queue=True)
+        system_resource_monitor.start()
+        queue = system_resource_monitor.queue
+        while True:
+            if not queue.empty():
+                results = queue.get()
+                print(results)
+
+        ================
+
+        Usage Example without queue:
+        interval = 1
+        system_resource_monitor = SystemResourceMonitor(interval=interval, use_queue=False)
+        system_resource_monitor.start()
+        while True:
+            time.sleep(interval)
+            results = system_resource_monitor.get_latest_results()
+            print(results)
+        """
+        # Store parameters as instance attributes
+        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()
+        else:
+            self.queue = None
+
+    def start(self, print_kwargs: dict = None):
+        """
+        Start the monitoring process.
+        :param print_kwargs:
+        :return:
+        """
+        if print_kwargs is None:
+            print_kwargs = {}
+
+        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_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)
+
+    def get_latest_results(self) -> dict:
+        """
+        Retrieve the latest results from the shared results dictionary.
+        """
+        return dict(self.shared_results)
+
+    def stop(self):
+        """
+        Stop the monitoring process.
+        """
+        if self.process is not None:
+            self.process.terminate()
+            self.process.join()
+
+
+# === END OF SYSTEM RESOURCE MONITOR. ==================================================================================
+
+
+SYSTEM_RESOURCES_MONITOR: Union[SystemResourceMonitor, None] = None
+
+
+def start_monitoring(
+        interval: float = 1,
+        get_cpu: bool = True,
+        get_memory: 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
+):
+    """
+    Start monitoring 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_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:
+    """
+
+    # if print_kwargs is None:
+    #     print_kwargs = {}
+
+    global SYSTEM_RESOURCES_MONITOR
+
+    if not SYSTEM_RESOURCES_MONITOR:
+        SYSTEM_RESOURCES_MONITOR = SystemResourceMonitor(
+            interval=interval,
+            get_cpu=get_cpu,
+            get_memory=get_memory,
+            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_monitoring():
+    """
+    Stop monitoring system resources.
+    :return: None
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    if SYSTEM_RESOURCES_MONITOR is not None:
+        SYSTEM_RESOURCES_MONITOR.stop()
+
+
+def get_monitoring_instance() -> SystemResourceMonitor:
+    """
+    Get the system resources monitoring instance.
+    :return: SystemResourceMonitor
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    return SYSTEM_RESOURCES_MONITOR
+
+
+def get_result():
+    """
+    Get system resources monitoring result.
+
+    Usage Example:
+    system_resources.start_monitoring()
+
+    while True:
+        time.sleep(1)
+        result = system_resources.get_result()
+
+        if result:
+            print(
+                f"{str(result['cpu_usage'])} | {str(result['memory_usage'])} | "
+                f"{str(result['disk_io_read'])} | {str(result['disk_io_write'])} | "
+                f"{str(result['disk_used_percent'])}"
+            )
+
+    :return: dict
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    if SYSTEM_RESOURCES_MONITOR is not None:
+        return SYSTEM_RESOURCES_MONITOR.get_latest_results()
+    else:
+        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,15 +1,86 @@
-import psutil
+import os
 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):
-    cpu_usage = cpus.get_cpu_usage(interval=interval)
-    memory_usage = memories.get_memory_usage()
-    disk_io_utilization = disks.get_disk_io_utilization(interval=interval)
-    return cpu_usage, memory_usage, disk_io_utilization
+def check_system_resources(
+        interval: float = 1,
+        get_cpu: bool = True,
+        get_memory: bool = True,
+        get_disk_io_bytes: bool = True,
+        get_disk_files_count: bool = False,
+        get_disk_used_percent: bool = True
+):
+    """
+    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_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:
+    """
+
+    threads: list = []
+    result: dict = {
+        'cpu_usage': None,
+        '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
+    }
+
+    def set_cpu_usage():
+        result['cpu_usage'] = cpus.get_cpu_usage(interval=interval)
+
+    def set_memory_usage():
+        result['memory_usage'] = memories.get_memory_usage()
+
+    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()['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_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))
+
+    # Start threads.
+    for thread in threads:
+        thread.start()
+
+    # Wait for all threads to complete.
+    for thread in threads:
+        thread.join()
+
+    return result
 
 
 def wait_for_resource_availability(cpu_percent_max: int = 80, memory_percent_max: int = 80, wait_time: float = 5):
@@ -26,3 +97,94 @@ def wait_for_resource_availability(cpu_percent_max: int = 80, 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
+
+
+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
+):
+    """
+    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.
+
+        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.
+    :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:
+        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)
+
+    overall_start_time = time.time()  # Start timing the entire operation
+
+    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']))
+
+            # 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 {}))
+
+            # 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)
+
+    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,31 +1,74 @@
-import psutil
 import time
 
+import psutil
+
 
-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.
+    Windows: because 'psutil.disk_io_counters' before using this function, you may need to execute the following
+    command in the command prompt:
+        diskperf -y
 
     :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.
+    :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
+        }
+    :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.
     """
 
+    if not aggregated and not separated:
+        raise ValueError('At least one of aggregated or separated must be True.')
+
+    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)
 
@@ -33,29 +76,107 @@ def get_disk_io_utilization(
     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
-                }
+                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_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
-        }
+
+        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:
+    """
+    Get the usage statistics of disks.
+
+    :param disk_list: List of disks to measure. If None, measure all disks.
+    :return:
+    """
+
+    disk_usage: dict = {}
+    for disk in psutil.disk_partitions():
+        if disk_list is None or disk.device in disk_list:
+            try:
+                disk_usage[disk.device] = psutil.disk_usage(disk.mountpoint)
+            except PermissionError as e:
+                disk_usage[disk.device] = str(e)
+
+    # Get total disk usage.
+    disk_usage['aggregated'] = psutil.disk_usage('/')
+
+    return disk_usage

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

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

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

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=e17yj2a8aF04r4QwWIjR6oIlVKG41Ua6ur7Uz7hUyic,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
@@ -22,7 +22,7 @@ atomicshop/ip_addresses.py,sha256=Hvi4TumEFoTEpKWaq5WNF-YzcRzt24IxmNgv-Mgax1s,11
 atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,452
 atomicshop/pbtkmultifile_argparse.py,sha256=aEk8nhvoQVu-xyfZosK3ma17CwIgOjzO1erXXdjwtS4,4574
 atomicshop/permissions.py,sha256=GYWxm9niuJWY0pWCnASF34_HiTuvhTamn8BCgcFyVAk,2540
-atomicshop/print_api.py,sha256=3n1CoiXvDcDGg00n5gEmQYInHryIhWbcpNjVobO1Gao,11468
+atomicshop/print_api.py,sha256=DhbCQd0MWZZ5GYEk4oTu1opRFC-b31g1VWZgTGewG2Y,11568
 atomicshop/process.py,sha256=5lqepm1psRbz66J4MB43ou6HHyac9F34QJedGukwAnk,14188
 atomicshop/process_name_cmd.py,sha256=TNAK6kQZm5JKWzEW6QLqVHEG98ZLNDQiSS4YwDk8V8c,3830
 atomicshop/process_poller.py,sha256=WfmwCLALfTYOq8ri0vkPeqq8ruEyA_43DaN--CU2_XY,10854
@@ -36,7 +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_resources.py,sha256=08hWyHNvwEsW0sGn12bKCDgafMk2Cn7MSDqUCKmcVwg,1207
+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
@@ -204,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=YAF6KvcFHOi48sSqlHg2Wt75rYOjbH3a082RqXT9Fic,2702
+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
@@ -225,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.8.1.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.8.1.dist-info/METADATA,sha256=fqt0fOE-tw0JyjUMhV9U20oK-xJ_0reGgyBeh8Jl_88,10369
-atomicshop-2.8.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-atomicshop-2.8.1.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.8.1.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,,