je-editor 0.0.104__py3-none-any.whl → 0.0.228__py3-none-any.whl

je_editor/pyside_ui/code_process/code_exec.py

@@ -1,190 +0,0 @@
-import os.path
-import queue
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from threading import Thread
-
-from PySide6.QtCore import QTimer
-from PySide6.QtWidgets import QMainWindow, QTextEdit
-
-from je_editor.pyside_ui.colors.global_color import error_color, output_color
-from je_editor.utils.exception.exception_tags import compiler_not_found_error, je_editor_init_error
-from je_editor.utils.exception.exception_tags import file_not_fond_error
-from je_editor.utils.exception.exceptions import JEditorExecException, JEditorException
-
-
-class ExecManager(object):
-
-    def __init__(
-            self,
-            main_window=None,
-            program_language="python",
-            program_encoding="utf-8",
-            program_buffer=10240000,
-    ):
-        """
-        :param main_window: tkinter main window
-        :param program_language: which program language
-        :param program_encoding: which encoding
-        """
-        self.read_program_error_output_from_thread = None
-        self.read_program_output_from_thread = None
-        self.main_window: QMainWindow = main_window
-        self.code_result: [QTextEdit, None] = None
-        self.timer: [QTimer, None] = None
-        self.still_run_program = True
-        self.process = None
-        self.run_output_queue = queue.Queue()
-        self.run_error_queue = queue.Queue()
-        self.program_language = program_language
-        self.program_encoding = program_encoding
-        self.program_buffer = program_buffer
-
-    def later_init(self):
-        if self.main_window is not None:
-            self.code_result: QTextEdit = self.main_window.code_result
-            self.timer = QTimer(self.main_window)
-        else:
-            raise JEditorException(je_editor_init_error)
-
-    def exec_code(self, exec_file_name):
-        """
-        :param exec_file_name: string file will open to run
-        :return: if error return result and True else return result and False
-        """
-        try:
-            self.exit_program()
-            self.code_result.setPlainText("")
-            reformat_os_file_path = os.path.abspath(exec_file_name)
-            # detect file is exist
-            try:
-                if not Path(exec_file_name).exists():
-                    raise JEditorExecException(file_not_fond_error)
-            except OSError as error:
-                raise JEditorExecException(error)
-            if sys.platform in ["win32", "cygwin", "msys"]:
-                venv_path = Path(os.getcwd() + "/venv/Scripts")
-            else:
-                venv_path = Path(os.getcwd() + "/venv/bin")
-            if venv_path.is_dir() and venv_path.exists():
-                compiler_path = shutil.which(
-                    cmd="python3",
-                    path=str(venv_path)
-                )
-            else:
-                compiler_path = shutil.which(cmd="python3")
-            if compiler_path is None:
-                compiler_path = shutil.which(
-                    cmd="python",
-                    path=str(venv_path)
-                )
-            else:
-                compiler_path = shutil.which(cmd="python")
-            if compiler_path is None:
-                raise JEditorExecException(compiler_not_found_error)
-            exec_file = reformat_os_file_path
-            # run program
-            execute_program_list = [compiler_path, exec_file]
-            self.process = subprocess.Popen(
-                execute_program_list,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                shell=True
-            )
-            self.still_run_program = True
-            # program output message queue thread
-            self.read_program_output_from_thread = Thread(
-                target=self.read_program_output_from_process,
-                daemon=True
-            )
-            self.read_program_output_from_thread.start()
-            # program error message queue thread
-            self.read_program_error_output_from_thread = Thread(
-                target=self.read_program_error_output_from_process,
-                daemon=True
-            )
-            self.read_program_error_output_from_thread.start()
-            # show which file execute
-            self.code_result.append(compiler_path + " " + reformat_os_file_path)
-            # start tkinter_ui update
-            # start timer
-            self.timer = QTimer(self.main_window)
-            self.timer.setInterval(1)
-            self.timer.timeout.connect(self.pull_text)
-            self.timer.start()
-        except Exception as error:
-            self.code_result.setTextColor(error_color)
-            self.code_result.append(str(error))
-            self.code_result.setTextColor(output_color)
-
-    # tkinter_ui update method
-    def pull_text(self):
-        try:
-            self.code_result.setTextColor(error_color)
-            if not self.run_error_queue.empty():
-                error_message = self.run_error_queue.get_nowait()
-                error_message = str(error_message).strip()
-                if error_message:
-                    self.code_result.append(error_message)
-            self.code_result.setTextColor(output_color)
-            if not self.run_output_queue.empty():
-                output_message = self.run_output_queue.get_nowait()
-                output_message = str(output_message).strip()
-                if output_message:
-                    self.code_result.append(output_message)
-        except queue.Empty:
-            pass
-        if self.process.returncode == 0:
-            self.timer.stop()
-            self.exit_program()
-        elif self.process.returncode is not None:
-            self.timer.stop()
-            self.exit_program()
-        if self.still_run_program:
-            # poll return code
-            self.process.poll()
-
-    # exit program change run flag to false and clean read thread and queue and process
-    def exit_program(self):
-        self.still_run_program = False
-        if self.read_program_output_from_thread is not None:
-            self.read_program_output_from_thread = None
-        if self.read_program_error_output_from_thread is not None:
-            self.read_program_error_output_from_thread = None
-        self.print_and_clear_queue()
-        if self.process is not None:
-            self.process.terminate()
-            print(f"Program exit with code {self.process.returncode}")
-            self.process = None
-
-    def print_and_clear_queue(self):
-        try:
-            for std_output in iter(self.run_output_queue.get_nowait, None):
-                std_output = str(std_output).strip()
-                if std_output:
-                    self.code_result.append(std_output)
-            self.code_result.setTextColor(error_color)
-            for std_err in iter(self.run_error_queue.get_nowait, None):
-                std_err = str(std_err).strip()
-                if std_err:
-                    self.code_result.append(std_err)
-            self.code_result.setTextColor(output_color)
-        except queue.Empty:
-            pass
-        self.run_output_queue = queue.Queue()
-        self.run_error_queue = queue.Queue()
-
-    def read_program_output_from_process(self):
-        while self.still_run_program:
-            program_output_data = self.process.stdout.raw.read(self.program_buffer).decode(self.program_encoding)
-            self.run_output_queue.put_nowait(program_output_data)
-
-    def read_program_error_output_from_process(self):
-        while self.still_run_program:
-            program_error_output_data = self.process.stderr.raw.read(self.program_buffer).decode(self.program_encoding)
-            self.run_error_queue.put_nowait(program_error_output_data)
-
-
-exec_manage = ExecManager()

