atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/ssh_remote.py

@@ -1,19 +1,23 @@
 import sys
-import base64
-import socket
+import logging
+from pathlib import Path
+import shlex
 
-from .print_api import print_api
-from .wrappers.loggingw import loggingw
-from .wrappers.socketw import base
-
-
-# External Libraries
 try:
     import paramiko
 except ImportError as exception_object:
     print(f"Library missing: {exception_object.name}. Install by executing: pip install paramiko")
     sys.exit()
 
+from .print_api import print_api
+from .wrappers.loggingw import loggingw
+from .wrappers.socketw import socket_base
+
+
+class SSHRemoteWrapperNoPythonFound(Exception):
+    """Raised when no usable Python 3 interpreter found on remote host."""
+    pass
+
 
 class SSHRemote:
     """
@@ -87,9 +91,13 @@ class SSHRemote:
             sys.exit(main())
 
     """
-    logger = loggingw.get_logger_with_level("network." + __name__.rpartition('.')[2])
-
-    def __init__(self, ip_address: str, username: str, password: str):
+    def __init__(
+            self,
+            ip_address: str,
+            username: str,
+            password: str,
+            logger: logging.Logger = None
+    ):
         self.ip_address: str = ip_address
         self.username: str = username
         self.password: str = password
@@ -97,11 +105,23 @@ class SSHRemote:
         # Initializing paramiko SSHClient class
         self.ssh_client = paramiko.SSHClient()
 
-    def connect(self):
+        # Variable to store detected python command on remote (python3 / python).
+        self.python_cmd: str | None = None
+
+        if logger:
+            # Create child logger for the provided logger with the module's name.
+            self.logger: logging.Logger = loggingw.get_logger_with_level(f'{logger.name}.{Path(__file__).stem}')
+        else:
+            self.logger: logging.Logger = logger
+
+    def connect(
+            self,
+            timeout: int = 60
+    ):
         error: str = str()
 
         # Get all local interfaces IPv4 addresses.
-        local_interfaces_ipv4 = base.get_local_network_interfaces_ip_address("ipv4", True)
+        local_interfaces_ipv4 = socket_base.get_local_network_interfaces_ip_address("ipv4", True)
         # Check if the target IP address is in the list of local interfaces.
         if self.ip_address in local_interfaces_ipv4:
             # If it is, we don't need to connect to it via SSH, it means that we want to connect to ourselves.
@@ -119,75 +139,15 @@ class SSHRemote:
         # with description of
         # Server 'address_goes_here' not found in known_hosts
         self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        try:
-            # Executing SSH connection to client.
-            self.ssh_client.connect(self.ip_address, username=self.username, password=self.password, timeout=60)
-        # When port 22 is unreachable on the client.
-        except paramiko.ssh_exception.NoValidConnectionsError as e:
-            error = str(e)
-            # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            pass
-        except paramiko.ssh_exception.SSHException as e:
-            error = str(e)
-            # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            pass
-        except ConnectionResetError:
-            # Returning the error.
-            error = "An existing connection was forcibly closed by the remote host."
-            # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            pass
-        except TimeoutError:
-            # Returning the error.
-            error = "Connection timed out."
-            # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            pass
+
+        # Executing SSH connection to client.
+        self.ssh_client.connect(self.ip_address, username=self.username, password=self.password, timeout=timeout)
 
         return error
 
     def close(self):
         self.ssh_client.close()
 
