atomicshop 2.9.3__py3-none-any.whl → 2.9.5__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.3'
+__version__ = '2.9.5'

atomicshop/basics/classes.py

@@ -185,6 +185,31 @@ def import_first_class_name_from_file_path(script_directory: str, file_path: str
     return imported_class
 
 
+def import_file_as_module(script_directory: str, file_path: str):
+    """
+    Function imports file as module and returns the module object.
+
+    :param script_directory: string, of file full path to working directory of the main script that will be subtracted
+        from the file path.
+    :param file_path: string, of full file path to python file module.
+    :return: module object.
+    """
+
+    # Get the module name string.
+    module_name: str = get_module_name_from_file_path(script_directory, file_path)
+
+    # Import the module.
+    try:
+        imported_module = import_module_by_string(module_name)
+    except ModuleNotFoundError:
+        # If the module is not found, we will try to add this path to the system path and try again.
+        sys.path.append(str(Path(file_path).parent))
+
+        imported_module = import_module_by_string(module_name)
+
+    return imported_module
+
+
 def get_attributes(
         obj,
         include_private_1: bool = False,

atomicshop/basics/numbers.py

@@ -1,3 +1,6 @@
+from typing import Union
+
+
 def is_divisible(n, k):
     """Return True if n is divisible by k, False otherwise."""
 
@@ -18,3 +21,28 @@ def find_highest_number(numbers: list[float, int, str]):
         raise ValueError('The list of numbers is empty.')
 
     return max(numbers)
+
+
+def convert_bytes_to_readable(byte_size: Union[int, float]):
+    """
+    Convert bytes to a more readable format (KB, MB, GB, etc.) with two numbers after the decimal point.
+
+    :param byte_size: Size in bytes
+    :type byte_size: int or float
+    :return: A string representing the size in a readable format
+    :rtype: str
+    """
+    # Define the suffixes for each unit of measurement
+    suffixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+    i = 0
+    # Convert byte_size to float for division
+    byte_size = float(byte_size)
+
+    # Calculate the unit of measurement to use
+    while byte_size >= 1024 and i < len(suffixes) - 1:
+        byte_size /= 1024.
+        i += 1
+
+    # Format the result to include two digits after the decimal point
+    readable_format = "{:.2f} {}".format(byte_size, suffixes[i])
+    return readable_format

atomicshop/system_resource_monitor.py

@@ -1,45 +1,11 @@
 from typing import Union
+import threading
 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_busy_time,
-        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_busy_time=get_disk_busy_time, 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.
@@ -54,7 +20,8 @@ class SystemResourceMonitor:
             get_disk_busy_time: bool = False,
             get_disk_used_percent: bool = True,
             calculate_maximum_changed_disk_io: bool = False,
-            use_queue: bool = False
+            queue_list: list = None,
+            manager_dict = None     # multiprocessing.Manager().dict()
     ):
         """
         Initialize the system resource monitor.
@@ -69,40 +36,55 @@ class SystemResourceMonitor:
         :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)
+        :param queue_list: list, list of queues to store results. The queue type depends on your application.
+            If you need to use the results of the System Resource Monitor in another process or several processes
+            you can pass several queues in the queue_list to store the results.
+
+            Usage Example with multiprocessing.Manager().dict():
+                # Create multiprocessing manager dict that will be shared for monitoring results between the processes.
+                manager = multiprocessing.Manager()
+                shared_dict = manager.dict()
+
+                # Start the system resource monitor.
+                multiprocessing.Process(
+                    target=system_resource_monitor.start_monitoring, kwargs={'manager_dict': shared_dict}).start()
+
+            # 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)
+        :param manager_dict: multiprocessing.Manager().dict(), a dictionary to store the results.
+            If you need to use the results of the System Resource Monitor in another process or several processes
+            you can pass the manager_dict to store the results.
         """
         # Store parameters as instance attributes
         self.interval: float = interval
@@ -113,10 +95,9 @@ class SystemResourceMonitor:
         self.get_disk_busy_time: bool = get_disk_busy_time
         self.get_disk_used_percent: bool = get_disk_used_percent
         self.calculate_maximum_changed_disk_io: bool = calculate_maximum_changed_disk_io
+        self.queue_list: list = queue_list
+        self.manager_dict: multiprocessing.Manager().dict = manager_dict
 
-        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,
@@ -124,10 +105,12 @@ class SystemResourceMonitor:
             'write_files_count_per_sec': 0
         }
 
