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

atomicshop/scheduling.py

@@ -12,7 +12,7 @@ def periodic_task(interval, priority, function_ref, args=(), sched_object=None):
     sched_object.run()
 
 
-def threaded_periodic_task(interval, function_ref, args=(), kwargs=None, thread_name=None):
+def threaded_periodic_task(interval, function_ref, args=(), kwargs=None, thread_name=None, daemon=True):
     """
     The function executes referenced function 'function_ref' with arguments 'args' each 'interval' in a new thread.
     The old thread is closed, each time the new is executed.
@@ -22,8 +22,12 @@ def threaded_periodic_task(interval, function_ref, args=(), kwargs=None, thread_
     :param args: tuple, of arguments to provide for the 'function_ref' to execute.
     :param kwargs: dictionary, of keyword arguments to provide for the 'function_ref' to execute.
     :param thread_name: the name of the thread that will be created:
-        threading.Thread(target=thread_timer, name=thread_name).start()
+        threading.Thread(target=thread_timer, name=thread_name)
         The default parameter for 'Thread' 'name' is 'None', so if you don't specify the name it works as default.
+    :param daemon: bool, if True, the thread will be a daemon thread. Default is True.
+        Since this is a periodic task, we don't need to wait for the thread to finish, so we can set it to True.
+
+    :return: thread object.
     """
 
     # If 'kwargs' is not provided, we'll initialize it as an empty dictionary.
@@ -50,7 +54,13 @@ def threaded_periodic_task(interval, function_ref, args=(), kwargs=None, thread_
             time.sleep(interval)
 
     # Start in a new thread.
-    threading.Thread(target=thread_timer, name=thread_name).start()
+    thread = threading.Thread(target=thread_timer, name=thread_name)
+
+    if daemon:
+        thread.daemon = True
+
+    thread.start()
+    return thread
 
 
 class ThreadLooper:
@@ -60,7 +70,14 @@ class ThreadLooper:
     def __init__(self):
         self.loop_queue = queue.Queue()
 
-    def run_loop(self, function_reference, args=(), kwargs=None, interval_seconds=0, thread_name: str = None):
+    def run_loop(
+            self,
+            function_reference,
+            args=(),
+            kwargs=None,
+            interval_seconds=0,
+            thread_name: str = None
+    ):
         """
         The function executes referenced function 'function_ref' with arguments 'args' each 'interval' in a new thread.
 
@@ -86,7 +103,9 @@ class ThreadLooper:
                 self.loop_queue.put(result_list)
                 time.sleep(interval_seconds)
 
-        threading.Thread(target=thread_function, name=thread_name).start()
+        thread = threading.Thread(target=thread_function, name=thread_name)
+        thread.daemon = True
+        thread.start()
 
     def emit_from_loop(self):
         """

atomicshop/sound.py

@@ -280,11 +280,13 @@ class StereoMixRecorder:
         # when playback can start before the input interface is initialized, since thread runs in parallel.
         self.loopback_input = self._initialize_input_interface()
 
-        threading.Thread(
+        thread = threading.Thread(
             target=self._thread_record,
             args=(split_emit_buffers, emit_type, file_path, record_until_zero_array, seconds),
             kwargs=kwargs
-        ).start()
+        )
+        thread.daemon = True
+        thread.start()
 
     def _thread_record(
             self, split_emit_buffers: int, emit_type: str, file_path: str, record_until_zero_array: bool, seconds,

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,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/startup/win/startup_folder.py

@@ -0,0 +1,53 @@
+import os
+from pathlib import Path
+
+from ...wrappers.pywin32w import winshell
+
+
+STARTUP_FOLDER = os.path.join(os.environ['APPDATA'], 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
+
+
+def add_to_startup_folder_with_shortcut(exe_file_path: str, shortcut_name: str) -> str:
+    """
+    This function will create a shortcut in the startup folder to your executable.
+
+    :param exe_file_path: The path to your executable file.
+    :param shortcut_name: The name of the shortcut file to create in the startup folder.
+        No need to add the ".lnk" extension.
+    :return: The path to the shortcut file created.
+    """
+
+    # Get the startup folder path and create if non-existent.
+    Path(STARTUP_FOLDER).mkdir(parents=True, exist_ok=True)
+
+    shortcut_file_path = str(Path(STARTUP_FOLDER, f'{shortcut_name}.lnk'))
+
+    # Create a shortcut to the executable file.
+    winshell.create_shortcut(exe_file_path, shortcut_file_path)
+
+    return shortcut_file_path
+
+
+def is_in_startup_folder(shortcut_name: str):
+    """
+    This function will check if the shortcut is in the startup folder.
+
+    :param shortcut_name: The name of the shortcut file to check in the startup folder.
+        No need to add the ".LNK" extension.
+    :return: True if the shortcut is in the startup folder, False otherwise.
+    """
+    return Path(STARTUP_FOLDER, f'{shortcut_name}.lnk').exists()
+
+
+def remove_from_startup_folder(shortcut_name: str):
+    """
+    This function will remove the shortcut from the startup folder.
+
+    :param shortcut_name: The name of the shortcut file to remove from the startup folder.
+        No need to add the ".LNK" extension.
+    """
+    shortcut_file_path = Path(STARTUP_FOLDER, f'{shortcut_name}.lnk')
+    if shortcut_file_path.exists():
+        shortcut_file_path.unlink()
+        return True
+    return False