-    def exec_command_with_error_handling(self, script_string: str):
-        # Defining variables.
-        stdin = None
-        stdout = None
-        stderr = None
-        result_exception = None
-
-        # Don't put debugging break point over the next line in PyCharm. For some reason it gets stuck.
-        # Put the point right after that.
-        try:
-            stdin, stdout, stderr = self.ssh_client.exec_command(command=script_string, timeout=30)
-        except AttributeError as function_exception_object:
-            if function_exception_object.name == "open_session":
-                result_exception = "'SSHRemote().connect' wasn't executed."
-                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-
-                # Since getting Process name is not the main feature of the server, we can pass the exception
-                pass
-            else:
-                result_exception = f"Couldn't execute script over SSH. Unknown yet exception with 'AttributeError' " \
-                                   f"and name: {function_exception_object.name}"
-                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-                # Since getting Process name is not the main feature of the server, we can pass the exception
-                pass
-        except socket.error:
-            result_exception = "Couldn't execute script over SSH. SSH socket closed."
-            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            # Since getting Process name is not the main feature of the server, we can pass the exception
-            pass
-        except Exception:
-            result_exception = "Couldn't execute script over SSH. Unknown yet exception."
-            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            # Since getting Process name is not the main feature of the server, we can pass the exception
-            pass
-
-        return stdin, stdout, stderr, result_exception
-
     @staticmethod
     def check_console_output_for_errors(console_output_string: str):
         # Defining variables.
@@ -202,104 +162,132 @@ class SSHRemote:
                 if "ModuleNotFoundError: No module named" in line:
                     function_result = f"Python library is not installed - {line}"
                     break
+        else:
+            function_result = console_output_string
 
         return function_result
 
-    def remote_execution(self, script_string: str):
-        # Defining variables.
-        output_lines = None
-        function_error = None
-        stdin = None
-        stdout = None
-        stderr = None
-        exec_exception = None
+    def remote_execution(
+            self,
+            command: str,
+            script_string: str = None
+    ) -> tuple[str, str]:
+        """
+        Function to execute any command over SSH.
+
+        :param command: command to execute over SSH.
+        :param script_string: string representation of script to execute as input.
+            Example:
+                command = "python - 56734"
+                script_string = "import sys;print(f'sys.argv[0]')"
+
+            Under ssh in terminal it would execute like this:
+                ssh User@HostIpv4
+
+                python - 56734 << EOF
+                import sys;print(f'sys.argv[0]')
+                EOF
+
+            Or as onliner:
+                ssh User@HostIpv4 "python - 56734 << EOF import sys;print(f'sys.argv[0]') EOF"
+
+            or using a specific file path:
+                ssh User@HostIpv4 "python - 56734" < /path/to/script.py
+
+        :return: SSH console output, Error output
+        """
+        output_result: str = str()
+        error_result: str = str()
 
         # Execute the command over SSH remotely.
-        stdin, stdout, stderr, exec_exception = self.exec_command_with_error_handling(script_string)
-        # If exception was returned from execution.
-        if exec_exception:
-            self.logger.info("Trying to reconnect over SSH.")
-            # Close existing SSH Connection.
-            self.close()
-            # And connect again.
-            self.connect()
-            self.logger.info("Reconnected. Trying to send the command one more time.")
-            # Try to execute the command over SSH remotely again.
-            stdin, stdout, stderr, exec_exception = self.exec_command_with_error_handling(script_string)
-            # If there was an exception again.
-            if exec_exception:
-                # Populate the function_error variable that will be returned outside.
-                function_error = exec_exception
-
-        # If there was no exception executing the remote command.
-        if not function_error:
-            # Reading the buffer of stdout.
-            output_lines = stdout.readlines()
-            # Reading the buffer of stderr.
-            function_error = stderr.readlines()
-
-            # Joining error lines list to string if not empty.
-            if function_error:
-                function_error = ''.join(function_error)
-            # Else, joining output lines to string.
-            else:
-                output_lines = ''.join(output_lines)
+        stdin, stdout, stderr = self.ssh_client.exec_command(command=command, timeout=30)
+
+        # Writing the script string into stdin buffer.
+        if script_string:
+            stdin.write(script_string)
+            stdin.channel.shutdown_write()
 
