screenbuffer 0.1.0__py3-none-any.whl

screenbuffer/store.py

@@ -0,0 +1,230 @@
+"""All file I/O for ScreenBuffer lives here.
+
+Four files are managed per log name (inside ./screen_buffer_logs):
+    <name>.txt          append-only history (trimmed to max_main lines)
+    <name>_wait.txt     current buffer snapshot (one line per entry, trimmed to max_wait)
+    <name>_header.txt   header text
+    <name>_footer.txt   footer text
+
+The wait file stores RAW text plus its alignment, one entry per line:
+    <alignment><TAB><escaped text>
+so reloading restores alignment exactly instead of baking in the old
+terminal width. Old-format files (plain padded text) still load; each
+line is simply treated as left-aligned.
+"""
+import os
+import threading
+
+_ALIGN_WORDS = {"left", "center", "right"}
+
+
+def _valid_alignment(head):
+    head = head.strip()
+    return head.lstrip("-").isdigit() or head.lower() in _ALIGN_WORDS
+
+
+def _escape(text):
+    return text.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r")
+
+
+# Every character that text readers treat as the end of a line. In the history
+# log they are written as visible text, so one put() can never create a second
+# (fake) log entry.
+_LINE_BREAKS = str.maketrans({
+    "\n": "\\n", "\r": "\\r", "\x0b": "\\x0b", "\x0c": "\\x0c",
+    "\x1c": "\\x1c", "\x1d": "\\x1d", "\x1e": "\\x1e", "\x85": "\\x85",
+    "\u2028": "\\u2028", "\u2029": "\\u2029",
+})
+
+
+def _one_line(text):
+    return text.translate(_LINE_BREAKS)
+
+
+def _unescape(text):
+    out = []
+    i = 0
+    mapping = {"n": "\n", "r": "\r", "\\": "\\"}
+    while i < len(text):
+        ch = text[i]
+        if ch == "\\" and i + 1 < len(text):
+            nxt = text[i + 1]
+            out.append(mapping.get(nxt, "\\" + nxt))
+            i += 2
+        else:
+            out.append(ch)
+            i += 1
+    return "".join(out)
+
+
+def _encode(text, alignment):
+    return f"{alignment}\t{_escape(text)}"
+
+
+def _decode(line):
+    head, sep, rest = line.partition("\t")
+    if not sep or not _valid_alignment(head):
+        return line, "left"  # old-format line
+    head = head.strip()
+    alignment = int(head) if head.lstrip("-").isdigit() else head.lower()
+    return _unescape(rest), alignment
+
+
+class LogStore:
+    LOGS_DIR = "screen_buffer_logs"
+
+    def __init__(self, log_file=None, max_main=None, max_wait=None):
+        self.file_lock = threading.RLock()
+        self.max_main = max_main
+        self.max_wait = max_wait
+        self._main_count = None   # history lines in the file, counted in memory
+        self.set_log_file(log_file)
+
+    # ------------------------------------------------------------------ paths
+    def set_log_file(self, log_file):
+        self._main_count = None   # a different file: count it again when needed
+        if not log_file:
+            self.log_file = None
+            self.wait_log_file = None
+            self.header_file = None
+            self.footer_file = None
+            return
+        os.makedirs(self.LOGS_DIR, exist_ok=True)
+        name = log_file if log_file.lower().endswith(".txt") else f"{log_file}.txt"
+        self.log_file = os.path.join(self.LOGS_DIR, name)
+        base, ext = os.path.splitext(self.log_file)
+        self.wait_log_file = f"{base}_wait{ext}"
+        self.header_file = f"{base}_header{ext}"
+        self.footer_file = f"{base}_footer{ext}"
+        # create the history file right away (never truncates)
+        try:
+            with open(self.log_file, "a", encoding="utf-8"):
+                pass
+        except Exception:
+            pass
+
+    @property
+    def enabled(self):
+        return self.log_file is not None
+
+    def _part_path(self, name):
+        return {"header": self.header_file, "footer": self.footer_file}[name]
+
+    # ---------------------------------------------------------- low-level io
+    def _write(self, path, text):
+        if not path:
+            return
+        try:
+            with self.file_lock, open(path, "w", encoding="utf-8") as f:
+                f.write(text)
+        except Exception:
+            pass
+
+    def _read(self, path):
+        if not path or not os.path.exists(path):
+            return None
+        try:
+            with self.file_lock, open(path, "r", encoding="utf-8") as f:
+                return f.read()
+        except Exception:
+            return None
+
+    def _count_lines(self, path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return sum(1 for _ in f)
+        except Exception:
+            return 0
+
+    def _trim_to(self, path, limit):
+        """Keep only the newest `limit` lines. Returns how many lines remain."""
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+            if len(lines) > limit:
+                lines = lines[len(lines) - limit:] if limit > 0 else []
+                with open(path, "w", encoding="utf-8") as f:
+                    f.writelines(lines)
+            return len(lines)
+        except Exception:
+            return self._count_lines(path)
+
+    # ------------------------------------------------------------ main log
+    def append_log(self, line):
+        """Append ONE history line (any line breaks inside it are escaped).
+        Raises RuntimeError if the write fails."""
+        if not self.log_file:
+            return
+        try:
+            with self.file_lock:
+                with open(self.log_file, "a", encoding="utf-8") as f:
+                    f.write(_one_line(line) + "\n")
+                # The file is only read again when it really is over the limit
+                # (the line count is kept in memory, counted once from the file).
+                if self._main_count is not None:
+                    self._main_count += 1
+                if self.max_main is not None:
+                    if self._main_count is None:
+                        self._main_count = self._count_lines(self.log_file)
+                    if self._main_count > self.max_main:
+                        self._main_count = self._trim_to(self.log_file, self.max_main)
+        except Exception as e:
+            raise RuntimeError(f"Error writing to log file: {e}") from e
+
+    def read_main(self):
+        """All history lines, oldest first ([] if the file is missing or empty)."""
+        content = self._read(self.log_file)
+        if not content:
+            return []
+        lines = content.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+        return lines
+
+    # ------------------------------------------------------------ wait log
+    def write_wait(self, entries):
+        """entries: list of (text, alignment). Trimmed to max_wait lines."""
+        if not self.wait_log_file:
+            return
+        lines = [_encode(text, align) for text, align in entries]
+        if self.max_wait is not None:
+            lines = lines[len(lines) - self.max_wait:] if self.max_wait > 0 else []
+        self._write(self.wait_log_file, "\n".join(lines) + "\n" if lines else "")
+
+    def append_wait(self, entries):
+        """Add entries to the end of the wait file (no rewrite of what is there)."""
+        if not self.wait_log_file or not entries:
+            return
+        text = "".join(_encode(t, a) + "\n" for t, a in entries)
+        try:
+            with self.file_lock, open(self.wait_log_file, "a", encoding="utf-8") as f:
+                f.write(text)
+        except Exception:
+            pass
+
+    def read_wait(self):
+        """Return a list of (text, alignment); [] when missing or empty."""
+        content = self._read(self.wait_log_file)
+        if content is None or not content.strip():
+            return []
+        lines = content.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+        return [_decode(line) for line in lines]
+
+    def clear_wait(self):
+        self._write(self.wait_log_file, "")
+
+    # ------------------------------------------------------ header / footer
+    def read_part(self, name):
+        """name is 'header' or 'footer'. None when there is no file."""
+        return self._read(self._part_path(name))
+
+    def write_part(self, name, text):
+        self._write(self._part_path(name), text or "")
+
+    # ---------------------------------------------------------------- reset
+    def reset_all(self, header="", footer=""):
+        self.clear_wait()
+        self.write_part("header", header)
+        self.write_part("footer", footer)

screenbuffer/view.py

@@ -0,0 +1,125 @@
+"""Pure rendering logic: no files, no locks, no printing.
+
+build_view() takes the raw buffer and the display options and returns a
+list of [text, alignment] pairs ready to be aligned and printed.
+"""
+
+
+def validate_selector(val, name="silent_display"):
+    """Validate a silent_display / only_display value."""
+    if val is None:
+        return None
+    if isinstance(val, (int, slice)):
+        return val
+    if isinstance(val, list):
+        if not all(isinstance(i, int) for i in val):
+            raise ValueError(f"{name} list must contain integers")
+        return val
+    if isinstance(val, str):
+        if val.lower() == "all":
+            return "all"
+        raise ValueError(f"{name} string must be 'all'")
+    raise ValueError(f"Invalid {name} value")
+
+
+def _selected_indices(selector, total):
+    """Turn an int / list / slice into a set of absolute buffer indices."""
+    if isinstance(selector, slice):
+        raw = range(total)[selector]
+    elif isinstance(selector, int):
+        raw = [selector]
+    else:
+        raw = selector
+    return {i + total if i < 0 else i for i in raw}
+
+
+def _tail(rows, n):
+    return rows[max(len(rows) - n, 0):]
+
+
+def build_view(
+    lines,
+    alignments,
+    *,
+    header=None,
+    footer=None,
+    header_alignment=None,
+    footer_alignment=None,
+    max_display=None,
+    shift_max_display=True,
+    only_display=None,
+    silent_display=None,
+    clean_silent_only=False,
+    clean_edges=False,
+    filler="<<FILLER>>",
+):
+    """Return [[text, alignment], ...].
+
+    shift_max_display=True : filter first, then keep the last `max_display`
+                             visible lines (muted lines don't use up slots).
+    shift_max_display=False: keep the last `max_display` buffer lines first,
+                             then filter.
+    """
+    total = len(lines)
+
+    # Only the last `max_display` rows can ever be shown. When muting cannot
+    # change how many rows there are (no clean_silent_only), or the window is
+    # taken first (shift_max_display=False), build just that window instead of
+    # one row per line: drawing then costs the same for 100 lines or 100,000.
+    # Indices stay absolute, so only_display/silent_display still match.
+    first = 0
+    if max_display is not None and (not shift_max_display or not clean_silent_only):
+        first = max(total - max_display, 0)
+
+    # each row: [text, alignment, original_index]
+    rows = []
+    for i in range(first, total):
+        line = lines[i]
+        rows.append(["" if line == filler else line, alignments.get(i, "left"), i])
+
+    # 1. window
+    if max_display is not None and not shift_max_display:
+        rows = _tail(rows, max_display)
+
+    # 2. only_display / silent_display (indices refer to the full buffer)
+    if only_display is not None:
+        if not (isinstance(only_display, str) and only_display == "all"):
+            keep = _selected_indices(only_display, total)
+            for row in rows:
+                if row[2] not in keep:
+                    row[0], row[1] = "", "left"
+    elif silent_display is not None:
+        if isinstance(silent_display, str) and silent_display == "all":
+            muted = None
+        else:
+            muted = _selected_indices(silent_display, total)
+        for row in rows:
+            if muted is None or row[2] in muted:
+                row[0], row[1] = "", "left"
+
+    # 3. drop blank rows left behind by silent/only
+    if clean_silent_only:
+        rows = [row for row in rows if row[0].strip() != ""]
+
+    # 4. window again (shifted mode)
+    if max_display is not None:
+        rows = _tail(rows, max_display)
+
+    # 5. trim blank edges, then pad with one blank line top and bottom
+    if clean_edges:
+        while rows and rows[0][0].strip() == "":
+            rows.pop(0)
+        while rows and rows[-1][0].strip() == "":
+            rows.pop()
+        if rows:
+            rows.insert(0, ["", "left", -1])
+            rows.append(["", "left", -1])
+
+    # 6. header + body + footer
+    result = []
+    if header:
+        result.append([header.rstrip("\n"), header_alignment or "left"])
+    result.extend([text, align] for text, align, _ in rows)
+    if footer:
+        result.append([footer.lstrip("\n"), footer_alignment or "left"])
+    return result