je-editor 0.0.182__py3-none-any.whl → 0.0.183__py3-none-any.whl

je_editor/__init__.py

@@ -1,4 +1,4 @@
-from je_editor.pyside_ui.browser.browser_widget import JEBrowser
+from je_editor.pyside_ui.browser.browser_widget import BrowserWidget
 from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
 from je_editor.pyside_ui.code.shell_process.shell_exec import ShellManager
 from je_editor.pyside_ui.code.syntax.python_syntax import PythonHighlighter
@@ -28,7 +28,7 @@ __all__ = [
     "JEditorRunOnShellException", "JEditorSaveFileException", "syntax_rule_setting_dict",
     "JEditorOpenFileException", "JEditorContentFileException", "syntax_word_setting_dict",
     "JEditorCantFindLanguageException", "JEditorJsonException", "PythonHighlighter",
-    "user_setting_dict", "user_setting_color_dict", "EditorWidget", "JEBrowser",
+    "user_setting_dict", "user_setting_color_dict", "EditorWidget", "BrowserWidget",
     "ExecManager", "ShellManager", "traditional_chinese_word_dict", "english_word_dict",
     "language_wrapper"
 ]

je_editor/pyside_ui/browser/browser_download_window.py

@@ -2,6 +2,7 @@ from PySide6.QtCore import Qt
 from PySide6.QtWebEngineCore import QWebEngineDownloadRequest
 from PySide6.QtWidgets import QWidget, QBoxLayout, QPlainTextEdit
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
@@ -9,6 +10,8 @@ class BrowserDownloadWindow(QWidget):
 
     def __init__(self, download_instance: QWebEngineDownloadRequest):
         super().__init__()
+        jeditor_logger.info(f"Init BrowserDownloadWindow "
+                            f"download_instance: {download_instance}")
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
         self.show_download_detail_plaintext = QPlainTextEdit()
@@ -22,11 +25,15 @@ class BrowserDownloadWindow(QWidget):
         self.box_layout.addWidget(self.show_download_detail_plaintext)
         self.setLayout(self.box_layout)
 
+
     def print_finish(self):
+        jeditor_logger.info("BrowserDownloadWindow Print Download is Finished")
         self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.isFinished()))
 
     def print_interrupt(self):
+        jeditor_logger.info("BrowserDownloadWindow Print interruptReason")
         self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.interruptReason()))
 
     def print_state(self):
+        jeditor_logger.info("BrowserDownloadWindow Print State")
         self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.state()))

je_editor/pyside_ui/browser/browser_serach_lineedit.py

@@ -5,18 +5,23 @@ from typing import TYPE_CHECKING
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QLineEdit
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
 if TYPE_CHECKING:
-    from je_editor.pyside_ui.browser.browser_widget import JEBrowser
+    from je_editor.pyside_ui.browser.browser_widget import BrowserWidget
 
 
 class BrowserLineSearch(QLineEdit):
 
-    def __init__(self, browser_widget: JEBrowser):
+    def __init__(self, browser_widget: BrowserWidget):
         super().__init__()
+        jeditor_logger.info(f"Init BrowserLineSearch "
+                            f"browser_widget: {browser_widget}")
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
         self.browser = browser_widget
 
     def keyPressEvent(self, event) -> None:
         if event.key() in [Qt.Key.Key_Enter, Qt.Key.Key_Return]:
+            jeditor_logger.info("Browser Search")
             self.browser.search()
         super().keyPressEvent(event)

je_editor/pyside_ui/browser/browser_view.py

@@ -5,12 +5,15 @@ from PySide6.QtWebEngineCore import QWebEngineDownloadRequest
 from PySide6.QtWebEngineWidgets import QWebEngineView
 
 from je_editor.pyside_ui.browser.browser_download_window import BrowserDownloadWindow
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 class BrowserView(QWebEngineView):
 
     def __init__(self, start_url: str = "https://www.google.com/"):
         super().__init__()
