atomicshop 2.9.4__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.4'
+__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/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-2.9.4.dist-info → atomicshop-2.9.5.dist-info}/METADATA

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

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

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=dZIpzFGnWOf7YHuvrZV0hsYuG3JASwDR_XTcuAxjpiE,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
@@ -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.4.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.9.4.dist-info/METADATA,sha256=sC0_j2Dy547Mt5pDAzhzoxcJz05jWkq7RifmyR5uTp4,10395
-atomicshop-2.9.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-atomicshop-2.9.4.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.9.4.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,,