PyBreeze 1.0.22__tar.gz → 1.0.24__tar.gz

{pybreeze-1.0.22 → pybreeze-1.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybreeze
-Version: 1.0.22
+Version: 1.0.24
 Summary: IDE for multi automation
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/AutomationEditor

pybreeze-1.0.24/pybreeze/extend/process_executor/api_testka/api_testka_process.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pybreeze.extend.process_executor.process_executor_utils import (
+    build_process, run_dir_files_with_package,
+)
+
+if TYPE_CHECKING:
+    from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
+
+_PACKAGE = "je_api_testka"
+
+
+def call_api_testka(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, False, program_buffer)
+
+
+def call_api_testka_with_send(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, True, program_buffer)
+
+
+def call_api_testka_multi_file(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, False, program_buffer)
+
+
+def call_api_testka_multi_file_and_send(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, True, program_buffer)

pybreeze-1.0.24/pybreeze/extend/process_executor/auto_control/auto_control_process.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pybreeze.extend.process_executor.process_executor_utils import (
+    build_process, run_dir_files_with_package,
+)
+
+if TYPE_CHECKING:
+    from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
+
+_PACKAGE = "je_auto_control"
+
+
+def call_auto_control(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, False, program_buffer)
+
+
+def call_auto_control_with_send(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, True, program_buffer)
+
+
+def call_auto_control_multi_file(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, False, program_buffer)
+
+
+def call_auto_control_multi_file_and_send(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, True, program_buffer)

pybreeze-1.0.24/pybreeze/extend/process_executor/file_automation/file_automation_process.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pybreeze.extend.process_executor.process_executor_utils import (
+    build_process, run_dir_files_with_package,
+)
+
+if TYPE_CHECKING:
+    from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
+
+_PACKAGE = "automation_file"
+
+
+def call_file_automation_test(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, False, program_buffer)
+
+
+def call_file_automation_test_with_send(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, True, program_buffer)
+
+
+def call_file_automation_test_multi_file(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, False, program_buffer)
+
+
+def call_file_automation_test_multi_file_and_send(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, True, program_buffer)

{pybreeze-1.0.22 → pybreeze-1.0.24}/pybreeze/extend/process_executor/file_runner_process.py

@@ -21,6 +21,8 @@ from PySide6.QtGui import QTextCharFormat
 from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
 
 from pybreeze.pybreeze_ui.show_code_window.code_window import CodeWindow
+from pybreeze.utils.logging.logger import pybreeze_logger
+from pybreeze.utils.subprocess_util import no_window_creationflags, utf8_subprocess_env
 
 
 class FileRunnerProcess:
@@ -81,6 +83,7 @@ class FileRunnerProcess:
                 compile_cmd,
                 capture_output=True,
                 timeout=60,
+                creationflags=no_window_creationflags(),
             )
         except FileNotFoundError:
             self._append_text(f"[Error] Compiler not found: {compiler}\n", is_error=True)
@@ -117,6 +120,8 @@ class FileRunnerProcess:
                 stderr=subprocess.PIPE,
                 stdin=subprocess.PIPE,
                 shell=False,
+                creationflags=no_window_creationflags(),
+                env=utf8_subprocess_env(self.program_encoding),
             )
         except FileNotFoundError:
             self._append_text(f"[Error] Command not found: {command[0]}\n", is_error=True)
@@ -189,8 +194,8 @@ class FileRunnerProcess:
         if self._cleanup_binary:
             try:
                 os.remove(self._cleanup_binary)
-            except OSError:
-                pass
+            except OSError as error:
+                pybreeze_logger.debug("Could not remove compiled binary %s: %s", self._cleanup_binary, error)
 
     def _drain_queues(self) -> None:
         """Drain all remaining messages from output/error queues to UI."""
@@ -211,37 +216,29 @@ class FileRunnerProcess:
             except queue.Empty:
                 break
 
-    def _read_stdout(self) -> None:
+    def _read_stream(self, stream_name: str, target_queue: Queue) -> None:
+        # Empty read from readline means the pipe reached EOF (the child closed
+        # the stream), so stop immediately rather than spinning on a closed pipe
+        # until the process is reaped.
         try:
             while self.still_running:
                 proc = self.process
                 if proc is None:
                     break
-                data = proc.stdout.readline(self.program_buffer_size)
-                if not data and proc.poll() is not None:
+                data = getattr(proc, stream_name).readline(self.program_buffer_size)
+                if not data:
                     break
                 if isinstance(data, bytes):
                     data = data.decode(self.program_encoding, "replace")
-                if data:
-                    self.output_queue.put(data)
-        except (OSError, ValueError):
-            pass
+                target_queue.put(data)
+        except (OSError, ValueError) as error:
+            pybreeze_logger.debug("Reader for %s stopped: %s", stream_name, error)
+
+    def _read_stdout(self) -> None:
+        self._read_stream("stdout", self.output_queue)
 
     def _read_stderr(self) -> None:
-        try:
-            while self.still_running:
-                proc = self.process
-                if proc is None:
-                    break
-                data = proc.stderr.readline(self.program_buffer_size)
-                if not data and proc.poll() is not None:
-                    break
-                if isinstance(data, bytes):
-                    data = data.decode(self.program_encoding, "replace")
-                if data:
-                    self.error_queue.put(data)
-        except (OSError, ValueError):
-            pass
+        self._read_stream("stderr", self.error_queue)
 
     def _append_text(self, text: str, is_error: bool) -> None:
         """Append text to the code result widget."""

pybreeze-1.0.24/pybreeze/extend/process_executor/load_density/load_density_process.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pybreeze.extend.process_executor.process_executor_utils import (
+    build_process, run_dir_files_with_package,
+)
+
+if TYPE_CHECKING:
+    from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
+
+_PACKAGE = "je_load_density"
+
+
+def call_load_density(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, False, program_buffer)
+
+
+def call_load_density_with_send(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, True, program_buffer)
+
+
+def call_load_density_multi_file(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, False, program_buffer)
+
+
+def call_load_density_multi_file_and_send(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, True, program_buffer)

{pybreeze-1.0.22 → pybreeze-1.0.24}/pybreeze/extend/process_executor/process_executor_utils.py

@@ -10,6 +10,7 @@ from pybreeze.extend.mail_thunder_extend.mail_thunder_setting import send_after_
 from pybreeze.extend.process_executor.python_task_process_manager import TaskProcessManager
 from pybreeze.utils.exception.exception_tags import wrong_test_data_format_exception_tag
 from pybreeze.utils.exception.exceptions import ITETestExecutorException
+from pybreeze.utils.file_process.get_dir_file_list import ask_and_get_dir_files_as_list
 from pybreeze.utils.logging.logger import pybreeze_logger
 
 if TYPE_CHECKING:
@@ -31,7 +32,7 @@ def build_process(
             test_format_code = exec_str
         start_process(main_window, package, test_format_code, send_mail, program_buffer)
     except json.decoder.JSONDecodeError as error:
-        pybreeze_logger.error(f"{repr(error)}\n{wrong_test_data_format_exception_tag}")
+        pybreeze_logger.error(f"{error!r}\n{wrong_test_data_format_exception_tag}")
     except ITETestExecutorException as error:
         pybreeze_logger.error(repr(error))
 
@@ -70,6 +71,30 @@ def build_process_from_file(
         pybreeze_logger.error(repr(error))
 
 
+def run_dir_files_with_package(
+        main_window: PyBreezeMainWindow,
+        package: str,
+        send_mail: bool = False,
+        program_buffer: int = 1024000,
+) -> None:
+    """Prompt for a directory and run every matching file through *package*.
+
+    Each file is executed via its on-disk path (``--execute_file``) so large
+    action JSON never trips the Windows ~32K command-line limit, and one run
+    window is opened per file. ``build_process_from_file`` already logs and
+    contains per-file executor errors; the broad guard here only keeps a single
+    bad directory pick from crashing the menu callback.
+    """
+    try:
+        execute_list = ask_and_get_dir_files_as_list(main_window)
+        if not execute_list:
+            return
+        for execute_file in execute_list:
+            build_process_from_file(main_window, package, execute_file, send_mail, program_buffer)
+    except Exception as error:  # noqa: BLE001 — batch UI action must not abort on one bad entry
+        pybreeze_logger.error("%s multi file error: %r", package, error)
+
+
 def _build_task_process(
         main_window: PyBreezeMainWindow,
         send_mail: bool,

{pybreeze-1.0.22 → pybreeze-1.0.24}/pybreeze/extend/process_executor/python_task_process_manager.py

@@ -13,11 +13,13 @@ from threading import Thread
 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.exception.exceptions import JEditorExecException
 from je_editor.utils.venv_check.check_venv import check_and_choose_venv
 
 from pybreeze.extend.process_executor.queue_pump import pump_message_queue
 from pybreeze.pybreeze_ui.show_code_window.code_window import CodeWindow
 from pybreeze.utils.logging.logger import pybreeze_logger
+from pybreeze.utils.subprocess_util import no_window_creationflags, utf8_subprocess_env
 
 
 def find_venv_path() -> Path:
@@ -65,15 +67,26 @@ class TaskProcessManager:
         self.error_trigger_function: Callable = error_trigger_function
         self.program_buffer_size = program_buffer_size
 
-    def renew_path(self) -> None:
+    def renew_path(self) -> bool:
+        """Resolve the interpreter path. Returns False (without raising) when no
+        Python can be found, surfacing the error in the run window instead of
+        crashing the menu callback."""
         if self.main_window.python_compiler is None:
             venv_path = find_venv_path()
-            self.compiler_path = check_and_choose_venv(venv_path)
+            try:
+                self.compiler_path = check_and_choose_venv(venv_path)
+            except JEditorExecException as error:
+                pybreeze_logger.error("No Python interpreter found for run: %r", error)
+                self._append_text(f"[Error] No Python interpreter found: {error}", is_error=True)
+                self.main_window.show()
+                return False
         else:
             self.compiler_path = self.main_window.python_compiler
+        return True
 
     def start_test_process(self, package: str, exec_str: str):
-        self.renew_path()
+        if not self.renew_path():
+            return
         if sys.platform in ["win32", "cygwin", "msys"]:
             exec_str = json.dumps(exec_str)
         args = [
@@ -88,7 +101,8 @@ class TaskProcessManager:
     def start_test_process_file(self, package: str, file_path: str):
         # Pass the action JSON as a path so we never hit the Windows ~32K
         # command-line cap when scripts are large. Caller owns the file.
-        self.renew_path()
+        if not self.renew_path():
+            return
         args = [
             str(self.compiler_path),
             "-m",
@@ -106,6 +120,8 @@ class TaskProcessManager:
             args,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            creationflags=no_window_creationflags(),
+            env=utf8_subprocess_env(self.program_encoding),
         )
         self.still_run_program = True
         self.read_program_output_from_thread = Thread(
@@ -186,24 +202,31 @@ class TaskProcessManager:
             except queue.Empty:
                 break
 
-    def read_program_output_from_process(self):
+    def _read_stream_into_queue(self, stream_name: str, target_queue: Queue) -> None:
+        # Block on readline until a line arrives or the pipe hits EOF. Stopping on
+        # EOF (empty read) is essential: without it the loop spins at 100% CPU
+        # re-reading a closed pipe until the QTimer notices the process exited.
         while self.still_run_program:
             proc = self.process
             if proc is None:
                 break
-            program_output_data = proc.stdout.readline(self.program_buffer_size)
-            if isinstance(program_output_data, bytes):
-                program_output_data = program_output_data.decode(self.program_encoding, "replace")
-            if program_output_data.strip():
-                self.run_output_queue.put(program_output_data)
+            stream = getattr(proc, stream_name)
+            if stream is None:
+                break
+            try:
+                line = stream.readline(self.program_buffer_size)
+            except (ValueError, OSError):
+                # Pipe closed underneath us during shutdown.
+                break
+            if not line:
+                break
+            if isinstance(line, bytes):
+                line = line.decode(self.program_encoding, "replace")
+            if line.strip():
+                target_queue.put(line)
+
+    def read_program_output_from_process(self):
+        self._read_stream_into_queue("stdout", self.run_output_queue)
 
     def read_program_error_output_from_process(self):
-        while self.still_run_program:
-            proc = self.process
-            if proc is None:
-                break
-            program_error_output_data = proc.stderr.readline(self.program_buffer_size)
-            if isinstance(program_error_output_data, bytes):
-                program_error_output_data = program_error_output_data.decode(self.program_encoding, "replace")
-            if program_error_output_data.strip():
-                self.run_error_queue.put(program_error_output_data)
+        self._read_stream_into_queue("stderr", self.run_error_queue)

pybreeze-1.0.24/pybreeze/extend/process_executor/queue_pump.py

@@ -0,0 +1,40 @@
+"""Shared helper for the process-executor QTimer pump loop.
+
+The Python task runner and the Test Pioneer runner both drain the same
+``(output_queue, error_queue) → append_text`` pattern on a ~100 ms timer.
+This module factors the per-tick drain into a single function so changes
+(e.g., multi-message batching) can be made in one place.
+"""
+from __future__ import annotations
+
+import queue
+from collections.abc import Callable
+from queue import Queue
+
+# Drain up to this many messages per timer tick. Draining one line per ~100 ms
+# tick caps throughput at ~10 lines/s and makes chatty scripts crawl; batching
+# many lines per tick keeps up with bursty output while the bound keeps the UI
+# thread from stalling when a process floods stdout.
+MAX_MESSAGES_PER_PUMP = 256
+
+
+def pump_message_queue(
+    q: Queue,
+    append_fn: Callable[[str, bool], None],
+    *,
+    is_error: bool,
+    max_messages: int = MAX_MESSAGES_PER_PUMP,
+) -> None:
+    """Drain up to *max_messages* pending messages from *q* into *append_fn*.
+
+    Stops early when the queue empties. Empty strings (after stripping) are
+    skipped. ``queue.Empty`` from the racy non-blocking get is treated as a
+    clean stop, not an error.
+    """
+    for _ in range(max_messages):
+        try:
+            message = str(q.get_nowait()).strip()
+        except queue.Empty:
+            return
+        if message:
+            append_fn(message, is_error)

{pybreeze-1.0.22 → pybreeze-1.0.24}/pybreeze/extend/process_executor/test_pioneer/test_pioneer_process_manager.py

@@ -14,6 +14,7 @@ from je_editor.utils.venv_check.check_venv import check_and_choose_venv
 from pybreeze.extend.process_executor.python_task_process_manager import find_venv_path
 from pybreeze.extend.process_executor.queue_pump import pump_message_queue
 from pybreeze.pybreeze_ui.show_code_window.code_window import CodeWindow
+from pybreeze.utils.subprocess_util import no_window_creationflags, utf8_subprocess_env
 
 if TYPE_CHECKING:
     from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
@@ -61,6 +62,8 @@ class TestPioneerProcess:
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            creationflags=no_window_creationflags(),
+            env=utf8_subprocess_env(self._program_encoding),
         )
 
     def _append_text(self, text: str, is_error: bool = False) -> None:
@@ -119,27 +122,34 @@ class TestPioneerProcess:
             except queue.Empty:
                 break
 
-    def read_program_output_from_process(self):
+    def _read_stream_into_queue(self, stream_name: str, target_queue: Queue) -> None:
+        # Block on readline until a line arrives or the pipe hits EOF. Stopping on
+        # EOF (empty read) is essential: without it the loop spins at 100% CPU
+        # re-reading a closed pipe until the QTimer notices the process exited.
         while self._still_run_program:
             proc = self._process
             if proc is None:
                 break
-            program_output_data = proc.stdout.readline(self._program_buffer_size)
-            if isinstance(program_output_data, bytes):
-                program_output_data = program_output_data.decode(self._program_encoding, "replace")
-            if program_output_data.strip():
-                self._run_output_queue.put(program_output_data)
+            stream = getattr(proc, stream_name)
+            if stream is None:
+                break
+            try:
+                line = stream.readline(self._program_buffer_size)
+            except (ValueError, OSError):
+                # Pipe closed underneath us during shutdown.
+                break
+            if not line:
+                break
+            if isinstance(line, bytes):
+                line = line.decode(self._program_encoding, "replace")
+            if line.strip():
+                target_queue.put(line)
+
+    def read_program_output_from_process(self):
+        self._read_stream_into_queue("stdout", self._run_output_queue)
 
     def read_program_error_output_from_process(self):
-        while self._still_run_program:
-            proc = self._process
-            if proc is None:
-                break
-            program_error_output_data = proc.stderr.readline(self._program_buffer_size)
-            if isinstance(program_error_output_data, bytes):
-                program_error_output_data = program_error_output_data.decode(self._program_encoding, "replace")
-            if program_error_output_data.strip():
-                self._run_error_queue.put(program_error_output_data)
+        self._read_stream_into_queue("stderr", self._run_error_queue)
 
     def start_test_pioneer_process(self):
         self._still_run_program = True

pybreeze-1.0.24/pybreeze/extend/process_executor/web_runner/web_runner_process.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pybreeze.extend.process_executor.process_executor_utils import (
+    build_process, run_dir_files_with_package,
+)
+
+if TYPE_CHECKING:
+    from pybreeze.pybreeze_ui.editor_main.main_ui import PyBreezeMainWindow
+
+_PACKAGE = "je_web_runner"
+
+
+def call_web_runner_test(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, False, program_buffer)
+
+
+def call_web_runner_test_with_send(
+        main_window: PyBreezeMainWindow,
+        exec_str: str | None = None,
+        program_buffer: int = 1024000
+):
+    build_process(main_window, _PACKAGE, exec_str, True, program_buffer)
+
+
+def call_web_runner_test_multi_file(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, False, program_buffer)
+
+
+def call_web_runner_test_multi_file_and_send(
+        main_window: PyBreezeMainWindow,
+        program_buffer: int = 1024000
+):
+    run_dir_files_with_package(main_window, _PACKAGE, True, program_buffer)

{pybreeze-1.0.22 → pybreeze-1.0.24}/pybreeze/extend_multi_language/extend_traditional_chinese.py

@@ -125,7 +125,7 @@ pybreeze_traditional_chinese_word_dict = {
     "ssh_command_widget_status_label_disconnected": "已斷線",
     "ssh_command_widget_log_message_connected": "已連線至",
     "ssh_command_widget_log_message_error": "[錯誤]",
-    "ssh_command_widget_error_message_decode_failed": "<解碼錯誤> {error}",
+    "ssh_command_widget_error_message_decode_failed": "<解碼錯誤> ",
     "ssh_command_widget_log_message_channel_closed": "[通道已關閉]",
     "ssh_command_widget_error_message_reader_failed": "讀取錯誤",
     "ssh_command_widget_log_message_reader_closed": "讀取已關閉",