-            # Since they're "file-like" objects we need to close them after we finished using.
-            stdin.close()
-            stdout.close()
-            stderr.close()
+        # Reading the buffer of stdout.
+        output_lines: list = stdout.readlines()
+        # Reading the buffer of stderr.
+        error_lines: list = stderr.readlines()
 
-        return output_lines, function_error
+        # Joining error lines list to string if not empty.
+        if error_lines:
+            error_result: str = ''.join(error_lines)
+        # Else, joining output lines to string.
+        else:
+            output_result = ''.join(output_lines)
 
-    def remote_execution_python(self, script_string: str):
+        # Since they're "file-like" objects we need to close them after we finished using.
+        stdin.close()
+        stdout.close()
+        stderr.close()
+
+        return output_result, error_result
+
+    def _detect_remote_python_cmd_name(self) -> str:
+        """
+        Try 'python3' then 'python' on the remote, return the one that is Python 3.
+        Raises if neither works.
+        """
+        for candidate in ("python3", "python"):
+            # Use a simple version check that works on both Windows and Linux
+            cmd = f'{candidate} -c "import sys; print(sys.version_info[0])"'
+            stdin, stdout, stderr = self.ssh_client.exec_command(cmd, timeout=5)
+
+            out = stdout.read().decode().strip()
+            exit_status = stdout.channel.recv_exit_status()
+
+            if exit_status == 0 and out == "3":
+                print_api(f"Detected remote Python 3 interpreter (once per client port): {candidate}", logger=self.logger)
+                return candidate
+
+        raise SSHRemoteWrapperNoPythonFound("No usable Python 3 interpreter found on remote host")
+
+    def _get_python_cmd(self) -> str:
+        if self.python_cmd is None:
+            self.python_cmd = self._detect_remote_python_cmd_name()
+        return self.python_cmd
+
+    def remote_execution_python(
+            self,
+            script_string: str,
+            script_arg_values: tuple = None,
+            script_kwargs: dict = None,
+    ):
         """
         Function to execute python script over SSH.
 
-        Example:
-                network.logger.info("Initializing SSH connection to get the calling process.")
-
-                # Initializing SSHRemote class.
-                ssh_client = SSHRemote(ip_address=client_message.client_ip, username=username, password=password)
-                # Making actual SSH Connection to the computer.
-                ssh_connection_error = ssh_client.connect()
-                # If there's an exception / error during connection.
-                if ssh_connection_error:
-                    # Put the error in the process name value.
-                    client_message.process_name = ssh_connection_error
-                else:
-                    # If no error, then initialize the variables for python script execution over SSH.
-                    remote_output = remote_error = None
-
-                    # Put source port variable inside the string script.
-                    script_string: str = \
-                        put_variable_into_string_script(ssh_script_port_by_process_string, client_message.source_port)
-
-                    # Execute the python script on remote computer over SSH.
-                    remote_output, remote_error = ssh_client.remote_execution_python(script_string)
-
-                    # If there was an error during execution, put it in process name.
-                    if remote_error:
-                        client_message.process_name = remote_error
-                    # If there was no error during execution, put the output of the ssh to process name.
-                    else:
-                        client_message.process_name = remote_output
-                        network.logger.info(f"Remote SSH: Client executing Command Line: {client_message.process_name}")
-
         :param script_string: string representation of python script.
+        :param script_arg_values: values arguments to pass to the script. Example for first argument: 56734
+        :param script_kwargs: keyword arguments to pass to the script.
+            Example: {'-r': None}
+            Interpreted as: -r
+            Example: {'-f': 'value'}
+            Interpreted as: -f value
+            Example: {'--arg': value}
+            Interpreted as: --arg value
+
         :return: SSH console output, Error output
         """
         # Defining variables.
-        function_return = None
-        function_error = None
+        error_result: str | None = None
+
+        python_cmd = self._get_python_cmd()
+        command: str = f"{python_cmd} -"
 
