PyBreeze 1.0.4__py3-none-any.whl

automation_ide/extend/process_executor/file_automation/file_automation_process.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+
+from automation_ide.extend.process_executor.process_executor_utils import build_process
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+import sys
+
+from automation_ide.utils.file_process.get_dir_file_list import ask_and_get_dir_files_as_list
+
+
+def call_file_automation_test(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "automation_file", exec_str, False, program_buffer)
+
+
+def call_file_automation_test_with_send(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "automation_file", exec_str, True, program_buffer)
+
+
+def call_file_automation_test_multi_file(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None \
+                and isinstance(need_to_execute_list, list) and len(need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_file_automation_test(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)
+
+
+def call_file_automation_test_multi_file_and_send(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None \
+                and isinstance(need_to_execute_list, list) and len(need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_file_automation_test_with_send(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)

automation_ide/extend/process_executor/load_density/load_density_process.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+
+from automation_ide.extend.process_executor.process_executor_utils import build_process
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+import sys
+
+from automation_ide.utils.file_process.get_dir_file_list import ask_and_get_dir_files_as_list
+
+
+def call_load_density(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "je_load_density", exec_str, False, program_buffer)
+
+
+def call_load_density_with_send(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "je_load_density", exec_str, True, program_buffer)
+
+
+def call_load_density_multi_file(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None and isinstance(need_to_execute_list, list) and len(
+                need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_load_density(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)
+
+
+def call_load_density_multi_file_and_send(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None and isinstance(need_to_execute_list, list) and len(
+                need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_load_density_with_send(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)

automation_ide/extend/process_executor/mail_thunder/mail_thunder_process.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+
+from automation_ide.extend.process_executor.process_executor_utils import build_process
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+
+
+def call_mail_thunder(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "je_mail_thunder", exec_str, False, program_buffer)

automation_ide/extend/process_executor/process_executor_utils.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import TYPE_CHECKING, Union
+
+from je_editor import EditorWidget
+
+from automation_ide.automation_editor_ui.show_code_window.code_window import CodeWindow
+from automation_ide.extend.mail_thunder_extend.mail_thunder_setting import send_after_test
+from automation_ide.extend.process_executor.python_task_process_manager import TaskProcessManager
+from automation_ide.utils.exception.exception_tags import wrong_test_data_format_exception_tag
+from automation_ide.utils.exception.exceptions import ITETestExecutorException
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+
+
+def build_process(
+        main_window: AutomationEditor,
+        package: str,
+        exec_str: Union[str, None] = None,
+        send_mail: bool = False,
+        program_buffer: int = 1024000,
+):
+    try:
+        widget = main_window.tab_widget.currentWidget()
+        if isinstance(widget, EditorWidget) and exec_str is None:
+            test_format_code = widget.code_edit.toPlainText()
+        else:
+            test_format_code = exec_str
+        start_process(main_window, package, test_format_code, send_mail, program_buffer)
+    except json.decoder.JSONDecodeError as error:
+        print(
+            repr(error) +
+            "\n"
+            + wrong_test_data_format_exception_tag,
+            file=sys.stderr
+        )
+    except ITETestExecutorException as error:
+        print(repr(error), file=sys.stderr)
+
+
+def start_process(
+        main_window: AutomationEditor,
+        package: str,
+        test_format_code: str,
+        send_mail: bool = False,
+        program_buffer: int = 1024000
+):
+    # Code window init
+    code_window = CodeWindow()
+    main_window.current_run_code_window.append(code_window)
+    main_window.clear_code_result()
+    # Process init
+    if send_mail:
+        process = TaskProcessManager(
+            main_window=code_window,
+            program_buffer_size=program_buffer,
+            program_encoding=main_window.encoding
+        )
+    else:
+        process = TaskProcessManager(
+            code_window,
+            task_done_trigger_function=send_after_test,
+            program_buffer_size=program_buffer,
+            program_encoding=main_window.encoding
+        )
+    process.start_test_process(
+        package,
+        exec_str=test_format_code,
+    )

automation_ide/extend/process_executor/python_task_process_manager.py

@@ -0,0 +1,177 @@
+import json
+import queue
+import subprocess
+import sys
+import threading
+import typing
+from pathlib import Path
+from queue import Queue
+from threading import Thread
+from typing import Union
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QTextCharFormat
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
+from je_editor.utils.venv_check.check_venv import check_and_choose_venv
+
+from automation_ide.automation_editor_ui.show_code_window.code_window import CodeWindow
+
+
+class TaskProcessManager(object):
+    def __init__(
+            self,
+            main_window: CodeWindow,
+            task_done_trigger_function: typing.Callable = None,
+            error_trigger_function: typing.Callable = None,
+            program_buffer_size: int = 1024,
+            program_encoding: str = "utf-8"
+    ):
+        super().__init__()
+        self.compiler_path = None
+        # ite_instance param
+        self.read_program_error_output_from_thread: Union[threading.Thread, None] = None
+        self.read_program_output_from_thread: Union[threading.Thread, None] = None
+        self.main_window: CodeWindow = main_window
+        self.timer: QTimer = QTimer(self.main_window)
+        self.still_run_program: bool = True
+        self.program_encoding: str = program_encoding
+        self.run_output_queue: Queue = Queue()
+        self.run_error_queue: Queue = Queue()
+        self.process: Union[subprocess.Popen, None] = None
+
+        self.task_done_trigger_function: typing.Callable = task_done_trigger_function
+        self.error_trigger_function: typing.Callable = error_trigger_function
+        self.program_buffer_size = program_buffer_size
+
+    def renew_path(self) -> None:
+        if self.main_window.python_compiler is None:
+            # Renew compiler path
+            if sys.platform in ["win32", "cygwin", "msys"]:
+                venv_path = Path(str(Path.cwd()) + "/venv/Scripts")
+            else:
+                venv_path = Path(str(Path.cwd()) + "/venv/bin")
+            self.compiler_path = check_and_choose_venv(venv_path)
+        else:
+            self.compiler_path = self.main_window.python_compiler
+
+    def start_test_process(self, package: str, exec_str: str):
+        self.renew_path()
+        if sys.platform in ["win32", "cygwin", "msys"]:
+            exec_str = json.dumps(exec_str)
+            args = [
+                self.compiler_path,
+                "-m",
+                package,
+                "--execute_str",
+                exec_str
+            ]
+        else:
+            args = " ".join([f"{self.compiler_path}", f"-m {package}", "--execute_str", f"{exec_str}"])
+        self.process: subprocess.Popen = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            encoding=self.program_encoding
+        )
+        self.still_run_program = True
+        # program output message queue thread
+        self.read_program_output_from_thread = Thread(
+            target=self.read_program_output_from_process,
+            daemon=True
+        )
+        self.read_program_output_from_thread.start()
+        # program error message queue thread
+        self.read_program_error_output_from_thread = Thread(
+            target=self.read_program_error_output_from_process,
+            daemon=True
+        )
+        self.read_program_error_output_from_thread.start()
+        # start Pyside update
+        # start timer
+        self.main_window.setWindowTitle(package)
+        self.main_window.show()
+        self.timer = QTimer()
+        self.timer.setInterval(100)
+        self.timer.timeout.connect(self.pull_text)
+        self.timer.start()
+
+    # Pyside UI update method
+    def pull_text(self):
+        try:
+            if not self.run_output_queue.empty():
+                output_message = self.run_output_queue.get_nowait()
+                output_message = str(output_message).strip()
+                if output_message:
+                    text_cursor = self.main_window.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("normal_output_color"))
+                    text_cursor.insertText(output_message, text_format)
+                    text_cursor.insertBlock()
+            if not self.run_error_queue.empty():
+                error_message = self.run_error_queue.get_nowait()
+                error_message = str(error_message).strip()
+                if error_message:
+                    text_cursor = self.main_window.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("error_output_color"))
+                    text_cursor.insertText(error_message, text_format)
+                    text_cursor.insertBlock()
+        except queue.Empty:
+            pass
+        if self.process is not None:
+            if self.process.returncode == 0:
+                if self.timer.isActive():
+                    self.timer.stop()
+                self.exit_program()
+            elif self.process.returncode is not None:
+                if self.timer.isActive():
+                    self.timer.stop()
+                self.exit_program()
+            if self.still_run_program:
+                # poll return code
+                self.process.poll()
+        else:
+            if self.timer.isActive():
+                self.timer.stop()
+
+    # exit program change run flag to false and clean read thread and queue and process
+    def exit_program(self):
+        self.still_run_program = False
+        if self.read_program_output_from_thread is not None:
+            self.read_program_output_from_thread = None
+        if self.read_program_error_output_from_thread is not None:
+            self.read_program_error_output_from_thread = None
+        self.print_and_clear_queue()
+        if self.process is not None:
+            self.process.terminate()
+            text_cursor = self.main_window.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(f"Task exit with code {self.process.returncode}", text_format)
+            text_cursor.insertBlock()
+            self.process = None
+
+    def print_and_clear_queue(self):
+        self.run_output_queue = queue.Queue()
+        self.run_error_queue = queue.Queue()
+
+    def read_program_output_from_process(self):
+        while self.still_run_program:
+            self.process: subprocess.Popen
+            program_output_data = self.process.stdout.readline(self.program_buffer_size) \
+                .decode("utf-8", "replace")
+            if self.process:
+                self.process.stdout.flush()
+            if program_output_data.strip() != "":
+                self.run_output_queue.put(program_output_data)
+
+    def read_program_error_output_from_process(self):
+        while self.still_run_program:
+            program_error_output_data = self.process.stderr.readline(self.program_buffer_size) \
+                .decode("utf-8", "replace")
+            if self.process:
+                self.process.stderr.flush()
+            if program_error_output_data.strip() != "":
+                self.run_error_queue.put(program_error_output_data)

automation_ide/extend/process_executor/test_pioneer/test_pioneer_process_manager.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import queue
+import subprocess
+import sys
+import threading
+from pathlib import Path
+from queue import Queue
+from typing import TYPE_CHECKING, Union
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QTextCharFormat
+from PySide6.QtWidgets import QWidget
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
+from je_editor.utils.venv_check.check_venv import check_and_choose_venv
+
+from automation_ide.automation_editor_ui.show_code_window.code_window import CodeWindow
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+
+
+class TestPioneerProcess(object):
+
+    def __init__(
+            self,
+            main_window: AutomationEditor,
+            executable_path: str,
+            program_buffer: int = 1024000,
+            encoding: str = "utf-8",
+    ):
+        self._main_window: AutomationEditor = main_window
+        self._widget: QWidget = main_window.tab_widget.currentWidget()
+        # Code window init
+        self._code_window = CodeWindow()
+        self._main_window.current_run_code_window.append(self._code_window)
+        self._main_window.clear_code_result()
+        self._still_run_program: bool = False
+        self._program_buffer_size = program_buffer
+        self._run_output_queue: Queue = Queue()
+        self._run_error_queue: Queue = Queue()
+        self._read_program_error_output_from_thread: Union[threading.Thread, None] = None
+        self._read_program_output_from_thread: Union[threading.Thread, None] = None
+        self._timer: QTimer = QTimer(self._code_window)
+        if self._main_window.python_compiler is None:
+            # Renew compiler path
+            if sys.platform in ["win32", "cygwin", "msys"]:
+                venv_path = Path(str(Path.cwd()) + "/venv/Scripts")
+            else:
+                venv_path = Path(str(Path.cwd()) + "/venv/bin")
+            self._compiler_path = check_and_choose_venv(venv_path)
+        else:
+            self._compiler_path = main_window.python_compiler
+        if sys.platform in ["win32", "cygwin", "msys"]:
+            args = [
+                self._compiler_path,
+                "-m",
+                "test_pioneer",
+                "-e",
+                executable_path
+            ]
+        else:
+            args = " ".join([
+                f"{self._compiler_path}", "-m test_pioneer", "-e", f"{executable_path}"
+            ])
+        self._process: subprocess.Popen = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            encoding=encoding
+        )
+
+    # Pyside UI update method
+    def pull_text(self):
+        try:
+            if not self._run_output_queue.empty():
+                output_message = self._run_output_queue.get_nowait()
+                output_message = str(output_message).strip()
+                if output_message:
+                    text_cursor = self._code_window.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("normal_output_color"))
+                    text_cursor.insertText(output_message, text_format)
+                    text_cursor.insertBlock()
+            if not self._run_error_queue.empty():
+                error_message = self._run_error_queue.get_nowait()
+                error_message = str(error_message).strip()
+                if error_message:
+                    text_cursor = self._code_window.code_result.textCursor()
+                    text_format = QTextCharFormat()
+                    text_format.setForeground(actually_color_dict.get("error_output_color"))
+                    text_cursor.insertText(error_message, text_format)
+                    text_cursor.insertBlock()
+        except queue.Empty:
+            pass
+        if self._process is not None:
+            if self._process.returncode == 0:
+                if self._timer.isActive():
+                    self._timer.stop()
+                self.exit_program()
+            elif self._process.returncode is not None:
+                if self._timer.isActive():
+                    self._timer.stop()
+                self.exit_program()
+            if self._still_run_program:
+                # poll return code
+                self._process.poll()
+        else:
+            if self._timer.isActive():
+                self._timer.stop()
+
+    # exit program change run flag to false and clean read thread and queue and process
+    def exit_program(self):
+        self._still_run_program = False
+        if self._read_program_output_from_thread is not None:
+            self._read_program_output_from_thread = None
+        if self._read_program_error_output_from_thread is not None:
+            self._read_program_error_output_from_thread = None
+        self.print_and_clear_queue()
+        if self._process is not None:
+            self._process.terminate()
+            text_cursor = self._code_window.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(f"Task exit with code {self._process.returncode}", text_format)
+            text_cursor.insertBlock()
+            self._process = None
+
+    def print_and_clear_queue(self):
+        self._run_output_queue = queue.Queue()
+        self._run_error_queue = queue.Queue()
+
+    def read_program_output_from_process(self):
+        while self._still_run_program:
+            self.process: subprocess.Popen
+            program_output_data = self._process.stdout.readline(self._program_buffer_size) \
+                .decode("utf-8", "replace")
+            if self._process:
+                self._process.stdout.flush()
+            if program_output_data.strip() != "":
+                self._run_output_queue.put(program_output_data)
+
+    def read_program_error_output_from_process(self):
+        while self._still_run_program:
+            program_error_output_data = self._process.stderr.readline(self._program_buffer_size) \
+                .decode("utf-8", "replace")
+            if self._process:
+                self._process.stderr.flush()
+            if program_error_output_data.strip() != "":
+                self._run_error_queue.put(program_error_output_data)
+
+    def start_test_pioneer_process(self):
+        self._still_run_program = True
+        # program output message queue thread
+        self._read_program_output_from_thread = threading.Thread(
+            target=self.read_program_output_from_process,
+            daemon=True
+        )
+        self._read_program_output_from_thread.start()
+        # program error message queue thread
+        self._read_program_error_output_from_thread = threading.Thread(
+            target=self.read_program_error_output_from_process,
+            daemon=True
+        )
+        self._read_program_error_output_from_thread.start()
+        # start Pyside update
+        # start timer
+        self._code_window.setWindowTitle("Test Pioneer")
+        self._code_window.show()
+        self._timer = QTimer()
+        self._timer.setInterval(100)
+        self._timer.timeout.connect(self.pull_text)
+        self._timer.start()
+
+
+def init_and_start_test_pioneer_process(ui_we_want_to_set: AutomationEditor, file_path: str):
+    test_pioneer_process_manager = TestPioneerProcess(
+        main_window=ui_we_want_to_set, executable_path=file_path)
+    test_pioneer_process_manager.start_test_pioneer_process()

automation_ide/extend/process_executor/web_runner/web_runner_process.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+
+from automation_ide.extend.process_executor.process_executor_utils import build_process
+
+if TYPE_CHECKING:
+    from automation_ide.automation_editor_ui.editor_main.main_ui import AutomationEditor
+import sys
+
+from automation_ide.utils.file_process.get_dir_file_list import ask_and_get_dir_files_as_list
+
+
+def call_web_runner_test(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "je_web_runner", exec_str, False, program_buffer)
+
+
+def call_web_runner_test_with_send(
+        main_window: AutomationEditor,
+        exec_str: Union[str, None] = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, "je_web_runner", exec_str, True, program_buffer)
+
+
+def call_web_runner_test_multi_file(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None and isinstance(need_to_execute_list, list) and len(
+                need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_web_runner_test(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)
+
+
+def call_web_runner_test_multi_file_and_send(
+        main_window: AutomationEditor,
+        program_buffer: int = 1024000
+):
+    try:
+
+        need_to_execute_list: list = ask_and_get_dir_files_as_list(main_window)
+        if need_to_execute_list is not None and isinstance(need_to_execute_list, list) and len(
+                need_to_execute_list) > 0:
+            for execute_file in need_to_execute_list:
+                with open(execute_file, "r+") as test_script_json:
+                    call_web_runner_test_with_send(
+                        main_window,
+                        test_script_json.read(),
+                        program_buffer
+                    )
+    except Exception as error:
+        print(repr(error), file=sys.stderr)