log buffer code optimization

Author: cfunkz

README.md

@@ -71,7 +71,7 @@ At its core, Pythonator is a **local Python process manager with a GUI**.
 ## Capabilities
 
 * ✅ Full ANSI color recognition (256-color, true color, bold, inverse)
-* ✅ Multi-bot process management with isolation
+* ✅ Multi-script process management with isolation
 * ✅ Separate execution paths for UI and processes (`QProcess`, `QThreadPool`)
 * ✅ Live / History / Search log modes
 * ✅ CPU and RAM usage monitoring (via `psutil`)

config.py

@@ -4,7 +4,7 @@
 from dataclasses import dataclass, asdict
 from pathlib import Path
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 
 # Paths
 def _app_dir() -> Path:

log_buffer.py

@@ -1,102 +1,49 @@
-"""
-Log buffer - Ring buffer with timestamps and file persistence.
-
-NOTE: Log file writes are performed asynchronously on a background thread.
-Qt delivers process output on the main (UI) thread; synchronous disk I/O here
-can cause UI stalls/freeze during heavy output or when stopping many processes.
-"""
+"""Log buffer - Ring buffer with async file persistence (non-blocking UI)."""
 from __future__ import annotations
-
+import atexit, queue, threading
 from collections import deque
 from datetime import datetime
 from pathlib import Path
-import queue
-import threading
 from typing import Optional
-
 from config import LOGS_DIR, MAX_LOG_LINES, HISTORY_CHUNK, normalize, strip_ansi
 
+class _AsyncWriter:
+    """Background thread for non-blocking log file writes."""
+    _instance: Optional["_AsyncWriter"] = None
 
-class _AsyncFileWriter:
-    """Non-blocking log file appender.
-
-    UI thread enqueues writes; a worker thread does disk I/O.
-    """
-
-    def __init__(self, max_queue: int = 10000):
-        self._q: "queue.Queue[tuple[Path, str]]" = queue.Queue(maxsize=max_queue)
+    def __init__(self):
+        self._q: queue.Queue[tuple[Path, str]] = queue.Queue(maxsize=10000)
         self._stop = threading.Event()
-        self._dropped = 0
-        self._thread = threading.Thread(target=self._run, name="log-writer", daemon=True)
+        self._thread = threading.Thread(target=self._run, daemon=True)
         self._thread.start()
+        atexit.register(self.close)
+
+    @classmethod
+    def get(cls) -> "_AsyncWriter":
+        if cls._instance is None: cls._instance = cls()
+        return cls._instance
 
     def write(self, path: Path, text: str) -> None:
-        """Enqueue text to append to a file. Never blocks the caller."""
-        if not text:
-            return
-        try:
-            self._q.put_nowait((path, text))
-        except queue.Full:
-            # Never block the UI thread. Drop the chunk and count it.
-            self._dropped += 1
+        if text:
+            try: self._q.put_nowait((path, text))
+            except queue.Full: pass  # Drop rather than block UI
 
     def _run(self) -> None:
         while not self._stop.is_set() or not self._q.empty():
-            try:
-                path, text = self._q.get(timeout=0.2)
-            except queue.Empty:
-                continue
-
+            try: path, text = self._q.get(timeout=0.2)
+            except queue.Empty: continue
             try:
                 path.parent.mkdir(exist_ok=True)
-                with open(path, "a", encoding="utf-8", newline="\n") as f:
-                    f.write(text)
-
-                # If we dropped anything, record it once we successfully write again.
-                if self._dropped:
-                    dropped = self._dropped
-                    self._dropped = 0
-                    try:
-                        with open(path, "a", encoding="utf-8", newline="\n") as f:
-                            f.write(f"[log-writer] dropped {dropped} chunks due to backpressure\n")
-                    except Exception:
-                        pass
-            except Exception:
-                # Never crash the writer thread.
-                pass
+                with open(path, "a", encoding="utf-8", newline="\n") as f: f.write(text)
+            except: pass
             finally:
-                try:
-                    self._q.task_done()
-                except Exception:
-                    pass
+                try: self._q.task_done()
+                except: pass
 
-    def close(self, timeout_s: float = 2.0) -> None:
-        """Request stop and wait briefly for draining."""
+    def close(self) -> None:
         self._stop.set()
-        try:
-            self._thread.join(timeout=timeout_s)
-        except Exception:
-            pass
-
-
-_GLOBAL_WRITER: Optional[_AsyncFileWriter] = None
-
-
-def _writer() -> _AsyncFileWriter:
-    global _GLOBAL_WRITER
-    if _GLOBAL_WRITER is None:
-        _GLOBAL_WRITER = _AsyncFileWriter()
-    return _GLOBAL_WRITER
-
-
-def shutdown_log_writer() -> None:
-    """Flush pending async log writes and stop the writer thread."""
-    global _GLOBAL_WRITER
-    if _GLOBAL_WRITER is None:
-        return
-    _GLOBAL_WRITER.close()
-    _GLOBAL_WRITER = None
-
+        try: self._thread.join(timeout=2.0)
+        except: pass
 
 class LogBuffer:
     __slots__ = ("name", "lines", "file", "_cache", "_mtime", "_partial")
