Merge pull request #1 from muziing/subprocess_dialog

muziing · web-flow · commit c0ecea0a71bd · 2022-09-19T10:13:48.000+08:00
Subprocess Dialog
diff --git a/src/py2exe_gui/Core/packaging.py b/src/py2exe_gui/Core/packaging.py
@@ -3,7 +3,7 @@
 from PySide6 import QtCore
 from PySide6.QtCore import QObject
 
-from .subprocess_tool import QSubProcessTool
+from .subprocess_tool import SubProcessTool
 
 
 class Packaging(QObject):
@@ -23,9 +23,9 @@ def __init__(self, parent: Optional[QObject] = None):
         ]
         self.args_dict: dict = dict.fromkeys(pyinstaller_args, "")
         self._args: List[str] = []
-        self.subprocess: Optional[QSubProcessTool] = None
+        self.subprocess: SubProcessTool = SubProcessTool(self, program="pyinstaller")
 
-    def get_pyinstaller_args(self, arg: tuple[str, str]) -> None:
+    def set_pyinstaller_args(self, arg: tuple[str, str]) -> None:
         """
         解析传递来的PyInstaller运行参数，并添加至命令参数字典 \n
         :param arg: 运行参数
@@ -34,9 +34,9 @@ def get_pyinstaller_args(self, arg: tuple[str, str]) -> None:
         arg_key, arg_value = arg
         if arg_key in self.args_dict.keys():
             self.args_dict[arg_key] = arg_value
-        self.set_pyinstaller_args()
+        self._add_pyinstaller_args()
 
-    def set_pyinstaller_args(self) -> None:
+    def _add_pyinstaller_args(self) -> None:
         """
         将命令参数字典中的参数按顺序添加到命令参数列表中 \n
         :return: None
@@ -67,7 +67,6 @@ def run_packaging_process(self) -> None:
         :return: None
         """
 
-        if self.subprocess is None:  # 确保只在首次调用时实例化一个QSubProcess对象
-            self.subprocess = QSubProcessTool()
-        self.subprocess.output.connect(lambda val: print(val))  # 测试用
-        self.subprocess.start_process("pyinstaller", self._args)
+        # self._subprocess.output.connect(lambda val: print(val))  # 测试用
+        self.subprocess.set_arguments(self._args)
+        self.subprocess.start_process()
diff --git a/src/py2exe_gui/Core/subprocess_tool.py b/src/py2exe_gui/Core/subprocess_tool.py
@@ -1,69 +1,140 @@
+import os.path
 from sys import getdefaultencoding
 from typing import Optional, Sequence
 
 from PySide6 import QtCore
 
 
-class QSubProcessTool(QtCore.QObject):
-    """辅助使用QProcess创建并管理子进程的工具类"""
+class SubProcessTool(QtCore.QObject):
+    """辅助QProcess使用的工具类，将所有直接对子进程进行的操作都封装在此类中"""
 
-    # 自定义信号，参数为 (output_type: QSubProcessTool.output_type, output_text: str)
+    # 自定义信号，参数为 tuple[output_type: SubProcessTool.output_type, output_text: str]
     output = QtCore.Signal(tuple)
 
     # output_types
-    STATE = 0
-    FINISHED = 1
+    STATE = 1
     STDOUT = 2
     STDERR = 3
+    FINISHED = 4
+
+    def __init__(
+        self,
+        parent: Optional[QtCore.QObject] = None,
+        *,
+        program: str = "",
+        arguments: Sequence[str] = (),
+        working_directory: str = "./",
+    ) -> None:
+        """
+        :param parent: 父对象
+        :param program: 待运行的子进程
+        :param arguments: 运行参数
+        :param working_directory: 子进程工作目录
+        :return: None
+        """
+
+        super(SubProcessTool, self).__init__(parent)
+
+        self.program: str = program
+        self._arguments: Sequence[str] = arguments
+        self._working_directory: str = working_directory
+        self._process: Optional[QtCore.QProcess] = None
+        self.exit_code: int = 0
+        self.exit_status: QtCore.QProcess.ExitStatus = QtCore.QProcess.NormalExit
+
+    def start_process(
+        self,
+        *,
+        mode: QtCore.QIODeviceBase.OpenMode = QtCore.QIODeviceBase.OpenModeFlag.ReadWrite,  # type: ignore
+    ) -> None:
+        """
+        创建并启动子进程 \n
+        :param mode: 设备打开的模式
+        :return: None
+        """
+
+        if self._process is None:  # 防止在子进程运行结束前重复启动
+            self._process = QtCore.QProcess(self)
+
+            self._process.stateChanged.connect(self._handle_state)  # type: ignore
+            self._process.readyReadStandardOutput.connect(self._handle_stdout)  # type: ignore
+            self._process.readyReadStandardError.connect(self._handle_stderr)  # type: ignore
+            self._process.started.connect(self._process_started)  # type: ignore
+            self._process.finished.connect(self._process_finished)  # type: ignore
+            self._process.errorOccurred.connect(self._handle_error)  # type: ignore
+
+            self._process.setWorkingDirectory(self._working_directory)
+            self._process.start(self.program, self._arguments, mode)
+            self._process.waitForStarted(1000)  # 阻塞，直到启动了子进程或超时（单位为毫秒）
 
-    def __init__(self, parent: Optional[QtCore.QObject] = None) -> None:
-        super(QSubProcessTool, self).__init__(parent)
-        self.process: Optional[QtCore.QProcess] = None
+    def abort_process(self, timeout: int = 10000) -> bool:
+        """
+        终止子进程 \n
+        :param timeout: 超时时间，单位为毫秒
+        :return: 子进程是否完成
+        """
+
+        if self._process:
+            self._process.terminate()
+            finished = self._process.waitForFinished(timeout)  # 阻塞，直到进程终止或超时
+            if not finished:
+                self._process.kill()  # 超时后杀死子进程
+            return finished
+        else:
+            return True
 
-    def start_process(self, program: str, arguments: Sequence[str]) -> None:
+    def set_arguments(self, arguments: Sequence[str]) -> None:
         """
