atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/python_functions.py

@@ -4,7 +4,7 @@ from typing import Union
 from .print_api import print_api
 
 
-def get_current_python_version_string() -> str:
+def get_python_version_string() -> str:
     """
     Function gets version MAJOR.MINOR.MICRO from 'sys.version_info' object and returns it as a string.
     :return: python MAJOR.MINOR.MICRO version string.
@@ -13,120 +13,35 @@ def get_current_python_version_string() -> str:
     return f'{sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]}'
 
 
-# noinspection PyUnusedLocal
-def check_if_version_object_is_tuple_or_string(version_object: any,
-                                               **kwargs) -> tuple:
-    """
-    Function checks if 'version_object' that was passed is tuple or string.
-    If it's tuple then returns it back. If it's string, converts to tuple then returns it.
-    If the object is none of the above, returns None.
-
-    :param version_object: Can be string ('3.10') or tuple of integers ((3, 10)).
-    :return:
-    """
-    # Check if tuple was passed.
-    if isinstance(version_object, tuple):
-        return version_object
-    else:
-        # Then check if a string was passed.
-        if isinstance(version_object, str):
-            # The check will be against tuple of integers, so we'll convert a string to tuple of integers.
-            return tuple(map(int, version_object.split('.')))
-        else:
-            message = f'[*] Function: [check_if_version_object_is_tuple_or_string]\n' \
-                      f'[*] [version_object] object passed is not tuple or string.\n' \
-                      f'[*] Object type: {type(version_object)}\n' \
-                      f'[*] Object content {version_object}\n' \
-                      f'Exiting...'
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return None
-
-
-# noinspection PyUnusedLocal
 def check_python_version_compliance(
-        minimum_version: Union[str, tuple] = None,
-        maximum_version: Union[str, tuple] = None,
-        minor_version: Union[str, tuple] = None,
-        **kwargs
-) -> bool:
+        min_ver: tuple = None,
+        max_ver: tuple = None,
+) -> str | None:
     """
     Python version check. Should be executed before importing external libraries, since they depend on Python version.
 
-    :param minimum_version: Can be string ('3.10') or tuple of integers ((3, 10)).
-    :param maximum_version: Can be string ('3.10') or tuple of integers ((3, 10)).
+    :param min_ver: tuple of integers (3, 10).
+    :param max_ver: tuple of integers (3, 10).
         If maximum version is not specified, it will be considered as all versions above the minimum are compliant.
