PyInstallerGUI-NZ.py

import sys
import os
import shutil
import subprocess
import re
from PyQt5.QtWidgets import (
    QApplication, QWidget, QLabel, QLineEdit, QPushButton,
    QTextEdit, QCheckBox, QFileDialog, QVBoxLayout, QHBoxLayout
)

class PyInstallerGUI(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("PyInstallerGUI+Nanozip-SFX")

        # Метки и поля ввода
        self.label_py = QLabel("Python файл (*.py):")
        self.line_py = QLineEdit()
        self.btn_py = QPushButton("Выбрать")
        self.btn_py.clicked.connect(self.select_py_file)

        self.label_out = QLabel("Папка вывода:")
        self.line_out = QLineEdit()
        self.btn_out = QPushButton("Выбрать")
        self.btn_out.clicked.connect(self.select_out_folder)

        self.label_icon = QLabel("Иконка (*.ico):")
        self.line_icon = QLineEdit()
        self.btn_icon = QPushButton("Выбрать")
        self.btn_icon.clicked.connect(self.select_icon_file)

        self.checkbox_compress = QCheckBox("Использовать сжатие nanozip + SFX")

        self.checkbox_no_console = QCheckBox("Создавать EXE без консоли (GUI-приложение)")

        self.btn_run = QPushButton("Собрать EXE")
        self.btn_run.clicked.connect(self.run_pyinstaller)

        self.log = QTextEdit()
        self.log.setReadOnly(True)

        layout = QVBoxLayout()

        h_py = QHBoxLayout()
        h_py.addWidget(self.line_py)
        h_py.addWidget(self.btn_py)
        layout.addWidget(self.label_py)
        layout.addLayout(h_py)

        h_out = QHBoxLayout()
        h_out.addWidget(self.line_out)
        h_out.addWidget(self.btn_out)
        layout.addWidget(self.label_out)
        layout.addLayout(h_out)

        h_icon = QHBoxLayout()
        h_icon.addWidget(self.line_icon)
        h_icon.addWidget(self.btn_icon)
        layout.addWidget(self.label_icon)
        layout.addLayout(h_icon)

        layout.addWidget(self.checkbox_compress)
        layout.addWidget(self.checkbox_no_console)
        layout.addWidget(self.btn_run)
        layout.addWidget(self.log)

        self.setLayout(layout)
        self.resize(700, 500)

    def select_py_file(self):
        path, _ = QFileDialog.getOpenFileName(self, "Выбрать Python файл", "", "Python Files (*.py)")
        if path:
            self.line_py.setText(path)

    def select_out_folder(self):
        path = QFileDialog.getExistingDirectory(self, "Выбрать папку вывода")
        if path:
            self.line_out.setText(path)

    def select_icon_file(self):
        path, _ = QFileDialog.getOpenFileName(self, "Выбрать иконку", "", "Icon Files (*.ico)")
        if path:
            self.line_icon.setText(path)

    def run_process(self, cmd, name):
        self.log.append(f"Запуск: {name} — {' '.join(cmd)}")
        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        for line in process.stdout:
            self.log.append(line.rstrip())
        process.wait()
        if process.returncode != 0:
            self.log.append(f"Ошибка: {name} завершился с кодом {process.returncode}")
            return False
        self.log.append(f"{name} завершён успешно.")
        return True

    def collect_extra_files(self, script_path):
        base_dir = os.path.dirname(os.path.abspath(script_path))
        extra_paths = []

        for item in os.listdir(base_dir):
            full_path = os.path.join(base_dir, item)
            if os.path.abspath(full_path) == os.path.abspath(script_path):
                continue
            if os.path.isdir(full_path):
                extra_paths.append(f"{full_path};{item}")
            else:
                extra_paths.append(f"{full_path};.")

        # Добавляем папку tkthemes, если есть
        tkthemes_path = os.path.join(base_dir, "tkthemes")
        if os.path.isdir(tkthemes_path):
            extra_paths.append(f"{tkthemes_path};tkthemes")

        return extra_paths

    def prepare_script_for_build(self, orig_path):
        """
        Создаёт временную копию скрипта с вставленной функцией resource_path,
        подменой open() на open(resource_path()), и добавлением os.chdir(sys._MEIPASS)
        при запуске из frozen.
        """

        with open(orig_path, "r", encoding="utf-8") as f:
            src = f.read()

        # Функция resource_path + переключение cwd, вставляем в начало
        patch_code = '''
import sys
import os

def resource_path(relative_path):
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)

if getattr(sys, 'frozen', False):
    os.chdir(sys._MEIPASS)
'''

        # Заменяем open("...") и open('...') на open(resource_path("..."))
        # Регулярное выражение ищет open("somepath") или open('somepath')
        pattern = re.compile(r'''open\s*\(\s*(['"])(.+?)\1''')

        def replacer(m):
            quote = m.group(1)
            path_inside = m.group(2)
            # Если уже используется resource_path, не трогаем
            if "resource_path" in m.group(0):
                return m.group(0)
            return f'open(resource_path({quote}{path_inside}{quote})'

        patched_src = pattern.sub(replacer, src)

        # Собираем итоговый код
        final_src = patch_code + "\n" + patched_src

        # Запишем во временный файл рядом с оригиналом
        tmp_path = orig_path + "_patched.py"
        with open(tmp_path, "w", encoding="utf-8") as f:
            f.write(final_src)

        return tmp_path

    def run_pyinstaller(self):
        py_file = self.line_py.text().strip()
        out_dir = self.line_out.text().strip()
        icon_file = self.line_icon.text().strip()
        use_compress = self.checkbox_compress.isChecked()
        no_console = self.checkbox_no_console.isChecked()

        if not os.path.isfile(py_file):
            self.log.append("Ошибка: выбранный Python файл не существует")
            return
        if not os.path.isdir(out_dir):
            self.log.append("Ошибка: выбрана несуществующая папка для результата")
            return
        if icon_file and not os.path.isfile(icon_file):
            self.log.append("Ошибка: выбранный файл иконки не существует")
            return

        nz_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "nz.exe")

        if use_compress:
            if not os.path.isfile(nz_path) or not os.access(nz_path, os.X_OK):
                self.log.append("Ошибка: nz.exe не найден или не исполняемый рядом со скриптом")
                return

        self.log.append(f"Запуск сборки для: {py_file}")
        self.log.append(f"Вывод в: {out_dir}")
        if icon_file:
            self.log.append(f"Используется иконка: {icon_file}")
        if use_compress:
            self.log.append(f"Используется сжатие nanozip + создание SFX")
        if no_console:
            self.log.append("Сборка EXE без консоли (--noconsole)")

        workpath = os.path.join(out_dir, "build")
        specpath = os.path.join(out_dir, "spec")

        os.makedirs(workpath, exist_ok=True)
        os.makedirs(specpath, exist_ok=True)

        extra_data = self.collect_extra_files(py_file)

        # Патчим исходный скрипт
        tmp_py = self.prepare_script_for_build(py_file)

        cmd = [
            sys.executable, "-m", "PyInstaller",
            "--clean",
            "--onefile",
            f"--distpath={out_dir}",
            f"--workpath={workpath}",
            f"--specpath={specpath}",
        ]

        if no_console:
            cmd.append("--noconsole")

        if icon_file:
            cmd.append(f"--icon={icon_file}")

        for data in extra_data:
            cmd.append(f"--add-data={data}")

        cmd.append(tmp_py)

        self.log.append("Команда PyInstaller: " + " ".join(cmd))
        self.btn_run.setEnabled(False)

        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        for line in process.stdout:
            self.log.append(line.rstrip())
        process.wait()

        # Удаляем временный файл
        try:
            os.remove(tmp_py)
        except Exception as e:
            self.log.append(f"Не удалось удалить временный файл: {e}")

        if process.returncode != 0:
            self.log.append(f"Ошибка сборки PyInstaller. Код выхода: {process.returncode}")
            self.btn_run.setEnabled(True)
            return
        self.log.append("Сборка PyInstaller завершена успешно.")

        exe_name = os.path.splitext(os.path.basename(py_file))[0] + ".exe"
        exe_path = os.path.join(out_dir, exe_name)
        sfx_path = os.path.join(out_dir, "sfx_" + exe_name)

        if use_compress:
            nz_cmd = [
                nz_path, "w32c",
                "-cO",
                "-m.5g",
                "-o", sfx_path,
                exe_path
            ]
            if not self.run_process(nz_cmd, "nanozip SFX"):
                self.btn_run.setEnabled(True)
                return

            try:
                os.replace(sfx_path, exe_path)
                self.log.append(f"SFX создан и заменён: {exe_path}")
            except Exception as e:
                self.log.append(f"Ошибка замены EXE на SFX: {e}")
                self.btn_run.setEnabled(True)
                return

        try:
            if os.path.exists(workpath):
                shutil.rmtree(workpath)
                self.log.append(f"Папка сборки '{workpath}' удалена.")
            if os.path.exists(specpath):
                shutil.rmtree(specpath)
                self.log.append(f"Папка spec '{specpath}' удалена.")
        except Exception as e:
            self.log.append(f"Ошибка при удалении временных папок: {e}")

        self.log.append("Все операции завершены.")
        self.btn_run.setEnabled(True)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = PyInstallerGUI()
    window.show()
    sys.exit(app.exec())