-        if use_queue:
-            self.queue = multiprocessing.Queue()
-        else:
-            self.queue = None
+        # Main thread that gets the monitoring results.
+        self.thread: Union[threading.Thread, None] = None
+        # Sets the running state of the monitoring process. Needed to stop the monitoring and queue threads.
+        self.running: bool = False
+        # The shared results dictionary.
+        self.results: dict = {}
 
     def start(self, print_kwargs: dict = None):
         """
@@ -135,31 +118,72 @@ class SystemResourceMonitor:
         :param print_kwargs:
         :return:
         """
+
+        def run_check_system_resources(
+                interval, get_cpu, get_memory, get_disk_io_bytes, get_disk_files_count, get_disk_busy_time,
+                get_disk_used_percent, calculate_maximum_changed_disk_io, maximum_disk_io, queue_list, manager_dict):
+            """
+            Continuously update the system resources in the shared results dictionary.
+            This function runs in a separate process.
+            """
+
+            while self.running:
+                # 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_busy_time=get_disk_busy_time, 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
+
+                if queue_list is not None:
+                    for queue in queue_list:
+                        queue.put(results)
+
+                # 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.
+                if manager_dict is not None:
+                    manager_dict.update(results)
+
+                self.results = results
+
         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=(
+        if self.thread is None:
+            self.running = True
+            self.thread = threading.Thread(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_busy_time, self.get_disk_used_percent, self.calculate_maximum_changed_disk_io,
-                self.maximum_disk_io, self.shared_results, self.queue))
-            self.process.start()
+                self.maximum_disk_io, self.queue_list, self.manager_dict))
+            self.thread.start()
         else:
-            print_api("Monitoring process is already running.", color='yellow', **print_kwargs)
+            print_api("Monitoring is already running.", color='yellow', **print_kwargs)
 
-    def get_latest_results(self) -> dict:
+    def get_results(self) -> dict:
         """
-        Retrieve the latest results from the shared results dictionary.
+        Retrieve the latest results.
         """
-        return dict(self.shared_results)
+
+        return self.results
 
     def stop(self):
         """
         Stop the monitoring process.
         """
-        if self.process is not None:
-            self.process.terminate()
-            self.process.join()
+        if self.thread is not None:
+            self.running = False
+            self.thread.join()
 
 
 # === END OF SYSTEM RESOURCE MONITOR. ==================================================================================
@@ -177,7 +201,8 @@ def start_monitoring(
         get_disk_busy_time: bool = False,
         get_disk_used_percent: bool = True,
         calculate_maximum_changed_disk_io: bool = False,
-        use_queue: bool = False,
+        queue_list: list = None,
+        manager_dict=None,      # multiprocessing.Manager().dict()
         print_kwargs: dict = None
 ):
     """
@@ -192,14 +217,21 @@ def start_monitoring(
     :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 queue_list: list, list of queues to store results. The queue type depends on your application.
+        If you need to use the results of the System Resource Monitor in another process or several processes
+        you can pass several queues in the queue_list to store the results.
+    :param manager_dict: multiprocessing.Manager().dict(), a dictionary to store the results.
+        If you need to use the results of the System Resource Monitor in another process or several processes
+        you can pass the manager_dict to store the results.
+
+        Usage Example with multiprocessing.Manager().dict():
+            # Create multiprocessing manager dict that will be shared for monitoring results between the processes.
+            manager = multiprocessing.Manager()
+            shared_dict = manager.dict()
+
+            # Start the system resource monitor.
+            multiprocessing.Process(
+                target=system_resource_monitor.start_monitoring, kwargs={'manager_dict': shared_dict}).start()
 
     :param print_kwargs: dict, print kwargs.
     :return:
@@ -220,7 +252,8 @@ def start_monitoring(
             get_disk_busy_time=get_disk_busy_time,
             get_disk_used_percent=get_disk_used_percent,
             calculate_maximum_changed_disk_io=calculate_maximum_changed_disk_io,
-            use_queue=use_queue
+            queue_list=queue_list,
+            manager_dict=manager_dict
         )
         SYSTEM_RESOURCES_MONITOR.start()
     else:
@@ -246,7 +279,7 @@ def get_monitoring_instance() -> SystemResourceMonitor:
     return SYSTEM_RESOURCES_MONITOR
 
 
-def get_result():
+def get_results():
     """
     Get system resources monitoring result.
 
