je-editor 0.0.62__py3-none-any.whl → 0.0.64__py3-none-any.whl

je_editor/pyside_ui/auto_save/auto_save_thread.py

@@ -0,0 +1,34 @@
+import time
+from pathlib import Path
+from threading import Thread
+
+from je_editor.utils.file.save.save_file import write_file
+
+
+class SaveThread(Thread):
+
+    def __init__(self, file_to_save, text_to_write, auto_save=False):
+        """
+        :param file_to_save: file we want to auto save
+        :param text_to_write: text that will be output to file
+        :param auto_save: enable auto save or not
+        """
+        super().__init__()
+        self.file = file_to_save
+        self.path = None
+        self.text_to_write = text_to_write
+        self.auto_save = auto_save
+        # set daemon
+        self.daemon = True
+
+    def run(self):
+        # loop and save current edit file
+        if self.file is not None:
+            self.auto_save = True
+            self.path = Path(self.file)
+        while self.auto_save and self.file is not None:
+            time.sleep(5)
+            if self.path.exists() and self.path.is_file():
+                write_file(self.file, self.text_to_write)
+            else:
+                break

je_editor/pyside_ui/code_process/code_exec.py

@@ -0,0 +1,171 @@
+import os.path
+import queue
+import shutil
+import subprocess
+from pathlib import Path
+from threading import Thread
+
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QMainWindow, QTextEdit
+
+from je_editor.utils.exception.exception_tags import compiler_not_found_error
+from je_editor.utils.exception.exception_tags import file_not_fond_error
+from je_editor.utils.exception.exceptions import JEditorExecException
+
+
+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:
+            # TODO Exception
+            raise Exception
+
+    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)
+            compiler_path = shutil.which(self.program_language)
+            if compiler_path is None and self.program_language == "python":
+                compiler_path = shutil.which("python3")
+            elif compiler_path is None and self.program_language == "python3":
+                compiler_path = shutil.which("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=False
+            )
+            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
+            ).start()
+            # program error message queue thread
+            self.read_program_error_output_from_thread = Thread(
+                target=self.read_program_error_output_from_process,
+                daemon=True
+            ).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(self.main_window.red_color)
+            self.code_result.append(str(error))
+            self.code_result.setTextColor(self.main_window.black_color)
+
+    # tkinter_ui update method
+    def pull_text(self):
+        try:
+            self.code_result.setTextColor(self.main_window.red_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(self.main_window.black_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.exit_program()
+        elif self.process.returncode is not None:
+            self.exit_program()
+            self.timer.stop()
+        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()
+
+    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(self.main_window.red_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(self.main_window.black_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/file_dialog/save_file_dialog.py

@@ -2,7 +2,8 @@ import os
 
 from PySide6.QtWidgets import QFileDialog
 
-from je_editor.utils.file.save.save_file import write_file, SaveThread
+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):
@@ -18,5 +19,6 @@ def choose_file_get_save_filename(parent_qt_instance):
                 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,12 +1,14 @@
 import os
 
-from PySide6.QtGui import QFontDatabase, QAction
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QFontDatabase, QAction, QColor
 from PySide6.QtWidgets import QMainWindow
 
 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.treeview.project_treeview.set_project_treeview import set_project_treeview
-from je_editor.utils.file.save.save_file import SaveThread
+from je_editor.pyside_ui.auto_save.auto_save_thread import SaveThread
+from je_editor.utils.redirect_manager.redirect_manager_class import redirect_manager_instance
 
 
 class EditorMain(QMainWindow):
@@ -21,6 +23,14 @@ class EditorMain(QMainWindow):
         self.current_file = None
         # Font
         self.font_database = QFontDatabase()
+        # Color
+        self.red_color: QColor = QColor(255, 0, 0)
+        self.black_color: QColor = QColor(0, 0, 0)
+        # 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)
@@ -33,6 +43,8 @@ class EditorMain(QMainWindow):
                 self.current_file,
                 self.code_edit.code_edit.toPlainText()
             )
+            self.auto_save_thread.start()
+        redirect_manager_instance.set_redirect(self, True)
 
     def add_font_menu(self):
         self.font_menu = self.text_menu.addMenu("Font")
@@ -67,3 +79,19 @@ class EditorMain(QMainWindow):
                 int(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(self.red_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(self.black_color)

je_editor/pyside_ui/main_ui_setting/ui_setting.py

@@ -1,4 +1,7 @@
-from PySide6.QtWidgets import QMainWindow, QScrollArea, QPlainTextEdit, QGridLayout, QWidget
+from PySide6 import QtGui
+from PySide6.QtWidgets import QMainWindow, QScrollArea, QPlainTextEdit, QGridLayout, QWidget, QTextEdit
+
+from je_editor.pyside_ui.syntax.python_syntax import PythonHighlighter
 
 
 def set_ui(ui_we_want_to_set: QMainWindow):
@@ -11,8 +14,11 @@ def set_ui(ui_we_want_to_set: QMainWindow):
     # code edit and code result plaintext
     ui_we_want_to_set.code_edit = QPlainTextEdit()
     ui_we_want_to_set.code_edit.setLineWrapMode(ui_we_want_to_set.code_edit.LineWrapMode.NoWrap)
-    ui_we_want_to_set.code_result = QPlainTextEdit()
-    ui_we_want_to_set.code_result.setLineWrapMode(ui_we_want_to_set.code_edit.LineWrapMode.NoWrap)
+    ui_we_want_to_set.code_edit.setTabStopDistance(
+        QtGui.QFontMetricsF(ui_we_want_to_set.code_edit.font()).horizontalAdvance(' ') * 4)
+    PythonHighlighter(ui_we_want_to_set.code_edit.document())
+    ui_we_want_to_set.code_result = QTextEdit()
+    ui_we_want_to_set.code_result.setLineWrapMode(ui_we_want_to_set.code_result.LineWrapMode.NoWrap)
     ui_we_want_to_set.code_result.setReadOnly(True)
     ui_we_want_to_set.code_edit_scroll_area = QScrollArea()
     ui_we_want_to_set.code_edit_scroll_area.setWidgetResizable(True)

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

@@ -1,25 +1,56 @@
 from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QMainWindow
 
+from je_editor.pyside_ui.code_process.code_exec import exec_manage
+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_run_menu(ui_we_want_to_set: QMainWindow):
-    # TODO run
+
     ui_we_want_to_set.run_program_action = QAction("Run Program")
-    ui_we_want_to_set.run_program_action.triggered.connect(temp)
+    ui_we_want_to_set.run_program_action.triggered.connect(
+        lambda: run_program(ui_we_want_to_set)
+    )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_program_action)
-    # TODO run on shell
     ui_we_want_to_set.run_on_shell_action = QAction("Run On Shell")
-    ui_we_want_to_set.run_on_shell_action.triggered.connect(temp)
+    ui_we_want_to_set.run_on_shell_action.triggered.connect(
+        lambda: shell_exec(ui_we_want_to_set)
+    )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_on_shell_action)
-    # TODO clean result
     ui_we_want_to_set.clean_result_action = QAction("Clean Result")
-    ui_we_want_to_set.clean_result_action.triggered.connect(temp)
+    ui_we_want_to_set.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.clean_result_action)
-    # TODO stop program
+
     ui_we_want_to_set.stop_program_action = QAction("Stop Program")
-    ui_we_want_to_set.stop_program_action.triggered.connect(temp)
+    ui_we_want_to_set.stop_program_action.triggered.connect(
+        stop_program
+    )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.stop_program_action)
 
 
-def temp():
-    print("temp")
+def run_program(ui_we_want_to_set):
+    choose_file_get_save_filename(ui_we_want_to_set)
+    exec_manage.main_window = ui_we_want_to_set
+    exec_manage.later_init()
+    exec_manage.exec_code(
+        ui_we_want_to_set.current_file
+    )
+
+
+def shell_exec(ui_we_want_to_set):
+    shell_manager.main_window = ui_we_want_to_set
+    shell_manager.later_init()
+    shell_manager.exec_shell(
+        ui_we_want_to_set.code_edit.toPlainText()
+    )
+
+
+def stop_program():
+    exec_manage.exit_program()
+
+
+def clean_result(ui_we_want_to_set):
+    ui_we_want_to_set.code_result.setPlainText("")