je_editor/pyside_ui/code_result/code_record.py

@@ -1,39 +0,0 @@
-from PySide6.QtGui import QTextDocument, QAction
-from PySide6.QtWidgets import QTextEdit
-
-from je_editor.pyside_ui.search_ui.search_error_box import SearchResultBox
-
-
-class CodeRecord(QTextEdit):
-
-    def __init__(self):
-        super().__init__()
-        self.setLineWrapMode(self.LineWrapMode.NoWrap)
-        self.setReadOnly(True)
-        # Search Result
-        self.search_result_action = QAction("Search Error")
-        self.search_result_action.setShortcut("Ctrl+e")
-        self.search_result_action.triggered.connect(
-            self.start_search_result_dialog
-        )
-        self.addAction(self.search_result_action)
-
-    def start_search_result_dialog(self):
-        self.search_result_box = SearchResultBox()
-        self.search_result_box.search_back_button.clicked.connect(
-            self.find_back_text
-        )
-        self.search_result_box.search_next_button.clicked.connect(
-            self.find_next_text
-        )
-        self.search_result_box.show()
-
-    def find_next_text(self):
-        if self.search_result_box.isVisible():
-            text = self.search_result_box.search_input.text()
-            self.find(text)
-
-    def find_back_text(self):
-        if self.search_result_box.isVisible():
-            text = self.search_result_box.search_input.text()
-            self.find(text, QTextDocument.FindFlag.FindBackward)

je_editor/pyside_ui/colors/global_color.py

@@ -1,4 +0,0 @@
-from PySide6.QtGui import QColor
-
-error_color: QColor = QColor(255, 51, 51)
-output_color: QColor = QColor(255, 255, 255)

je_editor/pyside_ui/file_dialog/open_file_dialog.py