@@ -268,39 +301,6 @@ def get_result():
     """
     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
+        return SYSTEM_RESOURCES_MONITOR.get_results()
     else:
         raise RuntimeError("System resources monitoring is not running.")

atomicshop/wrappers/psutilw/disks.py

@@ -38,14 +38,16 @@ def get_disk_io(
         }
     :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.
+        !!! On Ubuntu it gets the time in ms, but for some reason it can return value higher than the interval.
+            Which is not possible, so it is not reliable.
         Returned dictionary:
         {
             'read_time_ms': int,
             'write_time_ms': int,
-            'read_time_per_sec': float,
-            'write_time_per_sec': float,
+            'read_time_in_sec': float,
+            'write_time_in_sec': float,
             'busy_time': int,
-            'busy_time_per_sec': float,
+            'busy_time_in_sec': float,
             'busy_time_percent': float
         }
     :return: Disk utilization data.
@@ -121,40 +123,44 @@ def get_disk_io(
         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
+            aggregated_read_change = io_end_aggregated.read_bytes - io_start_aggregated.read_bytes
+            aggregated_write_change = io_end_aggregated.write_bytes - io_start_aggregated.write_bytes
+            aggregated_read_change_per_sec = aggregated_read_change / interval
+            aggregated_write_change_per_sec = aggregated_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,
+                'read_change_bytes': aggregated_read_change,
+                'write_change_bytes': aggregated_write_change,
+                'total_change_bytes': aggregated_read_change + aggregated_write_change,
+                'read_change_per_sec': aggregated_read_change_per_sec,
+                'write_change_per_sec': aggregated_write_change_per_sec,
+                'total_change_per_sec': aggregated_read_change_per_sec + aggregated_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
+            aggregated_read_count = io_end_aggregated.read_count - io_start_aggregated.read_count
+            aggregated_write_count = io_end_aggregated.write_count - io_start_aggregated.write_count
+            aggregated_read_count_per_sec = aggregated_read_count / interval
+            aggregated_write_count_per_sec = aggregated_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,
+                'read_file_count': aggregated_read_count,
+                'write_file_count': aggregated_write_count,
+                'total_file_count': aggregated_read_count + aggregated_write_count,
+                'read_file_count_per_sec': aggregated_read_count_per_sec,
+                'write_file_count_per_sec': aggregated_write_count_per_sec,
+                'total_file_count_per_sec': aggregated_read_count_per_sec + aggregated_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 / 1000 / interval
-            total_write_time_per_sec = total_write_time / 1000 / interval
+            aggregated_read_time = io_end_aggregated.read_time - io_start_aggregated.read_time
+            aggregated_write_time = io_end_aggregated.write_time - io_start_aggregated.write_time
+            aggregated_read_time_per_sec = aggregated_read_time / 1000 / interval
+            aggregated_write_time_per_sec = aggregated_write_time / 1000 / 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_ms': 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) / 1000 / interval
+                'read_time_ms': aggregated_read_time,
+                'write_time_ms': aggregated_write_time,
+                'read_time_in_sec': aggregated_read_time_per_sec,
+                'write_time_in_sec': aggregated_write_time_per_sec,
+                'busy_time_ms': aggregated_read_time + aggregated_write_time,
+                'busy_time_in_sec': aggregated_read_time_per_sec + aggregated_write_time_per_sec,
+                'busy_time_percent': (aggregated_read_time + aggregated_write_time) / 1000 / interval
             })
 
     return io_change

{atomicshop-2.9.3.dist-info → atomicshop-2.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.9.3
+Version: 2.9.5
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License
@@ -52,6 +52,7 @@ Requires-Dist: pyopenssl
 Requires-Dist: python-bidi
 Requires-Dist: python-docx
 Requires-Dist: python-magic
+Requires-Dist: reportlab
 Requires-Dist: SoundCard
 Requires-Dist: soundfile
 Requires-Dist: SpeechRecognition

{atomicshop-2.9.3.dist-info → atomicshop-2.9.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=UjSVtKaCSXbeT09qt1iqtuZYnzeqYmKlvao2qVvXB28,122
+atomicshop/__init__.py,sha256=QkIgch9FQImXtv5BITVxDWIEqyTcxufteFX_AG9NohM,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,7 +36,7 @@ atomicshop/sound.py,sha256=KSzWRF8dkpEVXmFidIv-Eftc3kET-hQzQOxZRE7rMto,24297
 atomicshop/speech_recognize.py,sha256=55-dIjgkpF93mvJnJuxSFuft5H5eRvGNlUj9BeIOZxk,5903
 atomicshop/ssh_remote.py,sha256=Sas3nrQv8ardxR51t59xZZsYm8nvUcA7tMSqEDViRLk,17155
 atomicshop/sys_functions.py,sha256=MTBxRve5bh58SPvhX3gMiGqHlSBuI_rdNN1NnnBBWqI,906
-atomicshop/system_resource_monitor.py,sha256=20pnGrr9bgCK03ptlKcoRifgFHzUP-UfkJY87Ige6FY,11923
+atomicshop/system_resource_monitor.py,sha256=rQrY_iSNYisRXOXcCwykUxj937jCqeg-dDOF_ETO_0I,13626
 atomicshop/system_resources.py,sha256=BndRa6qgHAe4vzhQYWKfhQIuw3WwnwgJ8Etda4i1914,8059
 atomicshop/tempfiles.py,sha256=uq1ve2WlWehZ3NOTXJnpBBMt6HyCdBufqedF0HyzA6k,2517
 atomicshop/timer.py,sha256=KxBBgVM8po6pUJDW8TgY1UXj0iiDmRmL5XDCq0VHAfU,1670
@@ -73,7 +73,7 @@ atomicshop/basics/ansi_escape_codes.py,sha256=WtIkm-BjSZS5J5irDUdAMBNvdX-qXFZcTX
 atomicshop/basics/argparse_template.py,sha256=horwgSf3MX1ZgRnYxtmmQuz9OU_vKrKggF65gmjlmfg,5836
 atomicshop/basics/booleans.py,sha256=-4JnSQ1pSb6CNY_62wtHBW8NltjPJEKM-gYOxFujunA,1772
 atomicshop/basics/bytes_arrays.py,sha256=WvSRDhIGt1ywF95t-yNgpxLm1nlZUbM1Dz6QckcyE8Y,5915
-atomicshop/basics/classes.py,sha256=Ogb7i6sNYlUK219iJDA5PwhNvHlYmxPGXfm1AfX_ZQI,8854
+atomicshop/basics/classes.py,sha256=EijW_g4EhdNBnKPMG3nT3HjFspTchtM7to6zm9Ad_Mk,9771
 atomicshop/basics/dicts.py,sha256=w9_ZolDNSf2ZyoZ53zIOrFq7VZWGWYAvAvwc4qHORAo,10973
 atomicshop/basics/dicts_nested.py,sha256=StYxYnYPa0SEJr1lmEwAv5zfERWWqoULeyG8e0zRAwE,4107
 atomicshop/basics/enumerations.py,sha256=41VVQYh_vnVapggxKg2IRU5e_EiMpZzX1n1mtxvoSzM,1364
@@ -86,7 +86,7 @@ atomicshop/basics/isinstancing.py,sha256=fQ35xfqbguQz2BUn-3a4KVGskhTcIn8JjRtxV2r
 atomicshop/basics/list_of_dicts.py,sha256=fu0H6dUD9uUo2kl7FYIrWzOQMwCmg7qRxGnFM5S319E,5716
 atomicshop/basics/lists.py,sha256=pLpYPSu0BjJIAe_Ar55XhLsH2YBhftn7b-tTAdkK1sw,3928
 atomicshop/basics/multiprocesses.py,sha256=AczaI4TmYduNjE6_VEQhxvDQn4VLDdXYRxhPDpjH4T0,17974
-atomicshop/basics/numbers.py,sha256=II-jP8MG0IYvmjT9_BLEai65xzDJ0LTHK2eFVSrgVqo,527
+atomicshop/basics/numbers.py,sha256=j0f4glCtyIypEdCKv145F1gkzEEoZ2GdsGO-OM4BN7o,1439
 atomicshop/basics/randoms.py,sha256=DmYLtnIhDK29tAQrGP1Nt-A-v8WC7WIEB8Edi-nk3N4,282
 atomicshop/basics/strings.py,sha256=aQ92AJPvb3U0O6n2FMqRUqEsPCiklwGX--jPmB9M0_s,15418
 atomicshop/basics/threads.py,sha256=xvgdDJdmgN0wmmARoZ-H7Kvl1GOcEbvgaeGL4M3Hcx8,2819
@@ -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=CMCDtM1kCvFvvaV2lX2rNiiNgrdPhrvBk4OBMeTYrLI,8487
+atomicshop/wrappers/psutilw/disks.py,sha256=3ZSVoommKH1TWo37j_83frB-NqXF4Nf5q5mBCX8G4jE,9221
 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.3.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.9.3.dist-info/METADATA,sha256=Md_39e1f8ZxkuyLAGiYU_PZDuIu9oBsWP_or49eBOWQ,10369
-atomicshop-2.9.3.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-atomicshop-2.9.3.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.9.3.dist-info/RECORD,,
+atomicshop-2.9.5.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.9.5.dist-info/METADATA,sha256=e5PpNLxmJbvsfWIKUZsmDxPJUk3LFk6RZtaW3E3infM,10395
+atomicshop-2.9.5.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+atomicshop-2.9.5.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.9.5.dist-info/RECORD,,