-        使用给定参数启动指定子进程 \n
-        :param program: 子进程命令
-        :param arguments: 子进程参数
+        设置子进程参数 \n
+        :param arguments: 参数列表
         :return: None
         """
 
-        if self.process is None:  # 防止在子进程运行结束前重复启动
-            self.process = QtCore.QProcess()
+        self._arguments = arguments
 
-            self.process.stateChanged.connect(self._handle_state)  # type: ignore
-            self.process.readyReadStandardOutput.connect(self._handle_stdout)  # type: ignore
-            self.process.readyReadStandardError.connect(self._handle_stderr)  # type: ignore
-            self.process.started.connect(self._process_started)  # type: ignore
-            self.process.finished.connect(self._process_finished)  # type: ignore
+    def set_working_dir(self, work_dir: str) -> bool:
+        """
+        设置子进程工作目录 \n
+        :param work_dir: 工作目录
+        :return: 是否设置成功
+        """
 
-            self.process.start(program, arguments)
+        if os.path.isdir(work_dir):
+            self._working_directory = work_dir
+            return True
+        else:
+            return False
 
     def _process_started(self) -> None:
         """
-        处理子进程的槽 \n
+        处理子进程开始的槽 \n
         :return: None
         """
+
         pass
 
-    def _process_finished(self) -> None:
+    def _process_finished(self, code: int, status: QtCore.QProcess.ExitStatus) -> None:
         """
-        处理子进程的槽 \n
+        处理子进程结束的槽 \n
+        :param code: 退出码
+        :param status: 退出状态
         :return: None
         """
 
-        self.output.emit((self.FINISHED, "Subprocess finished."))
-        self.process = None
+        self.exit_code = code
+        self.exit_status = status
+        self.output.emit((self.FINISHED, str(code)))
+        self._process = None
 
     def _handle_stdout(self) -> None:
         """
         处理标准输出的槽 \n
         :return: None
         """
 
-        if self.process:
-            data = self.process.readAllStandardOutput()
-            stdout = bytes(data).decode(getdefaultencoding())
+        if self._process:
+            data = self._process.readAllStandardOutput()
+            stdout = bytes(data).decode(getdefaultencoding())  # 将QByteArray转为str
             self.output.emit((self.STDOUT, stdout))
 
     def _handle_stderr(self) -> None:
@@ -72,9 +143,9 @@ def _handle_stderr(self) -> None:
         :return: None
         """
 
-        if self.process:
-            data = self.process.readAllStandardError()
-            stderr = bytes(data).decode(getdefaultencoding())
+        if self._process:
+            data = self._process.readAllStandardError()
+            stderr = bytes(data).decode(getdefaultencoding())  # 将QByteArray转为str
             self.output.emit((self.STDERR, stderr))
 
     def _handle_state(self, state: QtCore.QProcess.ProcessState) -> None:
@@ -91,3 +162,12 @@ def _handle_state(self, state: QtCore.QProcess.ProcessState) -> None:
         }
         state_name = states[state]
         self.output.emit((self.STATE, state_name))
+
+    def _handle_error(self, error: QtCore.QProcess.ProcessError) -> None:
+        """
+        处理子进程错误 \n
+        :param error: 子进程错误
+        :return: None
+        """
+
+        pass
diff --git a/src/py2exe_gui/Widgets/dialog_widgets.py b/src/py2exe_gui/Widgets/dialog_widgets.py
@@ -1,16 +1,22 @@
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QFileDialog, QMessageBox, QWidget
+from PySide6.QtWidgets import (
+    QDialog,
+    QFileDialog,
+    QLabel,
+    QMessageBox,
+    QTextBrowser,
+    QVBoxLayout,
+    QWidget,
+)
 