je_editor/pyside_ui/shell_process/shell_exec.py

@@ -0,0 +1,147 @@
+import queue
+import shlex
+import subprocess
+from threading import Thread
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QMainWindow, QTextEdit
+
+
+class ShellManager(object):
+
+    def __init__(
+            self,
+            main_window: QMainWindow = None,
+            shell_encoding: str = "utf-8",
+            program_buffer: int = 10240000,
+    ):
+        """
+        :param main_window: tkinter main window
+        """
+        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_shell: bool = True
+        self.process = None
+        self.run_output_queue: queue = queue.Queue()
+        self.run_error_queue: queue = queue.Queue()
+        self.program_encoding: str = shell_encoding
+        self.program_buffer: int = program_buffer
+
+    def later_init(self):
+        if self.main_window is not None:
+            self.code_result: QTextEdit = self.main_window.code_result
+        else:
+            # TODO Exception
+            raise Exception
+
+    def exec_shell(self, shell_command: str):
+        """
+        :param shell_command: shell command will run
+        :return: if error return result and True else return result and False
+        """
+        try:
+            self.exit_program()
+            self.code_result.setPlainText("")
+            # run shell command
+            args = shlex.split(shell_command)
+            self.process = subprocess.Popen(
+                args,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                shell=False,
+            )
+            self.still_run_shell = True
+            # program output message queue thread
+            self.read_program_output_from_thread = Thread(
+                target=self.read_program_output_from_process,
+                daemon=True
+            ).start()
+            # program error message queue thread
+            self.read_program_error_output_from_thread = Thread(
+                target=self.read_program_error_output_from_process,
+                daemon=True
+            ).start()
+            # 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(self.main_window.red_color)
+            self.code_result.append(str(error))
+            self.code_result.setTextColor(self.main_window.black_color)
+
+    # tkinter_ui update method
+    def pull_text(self):
+        try:
+            self.code_result.setTextColor(self.main_window.red_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(self.main_window.black_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.exit_program()
+        elif self.process.returncode is not None:
+            self.exit_program()
+            self.timer.stop()
+        if self.still_run_shell:
+            # 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_shell = 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()
+
+    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(self.main_window.red_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(self.main_window.black_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_shell:
+            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_shell:
+            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)
+
+
+shell_manager = ShellManager()

je_editor/pyside_ui/syntax/python_syntax.py

@@ -0,0 +1,97 @@
+from PySide6.QtCore import QRegularExpression
+from PySide6.QtGui import QColor
+from PySide6.QtGui import QFont
+from PySide6.QtGui import QSyntaxHighlighter
+from PySide6.QtGui import QTextCharFormat
+
+keywords = [
+    "False", "None", "True", "and", "as", "assert", "async", 
+    "await", "break", "class", "continue", "def", "del",
+    "elif", "else", "except", "finally", "for", "from", 
+    "global", "if", "import", "in", "is", "lambda", "nonlocal",
+    "not", "or", "pass", "raise", "return", "try", "while", "with", "yield"
+]
+
+builtins_keyword = [
+    "abs", "aiter", "all", "any", "anext", "ascii",
+    "bin", "bool", "breakpoint", "bytearray", "bytes",
+    "callable", "chr", "classmethod", "compile", "complex",
+    "delattr", "dict", "dir", "divmod",
+    "enumerate", "eval", "exec",
+    "filter", "float", "format", "frozenset",
+    "getattr", "globals",
+    "hasattr", "hash", "help", "hex",
+    "id", "input", "int", "isinstance", "issubclass", "iter",
+    "len", "list", "locals",
+    "map", "max", "memoryview", "min",
+    "next",
+    "object", "oct", "open", "ord",
+    "pow", "print", "property",
+    "range", "repr", "reversed", "round",
+    "set", "setattr", "slice", "sorted", "staticmethod",
+    "str", "sum", "super",
+    "tuple", "type",
+    "vars",
+    "zip",
+    "__import__"
+]
+
+string_rule = [
+    r"'[^'\\]*(\\.[^'\\]*)*'",  # Singel
+    r'"[^"\\]*(\\.[^"\\]*)*"'  # Double
+]
+
+number_rule = [
+    r"\b[+-]?[0-9]+[lL]?\b",
+    r"\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b",
+    r"\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b"
+]
+
+
+class PythonHighlighter(QSyntaxHighlighter):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.highlight_rules = []
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(255, 212, 102))
+        text_char_format.setFontWeight(QFont.Bold)
+        for word in keywords:
+            pattern = QRegularExpression(rf"\b{word}\b")
+            self.highlight_rules.append((pattern, text_char_format))
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(0, 153, 0))
+        for rule in string_rule:
+            pattern = QRegularExpression(rule)
+            self.highlight_rules.append((pattern, text_char_format))
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(0, 128, 255))
+        for rule in number_rule:
+            pattern = QRegularExpression(rule)
+            self.highlight_rules.append((pattern, text_char_format))
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(0, 0, 255))
+        for rule in builtins_keyword:
+            pattern = QRegularExpression(rule)
+            self.highlight_rules.append((pattern, text_char_format))
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(80, 80, 80))
+        pattern = QRegularExpression(r"#[^\n]*")
+        self.highlight_rules.append((pattern, text_char_format))
+
+        text_char_format = QTextCharFormat()
+        text_char_format.setForeground(QColor(204, 0, 204))
+        pattern = QRegularExpression(r"\bself\b")
+        self.highlight_rules.append((pattern, text_char_format))
+
+    def highlightBlock(self, text):
+        for pattern, format in self.highlight_rules:
+            match_iterator = pattern.globalMatch(text)
+            while match_iterator.hasNext():
+                match = match_iterator.next()
+                self.setFormat(match.capturedStart(), match.capturedLength(), format)

