je-editor 0.0.222__py3-none-any.whl → 0.0.224__py3-none-any.whl

je_editor/pyside_ui/main_ui/menu/python_env_menu/build_venv_menu.py

@@ -1,70 +1,94 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入顏色設定，用於輸出訊息時的字體顏色
+# Import color settings for console/text output
 from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
 
+# 匯入編輯器元件
+# Import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+
+# 匯入使用者設定字典，用來保存 Python 解譯器與環境設定
+# Import user settings dictionary for saving Python interpreter and environment settings
 from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
+
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
 import os
 from pathlib import Path
 
+# 匯入 Qt 動作、快捷鍵、文字格式、訊息框、輸入框、檔案對話框
+# Import QAction, QKeySequence, QTextCharFormat, QMessageBox, QInputDialog, QFileDialog
 from PySide6.QtGui import QAction, QKeySequence, QTextCharFormat
 from PySide6.QtWidgets import QMessageBox, QInputDialog, QFileDialog
 
+# 匯入 ShellManager，用於執行系統命令 (建立 venv、pip install 等)
+# Import ShellManager for executing shell commands (create venv, pip install, etc.)
 from je_editor.pyside_ui.code.shell_process.shell_exec import ShellManager
 
+# 匯入多語言包裝器，用於 UI 多語言顯示
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Python 環境選單 (venv menu)
+# Set up the Python Environment (venv) menu
 def set_venv_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py set_venv_menu ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.venv_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("python_env_menu_label"))
-    # Create an venv
+
+    # 建立虛擬環境 (Ctrl+Shift+V)
+    # Create virtual environment
     ui_we_want_to_set.venv_menu.change_language_menu = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_create_venv_label"))
-    ui_we_want_to_set.venv_menu.change_language_menu.setShortcut(
-        QKeySequence("Ctrl+Shift+V")
-    )
+    ui_we_want_to_set.venv_menu.change_language_menu.setShortcut(QKeySequence("Ctrl+Shift+V"))
     ui_we_want_to_set.venv_menu.change_language_menu.triggered.connect(
-        lambda: create_venv(ui_we_want_to_set)
-    )
+        lambda: create_venv(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.change_language_menu)
+
+    # pip 升級套件 (Ctrl+Shift+U)
     # pip upgrade package
     ui_we_want_to_set.venv_menu.pip_upgrade_action = QAction(
-        language_wrapper.language_word_dict.get("python_env_menu_pip_upgrade_label")
-    )
-    ui_we_want_to_set.venv_menu.pip_upgrade_action.setShortcut(
-        QKeySequence("Ctrl+Shift+U")
-    )
+        language_wrapper.language_word_dict.get("python_env_menu_pip_upgrade_label"))
+    ui_we_want_to_set.venv_menu.pip_upgrade_action.setShortcut(QKeySequence("Ctrl+Shift+U"))
     ui_we_want_to_set.venv_menu.pip_upgrade_action.triggered.connect(
-        lambda: pip_install_package_update(ui_we_want_to_set)
-    )
+        lambda: pip_install_package_update(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.pip_upgrade_action)
-    # pip package
+
+    # pip 安裝套件 (Ctrl+Shift+P)
+    # pip install package
     ui_we_want_to_set.venv_menu.pip_action = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_pip_label"))