@@ -1,27 +0,0 @@
-import os
-
-from PySide6.QtWidgets import QFileDialog
-
-from je_editor.pyside_ui.auto_save.auto_save_thread import SaveThread
-from je_editor.utils.file.open.open_file import read_file
-
-
-def choose_file_get_open_filename(parent_qt_instance):
-    filename = QFileDialog().getOpenFileName(
-        parent=parent_qt_instance,
-        dir=os.getcwd()
-    )[0]
-    if filename is not None and filename != "":
-        parent_qt_instance.current_file = filename
-        file_content = read_file(filename)[1]
-        parent_qt_instance.code_edit.setPlainText(
-            file_content
-            )
-        if parent_qt_instance.auto_save_thread is None:
-            parent_qt_instance.auto_save_thread = SaveThread(
-                parent_qt_instance.current_file,
-                parent_qt_instance.code_edit.toPlainText()
-            )
-            parent_qt_instance.auto_save_thread.start()
-        if parent_qt_instance.auto_save_thread is not None:
-            parent_qt_instance.auto_save_thread.file = parent_qt_instance.current_file

je_editor/pyside_ui/file_dialog/save_file_dialog.py

@@ -1,24 +0,0 @@
-import os
-
-from PySide6.QtWidgets import QFileDialog
-
-from je_editor.utils.file.save.save_file import write_file
-from je_editor.pyside_ui.auto_save.auto_save_thread import SaveThread
-
-
-def choose_file_get_save_filename(parent_qt_instance):
-    filename = QFileDialog().getSaveFileName(
-        parent=parent_qt_instance,
-        dir=os.getcwd()
-    )[0]
-    if filename is not None and filename != "":
-        parent_qt_instance.current_file = filename
-        write_file(filename, parent_qt_instance.code_edit.toPlainText())
-        if parent_qt_instance.auto_save_thread is None:
-            parent_qt_instance.auto_save_thread = SaveThread(
-                parent_qt_instance.current_file,
-                parent_qt_instance.code_edit.toPlainText()
-            )
-            parent_qt_instance.auto_save_thread.start()
-        elif parent_qt_instance.auto_save_thread is not None:
-            parent_qt_instance.auto_save_thread.file = parent_qt_instance.current_file

je_editor/pyside_ui/main_ui/editor_main_ui/main_editor.py

