atomicshop 2.8.1__py3-none-any.whl → 2.9.0__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.8.1'
+__version__ = '2.9.0'

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,220 @@
+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, get_disk_used_percent, 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=get_disk_io,
+            get_disk_used_percent=get_disk_used_percent)
+        # 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: bool = True,
+            get_disk_used_percent: bool = True,
+            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: bool, get the disk I/O utilization.
+        :param get_disk_used_percent: bool, get the disk used percentage.
+        :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 = 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.manager = multiprocessing.Manager()
+        self.shared_results = self.manager.dict()
+        self.process = None
+
+        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,
+                self.get_disk_used_percent, self.shared_results))
+            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_system_resources_monitoring(
+        interval: float = 1,
+        get_cpu: bool = True,
+        get_memory: bool = True,
+        get_disk_io: bool = True,
+        get_disk_used_percent: bool = True,
+        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: bool, get TOTAL disk I/O utilization in bytes/s.
+    :param get_disk_used_percent: bool, get TOTAL disk used percentage.
+    :param print_kwargs: dict, print kwargs.
+    :return: SystemResourceMonitor
+    """
+
+    # 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=get_disk_io,
+            get_disk_used_percent=get_disk_used_percent
+        )
+        SYSTEM_RESOURCES_MONITOR.start()
+    else:
+        print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
+
+
+def stop_system_resources_monitoring():
+    """
+    Stop monitoring system resources.
+    :return: None
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    if SYSTEM_RESOURCES_MONITOR is not None:
+        SYSTEM_RESOURCES_MONITOR.stop()
+
+
+def get_system_resources_monitoring_instance() -> SystemResourceMonitor:
+    """
+    Get the system resources monitoring instance.
+    :return: SystemResourceMonitor
+    """
+    global SYSTEM_RESOURCES_MONITOR
+    return SYSTEM_RESOURCES_MONITOR
+
+
+def get_system_resources_monitoring_result():
+    """
+    Get system resources monitoring result.
+
+    Usage Example:
+    system_resources.start_system_resources_monitoring()
+
+    while True:
+        time.sleep(1)
+        result = system_resources.get_system_resources_monitoring_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:
+        return {}

atomicshop/system_resources.py

@@ -1,15 +1,72 @@
-import psutil
+import os
+import shutil
+import tempfile
 import time
+import threading
 
 from .print_api import print_api
 from .wrappers.psutilw import cpus, memories, disks
 
 
-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: bool = True,
+        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: bool, get TOTAL disk I/O utilization in bytes/s.
+    :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_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_utilization():
+        aggregated_disk_io_utilization = disks.get_disk_io_utilization(interval=interval)['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_used_percent():
+        result['disk_used_percent'] = disks.get_disk_usage()['total'].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_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 +83,71 @@ 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(file_size_bytes, file_count, remove_file_after_each_copy: bool = True, target_directory=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.
+
+    :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: Tuple of peak write speed, peak read speed, and total execution time in seconds.
+    """
+    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
+
+        # 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)
+
+    overall_end_time = time.time()
+
+    # Calculate peak speeds in Bytes/s and total execution time
+    peak_write_speed = max(write_speeds)
+    peak_read_speed = max(read_speeds)
+    total_execution_time = overall_end_time - overall_start_time
+
+    # 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

atomicshop/wrappers/psutilw/disks.py

@@ -1,5 +1,12 @@
-import psutil
+import os
 import time
+import tempfile
+import shutil
+import threading
+
+import psutil
+
+from ... import system_resources
 
 
 def get_disk_io_utilization(
@@ -10,6 +17,9 @@ def get_disk_io_utilization(
 ) -> 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.
@@ -41,7 +51,7 @@ def get_disk_io_utilization(
                     '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
+                    'write_change_per_sec': write_change_per_sec,
                 }
 
     if aggregated:
@@ -55,7 +65,184 @@ def get_disk_io_utilization(
             '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
+            'write_change_per_sec': total_write_change_per_sec,
         }
 
     return io_change
+
+
+def _get_disk_busy_time(
+        interval: float = 1,
+        disk_list: list = None,
+        aggregated: bool = True,
+        separated: bool = False
+) -> dict:
+    """
+    !!! 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
+
+    :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.
+    """
+
+    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)
+
+    busy_time = {}
+    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
+                }
+
+    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
+
+
+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['total'] = 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.8.1.dist-info → atomicshop-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.8.1
+Version: 2.9.0
 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.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=e17yj2a8aF04r4QwWIjR6oIlVKG41Ua6ur7Uz7hUyic,122
+atomicshop/__init__.py,sha256=IbBAx01GvuncS_hxpSRIAExpJW75V-EhMbbVnwzyzVo,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=SF376RE952sYbZJxVqHt32Bek0zMFxBVDocbUfon6-E,7538
+atomicshop/system_resources.py,sha256=y5SjM87k3h4mffvBHn6P4DqNiMmLjtdgUb6gkZU_p0U,5882
 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=AfeQIi-ugZIzAd7dmkMwFku1rb6Yl0Uzt8dFYvJMRnI,10490
 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.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,,