-    :param minor_version: Can be string ('3.10') or tuple of integers ((3, 10)).
-        If minor version is specified, it will be considered as all the versions with the same major, minor version
-        are compliant. Example: if minor_version is '3.10', then all the versions with '3.10.x' are compliant.
-    :return:
+    :return: If version is not compliant, returns string with error message. Otherwise, returns None.
     """
 
-    if not minimum_version and not maximum_version and not minor_version:
+    if not min_ver and not max_ver:
         raise ValueError("At least one of the version parameters should be passed.")
 
-    if minor_version and (minimum_version or maximum_version):
-        raise ValueError("Minor version should be passed alone.")
-
-    # Check objects for string or tuple and get the tuple.
-    if minimum_version:
-        minimum_version_scheme: tuple = check_if_version_object_is_tuple_or_string(minimum_version, **kwargs)
-    else:
-        minimum_version_scheme = tuple()
-    # If 'maximum_version' object was passed, check it for string or tuple and get the tuple.
-    if maximum_version:
-        maximum_version_scheme: tuple = check_if_version_object_is_tuple_or_string(maximum_version, **kwargs)
-    else:
-        maximum_version_scheme = tuple()
-
-    # If 'minor_version' object was passed, check it for string or tuple and get the tuple.
-    if minor_version:
-        minor_version_scheme: tuple = check_if_version_object_is_tuple_or_string(minor_version, **kwargs)
+    current_version_info: tuple = sys.version_info[:3]
+    if min_ver and not max_ver:
+        if current_version_info < min_ver:
+            return f'Python version {".".join(map(str, min_ver))} or higher is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
+    elif max_ver and not min_ver:
+        if current_version_info > max_ver:
+            return f'Python version up to {".".join(map(str, max_ver))} is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
+    elif min_ver and max_ver:
+        if not (min_ver <= current_version_info <= max_ver):
+            return f'Python version between {".".join(map(str, min_ver))} and '\
+                   f'{".".join(map(str, max_ver))} is required. '\
+                   f'Current version is {".".join(map(str, current_version_info))}.'
     else:
-        minor_version_scheme = tuple()
-
-    # Get current python version.
-    python_version_full: str = get_current_python_version_string()
-
-    message = f"[*] Current Python Version: {python_version_full}"
-    print_api(message, logger_method='info', **kwargs)
-
-    if minor_version_scheme:
-        # Check if current python version is later or equals to the minimum required version.
-        if sys.version_info[:2] != minor_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL ANY PYTHON " \
-                      f"[{'.'.join(str(i) for i in minor_version_scheme)}] version, " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif minimum_version_scheme and maximum_version_scheme:
-        if not sys.version_info >= minimum_version_scheme or not sys.version_info < maximum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL AT LEAST PYTHON " \
-                      f"[{'.'.join(str(i) for i in minimum_version_scheme)}], " \
-                      f"AND EARLIER THAN [{'.'.join(str(i) for i in maximum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif minimum_version_scheme and not maximum_version_scheme:
-        if not sys.version_info >= minimum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL AT LEAST PYTHON " \
-                      f"[{'.'.join(str(i) for i in minimum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-    elif not minimum_version_scheme and maximum_version_scheme:
-        if not sys.version_info < maximum_version_scheme:
-            message = f"[!!!] YOU NEED TO INSTALL EARLIER THAN PYTHON " \
-                      f"[{'.'.join(str(i) for i in maximum_version_scheme)}], " \
-                      f"to work properly."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
-
-            return False
-
-    message = "[*] Version Check PASSED."
-    print_api(message, logger_method='info', **kwargs)
-
-    return True
+        return None

atomicshop/speech_recognize.py

@@ -1,3 +1,11 @@
+# TODO: Change manual wrapper to:
+# from ffmpy import FFmpeg
+# ff = FFmpeg(
+#     inputs={'input.mp4': None},
+#     outputs={'output.avi': None}
+# )
+# ff.run()
+
 from .wrappers.ffmpegw import FFmpegWrapper
 from .tempfiles import TempFile
 from .web import download

atomicshop/ssh_remote.py

@@ -1,8 +1,7 @@
 import sys
-import base64
-import socket
 import logging
 from pathlib import Path
+import shlex
 
 try:
     import paramiko
@@ -12,7 +11,12 @@ except ImportError as exception_object:
 
 from .print_api import print_api
 from .wrappers.loggingw import loggingw
-from .wrappers.socketw import base
+from .wrappers.socketw import socket_base
+
+
+class SSHRemoteWrapperNoPythonFound(Exception):
+    """Raised when no usable Python 3 interpreter found on remote host."""
+    pass
 
 
 class SSHRemote:
@@ -101,17 +105,23 @@ class SSHRemote:
         # Initializing paramiko SSHClient class
         self.ssh_client = paramiko.SSHClient()
 
+        # 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):
+    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.
@@ -129,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)
-            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)
-            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)
-            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)
-            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)
-
-                # 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)
-                # 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)
-            # 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)
-            # 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.
@@ -212,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()
+
+        # Reading the buffer of stdout.
+        output_lines: list = stdout.readlines()
+        # Reading the buffer of stderr.
+        error_lines: list = stderr.readlines()
+
+        # 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)
 
-            # Since they're "file-like" objects we need to close them after we finished using.
-            stdin.close()
-            stdout.close()
-            stderr.close()
+        # Since they're "file-like" objects we need to close them after we finished using.
+        stdin.close()
+        stdout.close()
+        stderr.close()
 
-        return output_lines, function_error
+        return output_result, error_result
 
-    def remote_execution_python(self, script_string: str):
+    def _detect_remote_python_cmd_name(self) -> str:
         """
-        Function to execute python script over SSH.
+        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
 
-        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}")
+        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.
 
         :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
 
-        encoded_base64_string = base64.b64encode(script_string.encode('ascii'))
-        command_string: str = fr'python -c "import base64;exec(base64.b64decode({encoded_base64_string}))"'
+        python_cmd = self._get_python_cmd()
+        command: str = f"{python_cmd} -"
 
-        # 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_arg_values:
+            for arg in script_arg_values:
+                command += " " + shlex.quote(str(arg))
+
+        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:
@@ -318,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)
-                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