+        jeditor_logger.info(f"Init BrowserView "
+                            f"start_url: {start_url}")
         self.setUrl(start_url)
         self.download_list: List[QWebEngineDownloadRequest] = list()
         self.download_window_list: List[BrowserDownloadWindow] = list()
@@ -18,12 +21,15 @@ class BrowserView(QWebEngineView):
         self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
 
     def download_file(self, download_instance: QWebEngineDownloadRequest):
+        jeditor_logger.info(f"Download File "
+                            f"download_instance: {download_instance}")
         self.download_list.append(download_instance)
         download_detail_window = BrowserDownloadWindow(download_instance)
         self.download_window_list.append(download_detail_window)
         download_detail_window.show()
 
     def closeEvent(self, event) -> None:
+        jeditor_logger.info(f"BrowserView closeEvent event: {event}")
         for download_instance in self.download_list:
             download_instance.cancel()
         for download_window in self.download_window_list:

je_editor/pyside_ui/browser/browser_widget.py

@@ -3,14 +3,18 @@ from PySide6.QtWidgets import QWidget, QGridLayout, QPushButton, QInputDialog
 
 from je_editor.pyside_ui.browser.browser_serach_lineedit import BrowserLineSearch
 from je_editor.pyside_ui.browser.browser_view import BrowserView
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
-class JEBrowser(QWidget):
+class BrowserWidget(QWidget):
 
     def __init__(self, start_url: str = "https://www.google.com/",
                  search_prefix: str = "https://www.google.com.tw/search?q="):
         super().__init__()
+        jeditor_logger.info(f"Init BrowserWidget "
+                            f"start_url: {start_url} "
+                            f"search_prefix: {search_prefix}")
         # Browser setting
         self.browser = BrowserView(start_url)
         self.search_prefix = search_prefix
@@ -41,9 +45,11 @@ class JEBrowser(QWidget):
         self.setLayout(self.grid_layout)
 
     def search(self):
+        jeditor_logger.info("BrowserWidget Search")
         self.browser.setUrl(f"{self.search_prefix}{self.url_input.text()}")
 
     def find_text(self):
