meltygui 0.1.0__py3-none-any.whl

meltygui/model/trace_model.py

@@ -0,0 +1,198 @@
+"""Trace model functions and supporting definitions."""
+from pathlib import Path
+import json
+import os
+
+
+class SavedTrace:
+    """EXTERNAL frames for draw_stack_trace — a trace captured or saved
+    elsewhere (a crash report file, a queued capture) rather than a live
+    exception: `frames` = [(path, lineno, function_name[, scope]), ...]
+    outermost first, `scope` a {name: value} dict the view shows as the
+    frame's live values (None = none), `error` the raising line's message
+    for draw_text's error marker ("" = no marker). draw_stack_trace is the
+    default view for it, so `draw_any(SavedTrace(...))` works. Keep ONE
+    object per trace: the view rebuilds its panes whenever the input's
+    identity changes."""
+    __slots__ = ("frames", "error", "seen_height")
+
+    def __init__(self, frames, error=""):
+        self.frames = list(frames or ())
+        self.error = error or ""
+        # The view's height last measured while IN VIEW (a scrolling host
+        # stamps it - see crash_reports): the honest height to lay out even
+        # while the view sits off-screen, where the wrapper's group measure
+        # runs to the clip edge.
+        self.seen_height = None
+
+    def __repr__(self):
+        return f"SavedTrace({len(self.frames)} frames, {self.error!r})"
+
+
+class CrashReportStore(dict):
+    """path (str) → {"name", "time", "thread", "error", "commit", "mtime", "size"},
+    newest first. The trace bodies load lazily (`text`) and are cached by
+    the file's (mtime, size) so a rewritten file re-reads."""
+    # save_crash_report's header: `key: value` lines up to the first blank
+    # line - time / thread / error, and `frames` (JSON) when the trace saved
+    # frames. Parsed by _read_header; nothing here counts lines.
+    HEADER_KEYS = ("time", "thread", "error", "commit", "frames", "locals")
+
+    def __init__(self):
+        super().__init__()
+        self.loaded = False
+        self.error = ""
+        self._seen_generation = -1
+        self._dir_mtime = None
+        self._texts = {}                          # path → (signature, lines, SavedTrace)
+
+    def directory(self) -> Path:
+        from meltygui.core.windowing.glfw_utils import crash_reports_dir
+
+        return crash_reports_dir()
+
+    def refresh_if_stale(self):
+        """Reload the listing when a report was saved (`reports_changed`)
+        or the directory's mtime moved (a file deleted or added by hand).
+        One stat per call — content-free, so it is fine per frame."""
+        from meltygui.model.trace_report_model import _generation
+
+        directory = self.directory()
+        try:
+            dir_mtime = os.stat(directory).st_mtime_ns
+        except OSError:
+            dir_mtime = None
+        if (self.loaded and self._seen_generation == _generation
+                and dir_mtime == self._dir_mtime):
+            return
+        self._seen_generation = _generation
+        self._dir_mtime = dir_mtime
+        self.load()
+
+    def load(self):
+        self.clear()
+        self.error = ""
+        directory = self.directory()
+        try:
+            files = sorted(directory.glob("*.txt"), reverse=True)   # names sort by time
+        except OSError as exc:
+            files = []
+            self.error = str(exc)
+        for path in files:
+            try:
+                stat = path.stat()
+            except OSError:
+                continue
+            entry = {"name": path.stem, "time": "", "thread": "", "error": "", "commit": "",
+                     "mtime": stat.st_mtime, "size": stat.st_size}
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as handle:
+                    header, _ = self._read_header(handle)
+            except OSError:
+                header = {}
+            for key in ("time", "thread", "error", "commit"):
+                entry[key] = header.get(key, "")
+            self[str(path)] = entry
+        self.loaded = True
+        live = set(self.keys())
+        for stale in [key for key in self._texts if key not in live]:
+            del self._texts[stale]
+
+    @classmethod
+    def _read_header(cls, handle):
+        """(header dict, rest of the file) from an open report: `key: value`
+        lines up to the first blank line; an unknown first line means an
+        older file with no header (everything is body)."""
+        header = {}
+        first = handle.readline()
+        key, _, value = first.rstrip("\n").partition(": ")
+        if key not in cls.HEADER_KEYS:
+            return header, first + handle.read()
+        header[key] = value
+        while True:
+            line = handle.readline()
+            if not line or not line.strip():
+                break
+            key, _, value = line.rstrip("\n").partition(": ")
+            if key in cls.HEADER_KEYS:
+                header[key] = value
+        return header, handle.read()
+
+    def _load_body(self, path):
+        """(trace lines, SavedTrace) of one report, cached per file version.
+        The trace's frames are the header's JSON list as (path, lineno,
+        name, scope) tuples; `scope` is the frame's saved locals as
+        {name: value}, display strings restored to plain literals where
+        they parse (`_restore_value`), None when the report saved none;
+        its `error` the header's error line. ONE SavedTrace object per
+        file version, which draw_stack_trace needs: it rebuilds its panes
+        whenever the input's identity changes."""
+        from meltygui.model.trace_model import SavedTrace
+        from meltygui.model.trace_report_model import _frames_from_text
+        from meltygui.model.trace_report_model import _restore_scope
+
+        entry = self.get(path)
+        signature = (entry["mtime"], entry["size"]) if entry else None
+        cached = self._texts.get(path)
+        if cached is not None and cached[0] == signature:
+            return cached[1], cached[2]
+        frames = None
+        header = {}
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as handle:
+                header, body_text = self._read_header(handle)
+            if header.get("frames"):
+                rows = json.loads(header["frames"])
+                scopes = json.loads(header["locals"]) if header.get("locals") else []
+                scopes = list(scopes) + [None] * (len(rows) - len(scopes))
+                frames = [(str(row[0]), int(row[1]), str(row[2]), _restore_scope(scope))
+                          for row, scope in zip(rows, scopes)]
+        except (OSError, ValueError, TypeError, IndexError) as exc:
+            header, body_text = {}, f"<could not read {path}: {exc}>"
+        lines = body_text.split("\n")
+        while lines and not lines[0].strip():
+            lines = lines[1:]
+        while lines and not lines[-1].strip():
+            lines = lines[:-1]
+        if frames is None:
+            frames = _frames_from_text(lines)
+        trace = SavedTrace(frames, header.get("error") or (entry["error"] if entry else ""))
+        self._texts[path] = (signature, lines, trace)
+        return lines, trace
+
+    def text(self, path):
+        """The report's printed trace lines (header stripped)."""
+        return self._load_body(path)[0]
+
+    def trace(self, path):
+        """The report as a SavedTrace (draw_stack_trace's external-frames
+        input): the header's frames, else the ones its printed text names
+        (an older report) — empty when the text has none either."""
+        return self._load_body(path)[1]
+
+    def frames(self, path):
+        """The report's (path, lineno, name, scope) frames."""
+        return self.trace(path).frames
+
+    def remove(self, path):
+        from meltygui.model.trace_report_model import reports_changed
+
+        try:
+            os.unlink(path)
+        except OSError as exc:
+            self.error = str(exc)
+        self.pop(path, None)
+        self._texts.pop(path, None)
+        reports_changed()
+
+    def remove_all(self):
+        from meltygui.model.trace_report_model import reports_changed
+
+        for path in list(self.keys()):
+            try:
+                os.unlink(path)
+            except OSError as exc:
+                self.error = str(exc)
+        self.clear()
+        self._texts.clear()
+        reports_changed()