@@ -1,183 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-from PySide6.QtCore import QTimer
-from PySide6.QtGui import QFontDatabase, QAction, QIcon
-from PySide6.QtWidgets import QMainWindow, QSystemTrayIcon
-from qt_material import QtStyleTools
-
-from je_editor.pyside_ui.auto_save.auto_save_thread import SaveThread
-from je_editor.pyside_ui.code_process.code_exec import exec_manage
-from je_editor.pyside_ui.colors.global_color import error_color, output_color
-from je_editor.pyside_ui.main_ui_setting.ui_setting import set_ui
-from je_editor.pyside_ui.menu.menu_bar.set_menu_bar import set_menu_bar
-from je_editor.pyside_ui.shell_process.shell_exec import shell_manager
-from je_editor.pyside_ui.treeview.project_treeview.set_project_treeview import set_project_treeview
-from je_editor.pyside_ui.user_setting.user_setting_file import write_user_setting, user_setting_dict, read_user_setting
-from je_editor.utils.encodings.python_encodings import python_encodings_list
-from je_editor.utils.file.open.open_file import read_file
-from je_editor.utils.redirect_manager.redirect_manager_class import redirect_manager_instance
-
-
-class EditorMain(QMainWindow, QtStyleTools):
-
-    def __init__(self):
-        super(EditorMain, self).__init__()
-        # Windows setup
-        self.id = "JEditor"
-        # Venv
-        self.venv_path = None
-        if sys.platform in ["win32", "cygwin", "msys"]:
-            from ctypes import windll
-            windll.shell32.SetCurrentProcessExplicitAppUserModelID(self.id)
-        # set python buffered
-        os.environ["PYTHONUNBUFFERED"] = "1"
-        # Auto save thread
-        self.auto_save_thread = None
-        # current file
-        self.current_file = None
-        # Font
-        self.font_database = QFontDatabase()
-        # Color
-        # Timer to redirect error or message
-        self.redirect_timer = QTimer(self)
-        self.redirect_timer.setInterval(1)
-        self.redirect_timer.timeout.connect(self.redirect)
-        self.redirect_timer.start()
-        set_ui(self)
-        set_project_treeview(self)
-        set_menu_bar(self)
-        # Set font and font size menu
-        self.add_font_menu()
-        self.add_font_size_menu()
-        # Set encoding menu
-        self.add_encoding_menu()
-        if self.current_file is not None and self.auto_save_thread is None:
-            self.auto_save_thread = SaveThread(
-                self.current_file,
-                self.code_edit.code_edit.toPlainText()
-            )
-            self.auto_save_thread.start()
-        # Set Icon
-        self.icon_path = Path(os.getcwd() + "/je_driver_icon.ico")
-        self.icon = QIcon(str(self.icon_path))
-        if self.icon.isNull() is False:
-            self.setWindowIcon(self.icon)
-            self.system_icon = QSystemTrayIcon()
-            self.system_icon.setIcon(self.icon)
-        # Init shell manager
-        shell_manager.main_window = self
-        shell_manager.later_init()
-        # Put Redirect on last to trace exception
-        redirect_manager_instance.set_redirect(self, True)
-        # Add style menu
-        self.add_style_menu()
-
-    def add_style_menu(self):
-        self.menu.style_menu = self.menu.addMenu("UI Style")
-        for style in [
-            'dark_amber.xml', 'dark_blue.xml', 'dark_cyan.xml', 'dark_lightgreen.xml', 'dark_pink.xml',
-            'dark_purple.xml', 'dark_red.xml', 'dark_teal.xml', 'dark_yellow.xml', 'light_amber.xml',
-            'light_blue.xml', 'light_cyan.xml', 'light_cyan_500.xml', 'light_lightgreen.xml',
-            'light_pink.xml', 'light_purple.xml', 'light_red.xml', 'light_teal.xml', 'light_yellow.xml'
-        ]:
-            change_style_action = QAction(style, parent=self)
-            change_style_action.triggered.connect(self.set_style)
-            self.menu.style_menu.addAction(change_style_action)
-
-    def set_style(self):
-        self.apply_stylesheet(self, self.sender().text())
-
-    def startup_setting(self):
-        read_user_setting()
-        # self.code_edit.setFont(
-        #     self.font_database.font(
-        #         user_setting_dict.get("font", "Lato"),
-        #         "",
-        #         user_setting_dict.get("font_size", 12)
-        #     )
-        # )
-        self.code_edit.setStyleSheet(
-            f"font-size: {user_setting_dict.get('font_size', 12)}pt;"
-            f"font-family: {user_setting_dict.get('font', 'Lato')};"
-        )
-        self.code_result.setStyleSheet(
-            f"font-size: {user_setting_dict.get('font_size', 12)}pt;"
-            f"font-family: {user_setting_dict.get('font', 'Lato')};"
-        )
-        last_file = user_setting_dict.get("last_file", None)
-        if last_file is not None:
-            last_file_path = Path(last_file)
-            if last_file_path.is_file() and last_file_path.exists():
-                self.current_file = str(last_file_path)
-                self.code_edit.setPlainText(read_file(self.current_file)[1])
-
-    def add_font_menu(self):
-        self.font_menu = self.text_menu.addMenu("Font")
-        for family in self.font_database.families():
-            font_action = QAction(family, parent=self)
-            font_action.triggered.connect(self.set_font)
-            self.font_menu.addAction(font_action)
-
-    def add_font_size_menu(self):
-        self.font_size_menu = self.text_menu.addMenu("Font Size")
-        for size in range(12, 38, 2):
-            font_action = QAction(str(size), parent=self)
-            font_action.triggered.connect(self.set_font_size)
-            self.font_size_menu.addAction(font_action)
-
-    def set_font(self):
-        self.code_edit.setStyleSheet(
-            f"font-size: {self.code_edit.font().pointSize()}pt;"
-            f"font-family: {self.sender().text()};"
-        )
-        self.code_result.setStyleSheet(
-            f"font-size: {self.code_result.font().pointSize()}pt;"
-            f"font-family: {self.sender().text()};"
-        )
-        user_setting_dict.update({"font": self.sender().text()})
-
-    def set_font_size(self):
-        self.code_edit.setStyleSheet(
-            f"font-size: {int(self.sender().text())}pt;"
-            f"font-family: {self.code_edit.font().family()};"
-        )
-        self.code_result.setStyleSheet(
-            f"font-size: {int(self.sender().text())}pt;"
-            f"font-family: {self.code_result.font().family()};"
-        )
-        user_setting_dict.update({"font_size": int(self.sender().text())})
-
-    def add_encoding_menu(self):
-        self.encoding_menu = self.file_menu.addMenu("Encodings")
-        for encoding in python_encodings_list:
-            encoding_action = QAction(encoding, parent=self)
-            encoding_action.triggered.connect(self.set_encoding)
-            self.encoding_menu.addAction(encoding_action)
-
-    def set_encoding(self):
-        shell_manager.program_encoding = self.sender().text()
-        exec_manage.program_encoding = self.sender().text()
-        user_setting_dict.update({"encoding": self.sender().text()})
-
-    def redirect(self):
-        if self.auto_save_thread is not None:
-            self.auto_save_thread.text_to_write = self.code_edit.toPlainText()
-        if not redirect_manager_instance.std_out_queue.empty():
-            output_message = redirect_manager_instance.std_out_queue.get_nowait()
-            output_message = str(output_message).strip()
-            if output_message:
-                self.code_result.append(output_message)
-        self.code_result.setTextColor(error_color)
-        if not redirect_manager_instance.std_err_queue.empty():
-            error_message = redirect_manager_instance.std_err_queue.get_nowait()
-            error_message = str(error_message).strip()
-            if error_message:
-                self.code_result.append(error_message)
-        self.code_result.setTextColor(output_color)
-
-    def closeEvent(self, event) -> None:
-        super().closeEvent(event)
-        user_setting_dict.update({"last_file": str(self.current_file)})
-        write_user_setting()