+        jeditor_logger.info("BrowserWidget Find Text")
         search_box = QInputDialog(self)
         search_text, press_ok = search_box.getText(
             self, language_wrapper.language_word_dict.get("browser_find_text"),

je_editor/pyside_ui/code/auto_save/auto_save_manager.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorWidget
 
@@ -13,6 +15,9 @@ file_is_open_manager_dict: dict = dict()
 
 
 def init_new_auto_save_thread(file_path: str, widget: EditorWidget):
+    jeditor_logger.info(f"auto_save_manager.py init_new_auto_save_thread "
+                        f"file_path: {file_path} "
+                        f"widget: {widget}")
     widget.current_file = file_path
     if auto_save_manager_dict.get(file_path, None) is None:
         widget.code_save_thread = CodeEditSaveThread(

je_editor/pyside_ui/code/auto_save/auto_save_thread.py

@@ -5,6 +5,7 @@ from typing import Union
 
 from je_editor.pyside_ui.code.plaintext_code_edit.code_edit_plaintext import CodeEditor
 from je_editor.utils.file.save.save_file import write_file
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 class CodeEditSaveThread(Thread):
@@ -16,6 +17,9 @@ class CodeEditSaveThread(Thread):
         :param file_to_save: file we want to auto save
         :param editor: code editor to auto save
         """
+        jeditor_logger.info(f"Init CodeEditSaveThread "
+                            f"file_to_save: {file_to_save} "
+                            f"editor: {editor}")
         super().__init__()
         self.file: str = file_to_save
         self.editor: Union[None, CodeEditor] = editor
@@ -27,6 +31,7 @@ class CodeEditSaveThread(Thread):
         """
         loop and save current edit file
         """
+        jeditor_logger.info("CodeEditSaveThread run")
         if self.file is not None:
             path = Path(self.file)
             while path.is_file() and self.editor is not None:

je_editor/pyside_ui/code/code_format/pep8_format.py

@@ -2,10 +2,15 @@ import tokenize
 
 import pycodestyle
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
 
 class PEP8FormatChecker(pycodestyle.Checker):
 
     def __init__(self, filename: str, **kwargs):
+        jeditor_logger.info(f"Init PEP8FormatChecker "
+                            f"filename: {filename} "
+                            f"kwargs: {kwargs}")
         super().__init__(filename, **kwargs)
         # Init variable
         self.physical_line = None
@@ -21,14 +26,22 @@ class PEP8FormatChecker(pycodestyle.Checker):
         self.total_lines = None
         self.new_line = frozenset([tokenize.NL, tokenize.NEWLINE])
         self.report_error = self.replace_report_error
+        self.current_file: str = filename
         self.error_list: list = list()
 
     def replace_report_error(self, line_number, offset, text, check):
+        jeditor_logger.info(f"PEP8FormatChecker replace_report_error "
+                            f"line_number: {line_number} "
+                            f"offset: {offset} "
+                            f"text: {text}")
         if not text.startswith("W191"):
             self.error_list.append(f"{text} on line: {line_number}, offset: {offset}")
 
     def check_all_format(self, expected=None, line_offset=0) -> int:
         """Run all checks on the input file."""
+        jeditor_logger.info(f"PEP8FormatChecker check_all_format "
+                            f"expected: {expected} "
+                            f"line_offset: {line_offset}")
         self.report.init_file(self.filename, self.lines, expected, line_offset)
         self.total_lines = len(self.lines)
         if self._ast_checks:

je_editor/pyside_ui/code/code_process/code_exec.py

@@ -15,6 +15,7 @@ from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
 from je_editor.utils.exception.exception_tags import je_editor_init_error
 from je_editor.utils.exception.exceptions import JEditorException
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.venv_check.check_venv import check_and_choose_venv
 
 
@@ -32,6 +33,11 @@ class ExecManager(object):
         :param program_language: which program language
         :param program_encoding: which encoding
         """
+        jeditor_logger.info(f"Init ExecManager "
+                            f"main_window: {main_window} "
+                            f"program_language: {program_language} "
+                            f"program_encoding: {program_encoding} "
+                            f"program_buffer: {program_buffer}")
         self.read_program_error_output_from_thread = None
         self.read_program_output_from_thread = None
         self.main_window: EditorWidget = main_window
@@ -49,6 +55,7 @@ class ExecManager(object):
         run_instance_manager.instance_list.append(self)
 
     def renew_path(self) -> None:
+        jeditor_logger.info("ExecManager renew_path")
         if self.main_window.python_compiler is None:
             # Renew compiler path
             if sys.platform in ["win32", "cygwin", "msys"]:
@@ -60,6 +67,7 @@ class ExecManager(object):
             self.compiler_path = self.main_window.python_compiler
 
     def later_init(self) -> None:
+        jeditor_logger.info("ExecManager later_init")
         # Enable timer and code result area
         if self.main_window is not None:
             self.code_result: QTextEdit = self.main_window.code_result
@@ -73,6 +81,9 @@ class ExecManager(object):
         :param exec_prefix: user define exec prefix
         :return: if error return result and True else return result and False
         """
+        jeditor_logger.info(f"ExecManager exec_code "
+                            f"exec_file_name: {exec_file_name} "
+                            f"exec_prefix: {exec_prefix}")
         try:
             self.exit_program()
             self.code_result.setTextColor(actually_color_dict.get("normal_output_color"))
@@ -131,11 +142,13 @@ class ExecManager(object):
                 self.process.terminate()
 
     def full_exit_program(self):
+        jeditor_logger.info("ExecManager full_exit_program")
         self.timer.stop()
         self.exit_program()
         self.main_window.exec_program = None
 
     def pull_text(self) -> None:
+        jeditor_logger.info("ExecManager pull_text")
         # Pull text from queue and put in code result area
         try:
             self.code_result.setTextColor(actually_color_dict.get("normal_output_color"))
@@ -163,6 +176,7 @@ class ExecManager(object):
 
     # Exit program change run flag to false and clean read thread and queue and process
     def exit_program(self) -> None:
+        jeditor_logger.info("ExecManager exit_program")
         self.still_run_program = False
         if self.read_program_output_from_thread is not None:
             self.read_program_output_from_thread = None
@@ -176,10 +190,12 @@ class ExecManager(object):
 
     # Pull all remain string on queue and add to code result area
     def print_and_clear_queue(self) -> None:
+        jeditor_logger.info("ExecManager print_and_clear_queue")
         self.run_output_queue = queue.Queue()
         self.run_error_queue = queue.Queue()
 
     def read_program_output_from_process(self) -> None:
+        jeditor_logger.info("ExecManager read_program_output_from_process")
         while self.still_run_program:
             program_output_data: str = self.process.stdout.read(
                 self.program_buffer).decode(self.program_encoding, "replace")
@@ -188,6 +204,7 @@ class ExecManager(object):
             self.run_output_queue.put_nowait(program_output_data)
 
     def read_program_error_output_from_process(self) -> None:
+        jeditor_logger.info("ExecManager read_program_error_output_from_process")
         while self.still_run_program:
             program_error_output_data: str = self.process.stderr.read(
                 self.program_buffer).decode(self.program_encoding, "replace")

je_editor/pyside_ui/code/plaintext_code_edit/code_edit_plaintext.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
     from je_editor.pyside_ui.main_ui.editor.editor_widget_dock import FullEditorWidget
@@ -22,6 +24,7 @@ from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import ac
 
 
 def venv_check():
+    jeditor_logger.info("code_edit_plaintext.py venv check")
     venv_path = Path(str(Path.cwd()) + "/venv")
     return venv_path
 
@@ -33,6 +36,7 @@ class CodeEditor(QPlainTextEdit):
     """
 
     def __init__(self, main_window: Union[EditorWidget, FullEditorWidget]):
+        jeditor_logger.info(f"Init CodeEditor main_window: {main_window}")
         super().__init__()
         # Jedi
         self.env = None
@@ -76,6 +80,7 @@ class CodeEditor(QPlainTextEdit):
         self.set_complete([])
 
     def check_env(self):
+        jeditor_logger.info("CodeEditor check_env")
         path = venv_check()
         if path.exists():
             self.env = jedi.create_environment(str(path))
@@ -86,6 +91,7 @@ class CodeEditor(QPlainTextEdit):
         :param list_to_complete: keyword list to complete.
         :return: None
         """
+        jeditor_logger.info(f"CodeEditor set_complete list_to_complete: {list_to_complete}")
         completer = QCompleter(list_to_complete)
         completer.activated.connect(self.insert_completion)
         completer.setWidget(self)
@@ -100,6 +106,7 @@ class CodeEditor(QPlainTextEdit):
         :param completion: completion text
         :return: None
         """
+        jeditor_logger.info(f"CodeEditor insert_completion completion:{completion}")
         if self.completer.widget() != self:
             return
         text_cursor = self.textCursor()
@@ -111,12 +118,14 @@ class CodeEditor(QPlainTextEdit):
 
     @property
     def text_under_cursor(self):
+        jeditor_logger.info("CodeEditor text_under_cursor")
         # Find text under cursor
         text_cursor = self.textCursor()
         text_cursor.select(QTextCursor.SelectionType.WordUnderCursor)
         return text_cursor.selectedText()
 
     def focusInEvent(self, e) -> None:
+        jeditor_logger.info(f"CodeEditor focusInEvent event: {e}")
         if self.completer:
             self.completer.setWidget(self)
         QPlainTextEdit.focusInEvent(self, e)
@@ -126,6 +135,7 @@ class CodeEditor(QPlainTextEdit):
         Keyword autocomplete
         :return:  None
         """
+        jeditor_logger.info("CodeEditor complete")
         prefix = self.text_under_cursor
         if self.env is not None:
             script = jedi.Script(code=self.toPlainText(), environment=self.env)
@@ -152,6 +162,7 @@ class CodeEditor(QPlainTextEdit):
         Show search box ui and bind.
         :return: None
         """
+        jeditor_logger.info("CodeEditor start_search_dialog")
         # Search box connect to function
         self.search_box = SearchBox()
         self.search_box.search_back_button.clicked.connect(
@@ -167,6 +178,7 @@ class CodeEditor(QPlainTextEdit):
         Find next match text.
         :return: None
         """
+        jeditor_logger.info("CodeEditor find_next_text")
         if self.search_box.isVisible():
             text = self.search_box.command_input.text()
             self.find(text)
@@ -176,11 +188,13 @@ class CodeEditor(QPlainTextEdit):
         Find back match text.
         :return: None
         """
+        jeditor_logger.info("CodeEditor find_back_text")
         if self.search_box.isVisible():
             text = self.search_box.command_input.text()
             self.find(text, QTextDocument.FindFlag.FindBackward)
 
     def line_number_paint(self, event) -> None:
+        jeditor_logger.info(f"CodeEditor line_number_paint event: {event}")
         painter = QPainter(self.line_number)
         painter.fillRect(event.rect(), actually_color_dict.get("line_number_background_color"))
         block = self.firstVisibleBlock()
@@ -205,11 +219,13 @@ class CodeEditor(QPlainTextEdit):
             block_number += 1
 
     def line_number_width(self) -> int:
+        jeditor_logger.info("CodeEditor line_number_width")
         digits = len(str(self.blockCount()))
         space = 12 * digits
         return space
 
     def update_line_number_area_width(self, value) -> None:
+        jeditor_logger.info(f"CodeEditor update_line_number_area_width value: {value}")
         self.setViewportMargins(self.line_number_width(), 0, 0, 0)
 
     def resizeEvent(self, event) -> None:
@@ -218,6 +234,7 @@ class CodeEditor(QPlainTextEdit):
         :param event: QT event.
         :return: None
         """
+        jeditor_logger.info(f"CodeEditor resizeEvent event:{event}")
         QPlainTextEdit.resizeEvent(self, event)
         cr = self.contentsRect()
         self.line_number.setGeometry(
@@ -231,6 +248,7 @@ class CodeEditor(QPlainTextEdit):
         :param dy: update or not.
         :return: None
         """
+        jeditor_logger.info(f"CodeEditor update_line_number_area rect: {rect}, dy: {dy}")
         if dy:
             self.line_number.scroll(0, dy)
         else:
@@ -248,6 +266,7 @@ class CodeEditor(QPlainTextEdit):
         Change current line color.
         :return: None
         """
+        jeditor_logger.info("CodeEditor highlight_current_line")
         selections = []
         if not self.isReadOnly():
             formats = QTextCharFormat()
@@ -269,6 +288,7 @@ class CodeEditor(QPlainTextEdit):
         """
         # Catch soft wrap shift + return (line nuber not working on soft warp)
         key = event.key()
+        jeditor_logger.info(f"CodeEditor keyPressEvent event: {event} key: {key}")
         if event.modifiers() and Qt.Modifier.CTRL:
             if key == Qt.Key.Key_B:
                 if self.env is not None:
@@ -301,6 +321,7 @@ class CodeEditor(QPlainTextEdit):
             self.complete()
 
     def mousePressEvent(self, event) -> None:
+        jeditor_logger.info(f"CodeEditor mousePressEvent event: {event}")
         # Highlight mouse click line
         super().mousePressEvent(event)
         self.highlight_current_line()
@@ -312,8 +333,10 @@ class LineNumber(QWidget):
     """
 
     def __init__(self, editor):
+        jeditor_logger.info("Init LineNumber")
         QWidget.__init__(self, parent=editor)
         self.editor = editor
 
     def paintEvent(self, event) -> None:
+        jeditor_logger.info(f"LineNumber paintEvent event: {event}")
         self.editor.line_number_paint(event)

je_editor/pyside_ui/code/running_process_manager.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+
 if TYPE_CHECKING:
     from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
     from je_editor.pyside_ui.code.shell_process.shell_exec import ShellManager
@@ -12,9 +14,11 @@ from typing import List, Union
 class RunInstanceManager(object):
 
     def __init__(self):
+        jeditor_logger.info("Init RunInstanceManager")
         self.instance_list: List[Union[ExecManager, ShellManager]] = list()
 
     def close_all_instance(self):
+        jeditor_logger.info("RunInstanceManager close_all_instance")
         for manager in self.instance_list:
             if manager.process is not None:
                 manager.process.terminate()

je_editor/pyside_ui/code/shell_process/shell_exec.py

@@ -17,6 +17,7 @@ from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
 from je_editor.utils.exception.exception_tags import je_editor_init_error
 from je_editor.utils.exception.exceptions import JEditorException
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.venv_check.check_venv import check_and_choose_venv
 
 
@@ -29,6 +30,11 @@ class ShellManager(object):
             program_buffer: int = 1024,
             after_done_function: Union[None, Callable] = None
     ):
+        jeditor_logger.info(f"Init ShellManager "
+                            f"main_window: {main_window} "
+                            f"shell_encoding: {shell_encoding} "
+                            f"program_buffer: {program_buffer} "
+                            f"after_done_function: {after_done_function}")
         """
         :param main_window: Pyside main window
         :param shell_encoding: shell command read output encoding
@@ -51,6 +57,7 @@ class ShellManager(object):
         run_instance_manager.instance_list.append(self)
 
     def renew_path(self) -> None:
+        jeditor_logger.info("ShellManager renew_path")
         if self.main_window.python_compiler is None:
             # Renew compiler path
             if sys.platform in ["win32", "cygwin", "msys"]:
@@ -62,6 +69,7 @@ class ShellManager(object):
             self.compiler_path = self.main_window.python_compiler
 
     def later_init(self) -> None:
+        jeditor_logger.info("ShellManager later_init")
         if self.main_window is not None:
             self.code_result: QTextEdit = self.main_window.code_result
         else:
@@ -72,6 +80,7 @@ class ShellManager(object):
         :param shell_command: shell command will run
         :return: if error return result and True else return result and False
         """
+        jeditor_logger.info(f"ShellManager exec_shell, shell_command: {shell_command}")
         try:
             self.exit_program()
             self.code_result.setTextColor(actually_color_dict.get("normal_output_color"))
@@ -115,6 +124,7 @@ class ShellManager(object):
 
     # tkinter_ui update method
     def pull_text(self) -> None:
+        jeditor_logger.info("ShellManager pull_text")
         try:
             self.code_result.setTextColor(actually_color_dict.get("normal_output_color"))
             if not self.run_output_queue.empty():
@@ -140,6 +150,7 @@ class ShellManager(object):
             self.process.poll()
 
     def process_run_over(self):
+        jeditor_logger.info("ShellManager process_run_over")
         self.timer.stop()
         self.exit_program()
         self.main_window.exec_shell = None
@@ -148,6 +159,7 @@ class ShellManager(object):
 
     # exit program change run flag to false and clean read thread and queue and process
     def exit_program(self) -> None:
+        jeditor_logger.info("ShellManager exit_program")
         self.still_run_shell = False
         if self.read_program_output_from_thread is not None:
             self.read_program_output_from_thread = None
@@ -160,10 +172,12 @@ class ShellManager(object):
             self.process = None
 
     def print_and_clear_queue(self) -> None:
+        jeditor_logger.info("ShellManager print_and_clear_queue")
         self.run_output_queue = queue.Queue()
         self.run_error_queue = queue.Queue()
 
     def read_program_output_from_process(self) -> None:
+        jeditor_logger.info("ShellManager read_program_output_from_process")
         while self.still_run_shell:
             program_output_data = self.process.stdout.read(
                 self.program_buffer) \
@@ -173,6 +187,7 @@ class ShellManager(object):
             self.run_output_queue.put_nowait(program_output_data)
 
     def read_program_error_output_from_process(self) -> None:
+        jeditor_logger.info("ShellManager read_program_error_output_from_process")
         while self.still_run_shell:
             program_error_output_data = self.process.stderr.read(
                 self.program_buffer) \

je_editor/pyside_ui/code/syntax/python_syntax.py

@@ -3,10 +3,12 @@ from PySide6.QtGui import QSyntaxHighlighter
 from PySide6.QtGui import QTextCharFormat
 
 from je_editor.pyside_ui.code.syntax.syntax_setting import syntax_word_setting_dict, syntax_rule_setting_dict
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 class PythonHighlighter(QSyntaxHighlighter):
     def __init__(self, parent=None):
+        jeditor_logger.info(f"Init PythonHighlighter parent: {parent}")
         super().__init__(parent)
 
         self.highlight_rules = []
@@ -29,6 +31,7 @@ class PythonHighlighter(QSyntaxHighlighter):
                 self.highlight_rules.append((pattern, text_char_format))
 
     def highlightBlock(self, text) -> None:
+        jeditor_logger.info(f"PythonHighlighter highlightBlock text: {text}")
         for pattern, pattern_format in self.highlight_rules:
             match_iterator = pattern.globalMatch(text)
             while match_iterator.hasNext():

je_editor/pyside_ui/code/textedit_code_result/code_record.py

@@ -3,11 +3,13 @@ from PySide6.QtWidgets import QTextEdit
 
 from je_editor.pyside_ui.dialog.search_ui.search_error_box import SearchResultBox
 from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 
 class CodeRecord(QTextEdit):
     # Extend QTextEdit
     def __init__(self):
+        jeditor_logger.info("Init CodeRecord")
         super().__init__()
         self.setLineWrapMode(self.LineWrapMode.NoWrap)
         self.setReadOnly(True)
@@ -20,12 +22,14 @@ class CodeRecord(QTextEdit):
         self.addAction(self.search_result_action)
 
     def append(self, text: str) -> None:
+        jeditor_logger.info("CodeRecord append")
         max_line: int = user_setting_dict.get("max_line_of_output", 200000)
         if self.document().lineCount() >= max_line > 0:
             self.setPlainText("")
         super().append(text)
 
     def start_search_result_dialog(self) -> None:
+        jeditor_logger.info("CodeRecord start_search_result_dialog")
         # Binding search box
         self.search_result_box = SearchResultBox()
         self.search_result_box.search_back_button.clicked.connect(
@@ -37,11 +41,13 @@ class CodeRecord(QTextEdit):
         self.search_result_box.show()
 
     def find_next_text(self) -> None:
+        jeditor_logger.info("CodeRecord find_next_text")
         if self.search_result_box.isVisible():
             text = self.search_result_box.search_input.text()
             self.find(text)
 
     def find_back_text(self) -> None:
+        jeditor_logger.info("CodeRecord find_back_text")
         if self.search_result_box.isVisible():
             text = self.search_result_box.search_input.text()
             self.find(text, QTextDocument.FindFlag.FindBackward)

je_editor/pyside_ui/dialog/file_dialog/create_file_dialog.py

@@ -1,11 +1,13 @@
 from PySide6.QtWidgets import QWidget, QBoxLayout, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
 
+from je_editor.utils.logging.loggin_instance import jeditor_logger
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
 class CreateFileDialog(QWidget):
 
     def __init__(self):
+        jeditor_logger.info("Init CreateFileDialog")
         super().__init__()
         self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
         self.file_name_input = QLineEdit()
@@ -20,6 +22,7 @@ class CreateFileDialog(QWidget):
         self.setLayout(self.box_layout)
 
     def create_file(self):
+        jeditor_logger.info("CreateFileDialog create_file")
         file_name = self.file_name_input.text().strip()
         if file_name == "":
             create_file_message_box = QMessageBox(self)