je_editor/pyside_ui/treeview/project_treeview/set_project_treeview.py

@@ -27,7 +27,10 @@ def treeview_click(ui_we_want_to_set):
     model = clicked_item.model()
     path = pathlib.Path(os.getcwd() + "/" + model.data(clicked_item))
     if path.is_file():
-        file_content = read_file(path)[1]
+        file, file_content = read_file(path)
         ui_we_want_to_set.code_edit.setPlainText(
             file_content
         )
+        ui_we_want_to_set.current_file = file
+        if ui_we_want_to_set.auto_save_thread is not None:
+            ui_we_want_to_set.auto_save_thread.file = ui_we_want_to_set.current_file

je_editor/utils/file/save/save_file.py

@@ -29,31 +29,3 @@ def write_file(file, content):
     finally:
         lock.release()
 
-
-class SaveThread(Thread):
-
-    def __init__(self, file_to_save, text_to_write, auto_save=False):
-        """
-        :param file_to_save: file we want to auto save
-        :param text_to_write: text that will be output to file
-        :param auto_save: enable auto save or not
-        """
-        super().__init__()
-        self.file = file_to_save
-        self.path = None
-        self.text_to_write = text_to_write
-        self.auto_save = auto_save
-        # set daemon
-        self.daemon = True
-
-    def run(self):
-        # loop and save current edit file
-        if self.file is not None:
-            self.auto_save = True
-            self.path = Path(self.file)
-        while self.auto_save and self.file is not None:
-            time.sleep(15)
-            if self.path.exists() and self.path.is_file():
-                write_file(self.file, self.text_to_write)
-            else:
-                break