-        encoded_base64_string = base64.b64encode(script_string.encode('ascii'))
-        command_string: str = fr'python -c "import base64;exec(base64.b64decode({encoded_base64_string}))"'
+        if script_arg_values:
+            for arg in script_arg_values:
+                command += " " + shlex.quote(str(arg))
 
-        # remote_output, remote_error = ssh_client.remote_execution('ipconfig')
-        # remote_output, remote_error = ssh_client.remote_execution("python -c print('Hello')")
-        # remote_output, remote_error = ssh_client.remote_execution("python -c import psutil")
-        remote_output, remote_error = self.remote_execution(command_string)
+        if script_kwargs:
+            for key, value in script_kwargs.items():
+                command += f" {shlex.quote(str(key))}"
+                if value is not None:
+                    command += " " + shlex.quote(str(value))
+
+        remote_output, remote_error = self.remote_execution(command=command, script_string=script_string)
 
         # If there was an error during remote execution
         if remote_error:
@@ -308,37 +296,35 @@ class SSHRemote:
             # If the message is known and didn't return empty.
             if console_check:
                 # 'execution_error' variable will be that full error.
-                function_error = console_check
+                error_result = console_check
+            else:
+                error_result = remote_error
 
-        return remote_output, function_error
+        return remote_output, error_result
 
-    def connect_get_client_commandline(self, script_string):
+    def connect_get_client_commandline(
+            self,
+            port: int,
+            script_string: str):
         # Defining locals.
-        execution_output = None
-        execution_error = None
+        execution_output: str | None = None
 
         # Making actual SSH Connection to the computer.
         execution_error = self.connect()
         # if there was an error, try to connect again.
         if execution_error:
-            self.logger.info("Retrying SSH Connection Initialization.")
+            print_api("Retrying SSH Connection Initialization.", logger=self.logger, logger_method='info')
             execution_error = self.connect()
 
         # If there was still an error, we won't be executing the script. And the error will be passed to
         # 'process_name'.
         if not execution_error:
-            self.logger.info("Executing SSH command to acquire the calling process.")
+            print_api("Executing SSH command to acquire the calling process.", logger=self.logger, logger_method='info')
 