-    ui_we_want_to_set.venv_menu.pip_action.setShortcut(
-        QKeySequence("Ctrl+Shift+P")
-    )
+    ui_we_want_to_set.venv_menu.pip_action.setShortcut(QKeySequence("Ctrl+Shift+P"))
     ui_we_want_to_set.venv_menu.pip_action.triggered.connect(
-        lambda: pip_install_package(ui_we_want_to_set)
-    )
+        lambda: pip_install_package(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.pip_action)
-    # choose python interpreter
+
+    # 選擇 Python 解譯器
+    # Choose Python interpreter
     ui_we_want_to_set.venv_menu.choose_interpreter_action = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_choose_interpreter_label"))
     ui_we_want_to_set.venv_menu.choose_interpreter_action.triggered.connect(
-        lambda: chose_python_interpreter(ui_we_want_to_set)
-    )
+        lambda: chose_python_interpreter(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.choose_interpreter_action)
 
 
+# 建立虛擬環境
+# Create virtual environment
 def create_venv(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py create_venv ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
@@ -72,25 +96,31 @@ def create_venv(ui_we_want_to_set: EditorMain) -> None:
         widget.python_compiler = ui_we_want_to_set.python_compiler
         venv_path = Path(os.getcwd() + "/venv")
         if not venv_path.exists():
+            # 使用 ShellManager 執行 python -m venv venv
+            # Use ShellManager to run python -m venv venv
             create_venv_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
                                              shell_encoding=ui_we_want_to_set.encoding)
             create_venv_shell.later_init()
-            create_venv_shell.exec_shell(
-                [f"{create_venv_shell.compiler_path}", "-m", "venv", "venv"]
-            )
-            text_cursor =  widget.code_result.textCursor()
+            create_venv_shell.exec_shell([f"{create_venv_shell.compiler_path}", "-m", "venv", "venv"])
+
+            # 在編輯器輸出區顯示訊息
+            # Show message in editor output area
+            text_cursor = widget.code_result.textCursor()
             text_format = QTextCharFormat()
             text_format.setForeground(actually_color_dict.get("normal_output_color"))
-            text_cursor.insertText(
-                language_wrapper.language_word_dict.get("python_env_menu_creating_venv_message"), text_format)
+            text_cursor.insertText(language_wrapper.language_word_dict.get("python_env_menu_creating_venv_message"),
+                                   text_format)
             text_cursor.insertBlock()
         else:
+            # 如果 venv 已存在，顯示提示訊息
+            # If venv exists, show message
             message_box = QMessageBox()
-            message_box.setText(
-                language_wrapper.language_word_dict.get("python_env_menu_venv_exists"))
+            message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_venv_exists"))
             message_box.exec()
 
 
+# 使用 pip 安裝套件 (通用函式)
+# Run pip install command (general function)
 def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: list):
     jeditor_logger.info("build_venv_menu.py create_venv "
                         f"ui_we_want_to_set: {ui_we_want_to_set} "
@@ -100,10 +130,14 @@ def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: l
         widget.python_compiler = ui_we_want_to_set.python_compiler
         venv_path = Path(os.getcwd() + "/venv")
         if not venv_path.exists():
+            # 如果 venv 不存在，提醒使用者先建立
+            # If venv does not exist, remind user to create it first
             message_box = QMessageBox()
             message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_please_create_venv"))
             message_box.exec()
         else:
+            # 彈出輸入框，讓使用者輸入套件名稱
+            # Ask user to input package name
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -113,11 +147,11 @@ def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: l
             if press_ok:
                 pip_install_shell = ShellManager(main_window=widget, shell_encoding=ui_we_want_to_set.encoding)
                 pip_install_shell.later_init()
-                pip_install_shell.exec_shell(
-                    pip_install_command_list
-                )
+                pip_install_shell.exec_shell(pip_install_command_list)
 
 
+# 偵測 venv 是否存在
+# Detect if venv exists
 def detect_venv() -> bool:
     jeditor_logger.info("build_venv_menu.py detect_venv")
     venv_path = Path(os.getcwd() + "/venv")
@@ -126,15 +160,17 @@ def detect_venv() -> bool:
         message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_please_create_venv"))
         message_box.exec()
         return False
-    return True
-
 
+# pip 安裝或更新套件
+# pip install or update package
 def pip_install_package_update(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py pip_install_package_update ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.python_compiler = ui_we_want_to_set.python_compiler
-        if detect_venv:
+        if detect_venv():
+            # 彈出輸入框，讓使用者輸入要安裝或更新的套件名稱
+            # Ask user to input package name to install or update
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -142,20 +178,31 @@ def pip_install_package_update(ui_we_want_to_set: EditorMain) -> None:
                 language_wrapper.language_word_dict.get("python_env_menu_install_or_update_package_messagebox_label")
             )
             if press_ok:
-                pip_install_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
-                                                 shell_encoding=ui_we_want_to_set.encoding)
+                # 使用 ShellManager 執行 pip install -U
+                # Use ShellManager to run pip install -U
+                pip_install_shell = ShellManager(
+                    main_window=widget,
+                    after_done_function=widget.code_edit.check_env,
+                    shell_encoding=ui_we_want_to_set.encoding
+                )
                 pip_install_shell.later_init()
                 pip_install_shell.exec_shell(
                     [f"{pip_install_shell.compiler_path}", "-m", "pip", "install", f"{package_text}", "-U"]
                 )
 
 