@@ -111,92 +58,57 @@ def __init__(self, name: str):
         self._partial: str = ""
 
     def append(self, text: str) -> tuple[str, str]:
-        if not text:
-            return "", ""
-
-        text = normalize(text)
-        data = self._partial + text
-        self._partial = ""
-
-        # No newline yet: keep buffering partial line
-        if "\n" not in data:
-            self._partial = data
-            return "", ""
-
+        if not text: return "", ""
+        data = normalize(self._partial + text); self._partial = ""
+        if "\n" not in data: self._partial = data; return "", ""
+        
         ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         parts = data.splitlines(keepends=True)
-
-        # Keep trailing partial (no newline)
-        if parts and not parts[-1].endswith("\n"):
-            self._partial = parts.pop()
-
+        if parts and not parts[-1].endswith("\n"): self._partial = parts.pop()
+        
         display, file_out = [], []
         for part in parts:
             content = part.rstrip("\n")
             disp = f"[\x1b[94m{ts}\x1b[0m] {content}\n"
-            self.lines.append(disp)
-            display.append(disp)
+            self.lines.append(disp); display.append(disp)
             file_out.append(f"[{ts}] {strip_ansi(content)}\n")
-
+        
         self._cache = None
-
-        # Persist asynchronously to keep UI thread responsive.
-        try:
-            _writer().write(self.file, "".join(file_out))
-        except Exception:
-            pass
-
+        _AsyncWriter.get().write(self.file, "".join(file_out))
         return "".join(display), "".join(file_out)
 
-    def get_recent(self) -> str:
-        return "".join(self.lines)
+    def get_recent(self) -> str: return "".join(self.lines)
 
     def _read_file(self) -> list[str]:
-        if not self.file.exists():
-            return [l.rstrip("\n") for l in self.lines]
+        if not self.file.exists(): return [l.rstrip("\n") for l in self.lines]
         try:
             mtime = self.file.stat().st_mtime
-            if self._cache and mtime == self._mtime:
-                return self._cache
-            self._cache = normalize(
-                self.file.read_text(encoding="utf-8", errors="replace")
-            ).splitlines()
+            if self._cache and mtime == self._mtime: return self._cache
+            self._cache = normalize(self.file.read_text(encoding="utf-8", errors="replace")).splitlines()
             self._mtime = mtime
             return self._cache
-        except Exception:
-            return [l.rstrip("\n") for l in self.lines]
+        except: return [l.rstrip("\n") for l in self.lines]
 
-    def line_count(self) -> int:
-        return len(self._read_file())
+    def line_count(self) -> int: return len(self._read_file())
 
     def _colorize(self, line: str) -> str:
-        if line.startswith("["):
-            b = line.find("]")
-            if b > 0:
-                return f"[\x1b[94m{line[1:b]}\x1b[0m]{line[b+1:]}"
+        if line.startswith("[") and (b := line.find("]")) > 0:
+            return f"[\x1b[94m{line[1:b]}\x1b[0m]{line[b+1:]}"
         return line
 
     def search(self, pattern: str) -> tuple[str, int]:
         p = pattern.lower()
         matches = [l for l in self._read_file() if p in l.lower()]
-        if not matches:
-            return "", 0
-        return "".join(f"{self._colorize(l)}\n" for l in matches), len(matches)
+        return ("".join(f"{self._colorize(l)}\n" for l in matches), len(matches)) if matches else ("", 0)
 
     def load_chunk(self, end: int, size: int = HISTORY_CHUNK) -> tuple[str, int]:
         lines = self._read_file()
-        if not lines or end <= 0:
-            return "", 0
+        if not lines or end <= 0: return "", 0
         start = max(0, end - size)
         chunk = lines[start:end]
-        if not chunk:
-            return "", 0
-        return "".join(f"{self._colorize(l)}\n" for l in chunk), start
+        return ("".join(f"{self._colorize(l)}\n" for l in chunk), start) if chunk else ("", 0)
 
     def clear(self) -> None:
-        self.lines.clear()
-        self._cache = None
-        try:
-            self.file.write_text("", encoding="utf-8")
-        except Exception:
-            pass
+        self.lines.clear(); self._cache = None
+        try: self.file.write_text("", encoding="utf-8")
+        except: pass

main_window.py

@@ -8,7 +8,7 @@
 from PyQt6.QtWidgets import (QCheckBox, QComboBox, QFileDialog, QHBoxLayout, QInputDialog, QLabel, QLineEdit,
     QMainWindow, QMessageBox, QPlainTextEdit, QPushButton, QSplitter, QTabWidget, QVBoxLayout, QWidget, QProxyStyle, QStyle)
 from config import Bot, load_config, save_config, FLUSH_INTERVAL_MS, STATS_INTERVAL_MS, BTN, INPUT, __version__
-from log_buffer import LogBuffer, shutdown_log_writer
+from log_buffer import LogBuffer
 from log_view import LogView
 from process_mgr import ProcessManager
 from stats import ProcessStats, StatsMonitor