je_editor/pyside_ui/main_ui_setting/ui_setting.py

@@ -1,36 +0,0 @@
-from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QMainWindow, QScrollArea, QGridLayout, QWidget, QSplitter
-
-from je_editor.pyside_ui.code_editor.code_edit_plaintext import CodeEditor
-from je_editor.pyside_ui.code_result.code_record import CodeRecord
-
-
-def set_ui(ui_we_want_to_set: QMainWindow):
-    # set qt window
-    ui_we_want_to_set.main_widget = QWidget()
-    ui_we_want_to_set.grid_layout = QGridLayout(ui_we_want_to_set.main_widget)
-    ui_we_want_to_set.grid_layout.setContentsMargins(0, 0, 0, 0)
-    ui_we_want_to_set.setCentralWidget(ui_we_want_to_set.main_widget)
-    ui_we_want_to_set.setWindowTitle("JEditor")
-    # Splitter
-    ui_we_want_to_set.edit_splitter = QSplitter()
-    ui_we_want_to_set.edit_splitter.setOrientation(Qt.Orientation.Vertical)
-    ui_we_want_to_set.edit_splitter.setChildrenCollapsible(False)
-    # code edit and code result plaintext
-    ui_we_want_to_set.code_edit = CodeEditor()
-    ui_we_want_to_set.code_result = CodeRecord()
-    ui_we_want_to_set.code_edit_scroll_area = QScrollArea()
-    ui_we_want_to_set.code_edit_scroll_area.setWidgetResizable(True)
-    ui_we_want_to_set.code_edit_scroll_area.setViewportMargins(0, 0, 0, 0)
-    ui_we_want_to_set.code_edit_scroll_area.setWidget(ui_we_want_to_set.code_edit)
-    ui_we_want_to_set.code_result_scroll_area = QScrollArea()
-    ui_we_want_to_set.code_result_scroll_area.setWidgetResizable(True)
-    ui_we_want_to_set.code_result_scroll_area.setViewportMargins(0, 0, 0, 0)
-    ui_we_want_to_set.code_result_scroll_area.setWidget(ui_we_want_to_set.code_result)
-    ui_we_want_to_set.grid_layout.setRowStretch(0, 10)
-    ui_we_want_to_set.grid_layout.setColumnStretch(1, 10)
-    ui_we_want_to_set.edit_splitter.addWidget(ui_we_want_to_set.code_edit_scroll_area)
-    ui_we_want_to_set.edit_splitter.addWidget(ui_we_want_to_set.code_result_scroll_area)
-    ui_we_want_to_set.edit_splitter.setStretchFactor(0, 7)
-    ui_we_want_to_set.grid_layout.addWidget(ui_we_want_to_set.edit_splitter, 0, 1)
-

je_editor/pyside_ui/menu/menu_bar/check_style_menu/build_check_style_menu.py