+# pip 安裝套件 (不加 -U)
+# pip install package (without -U)
 def pip_install_package(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py pip_install_package ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.python_compiler = ui_we_want_to_set.python_compiler
-        if detect_venv:
+        # ⚠️ 同樣需要加上 () 呼叫 detect_venv
+        # ⚠️ Same here: should be detect_venv()
+        if detect_venv():
+            # 彈出輸入框，讓使用者輸入要安裝的套件名稱
+            # Ask user to input package name
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -163,14 +210,21 @@ def pip_install_package(ui_we_want_to_set: EditorMain) -> None:
                 language_wrapper.language_word_dict.get("python_env_menu_install_package_messagebox_label")
             )
             if press_ok:
-                pip_install_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
-                                                 shell_encoding=ui_we_want_to_set.encoding)
+                # 使用 ShellManager 執行 pip install
+                # Use ShellManager to run pip install
+                pip_install_shell = ShellManager(
+                    main_window=widget,
+                    after_done_function=widget.code_edit.check_env,
+                    shell_encoding=ui_we_want_to_set.encoding
+                )
                 pip_install_shell.later_init()
                 pip_install_shell.exec_shell(
                     [f"{pip_install_shell.compiler_path}", "-m", "pip", "install", f"{package_text}"]
                 )
 
 
+# 選擇 Python 解譯器
+# Choose Python interpreter
 def chose_python_interpreter(ui_we_want_to_set: EditorMain):
     jeditor_logger.info(f"build_venv_menu.py chose_python_interpreter ui_we_want_to_set: {ui_we_want_to_set}")
     file_path = QFileDialog().getOpenFileName(
@@ -178,5 +232,9 @@ def chose_python_interpreter(ui_we_want_to_set: EditorMain):
         dir=str(Path.cwd())
     )[0]
     if file_path is not None and file_path != "":
+        # 更新主程式的 Python 解譯器路徑
+        # Update main editor's Python interpreter path
         ui_we_want_to_set.python_compiler = file_path
-        user_setting_dict.update({"python_compiler": file_path})
+        # 同時更新使用者設定，讓下次啟動時能記住
+        # Update user settings so it persists across sessions
+        user_setting_dict.update({"python_compiler": file_path})

je_editor/pyside_ui/main_ui/menu/run_menu/build_run_menu.py

@@ -2,61 +2,98 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+# 匯入 Qt 訊息框
+# Import QMessageBox for showing dialogs
 from PySide6.QtWidgets import QMessageBox
 
+# 匯入執行中程序管理器，用於統一管理所有程式/除錯器/Shell 執行實例
+# Import run_instance_manager for managing all running processes
 from je_editor.pyside_ui.code.running_process_manager import run_instance_manager
+
+# 匯入編輯器元件
+# Import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+
+# 匯入子選單建構函式 (Program / Debug / Shell)
+# Import submenu builders (Program / Debug / Shell)
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_debug_menu import set_debug_menu
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_program_menu import set_program_menu
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_shell_menu import set_shell_menu
+
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
+# 匯入 Qt 動作
+# Import QAction
 from PySide6.QtGui import QAction
 
+# 匯入多語言包裝器
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Run 選單
+# Set up the Run menu
 def set_run_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py set_run_menu ui_we_want_to_set: {ui_we_want_to_set}")
