je-editor 0.0.62__tar.gz → 0.0.64__tar.gz

{je_editor-0.0.62 → je_editor-0.0.64}/PKG-INFO

@@ -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/je_editor/utils/file/save/save_file.py → je_editor-0.0.64/je_editor/pyside_ui/auto_save/auto_save_thread.py

@@ -1,33 +1,8 @@
 import time
 from pathlib import Path
-from threading import Lock
 from threading import Thread
 
-from je_editor.utils.exception.exceptions import JEditorSaveFileException
-
-
-def write_file(file, content):
-    """
-    :param file: file we want to write
-    :param content: content write in file
-    try
-        lock thread
-        if file not empty string
-            write content to file
-    finally
-        release lock
-    """
-    lock = Lock()
-    content = str(content)
-    try:
-        lock.acquire()
-        if file != "" and file is not None:
-            with open(file, "w+") as file_to_write:
-                file_to_write.write(content)
-    except JEditorSaveFileException:
-        raise JEditorSaveFileException
-    finally:
-        lock.release()
+from je_editor.utils.file.save.save_file import write_file
 
 
 class SaveThread(Thread):
@@ -52,7 +27,7 @@ class SaveThread(Thread):
             self.auto_save = True
             self.path = Path(self.file)
         while self.auto_save and self.file is not None:
-            time.sleep(15)
+            time.sleep(5)
             if self.path.exists() and self.path.is_file():
                 write_file(self.file, self.text_to_write)
             else:

je_editor-0.0.64/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-0.0.62 → je_editor-0.0.64}/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-0.0.62 → je_editor-0.0.64}/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-0.0.62 → je_editor-0.0.64}/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-0.0.64/je_editor/pyside_ui/menu/menu_bar/run_menu/build_run_menu.py

@@ -0,0 +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):
+
+    ui_we_want_to_set.run_program_action = QAction("Run Program")
+    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)
+    ui_we_want_to_set.run_on_shell_action = QAction("Run On Shell")
+    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)
+    ui_we_want_to_set.clean_result_action = QAction("Clean Result")
+    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)
+
+    ui_we_want_to_set.stop_program_action = QAction("Stop Program")
+    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 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-0.0.64/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-0.0.64/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-0.0.62 → je_editor-0.0.64}/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-0.0.64/je_editor/utils/file/save/save_file.py

@@ -0,0 +1,31 @@
+import time
+from pathlib import Path
+from threading import Lock
+from threading import Thread
+
+from je_editor.utils.exception.exceptions import JEditorSaveFileException
+
+
+def write_file(file, content):
+    """
+    :param file: file we want to write
+    :param content: content write in file
+    try
+        lock thread
+        if file not empty string
+            write content to file
+    finally
+        release lock
+    """
+    lock = Lock()
+    content = str(content)
+    try:
+        lock.acquire()
+        if file != "" and file is not None:
+            with open(file, "w+") as file_to_write:
+                file_to_write.write(content)
+    except JEditorSaveFileException:
+        raise JEditorSaveFileException
+    finally:
+        lock.release()
+

{je_editor-0.0.62 → je_editor-0.0.64}/je_editor.egg-info/PKG-INFO

@@ -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 → je_editor-0.0.64}/je_editor.egg-info/SOURCES.txt

@@ -11,6 +11,10 @@ je_editor.egg-info/requires.txt
 je_editor.egg-info/top_level.txt
 je_editor/pyside_ui/__init__.py
 je_editor/pyside_ui/actions/__init__.py
+je_editor/pyside_ui/auto_save/__init__.py
+je_editor/pyside_ui/auto_save/auto_save_thread.py
+je_editor/pyside_ui/code_process/__init__.py
+je_editor/pyside_ui/code_process/code_exec.py
 je_editor/pyside_ui/file_dialog/__init__.py
 je_editor/pyside_ui/file_dialog/open_file_dialog.py
 je_editor/pyside_ui/file_dialog/save_file_dialog.py
@@ -26,6 +30,10 @@ je_editor/pyside_ui/menu/menu_bar/file_menu/__init__.py
 je_editor/pyside_ui/menu/menu_bar/file_menu/build_file_menu.py
 je_editor/pyside_ui/menu/menu_bar/run_menu/__init__.py
 je_editor/pyside_ui/menu/menu_bar/run_menu/build_run_menu.py
+je_editor/pyside_ui/shell_process/__init__.py
+je_editor/pyside_ui/shell_process/shell_exec.py
+je_editor/pyside_ui/syntax/__init__.py
+je_editor/pyside_ui/syntax/python_syntax.py
 je_editor/pyside_ui/treeview/__init__.py
 je_editor/pyside_ui/treeview/project_treeview/__init__.py
 je_editor/pyside_ui/treeview/project_treeview/set_project_treeview.py

{je_editor-0.0.62 → je_editor-0.0.64}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "je_editor"
-version = "0.0.62"
+version = "0.0.64"
 authors = [
     { name = "JE-Chen", email = "zenmailman@gmail.com" },
 ]

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

@@ -1,25 +0,0 @@
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import QMainWindow
-
-
-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_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_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.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.run_menu.addAction(ui_we_want_to_set.stop_program_action)
-
-
-def temp():
-    print("temp")