meltygui/model/trace_report_model.py

@@ -0,0 +1,146 @@
+"""Crash Reports — the traces print_stack_trace saved under
+`Toggles.CrashReports.directory` (~/.lsd/crash_reports by default), one file
+per trace (glfw_utils.save_crash_report), listed newest first.
+
+Modelled on fast_dock: rows are plain draw-list rects/text with manual
+hit-testing; hover boosts and clicks resolve inside the body while the view
+is hovered (the wrapper repaints every frame then), and the idle tile is a
+cached blit that a new report repaints via `reports_changed()` (called by
+save_crash_report from whatever thread printed the trace).
+
+Model: `reports` (CrashReportStore, a dict path → entry dict with the
+report's header fields: time / thread / error). Clicking a row expands it
+and draws it through draw_stack_trace (the code behind each frame, from
+the report's saved (path, lineno, function) frames — an older report
+without a frames header has them parsed out of its printed text); the
+trash button on a hovered row deletes that file, the toolbar's Clear all
+deletes every file.
+Which rows are expanded persists in CrashReportsPanelState.
+"""
+from __future__ import annotations
+
+import ast
+import json
+import os
+import re
+import threading
+import time
+from pathlib import Path
+
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+
+from meltygui.core.melty import Melty
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.windowing.glfw_utils import crash_reports_dir
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.cache.tile_cache import add_shadow
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.layout.header_runtime import _brightness_clamp_fn
+from meltygui.editor.source_ui import _tab_text_color
+from meltygui.editor.text_editor import COLORS
+from meltygui.editor.source_ui import _file_meta_tint
+
+# Bumped by reports_changed(); the store refreshes when it sees a new value.
+_generation = 0
+_generation_lock = threading.Lock()
+
+
+def reports_changed():
+    """A report file was written or removed outside the window (any
+    thread): mark the store stale and repaint the window's cached tile."""
+    global _generation
+    with _generation_lock:
+        _generation += 1
+    try:
+        Melty.cache.invalidate_up_by_obj(reports, force=True)
+        request_render()
+    except Exception:
+        pass                                      # no studio (tests, launcher): nothing to repaint
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Store
+# ──────────────────────────────────────────────────────────────────────────
+
+from meltygui.model.trace_model import CrashReportStore
+
+
+# `File "path", line num, in func` - the printed trace's frame line, the
+# fallback source of frames for a report file without a frames header.
+_FRAME_LINE = re.compile(r'File "([^"]+)", line (\d+), in (\S+)')
+
+
+def _frames_from_text(lines):
+    return [(match.group(1), int(match.group(2)), match.group(3), None)
+            for line in lines for match in [_FRAME_LINE.search(line)] if match]
+
+
+def _restore_value(text):
+    """A saved local back to a plain value where its display string is a
+    literal (numbers, strings, None, small containers) so the marker shows
+    `5`, not `'5'`; anything else (`<Tensor (3, 4) float32>`, an object
+    repr) stays the string it was saved as."""
+    try:
+        return ast.literal_eval(text)
+    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError):
+        return text
+
+
+def _restore_scope(scope):
+    if not isinstance(scope, dict):
+        return None
+    return {str(name): _restore_value(value) for name, value in scope.items()}
+
+
+reports = CrashReportStore()
+
+
+from meltygui.state.trace_state import CrashReportsPanelState
+
+
+def date_bucket(epoch, now=None):
+    """The section a report files under by its day, local time: "Today",
+    "Yesterday", else the date ("Mon Sep 2, 2026")."""
+    when = time.localtime(epoch)
+    today = time.localtime(time.time() if now is None else now)
+    day = (when.tm_year, when.tm_yday)
+    if day == (today.tm_year, today.tm_yday):
+        return "Today"
+    yesterday = time.localtime(time.mktime(today) - 86400)
+    if day == (yesterday.tm_year, yesterday.tm_yday):
+        return "Yesterday"
+    return time.strftime("%a %b ", when) + f"{when.tm_mday}, {when.tm_year}"
+
+
+def _mix(style_manager, tint, value, factor, saturation):
+    return style_manager.make_color_rgb(tint[0], tint[1], tint[2], value=value,
+                                        factor=factor, saturation_scale=saturation)
+
+
+def _color_u32(color, alpha=1.0):
+    return pack_color(color[0], color[1], color[2], alpha)
+
+
+def _ellipsize(text, max_width):
+    if max_width <= 0:
+        return ""
+    if imgui.calc_text_size(text)[0] <= max_width:
+        return text
+    ellipsis = "…"
+    low, high = 0, len(text)
+    while low < high:
+        mid = (low + high + 1) // 2
+        if imgui.calc_text_size(text[:mid] + ellipsis)[0] <= max_width:
+            low = mid
+        else:
+            high = mid - 1
+    return text[:low] + ellipsis if low else ellipsis
+
+
+# disable_scroll=False: the @window draw path defaults it to True (most
+# windows lay out their own scrolling); this one is a scrolling list.
+from meltygui.view.trace_view import draw_crash_reports
+draw_crash_reports = window(input_value=reports, tint=(0.25, 0.23, 0.23), icon=f'\uf188', display_name='Crash Reports', initial={'width': 720, 'height': 480}, disable_scroll=False)(draw_crash_reports)