{je_editor-0.0.62.dist-info → je_editor-0.0.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: je-editor
-Version: 0.0.62
+Version: 0.0.64
 Summary: Simple editor for ITE
 Author-email: JE-Chen <zenmailman@gmail.com>
 License: MIT

{je_editor-0.0.62.dist-info → je_editor-0.0.64.dist-info}/RECORD

@@ -3,24 +3,32 @@ je_editor/__main__.py,sha256=tv19PbVG_8bg4HhRWINNYL_Zu6VtkJR00U_0v56GsK8,598
 je_editor/start_editor.py,sha256=ftqzkeMH8QrMbd73HraN7lajLDZ3DyIKYz48fBl-bwU,293
 je_editor/pyside_ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+je_editor/pyside_ui/auto_save/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+je_editor/pyside_ui/auto_save/auto_save_thread.py,sha256=IE2Uqf1lRewHeQX4iFmws_mbcHNywBuhiJy7DL_X6Sg,1071
+je_editor/pyside_ui/code_process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+je_editor/pyside_ui/code_process/code_exec.py,sha256=QCMsPvH01KgHdD0chD7P7mXeiHcvk_4LdmWnCR6M5eY,7200
 je_editor/pyside_ui/file_dialog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/file_dialog/open_file_dialog.py,sha256=BIoGImR9OT-9_Bn-9AmdoSaijqVTRokcFJ1d0WGlXOI,688
-je_editor/pyside_ui/file_dialog/save_file_dialog.py,sha256=6oHdpsVL-LAquRsvc0DFtvCjiJZI_bjqmJmcrajHD4w,879
+je_editor/pyside_ui/file_dialog/save_file_dialog.py,sha256=NedfsxGVtBbJLJ9IB6xnlk9-IuWNOVDJBdZtE-Fz9mY,995
 je_editor/pyside_ui/main_ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/main_ui/editor_main_ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-je_editor/pyside_ui/main_ui/editor_main_ui/main_editor.py,sha256=p-c0xQ_QPCsuPo0rOQu5DsmAn0sjD_tLA1RaroMTYl4,2487
+je_editor/pyside_ui/main_ui/editor_main_ui/main_editor.py,sha256=r_ZFpZ-j637tfcUi_NsOsU_iOoNVmY3LQD-FP3z1w0M,3942
 je_editor/pyside_ui/main_ui_setting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-je_editor/pyside_ui/main_ui_setting/ui_setting.py,sha256=krCBQJUwikgGSKfM-_ULgbIcSXVhUaSVhcsJ5WAEr1w,1763
+je_editor/pyside_ui/main_ui_setting/ui_setting.py,sha256=d0C_hrCy3lAkd3D1PkWqQpP7A3QTOvEqYTSUNhoCaXo,2081
 je_editor/pyside_ui/menu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/menu/menu_bar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/menu/menu_bar/set_menu_bar.py,sha256=HFvkCjhlQ2WTsMdBTMMLX-1lnlX75Zmp2txHJwtmBUE,617
 je_editor/pyside_ui/menu/menu_bar/file_menu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/menu/menu_bar/file_menu/build_file_menu.py,sha256=mHqlIC-P5Z8divvgJlNX4414SV4quGgIxCtcNl8-Z7c,1159
 je_editor/pyside_ui/menu/menu_bar/run_menu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-je_editor/pyside_ui/menu/menu_bar/run_menu/build_run_menu.py,sha256=MGVxR4KilxTDRUM2YEjITDnuY5v2RVkthLo8VYG-IZs,1124
+je_editor/pyside_ui/menu/menu_bar/run_menu/build_run_menu.py,sha256=YjyoNiPx95o0jhv5CAClBqrH8n6cmYdlTebwsCe7edo,2021
+je_editor/pyside_ui/shell_process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+je_editor/pyside_ui/shell_process/shell_exec.py,sha256=AW7rHDlJXxUcW7gdFtdkthmH5ucLDNk3kUwWrBx1m_0,5827
+je_editor/pyside_ui/syntax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+je_editor/pyside_ui/syntax/python_syntax.py,sha256=n3HI76WuSSYei4OtppX_jz7F3-VPUCLTkGFUMSKa3v4,3636
 je_editor/pyside_ui/treeview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/pyside_ui/treeview/project_treeview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-je_editor/pyside_ui/treeview/project_treeview/set_project_treeview.py,sha256=bTgIrmD9uPFoTWpdOvt_PfXgMO4dcVTROylZQxwwuv4,1344
+je_editor/pyside_ui/treeview/project_treeview/set_project_treeview.py,sha256=kGYpIUQWwG_6iMzkISGy4zOvIT32IF3MMUo27QmCt7o,1540
 je_editor/utils/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 je_editor/utils/exception/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 je_editor/utils/exception/exception_tags.py,sha256=OAe_4H8Th-5wUNZ80O0NnSxiEgWEF5SxHavFrxovyBs,910
@@ -29,15 +37,15 @@ je_editor/utils/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 je_editor/utils/file/open/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 je_editor/utils/file/open/open_file.py,sha256=U7stxZAYWSMlrhXbAWQOusq-rBfB8utS2LY9a76CQ94,962
 je_editor/utils/file/save/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-je_editor/utils/file/save/save_file.py,sha256=2H_kL55Dh0XkW9f1p7kxIP7MTzBZrTJ1vrKvVBTGjak,1727
+je_editor/utils/file/save/save_file.py,sha256=5KLWuXXMwvTFLi5RG3xBHdyIcaThUERxMoHbnPLieaY,788
 je_editor/utils/json_format/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 je_editor/utils/json_format/json_process.py,sha256=Ic-OpIueSYmtWgnHPP_RzM3dlSmKTsGdLm22pypLb5M,983
 je_editor/utils/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/utils/project/create_project.py,sha256=uMxlCuIWh-Dp0yiY5GaaN-mWffpp8Odm1X7dz3yQ8jw,398
 je_editor/utils/redirect_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 je_editor/utils/redirect_manager/redirect_manager_class.py,sha256=0HX7XyFhN8cFaZefKUsE1MrpQIcnLozrvNTMOsfV5zU,1991
-je_editor-0.0.62.dist-info/LICENSE,sha256=YcSMBs2sED35BtlErMkfIDye9Oo-3SYmUJiZJOpa34g,1085
-je_editor-0.0.62.dist-info/METADATA,sha256=9mgeeWurEOAIYNA0UcpTcOhUPauNbGCXgiAC-bmoHI8,3847
-je_editor-0.0.62.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-je_editor-0.0.62.dist-info/top_level.txt,sha256=_9YA7BgxpkmdLs-5V_UQILxClcMRgPyG1a3qaE-Bkcs,10
-je_editor-0.0.62.dist-info/RECORD,,
+je_editor-0.0.64.dist-info/LICENSE,sha256=YcSMBs2sED35BtlErMkfIDye9Oo-3SYmUJiZJOpa34g,1085
+je_editor-0.0.64.dist-info/METADATA,sha256=l6PmVbTIJ3_9b2NMbYD3JmfVWoMkNoMbRzDex09YYo0,3847
+je_editor-0.0.64.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+je_editor-0.0.64.dist-info/top_level.txt,sha256=_9YA7BgxpkmdLs-5V_UQILxClcMRgPyG1a3qaE-Bkcs,10
+je_editor-0.0.64.dist-info/RECORD,,