Merge pull request #168 from Integration-Automation/dev

Dev

Author: JE-Chen

.idea/discord.xml

@@ -6,16 +6,16 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "je_editor_dev"
-version = "0.0.231"
+version = "0.0.236"
 authors = [
     { name = "JE-Chen", email = "[email protected]" },
 ]
 description = "JEditor is basic but powerful editor include GPT"
 requires-python = ">=3.10"
 license-files = ["LICENSE"]
 dependencies = [
-    "PySide6==6.9.1", "qt-material", "yapf", "frontengine", "pycodestyle", "jedi",
-    "qtconsole", "langchain_openai", "langchain", "pydantic"
+    "PySide6==6.9.2", "qt-material", "yapf", "frontengine", "pycodestyle", "jedi",
+    "qtconsole", "langchain_openai", "langchain", "pydantic", "watchdog", "ruff"
 ]
 classifiers = [
     "Programming Language :: Python :: 3.10",
@@ -37,4 +37,4 @@ content-type = "text/markdown"
 
 
 [tool.setuptools.packages]
-find = { namespaces = false }
+find = { namespaces = false }

dev.toml

@@ -1 +1,2 @@
 print("Hello World")
+print(var)

exe/a.py

@@ -1,3 +1,3 @@
-from je_editor.start_editor import start_editor
+from je_editor import start_editor
 
 start_editor()

exe/start_editor.py

@@ -0,0 +1,31 @@
+import subprocess
+import threading
+import time
+from queue import Queue
+
+
+class RuffThread(threading.Thread):
+
+    def __init__(self, ruff_commands: list, std_queue: Queue, stderr_queue: Queue):
+        super().__init__()
+        if ruff_commands is None:
+            self.ruff_commands = ["ruff", "check"]
+        else:
+            self.ruff_commands = ruff_commands
+        self.ruff_process = None
+        self.std_queue = std_queue
+        self.stderr_queue = stderr_queue
+
+    def run(self):
+        self.ruff_process = subprocess.Popen(
+            self.ruff_commands, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+        while self.ruff_process.poll() is None:
+            time.sleep(1)
+        else:
+            for line in self.ruff_process.stdout:
+                print(line.strip())
+            for line in self.ruff_process.stderr:
+                print(line.strip())
+
+
+

je_editor/code_scan/__init__.py

@@ -0,0 +1,34 @@
+from queue import Queue
+
+from watchdog.events import FileSystemEventHandler
+
+from je_editor.code_scan.ruff_thread import RuffThread
+
+
+class RuffPythonFileChangeHandler(FileSystemEventHandler):
+
+    def __init__(self, ruff_commands: list = None):
+        super(RuffPythonFileChangeHandler, self).__init__()
+        self.ruff_commands = ruff_commands
+        self.stdout_queue = Queue()
+        self.stderr_queue = Queue()
+        self.ruff_threads_dict = dict()
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+        if event.src_path.endswith(".py"):
+            if self.ruff_threads_dict.get(event.src_path) is None:
+                ruff_thread = RuffThread(self.ruff_commands, self.stdout_queue, self.stderr_queue)
+                self.ruff_threads_dict.update({event.src_path: ruff_thread})
+                ruff_thread.start()
+            else:
+                ruff_thread = self.ruff_threads_dict.get(event.src_path)
+                if not ruff_thread.is_alive():
+                    ruff_thread = RuffThread(self.ruff_commands, self.stdout_queue, self.stderr_queue)
+                    self.ruff_threads_dict.update({event.src_path: ruff_thread})
+                    ruff_thread.start()
+                else:
+                    pass
+
+

je_editor/code_scan/ruff_thread.py

@@ -0,0 +1,33 @@
+import threading
+import time
+
+from watchdog.observers import Observer
+
+from je_editor.code_scan.watchdog_implement import RuffPythonFileChangeHandler
+
+
+class WatchdogThread(threading.Thread):
+
+    def __init__(self, check_path: str):
+        super().__init__()
+        self.check_path = check_path
+        self.ruff_handler = RuffPythonFileChangeHandler()
+        self.running = True
+
+    def run(self):
+        observer = Observer()
+        observer.schedule(self.ruff_handler, str(self.check_path), recursive=True)
+        observer.start()
+        try:
+            while self.running:
+                time.sleep(1)
+        finally:
+            observer.stop()
+
+
+if __name__ == '__main__':
+    watchdog_thread = WatchdogThread("")
+    watchdog_thread.start()
+    while True:
+        time.sleep(1)
+

je_editor/code_scan/watchdog_implement.py

@@ -0,0 +1,88 @@
+import logging
+from dataclasses import dataclass, field
+from typing import List, Dict
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class CommitNode:
+    commit_sha: str
+    author_name: str
+    commit_date: str
+    commit_message: str
+    parent_shas: List[str]
+    lane_index: int = -1  # assigned later
+
+@dataclass
+class CommitGraph:
+    nodes: List[CommitNode] = field(default_factory=list)
+    index: Dict[str, int] = field(default_factory=dict)  # sha -> row
+
+    def build(self, commits: List[Dict], refs: Dict[str, str]) -> None:
+        # commits are topo-ordered by git_client log --topo-order; we keep it.
+        self.nodes = [
+            CommitNode(
+                commit_sha=c["sha"],
+                author_name=c["author"],
+                commit_date=c["date"],
+                commit_message=c["message"],
+                parent_shas=c["parents"],
+            ) for c in commits
+        ]
+        self.index = {n.commit_sha: i for i, n in enumerate(self.nodes)}
+        self._assign_lanes()
+
+    def _assign_lanes(self) -> None:
+        """
+        Simple lane assignment similar to 'git_client log --graph' lanes.
+        Greedy: reuse freed lanes; parents may create new lanes.
+        """
+        active: Dict[int, str] = {}  # lane -> sha
+        free_lanes: List[int] = []
+
+        for i, node in enumerate(self.nodes):
+            # If any active lane points to this commit, use that lane
+            lane_found = None
+            for lane, sha in list(active.items()):
+                if sha == node.commit_sha:
+                    lane_found = lane
+                    break
+
+            if lane_found is None:
+                if free_lanes:
+                    node.lane_index = free_lanes.pop(0)
+                else:
+                    node.lane_index = 0 if not active else max(active.keys()) + 1
+            else:
+                node.lane_index = lane_found
+
+            # Update active: current node consumes its lane, parents occupy lanes
+            # Remove the current sha from any lane that pointed to it
+            for lane, sha in list(active.items()):
+                if sha == node.commit_sha:
+                    del active[lane]
+
+            # First parent continues in the same lane; others go to free/new lanes
+            if node.parent_shas:
+                first = node.parent_shas[0]
+                active[node.lane_index] = first
+                # Side branches
+                for p in node.parent_shas[1:]:
+                    # Pick a free lane or new one
+                    if free_lanes:
+                        pl = free_lanes.pop(0)
+                    else:
+                        pl = 0 if not active else max(active.keys()) + 1
+                    active[pl] = p
+
+            # Any lane whose target no longer appears in the future will be freed later
+            # We approximate by freeing lanes when a target didn't appear in the next rows;
+            # but for minimal viable, free when lane not reassigned by parents this row.
+            used_lanes = set(active.keys())
+            # Collect gaps below max lane as free lanes to reuse
+            max_lane = max(used_lanes) if used_lanes else -1
+            present = set(range(max_lane + 1))
+            missing = sorted(list(present - used_lanes))
+            # Merge missing into free_lanes maintaining order
+            free_lanes = sorted(set(free_lanes + missing))