@@ -1,44 +0,0 @@
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import QMainWindow
-from yapf.yapflib.yapf_api import FormatCode
-
-from je_editor.utils.json_format.json_process import reformat_json
-
-
-def set_check_menu(ui_we_want_to_set: QMainWindow):
-    # Yapf code check
-    ui_we_want_to_set.check_menu.check_python_action = QAction("yapf")
-    ui_we_want_to_set.check_menu.check_python_action.setShortcut("Ctrl+y")
-    ui_we_want_to_set.check_menu.check_python_action.triggered.connect(
-        lambda: check_python_code(
-            ui_we_want_to_set
-        )
-    )
-    ui_we_want_to_set.check_menu.addAction(ui_we_want_to_set.check_menu.check_python_action)
-    # Reformat JSON
-    ui_we_want_to_set.check_menu.reformat_json_action = QAction("Reformat JSON")
-    ui_we_want_to_set.check_menu.reformat_json_action.setShortcut("Ctrl+j")
-    ui_we_want_to_set.check_menu.reformat_json_action.triggered.connect(
-        lambda: reformat_json_text(
-            ui_we_want_to_set
-        )
-    )
-    ui_we_want_to_set.check_menu.addAction(ui_we_want_to_set.check_menu.reformat_json_action)
-
-
-def check_python_code(ui_we_want_to_set):
-    code_text = ui_we_want_to_set.code_edit.toPlainText()
-    ui_we_want_to_set.code_result.setPlainText("")
-    format_code = FormatCode(
-        unformatted_source=code_text,
-        verify=True,
-        style_config="google"
-    )
-    if isinstance(format_code, tuple):
-        ui_we_want_to_set.code_edit.setPlainText(format_code[0])
-
-
-def reformat_json_text(ui_we_want_to_set):
-    code_text = ui_we_want_to_set.code_edit.toPlainText()
-    ui_we_want_to_set.code_result.setPlainText("")
-    ui_we_want_to_set.code_edit.setPlainText(reformat_json(code_text))

je_editor/pyside_ui/menu/menu_bar/file_menu/build_file_menu.py

@@ -1,30 +0,0 @@
-import os
-import shutil
-import sys
-from pathlib import Path
-
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import QMainWindow, QMessageBox, QInputDialog
-
-from je_editor.pyside_ui.file_dialog.open_file_dialog import choose_file_get_open_filename
-from je_editor.pyside_ui.file_dialog.save_file_dialog import choose_file_get_save_filename
-from je_editor.pyside_ui.shell_process.shell_exec import shell_manager
-
-
-def set_file_menu(ui_we_want_to_set: QMainWindow):
-    ui_we_want_to_set.file_menu.open_file_action = QAction("Open File")
-    ui_we_want_to_set.file_menu.open_file_action.setShortcut(
-        "Ctrl+o"
-    )
-    ui_we_want_to_set.file_menu.open_file_action.triggered.connect(
-        lambda: choose_file_get_open_filename(parent_qt_instance=ui_we_want_to_set)
-    )
-    ui_we_want_to_set.file_menu.addAction(ui_we_want_to_set.file_menu.open_file_action)
-    ui_we_want_to_set.file_menu.save_file_action = QAction("Save File")
-    ui_we_want_to_set.file_menu.save_file_action.setShortcut(
-        "Ctrl+s"
-    )
-    ui_we_want_to_set.file_menu.save_file_action.triggered.connect(
-        lambda: choose_file_get_save_filename(parent_qt_instance=ui_we_want_to_set)
-    )
-    ui_we_want_to_set.file_menu.addAction(ui_we_want_to_set.file_menu.save_file_action)

je_editor/pyside_ui/menu/menu_bar/help_menu/build_help_menu.py

@@ -1,39 +0,0 @@
-import webbrowser
-
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import QMainWindow, QMessageBox
-
-
-def set_help_menu(ui_we_want_to_set: QMainWindow):
-    ui_we_want_to_set.help_menu .help_github_action = QAction("GitHub")
-    ui_we_want_to_set.help_menu .help_github_action.triggered.connect(
-        lambda: open_web_browser("https://github.com/Integrated-Testing-Environment/je_editor")
-    )
-    ui_we_want_to_set.help_menu.addAction(ui_we_want_to_set.help_menu .help_github_action)
-
-    ui_we_want_to_set.help_menu .help_doc_action = QAction("Doc")
-    ui_we_want_to_set.help_menu .help_doc_action.triggered.connect(
-        lambda: open_web_browser("https://je-editor.readthedocs.io/en/latest/")
-    )
-    ui_we_want_to_set.help_menu.addAction(ui_we_want_to_set.help_menu .help_doc_action)
-
-    ui_we_want_to_set.help_menu .help_about_action = QAction("About")
-    ui_we_want_to_set.help_menu .help_about_action.triggered.connect(
-        show_about
-    )
-    ui_we_want_to_set.help_menu.addAction(ui_we_want_to_set.help_menu.help_about_action)
-
-
-def open_web_browser(url: str):
-    webbrowser.open(url=url)
-
-
-def show_about():
-    message_box = QMessageBox()
-    message_box.setText(
-        """
-JEditor
-Create by JE-Chen
-        """
-    )
-    message_box.exec()