-"""
-由于各种对话框的设置代码较繁琐且独立，故单独在本模块中配置
-"""
+from py2exe_gui.Core.subprocess_tool import SubProcessTool
 
 
 class ScriptFileDlg(QFileDialog):
     """用于获取入口脚本文件的对话框"""
 
     def __init__(self, parent: QWidget = None) -> None:
-        super().__init__(parent)
+        super(ScriptFileDlg, self).__init__(parent)
         self._setup()
 
     def _setup(self) -> None:
@@ -56,7 +62,7 @@ class AboutMessage(QMessageBox):
     """用于显示关于信息的对话框"""
 
     def __init__(self, parent: QWidget = None) -> None:
-        super(AboutMessage, self).__init__(parent=parent)
+        super(AboutMessage, self).__init__(parent)
         self._about_text: str = ""
         self._setup()
 
@@ -86,6 +92,46 @@ def about_text(self) -> str:
         return self._about_text
 
 
+class SubProcessDlg(QDialog):
+    """用于显示子进程信息的对话框"""
+
+    def __init__(self, parent: QWidget = None) -> None:
+        super(SubProcessDlg, self).__init__(parent)
+        self.info_label = QLabel(self)
+        self.browser = QTextBrowser(self)
+        self._setup()
+
+    def _setup(self) -> None:
+        """
+        配置子进程信息对话框 \n
+        """
+
+        self.setWindowTitle("PyInstaller")
+        self.setModal(True)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.info_label)
+        layout.addWidget(self.browser)
+        self.setLayout(layout)
+
+    def handle_output(self, subprocess_output: tuple[int, str]) -> None:
+        """
+        处理子进程的输出 \n
+        :param subprocess_output: 子进程输出
+        :return: None
+        """
+
+        output_type, output_text = subprocess_output
+        if output_type == SubProcessTool.STDOUT:
+            self.browser.append(output_text)
+        elif output_type == SubProcessTool.STDERR:
+            self.browser.append(output_text)
+        elif output_type == SubProcessTool.FINISHED:
+            self.info_label.setText("打包完成！")
+        elif output_type == SubProcessTool.STATE:
+            self.info_label.setText(output_text)
+
+
 if __name__ == "__main__":
     import sys
 
@@ -95,6 +141,7 @@ def about_text(self) -> str:
     # window = ScriptFileDlg()
     # window = IconFileDlg()
     # window.fileSelected.connect(lambda f: print(f))  # type: ignore
-    window = AboutMessage()
+    # window = AboutMessage()
+    window = SubProcessDlg()
     window.open()
     sys.exit(app.exec())
diff --git a/src/py2exe_gui/__main__.py b/src/py2exe_gui/__main__.py
@@ -1,9 +1,11 @@
 import sys
 
+from PySide6 import QtGui
 from PySide6.QtWidgets import QApplication
 
-from .Core.packaging import Packaging
-from .Widgets.main_window import MainWindow
+from py2exe_gui.Core.packaging import Packaging
+from py2exe_gui.Widgets.dialog_widgets import SubProcessDlg
+from py2exe_gui.Widgets.main_window import MainWindow
 
 
 class MainApp(MainWindow):
@@ -12,21 +14,36 @@ class MainApp(MainWindow):
     def __init__(self, *args, **kwargs) -> None:
         super(MainApp, self).__init__(*args, **kwargs)
 
-        self.packager = Packaging()
+        self.packager = Packaging(self)
 
         self.packager.args_settled.connect(
             lambda val: self.center_widget.pyinstaller_args_browser.enrich_args_text(
                 val
             )
         )
+        self.center_widget.option_selected.connect(self.packager.set_pyinstaller_args)
 
-        self.center_widget.option_selected.connect(self.packager.get_pyinstaller_args)
-        self.center_widget.run_packaging_btn.clicked.connect(
-            self.packager.run_packaging_process
-        )
+        self.subprocess_dlg = SubProcessDlg(self)
+
+        def run_packaging():
+            self.packager.run_packaging_process()
+            self.subprocess_dlg.show()
+
+        self.center_widget.run_packaging_btn.clicked.connect(run_packaging)
+        self.packager.subprocess.output.connect(self.subprocess_dlg.handle_output)
 
         self.status_bar.showMessage("就绪")
 
+    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
+        """
+        重写关闭事件，进行收尾清理 \n
+        :param event: 关闭事件
+        :return: None
+        """
+
+        self.packager.subprocess.abort_process()
+        super(MainApp, self).closeEvent(event)
+
 
 app = QApplication(sys.argv)
 window = MainApp()