+    # 建立 Run 選單
+    # Create Run menu
     ui_we_want_to_set.run_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("run_menu_label"))
+
+    # 加入子選單：Program / Shell / Debug
+    # Add submenus: Program / Shell / Debug
     set_program_menu(ui_we_want_to_set)
     set_shell_menu(ui_we_want_to_set)
     set_debug_menu(ui_we_want_to_set)
-    # Clean result
+
+    # 清除結果
+    # Clear execution result
     ui_we_want_to_set.run_menu.clean_result_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_clear_result_label"))
     ui_we_want_to_set.run_menu.clean_result_action.triggered.connect(
         lambda: clean_result(ui_we_want_to_set)
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.clean_result_action)
-    # Close program
+
+    # 停止目前程式
+    # Stop current program
     ui_we_want_to_set.run_menu.stop_program_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_stop_program_label"))
     ui_we_want_to_set.run_menu.stop_program_action.triggered.connect(
         lambda: stop_program(ui_we_want_to_set)
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.stop_program_action)
-    # Close all program
+
+    # 停止所有程式
+    # Stop all programs
     ui_we_want_to_set.run_menu.stop_all_program_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_stop_all_program_label"))
     ui_we_want_to_set.run_menu.stop_all_program_action.triggered.connect(
         stop_all_program
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.stop_all_program_action)
-    # Run help menu
+
+    # Run 說明子選單
+    # Run Help submenu
     ui_we_want_to_set.run_menu.run_help_menu = ui_we_want_to_set.run_menu.addMenu(
         language_wrapper.language_word_dict.get("run_menu_run_help_label"))
-    # Run help action
+
+    # Run 說明動作
+    # Run Help action
     ui_we_want_to_set.run_menu.run_help_menu.run_help_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_run_help_label"))
     ui_we_want_to_set.run_menu.run_help_menu.run_help_action.triggered.connect(
         show_run_help
     )
     ui_we_want_to_set.run_menu.run_help_menu.addAction(ui_we_want_to_set.run_menu.run_help_menu.run_help_action)