@@ -65,7 +65,7 @@ def _build_config(self) -> QWidget:
         panel = QWidget(); layout = QVBoxLayout(panel); layout.setContentsMargins(0, 0, 8, 0); layout.setSpacing(8)
 
         # Bot selector
-        row = QHBoxLayout(); row.setSpacing(4)
+        row = QHBoxLayout(); row.setSpacing(4); row.addWidget(QLabel("Bot:"))
         self.bot_combo = QComboBox()
         self.bot_combo.setStyleSheet("QComboBox { padding: 4px 8px; border: 1px solid #333; border-radius: 2px; background: #1a1a1a; } QComboBox:hover { border-color: #444; } QComboBox::drop-down { border: none; width: 20px; } QComboBox QAbstractItemView { background: #1a1a1a; border: 1px solid #333; selection-background-color: #4688d8; }")
         self.bot_combo.currentTextChanged.connect(self._on_combo_changed); row.addWidget(self.bot_combo, 1)
@@ -162,10 +162,10 @@ def _save_bot(self) -> None:
         save_config(self.bots)
 
     def _add_bot(self) -> None:
-        name, ok = QInputDialog.getText(self, "New Workspace", "Workspace name:")
+        name, ok = QInputDialog.getText(self, "New Bot", "Bot name:")
         if not ok or not name.strip(): return
         name = name.strip()
-        if name in self.bots: QMessageBox.warning(self, "Duplicate", f"Workspace '{name}' exists"); return
+        if name in self.bots: QMessageBox.warning(self, "Duplicate", f"Bot '{name}' exists"); return
         self.bots[name] = Bot(name=name); save_config(self.bots)
         self._create_views(name); self.bot_combo.setCurrentText(name); self._load_bot_ui(name); self._update_ui()
 
@@ -288,10 +288,6 @@ def _update_ui(self) -> None:
 
     def closeEvent(self, event) -> None:
         self.proc_mgr.stop_all()
-        for e in self._editors.values():
-            e.close()
-        if self._scratch:
-            self._scratch.close()
-
-        shutdown_log_writer()  # <-- important
-        event.accept()
+        for e in self._editors.values(): e.close()
+        if self._scratch: self._scratch.close()
+        event.accept()  # atexit handles log writer cleanup

testscripts/crash/crashtest.py

@@ -0,0 +1,2 @@
+import ctypes
+ctypes.cast(0xdeadbeef, ctypes.py_object).value

testscripts/flask_uvicorn/app.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+import sys
+import time
+from flask import Flask, jsonify, request
+
+app = Flask(__name__)
+
+@app.get("/")
+def home():
+    return """
+<!doctype html>
+<html>
+  <head><meta charset="utf-8"><title>Flask Test</title></head>
+  <body style="font-family: monospace; background:#0a0a0a; color:#ddd; padding:16px">
+    <h2>Flask Test App</h2>
+    <p>Endpoints:</p>
+    <ul>
+      <li><a href="/health">/health</a></li>
+      <li><a href="/spam?n=200">/spam?n=200</a> (prints a lot to stdout)</li>
+      <li><a href="/slow?sec=2">/slow?sec=2</a> (delayed response)</li>
+      <li><a href="/crash">/crash</a> (intentional crash)</li>
+    </ul>
+    <p>POST /echo (JSON) → echos body</p>
+  </body>
+</html>
+""".strip()
+
+@app.get("/health")
+def health():
+    return jsonify(ok=True, pid=os.getpid(), python=sys.version)
+
+@app.get("/slow")
+def slow():
+    sec = float(request.args.get("sec", "1"))
+    time.sleep(max(0.0, min(sec, 10.0)))
+    print(f"[slow] slept {sec}s", flush=True)
+    return jsonify(ok=True, slept=sec)
+
+@app.get("/spam")
+def spam():
+    n = int(request.args.get("n", "200"))
+    n = max(0, min(n, 20000))
+    for i in range(n):
+        print(f"{i+1} hello", flush=True)
+    return jsonify(ok=True, printed=n)
+
+@app.post("/echo")
+def echo():
+    data = request.get_json(silent=True)
+    print(f"[echo] {data}", flush=True)
+    return jsonify(ok=True, received=data)
+
+@app.get("/crash")
+def crash():
+    print("[crash] about to raise", flush=True)
+    raise RuntimeError("Intentional crash for runner testing")
+
+if __name__ == "__main__":
+    # Use 127.0.0.1 so it's local only
+    # threaded=True helps simulate concurrent requests
+    app.run(host="127.0.0.1", port=5001, debug=False, threaded=True)

testscripts/flask_uvicorn/requirements.txt

@@ -0,0 +1,2 @@
+flask
+uvicorn

testscripts/loop/loop.py

@@ -0,0 +1,4 @@
+import math
+
+for i in range(100000):
+    print(i, "hello")

testscripts/timed_loop/timed_loop.py

@@ -0,0 +1,6 @@
+for i in range(100000):
+    print(i, "hello")
+    import time
+    time.sleep(0.0001)
+
+print("DONE")