je-load-density-dev 0.0.76__tar.gz → 0.0.78__tar.gz

{je_load_density_dev-0.0.76 → je_load_density_dev-0.0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: je_load_density_dev
-Version: 0.0.76
+Version: 0.0.78
 Summary: Load & Stress Automation Freamework
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/LoadDensity
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: locust
 Provides-Extra: gui
-Requires-Dist: PySide6==6.9.2; extra == "gui"
+Requires-Dist: PySide6==6.10.0; extra == "gui"
 Requires-Dist: qt-material; extra == "gui"
 Dynamic: license-file
 

je_load_density_dev-0.0.78/je_load_density/gui/load_density_gui_thread.py

@@ -0,0 +1,59 @@
+from PySide6.QtCore import QThread
+from je_load_density.wrapper.start_wrapper.start_test import start_test
+
+# 定義常數，避免硬編碼字串
+# Define constant to avoid hard-coded string
+DEFAULT_USER_TYPE = "fast_http_user"
+
+
+class LoadDensityGUIThread(QThread):
+    """
+    GUI 測試執行緒
+    GUI Test Thread
+
+    用於在背景執行負載測試，避免阻塞主介面。
+    Used to run load tests in the background without blocking the main GUI.
+    """
+
+    def __init__(self,
+                 request_url: str = None,
+                 test_duration: int = None,
+                 user_count: int = None,
+                 spawn_rate: int = None,
+                 http_method: str = None):
+        """
+        初始化執行緒參數
+        Initialize thread parameters
+
+        :param request_url: 測試目標 URL (Target request URL)
+        :param test_duration: 測試持續時間 (Test duration in seconds)
+        :param user_count: 使用者數量 (Number of simulated users)
+        :param spawn_rate: 使用者生成速率 (User spawn rate)
+        :param http_method: HTTP 方法 (HTTP method, e.g., "GET", "POST")
+        """
+        super().__init__()
+        self.request_url = request_url
+        self.test_duration = test_duration
+        self.user_count = user_count
+        self.spawn_rate = spawn_rate
+        self.http_method = http_method
+
+    def run(self):
+        """
+        執行負載測試
+        Run the load test
+        """
+        if not self.request_url or not self.http_method:
+            # 基本檢查，避免傳入 None
+            # Basic validation to avoid None values
+            raise ValueError("Request URL and HTTP method must be provided.")
+
+        start_test(
+            {"user": DEFAULT_USER_TYPE},  # 使用者類型 (User type)
+            self.user_count,
+            self.spawn_rate,
+            self.test_duration,
+            tasks={
+                self.http_method: {"request_url": self.request_url}
+            }
+        )

je_load_density_dev-0.0.78/je_load_density/gui/log_to_ui_filter.py

@@ -0,0 +1,30 @@
+import logging
+import queue
+
+# 建立一個佇列，用來存放攔截到的日誌訊息
+# Create a queue to store intercepted log messages
+log_message_queue: queue.Queue[str] = queue.Queue()
+
+
+class InterceptAllFilter(logging.Filter):
+    """
+    攔截所有日誌訊息並存入佇列
+    Intercept all log messages and store them into a queue
+
+    此 Filter 可用於將 logging 模組的輸出導向 GUI 或其他處理流程。
+    This filter can be used to redirect logging outputs to a GUI or other processing pipelines.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """
+        攔截日誌紀錄並存入佇列
+        Intercept log record and put it into the queue
+
+        :param record: logging.LogRecord 物件 (Log record object)
+        :return: False → 阻止訊息繼續傳遞到其他 Handler
+                 False → Prevents the message from propagating to other handlers
+        """
+        # 只存放訊息文字，也可以改成存整個 record 以保留更多資訊
+        # Only store the message text; alternatively, store the whole record for more details
+        log_message_queue.put(record.getMessage())
+        return False

je_load_density_dev-0.0.78/je_load_density/gui/main_widget.py

@@ -0,0 +1,131 @@
+import logging
+import queue
+from typing import Optional
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QIntValidator
+from PySide6.QtWidgets import (
+    QWidget, QFormLayout, QLineEdit, QComboBox,
+    QPushButton, QTextEdit, QVBoxLayout, QLabel, QMessageBox
+)
+
+from je_load_density.gui.load_density_gui_thread import LoadDensityGUIThread
+from je_load_density.gui.language_wrapper.multi_language_wrapper import language_wrapper
+from je_load_density.gui.log_to_ui_filter import InterceptAllFilter, log_message_queue
+
+
+class LoadDensityWidget(QWidget):
+    """
+    負載測試 GUI 控制元件
+    Load Test GUI Widget
+
+    提供使用者輸入測試參數並啟動負載測試，
+    並將日誌訊息即時顯示在 GUI 中。
+    Provides input fields for test parameters, starts load tests,
+    and displays log messages in real-time.
+    """
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+
+        # === 表單區域 (Form Section) ===
+        form_layout = QFormLayout()
+
+        # URL 輸入框 (Target URL input)
+        self.url_input = QLineEdit()
+
+        # 測試時間 (Test duration, must be int)
+        self.test_time_input = QLineEdit()
+        self.test_time_input.setValidator(QIntValidator())
+
+        # 使用者數量 (User count)
+        self.user_count_input = QLineEdit()
+        self.user_count_input.setValidator(QIntValidator())
+
+        # 生成速率 (Spawn rate)
+        self.spawn_rate_input = QLineEdit()
+        self.spawn_rate_input.setValidator(QIntValidator())
+
+        # HTTP 方法選擇 (HTTP method selection)
+        self.method_combobox = QComboBox()
+        self.method_combobox.addItems([
+            language_wrapper.language_word_dict.get("get"),
+            language_wrapper.language_word_dict.get("post"),
+            language_wrapper.language_word_dict.get("put"),
+            language_wrapper.language_word_dict.get("patch"),
+            language_wrapper.language_word_dict.get("delete"),
+            language_wrapper.language_word_dict.get("head"),
+            language_wrapper.language_word_dict.get("options"),
+        ])
+
+        # 將元件加入表單 (Add widgets to form layout)
+        form_layout.addRow(language_wrapper.language_word_dict.get("url"), self.url_input)
+        form_layout.addRow(language_wrapper.language_word_dict.get("test_time"), self.test_time_input)
+        form_layout.addRow(language_wrapper.language_word_dict.get("user_count"), self.user_count_input)
+        form_layout.addRow(language_wrapper.language_word_dict.get("spawn_rate"), self.spawn_rate_input)
+        form_layout.addRow(language_wrapper.language_word_dict.get("test_method"), self.method_combobox)
+
+        # === 啟動按鈕 (Start button) ===
+        self.start_button = QPushButton(language_wrapper.language_word_dict.get("start_button"))
+        self.start_button.clicked.connect(self.run_load_density)
+
+        # === 日誌面板 (Log panel) ===
+        self.log_panel = QTextEdit()
+        self.log_panel.setReadOnly(True)
+
+        # === 主版面配置 (Main layout) ===
+        main_layout = QVBoxLayout()
+        main_layout.addLayout(form_layout)
+        main_layout.addWidget(self.start_button)
+        main_layout.addWidget(QLabel(language_wrapper.language_word_dict.get("log")))
+        main_layout.addWidget(self.log_panel)
+
+        # === 執行緒與計時器 (Thread & Timer) ===
+        self.run_load_density_thread: Optional[LoadDensityGUIThread] = None
+        self.pull_log_timer = QTimer()
+        self.pull_log_timer.setInterval(50)  # 稍微放大間隔，避免 UI 卡頓
+        self.pull_log_timer.timeout.connect(self.add_text_to_log)
+
+        self.setLayout(main_layout)
+
+    def run_load_density(self) -> None:
+        """
+        啟動負載測試
+        Start the load test
+        """
+        try:
+            test_time = int(self.test_time_input.text())
+            user_count = int(self.user_count_input.text())
+            spawn_rate = int(self.spawn_rate_input.text())
+        except ValueError:
+            QMessageBox.warning(self, "Invalid Input", "請輸入有效的數字\nPlease enter valid numbers")
+            return
+
+        self.run_load_density_thread = LoadDensityGUIThread()
+        self.run_load_density_thread.request_url = self.url_input.text()
+        self.run_load_density_thread.test_duration = test_time
+        self.run_load_density_thread.user_count = user_count
+        self.run_load_density_thread.spawn_rate = spawn_rate
+        self.run_load_density_thread.http_method = self.method_combobox.currentText().lower()
+
+        # 設定日誌攔截器 (Attach log filter)
+        root_logger = logging.getLogger("root")
+        log_handler_list = [handler for handler in root_logger.handlers if handler.name == "log_reader"]
+        if log_handler_list:
+            log_handler = log_handler_list[0]
+            # 避免重複新增 Filter (Prevent duplicate filters)
+            if not any(isinstance(f, InterceptAllFilter) for f in log_handler.filters):
+                log_handler.addFilter(InterceptAllFilter())
+
+        # 啟動執行緒與計時器 (Start thread & timer)
+        self.run_load_density_thread.start()
+        self.pull_log_timer.start()
+        self.log_panel.clear()
+
+    def add_text_to_log(self) -> None:
+        """
+        將日誌訊息加入到 GUI 面板
+        Append log messages to GUI panel
+        """
+        while not log_message_queue.empty():
+            self.log_panel.append(log_message_queue.get_nowait())

je_load_density_dev-0.0.78/je_load_density/gui/main_window.py

@@ -0,0 +1,49 @@
+import sys
+from typing import Optional
+
+from PySide6.QtWidgets import QMainWindow, QApplication, QWidget
+from qt_material import QtStyleTools
+
+from je_load_density.gui.language_wrapper.multi_language_wrapper import language_wrapper
+from je_load_density.gui.main_widget import LoadDensityWidget
+
+
+class LoadDensityUI(QMainWindow, QtStyleTools):
+    """
+    負載測試主視窗
+    Load Test Main Window
+
+    提供 GUI 介面，整合測試控制元件與樣式設定。
+    Provides the main GUI window, integrating the load test widget and applying styles.
+    """
+
+    def __init__(self, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+
+        # 應用程式名稱 (Application name)
+        self.id = language_wrapper.language_word_dict.get("application_name")
+
+        # 在 Windows 平台設定 AppUserModelID，讓工作列顯示正確的應用程式名稱
+        # Set AppUserModelID on Windows so the taskbar shows the correct application name
+        if sys.platform in ["win32", "cygwin", "msys"]:
+            from ctypes import windll
+            windll.shell32.SetCurrentProcessExplicitAppUserModelID(self.id)
+
+        # 設定字體樣式 (Set font style)
+        self.setStyleSheet(
+            "font-size: 12pt;"
+            "font-family: 'Lato';"
+        )
+
+        # 套用 qt-material 樣式 (Apply qt-material theme)
+        self.apply_stylesheet(self, "dark_amber.xml")
+
+        # 建立並設定主要控制元件 (Create and set main widget)
+        self.load_density_widget = LoadDensityWidget()
+        self.setCentralWidget(self.load_density_widget)
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = LoadDensityUI()
+    window.show()
+    sys.exit(app.exec())

je_load_density_dev-0.0.78/je_load_density/utils/callback/callback_function_executor.py

@@ -0,0 +1,99 @@
+import typing
+from sys import stderr
+
+from je_load_density.utils.exception.exception_tags import (
+    get_bad_trigger_function,
+    get_bad_trigger_method,
+)
+from je_load_density.utils.exception.exceptions import CallbackExecutorException
+from je_load_density.utils.generate_report.generate_html_report import (
+    generate_html,
+    generate_html_report,
+)
+from je_load_density.utils.generate_report.generate_json_report import (
+    generate_json,
+    generate_json_report,
+)
+from je_load_density.utils.generate_report.generate_xml_report import (
+    generate_xml,
+    generate_xml_report,
+)
+from je_load_density.wrapper.start_wrapper.start_test import start_test
+
+
+class CallbackFunctionExecutor:
+    """
+    回呼函式執行器
+    Callback Function Executor
+
+    提供事件觸發與回呼機制，先執行指定的 trigger function，
+    再執行 callback function。
+    Provides a mechanism to trigger a function from event_dict,
+    then execute a callback function.
+    """
+
+    def __init__(self) -> None:
+        # 事件字典，定義可觸發的函式
+        # Event dictionary, defines available trigger functions
+        self.event_dict: dict[str, typing.Callable] = {
+            "user_test": start_test,
+            "LD_generate_html": generate_html,
+            "LD_generate_html_report": generate_html_report,
+            "LD_generate_json": generate_json,
+            "LD_generate_json_report": generate_json_report,
+            "LD_generate_xml": generate_xml,
+            "LD_generate_xml_report": generate_xml_report,
+        }
+
+    def callback_function(
+        self,
+        trigger_function_name: str,
+        callback_function: typing.Callable,
+        callback_function_param: typing.Optional[typing.Union[dict, list]] = None,
+        callback_param_method: str = "kwargs",
+        **kwargs,
+    ) -> typing.Any:
+        """
+        執行事件函式並呼叫回呼函式
+        Execute trigger function and then call callback function
+
+        :param trigger_function_name: 事件函式名稱 (must exist in event_dict)
+        :param callback_function: 回呼函式 (callback function to execute)
+        :param callback_function_param: 回呼函式參數 (dict for kwargs, list for args)
+        :param callback_param_method: 參數傳遞方式 ("kwargs" or "args")
+        :param kwargs: 傳給事件函式的參數 (parameters for trigger function)
+        :return: 事件函式的回傳值 (return value of trigger function)
+        """
+        try:
+            # 檢查事件函式是否存在
+            # Validate trigger function existence
+            if trigger_function_name not in self.event_dict:
+                raise CallbackExecutorException(get_bad_trigger_function)
+
+            # 執行事件函式
+            # Execute trigger function
+            execute_return_value = self.event_dict[trigger_function_name](**kwargs)
+
+            # 執行回呼函式
+            # Execute callback function
+            if callback_function_param is not None:
+                if callback_param_method not in ["kwargs", "args"]:
+                    raise CallbackExecutorException(get_bad_trigger_method)
+                if callback_param_method == "kwargs":
+                    callback_function(**callback_function_param)
+                else:
+                    callback_function(*callback_function_param)
+            else:
+                callback_function()
+
+            return execute_return_value
+
+        except Exception as error:
+            # 目前只輸出錯誤，可以改成 logging 或 raise
+            # Currently prints error; can be replaced with logging or re-raise
+            print(repr(error), file=stderr)
+
+
+# 建立全域執行器實例
+# Create global executor instance
+callback_executor = CallbackFunctionExecutor()

je_load_density_dev-0.0.78/je_load_density/utils/executor/action_executor.py

@@ -0,0 +1,167 @@
+import builtins
+import sys
+import types
+from inspect import getmembers, isbuiltin
+from typing import Union, Any
+
+from je_load_density.utils.exception.exception_tags import (
+    executor_data_error,
+    add_command_exception_tag,
+    executor_list_error,
+)
+from je_load_density.utils.exception.exceptions import LoadDensityTestExecuteException
+from je_load_density.utils.generate_report.generate_html_report import (
+    generate_html,
+    generate_html_report,
+)
+from je_load_density.utils.generate_report.generate_json_report import (
+    generate_json,
+    generate_json_report,
+)
+from je_load_density.utils.generate_report.generate_xml_report import (
+    generate_xml,
+    generate_xml_report,
+)
+from je_load_density.utils.json.json_file.json_file import read_action_json
+from je_load_density.utils.package_manager.package_manager_class import package_manager
+from je_load_density.wrapper.start_wrapper.start_test import start_test
+
+
+class Executor:
+    """
+    執行器 (Executor)
+    Event-driven executor
+
+    提供事件字典 (event_dict)，可根據動作名稱執行對應函式，
+    並支援批次執行與檔案驅動。
+    Provides an event dictionary to execute functions by name,
+    supporting batch execution and file-driven execution.
+    """
+
+    def __init__(self) -> None:
+        # 初始化事件字典 (Initialize event dictionary)
+        self.event_dict: dict[str, Any] = {
+            "LD_start_test": start_test,
+            "LD_generate_html": generate_html,
+            "LD_generate_html_report": generate_html_report,
+            "LD_generate_json": generate_json,
+            "LD_generate_json_report": generate_json_report,
+            "LD_generate_xml": generate_xml,
+            "LD_generate_xml_report": generate_xml_report,
+            # Executor internal methods
+            "LD_execute_action": self.execute_action,
+            "LD_execute_files": self.execute_files,
+            "LD_add_package_to_executor": package_manager.add_package_to_executor,
+        }
+
+        # 將所有 Python 內建函式加入事件字典
+        # Add all Python built-in functions to event_dict
+        for name, func in getmembers(builtins, isbuiltin):
+            self.event_dict[name] = func
+
+    def _execute_event(self, action: list) -> Any:
+        """
+        執行單一事件
+        Execute a single event
+
+        :param action: 事件結構，例如 ["function_name", {"param": value}]
+        :return: 事件回傳值 (return value of executed event)
+        """
+        event = self.event_dict.get(action[0])
+        if event is None:
+            raise LoadDensityTestExecuteException(executor_data_error + " " + str(action))
+
+        if len(action) == 2:
+            if isinstance(action[1], dict):
+                return event(**action[1])
+            else:
+                return event(*action[1])
+        elif len(action) == 1:
+            return event()
+        else:
+            raise LoadDensityTestExecuteException(executor_data_error + " " + str(action))
+
+    def execute_action(self, action_list: Union[list, dict]) -> dict[str, Any]:
+        """
+        執行多個事件
+        Execute multiple actions
+
+        :param action_list: 事件列表，例如：
+            [
+                ["LD_start_test", {"param": value}],
+                ["LD_generate_json", {"param": value}]
+            ]
+        :return: 執行紀錄字典 (execution record dict)
+        """
+        if isinstance(action_list, dict):
+            action_list = action_list.get("load_density", None)
+            if action_list is None:
+                raise LoadDensityTestExecuteException(executor_list_error)
+
+        execute_record_dict: dict[str, Any] = {}
+
+        try:
+            if not isinstance(action_list, list) or len(action_list) == 0:
+                raise LoadDensityTestExecuteException(executor_list_error)
+        except Exception as error:
+            print(repr(error), file=sys.stderr)
+
+        for action in action_list:
+            try:
+                event_response = self._execute_event(action)
+                execute_record = f"execute: {action}"
+                execute_record_dict[execute_record] = event_response
+            except Exception as error:
+                print(repr(error), file=sys.stderr)
+                print(action, file=sys.stderr)
+                execute_record = f"execute: {action}"
+                execute_record_dict[execute_record] = repr(error)
+
+        # 輸出執行結果 (Print execution results)
+        for key, value in execute_record_dict.items():
+            print(key)
+            print(value)
+
+        return execute_record_dict
+
+    def execute_files(self, execute_files_list: list[str]) -> list[dict[str, Any]]:
+        """
+        執行檔案中的事件
+        Execute actions from files
+
+        :param execute_files_list: 檔案路徑列表 (list of file paths)
+        :return: 每個檔案的執行結果列表 (list of execution results per file)
+        """
+        execute_detail_list: list[dict[str, Any]] = []
+        for file in execute_files_list:
+            execute_detail_list.append(self.execute_action(read_action_json(file)))
+        return execute_detail_list
+
+
+# 建立全域執行器 (Global executor instance)
+executor = Executor()
+package_manager.executor = executor
+
+
+def add_command_to_executor(command_dict: dict[str, Any]) -> None:
+    """
+    新增自訂命令到執行器
+    Add custom commands to executor
+
+    :param command_dict: {command_name: function}
+    """
+    for command_name, command in command_dict.items():
+        if isinstance(command, (types.MethodType, types.FunctionType)):
+            executor.event_dict[command_name] = command
+        else:
+            raise LoadDensityTestExecuteException(add_command_exception_tag)
+
+
+def execute_action(action_list: list) -> dict[str, Any]:
+    """全域執行事件 (Global execute action)"""
+    return executor.execute_action(action_list)
+
+
+def execute_files(execute_files_list: list[str]) -> list[dict[str, Any]]:
+    """全域執行檔案事件 (Global execute files)"""
+    return executor.execute_files(execute_files_list)

je_load_density_dev-0.0.78/je_load_density/utils/file_process/create_project_structure.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from typing import Optional
+
+# 定義常數，避免硬編碼
+# Define constant to avoid hard-coded string
+TEMPLATE_DIR = "je_load_density/template"
+
+
+def _create_dir(dir_name: str) -> Optional[Path]:
+    """
+    建立專案目錄
+    Create project directory
+
+    :param dir_name: 要建立的目錄名稱 (Directory name to create)
+    :return: 成功建立或已存在的 Path 物件 (Path object if created/existed), None if failed
+    """
+    try:
+        path = Path(dir_name)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    except Exception as error:
+        # 錯誤處理：避免因權限或路徑問題導致程式崩潰
+        # Error handling: prevent crash due to permission or path issues
+        print(f"Failed to create directory {dir_name}: {error}")
+        return None
+
+
+def create_template_dir() -> Optional[Path]:
+    """
+    建立模板目錄
+    Create template directory
+
+    :return: Path 物件或 None (Path object or None)
+    """
+    return _create_dir(TEMPLATE_DIR)

je_load_density_dev-0.0.78/je_load_density/utils/file_process/get_dir_file_list.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from typing import List
+
+
+def get_dir_files_as_list(
+    dir_path: str = str(Path.cwd()),
+    default_search_file_extension: str = ".json"
+) -> List[str]:
+    """
+    取得指定目錄下所有符合副檔名的檔案清單
+    Get all files in a directory that end with the given extension
+
+    :param dir_path: 要搜尋的目錄路徑 (Directory path to search)
+    :param default_search_file_extension: 要搜尋的副檔名 (File extension to search, e.g. ".json")
+    :return: 檔案絕對路徑清單 (List of absolute file paths)
+    """
+    try:
+        path_obj = Path(dir_path)
+        if not path_obj.exists() or not path_obj.is_dir():
+            raise FileNotFoundError(f"Directory not found: {dir_path}")
+
+        return [
+            str(file.resolve())
+            for file in path_obj.rglob(f"*{default_search_file_extension.lower()}")
+        ]
+    except Exception as error:
+        print(f"Error while scanning directory {dir_path}: {error}")
+        return []