-    # Shell help action
+
+    # Shell 說明動作
+    # Shell Help action
     ui_we_want_to_set.run_menu.run_help_menu.shell_help_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_shell_help_label"))
     ui_we_want_to_set.run_menu.run_help_menu.shell_help_action.triggered.connect(
@@ -65,29 +102,38 @@ def set_run_menu(ui_we_want_to_set: EditorMain) -> None:
     ui_we_want_to_set.run_menu.run_help_menu.addAction(ui_we_want_to_set.run_menu.run_help_menu.shell_help_action)
 
 
+# 停止目前分頁的程式 / Shell / 除錯器
+# Stop current tab's program / shell / debugger
 def stop_program(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py stop_program ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
+        # 停止程式
         if widget.exec_program is not None:
             if widget.exec_program.process is not None:
                 widget.exec_program.process.terminate()
             widget.exec_program = None
+        # 停止 Shell
         if widget.exec_shell is not None:
             if widget.exec_shell.process is not None:
                 widget.exec_shell.process.terminate()
             widget.exec_shell = None
+        # 停止除錯器
         if widget.exec_python_debugger is not None:
             if widget.exec_python_debugger.process is not None:
                 widget.exec_python_debugger.process.terminate()
             widget.exec_python_debugger = None
 
 
+# 停止所有執行中的程式
+# Stop all running programs
 def stop_all_program() -> None:
     jeditor_logger.info("build_run_menu.py stop_all_program")
     run_instance_manager.close_all_instance()
 
 
+# 清除目前分頁的輸出結果
+# Clear current tab's output result
 def clean_result(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py clean_result ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
@@ -95,6 +141,8 @@ def clean_result(ui_we_want_to_set: EditorMain) -> None:
         widget.code_result.setPlainText("")
 
 
+# 顯示 Run 說明
+# Show Run help
 def show_run_help() -> None:
     jeditor_logger.info("build_run_menu.py show_run_help")
     message_box = QMessageBox()
@@ -104,10 +152,12 @@ def show_run_help() -> None:
     message_box.exec()
 
 
+# 顯示 Shell 說明
+# Show Shell help
 def show_shell_help() -> None:
     jeditor_logger.info("build_run_menu.py show_shell_help")
     message_box = QMessageBox()
     message_box.setText(
         language_wrapper.language_word_dict.get("run_menu_shell_run_tip")
     )
-    message_box.exec()
+    message_box.exec()

je_editor/pyside_ui/main_ui/menu/run_menu/under_run_menu/build_debug_menu.py

@@ -1,34 +1,66 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入編輯器元件與輸入處理
+# Import EditorWidget and ProcessInput
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.process_input import ProcessInput
+
+# 匯入工具函式：顯示「請先關閉目前執行中的程式」訊息框
+# Import utility: show message box if a program is already running
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.utils import please_close_current_running_messagebox
+
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
+# 匯入 Qt 動作
+# Import QAction
 from PySide6.QtGui import QAction
 
+# 匯入程式執行管理器 (ExecManager)
+# Import ExecManager for running/debugging code
 from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
+
+# 匯入檔案儲存對話框
+# Import file save dialog
 from je_editor.pyside_ui.dialog.file_dialog.save_file_dialog import choose_file_get_save_file_path
+
+# 匯入多語言包裝器
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Debug 選單
+# Set up the Debug menu
 def set_debug_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py set_debug_menu ui_we_want_to_set: {ui_we_want_to_set}")
-    # Debug menu inside run menu
+    # 在 Run 選單下建立 Debug 子選單
+    # Create Debug submenu under Run menu
     ui_we_want_to_set.debug_menu = ui_we_want_to_set.run_menu.addMenu(
         language_wrapper.language_word_dict.get("editor_debugger_input_title_label"))
-    # Run debugger
+
+    # 建立「執行除錯器」動作
+    # Add "Run Debugger" action
     ui_we_want_to_set.debug_menu.run_debugger_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_run_debugger"))
     ui_we_want_to_set.debug_menu.run_debugger_action.triggered.connect(
         lambda: run_debugger(ui_we_want_to_set)
     )
     ui_we_want_to_set.debug_menu.addAction(ui_we_want_to_set.debug_menu.run_debugger_action)
-    # Show debugger input
+
+    # 建立「顯示除錯輸入」動作
+    # Add "Show Debugger Input" action
     ui_we_want_to_set.debug_menu.show_shell_input = QAction(
         language_wrapper.language_word_dict.get("show_debugger_input"))
     ui_we_want_to_set.debug_menu.show_shell_input.triggered.connect(
@@ -37,29 +69,43 @@ def set_debug_menu(ui_we_want_to_set: EditorMain) -> None:
     ui_we_want_to_set.debug_menu.addAction(ui_we_want_to_set.debug_menu.show_shell_input)
 
 
+# 執行除錯器 (pdb)
+# Run debugger (pdb)
 def run_debugger(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py run_debugger ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
+        # 確保沒有正在執行的除錯器
+        # Ensure no debugger is already running
         if widget.exec_python_debugger is None:
             widget.python_compiler = ui_we_want_to_set.python_compiler
+            # 要求使用者選擇儲存檔案路徑
+            # Ask user to choose save file path
             if choose_file_get_save_file_path(ui_we_want_to_set):
+                # 建立程式執行管理器，並以 pdb 模式執行
+                # Create ExecManager and run with pdb
                 code_exec = ExecManager(widget, program_encoding=ui_we_want_to_set.encoding)
                 code_exec.later_init()
                 code_exec.code_result = widget.debugger_result
                 code_exec.exec_code(
                     widget.current_file, exec_prefix=["-m", "pdb"]
                 )
+                # 綁定除錯器與輸入介面
+                # Bind debugger and input interface
                 widget.exec_python_debugger = code_exec
                 widget.debugger_input = ProcessInput(widget)
                 widget.debugger_input.show()
         else:
+            # 如果已有程式在執行，顯示提示訊息
+            # If a program is already running, show message
             please_close_current_running_messagebox(ui_we_want_to_set)
 
 
+# 顯示除錯輸入介面
+# Show debugger input interface
 def show_debugger_input(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py show_debugger_input ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.debugger_input = ProcessInput(widget, "debugger")
-        widget.debugger_input.show()
+        widget.debugger_input.show()

je_editor/pyside_ui/main_ui/menu/run_menu/under_run_menu/build_program_menu.py

@@ -1,33 +1,69 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入 Qt 動作
+# Import QAction
 from PySide6.QtGui import QAction
 
+# 匯入程式執行管理器 (ExecManager)
+# Import ExecManager for running code
 from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
+
+# 匯入檔案儲存對話框
+# Import file save dialog
 from je_editor.pyside_ui.dialog.file_dialog.save_file_dialog import choose_file_get_save_file_path
+
+# 匯入編輯器元件
+# Import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+
+# 匯入輸入處理 (用於程式輸入)
+# Import ProcessInput for handling program input
 from je_editor.pyside_ui.main_ui.editor.process_input import ProcessInput
+
+# 匯入工具函式：顯示「請先關閉目前執行中的程式」訊息框
+# Import utility: show message box if a program is already running
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.utils import please_close_current_running_messagebox
+
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
+
+# 匯入多語言包裝器
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
 
 
+# 設定「執行程式」選單
+# Set up the "Run Program" menu
 def set_program_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_program_menu.py set_program_menu ui_we_want_to_set: {ui_we_want_to_set}")
+    # 在 Run 選單下建立 Program 子選單
+    # Create Program submenu under Run menu
     ui_we_want_to_set.run_program_menu = ui_we_want_to_set.run_menu.addMenu(
         language_wrapper.language_word_dict.get("run_menu_run_program_label"))
-    # Run program
+
+    # 建立「執行程式」動作
+    # Add "Run Program" action
     ui_we_want_to_set.run_program_menu.run_program_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_run_program_label"))
     ui_we_want_to_set.run_program_menu.run_program_action.triggered.connect(
         lambda: run_program(ui_we_want_to_set)
     )
     ui_we_want_to_set.run_program_menu.addAction(ui_we_want_to_set.run_program_menu.run_program_action)
-    # Show shell input
+
+    # 建立「顯示程式輸入」動作
+    # Add "Show Program Input" action
     ui_we_want_to_set.run_program_menu.show_shell_input = QAction(
         language_wrapper.language_word_dict.get("show_program_input"))
     ui_we_want_to_set.run_program_menu.show_shell_input.triggered.connect(
@@ -36,26 +72,36 @@ def set_program_menu(ui_we_want_to_set: EditorMain) -> None:
     ui_we_want_to_set.run_program_menu.addAction(ui_we_want_to_set.run_program_menu.show_shell_input)
 
 
+# 執行程式
+# Run program
 def run_program(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_program_menu.py run_program ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
+        # 確保沒有正在執行的程式
+        # Ensure no program is already running
         if widget.exec_program is None:
             widget.python_compiler = ui_we_want_to_set.python_compiler
+            # 要求使用者選擇儲存檔案路徑
+            # Ask user to choose save file path
             if choose_file_get_save_file_path(ui_we_want_to_set):
+                # 建立程式執行管理器並執行程式
+                # Create ExecManager and run program
                 code_exec = ExecManager(widget, program_encoding=ui_we_want_to_set.encoding)
                 code_exec.later_init()
-                code_exec.exec_code(
-                    widget.current_file
-                )
+                code_exec.exec_code(widget.current_file)
                 widget.exec_program = code_exec
         else:
+            # 如果已有程式在執行，顯示提示訊息
+            # If a program is already running, show message
             please_close_current_running_messagebox(ui_we_want_to_set)
 
 
+# 顯示程式輸入介面
+# Show program input interface
 def show_program_input(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_program_menu.py show_program_input ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.program_input = ProcessInput(widget, "program")
-        widget.program_input.show()
+        widget.program_input.show()