-            try:
-                execution_output, execution_error = self.remote_execution_python(script_string)
-            # Basically we don't care much about SSH exceptions. Just log them and pass to record.
-            except Exception as function_exception_object:
-                execution_error = function_exception_object
-                print_api(execution_error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-                pass
+            execution_output, execution_error = self.remote_execution_python(script_string=script_string, script_arg_values=(str(port),))
 
             # Closing SSH connection at this stage.
             self.close()
-            self.logger.info("Acquired. Closed SSH connection.")
+            print_api("Acquired. Closed SSH connection.", logger=self.logger, logger_method='info')
 
         return execution_output, execution_error

atomicshop/system_resource_monitor.py

@@ -2,8 +2,7 @@ from typing import Union
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
-from . import system_resources
+from . import system_resources, print_api
 
 
 class SystemResourceMonitor:
@@ -109,67 +108,77 @@ class SystemResourceMonitor:
         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.
+        # The shared results' dictionary.
         self.results: dict = {}
 
-    def start(self, print_kwargs: dict = None):
+    def start(
+            self,
+            print_kwargs: dict = None,
+            thread_as_daemon: bool = True
+    ):
         """
         Start the monitoring process.
         :param print_kwargs:
+        :param thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the main
+            process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+            In child processes created by multiprocessing.Process, the thread works differently. You might not
+            get the desired result.
         :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.thread is None:
             self.running = True
-            self.thread = threading.Thread(target=run_check_system_resources, args=(
+            self.thread = threading.Thread(target=self.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.queue_list, self.manager_dict))
-            self.thread.daemon = True
+            self.thread.daemon = thread_as_daemon
             self.thread.start()
         else:
-            print_api("Monitoring is already running.", color='yellow', **print_kwargs)
+            print_api.print_api("Monitoring is already running.", color='yellow', **print_kwargs)
+
+    def run_check_system_resources(
+            self,
+            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
 
     def get_results(self) -> dict:
         """
@@ -204,6 +213,7 @@ def start_monitoring(
         calculate_maximum_changed_disk_io: bool = False,
         queue_list: list = None,
         manager_dict: multiprocessing.managers.DictProxy = None,      # multiprocessing.Manager().dict()
+        get_results_thread_as_daemon: bool = True,
         print_kwargs: dict = None
 ):
     """
@@ -234,6 +244,10 @@ def start_monitoring(
             multiprocessing.Process(
                 target=system_resource_monitor.start_monitoring, kwargs={'manager_dict': shared_dict}).start()
 
+    :param get_results_thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the
+        main process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+        In child processes created by multiprocessing.Process, the thread works differently.
+        You might not get the desired result.
     :param print_kwargs: dict, print kwargs.
     :return:
     """
@@ -256,9 +270,9 @@ def start_monitoring(
             queue_list=queue_list,
             manager_dict=manager_dict
         )
-        SYSTEM_RESOURCES_MONITOR.start()
+        SYSTEM_RESOURCES_MONITOR.start(thread_as_daemon=get_results_thread_as_daemon)
     else:
-        print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
+        print_api.print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
 
 
 def stop_monitoring():

atomicshop/system_resources.py

@@ -5,9 +5,8 @@ import shutil
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
 from .wrappers.psutilw import cpus, memories, disks
-from . import system_resource_monitor
+from . import system_resource_monitor, print_api
 
 
 def check_system_resources(
@@ -129,13 +128,13 @@ def wait_for_resource_availability(
 
         if result['cpu_usage'] < cpu_percent_max and result['memory_usage'] < memory_percent_max:
             break
-        print_api(
+        print_api.print_api(
             f"Waiting for resources to be available... "
             f"CPU: {result['cpu_usage']}%, Memory: {result['memory_usage']}%", color='yellow')
         time.sleep(wait_time)  # Wait for 'wait_time' seconds before checking again
 
 
-def test_disk_speed_with_monitoring(
+def _test_disk_speed_with_monitoring(
         file_settings: list[dict],
         remove_file_after_each_copy: bool = False,
         target_directory=None,
@@ -144,6 +143,7 @@ def test_disk_speed_with_monitoring(
         print_kwargs: dict = None
 ):
     """
+    THIS IS NOT TESTED.
     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.
@@ -171,7 +171,7 @@ def test_disk_speed_with_monitoring(
     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)
+            get_disk_files_count=True, calculate_maximum_changed_disk_io=True)
 
     if target_directory is None:
         target_directory = tempfile.mkdtemp()
@@ -196,7 +196,7 @@ def test_disk_speed_with_monitoring(
             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 {}))
+            print_api.print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
 
             # Measure read speed.
             with open(target_file_path, "rb") as file:
@@ -212,7 +212,7 @@ def test_disk_speed_with_monitoring(
 
     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 {}))
+    print_api.print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
 
     # Cleanup. Remove all created files and directories.
     shutil.rmtree(source_directory)
@@ -220,7 +220,7 @@ def test_disk_speed_with_monitoring(
 
     if monitoring:
         # Stop the I/O monitoring.
-        max_io_changes = system_resource_monitor.get_result()['maximum_disk_io']
+        max_io_changes = system_resource_monitor.get_results()['maximum_disk_io']
         system_resource_monitor.stop_monitoring()
 
     return total_execution_time, max_io_changes

atomicshop/tempfiles.py

@@ -1,4 +1,3 @@
-# v1.0.3 - 01.04.2021 - 15:30
 import os
 import datetime
 import tempfile
@@ -59,4 +58,4 @@ class TempFile:
         self.file_path: str = self.directory + os.sep + self.file_name
 
     def remove(self):
-        os.remove(self.file_path)
+        os.remove(self.file_path)