bouquin 0.1.10__py3-none-any.whl → 0.2.1.2__py3-none-any.whl

bouquin/db.py

@@ -3,10 +3,8 @@ from __future__ import annotations
 import csv
 import html
 import json
-import os
 
 from dataclasses import dataclass
-from markdownify import markdownify as md
 from pathlib import Path
 from sqlcipher3 import dbapi2 as sqlite
 from typing import List, Sequence, Tuple
@@ -257,68 +255,31 @@ class DBManager:
         ).fetchall()
         return [dict(r) for r in rows]
 
-    def get_version(
-        self,
-        *,
-        date_iso: str | None = None,
-        version_no: int | None = None,
-        version_id: int | None = None,
-    ) -> dict | None:
+    def get_version(self, *, version_id: int) -> dict | None:
         """
-        Fetch a specific version by (date, version_no) OR by version_id.
+        Fetch a specific version by version_id.
         Returns a dict with keys: id, date, version_no, created_at, note, content.
         """
         cur = self.conn.cursor()
-        if version_id is not None:
-            row = cur.execute(
-                "SELECT id, date, version_no, created_at, note, content "
-                "FROM versions WHERE id=?;",
-                (version_id,),
-            ).fetchone()
-        else:
-            if date_iso is None or version_no is None:
-                raise ValueError(
-                    "Provide either version_id OR (date_iso and version_no)"
-                )
-            row = cur.execute(
-                "SELECT id, date, version_no, created_at, note, content "
-                "FROM versions WHERE date=? AND version_no=?;",
-                (date_iso, version_no),
-            ).fetchone()
+        row = cur.execute(
+            "SELECT id, date, version_no, created_at, note, content "
+            "FROM versions WHERE id=?;",
+            (version_id,),
+        ).fetchone()
         return dict(row) if row else None
 
-    def revert_to_version(
-        self,
-        date_iso: str,
-        *,
-        version_no: int | None = None,
-        version_id: int | None = None,
-    ) -> None:
+    def revert_to_version(self, date_iso: str, version_id: int) -> None:
         """
         Point the page head (pages.current_version_id) to an existing version.
-        Fast revert: no content is rewritten.
         """
-        if self.conn is None:
-            raise RuntimeError("Database is not connected")
         cur = self.conn.cursor()
 
-        if version_id is None:
-            if version_no is None:
-                raise ValueError("Provide version_no or version_id")
-            row = cur.execute(
-                "SELECT id FROM versions WHERE date=? AND version_no=?;",
-                (date_iso, version_no),
-            ).fetchone()
-            if row is None:
-                raise ValueError("Version not found for this date")
-            version_id = int(row["id"])
-        else:
-            # Ensure that version_id belongs to the given date
-            row = cur.execute(
-                "SELECT date FROM versions WHERE id=?;", (version_id,)
-            ).fetchone()
-            if row is None or row["date"] != date_iso:
-                raise ValueError("version_id does not belong to the given date")
+        # Ensure that version_id belongs to the given date
+        row = cur.execute(
+            "SELECT date FROM versions WHERE id=?;", (version_id,)
+        ).fetchone()
+        if row is None or row["date"] != date_iso:
+            raise ValueError("version_id does not belong to the given date")
 
         with self.conn:
             cur.execute(
@@ -342,20 +303,18 @@ class DBManager:
         ).fetchall()
         return [(r[0], r[1]) for r in rows]
 
-    def export_json(
-        self, entries: Sequence[Entry], file_path: str, pretty: bool = True
-    ) -> None:
+    def export_json(self, entries: Sequence[Entry], file_path: str) -> None:
         """
         Export to json.
         """
         data = [{"date": d, "content": c} for d, c in entries]
         with open(file_path, "w", encoding="utf-8") as f:
-            if pretty:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-            else:
-                json.dump(data, f, ensure_ascii=False, separators=(",", ":"))
+            json.dump(data, f, ensure_ascii=False, indent=2)
 
     def export_csv(self, entries: Sequence[Entry], file_path: str) -> None:
+        """
+        Export pages to CSV.
+        """
         # utf-8-sig adds a BOM so Excel opens as UTF-8 by default.
         with open(file_path, "w", encoding="utf-8-sig", newline="") as f:
             writer = csv.writer(f)
@@ -369,6 +328,10 @@ class DBManager:
         separator: str = "\n\n— — — — —\n\n",
         strip_html: bool = True,
     ) -> None:
+        """
+        Strip the HTML from the latest version of the pages
+        and save to a text file.
+        """
         import re, html as _html
 
         # Precompiled patterns
@@ -407,6 +370,9 @@ class DBManager:
     def export_html(
         self, entries: Sequence[Entry], file_path: str, title: str = "Bouquin export"
     ) -> None:
+        """
+        Export to HTML with a heading.
+        """
         parts = [
             "<!doctype html>",
             '<html lang="en">',
@@ -429,25 +395,17 @@ class DBManager:
     def export_markdown(
         self, entries: Sequence[Entry], file_path: str, title: str = "Bouquin export"
     ) -> None:
-        parts = [
-            "<!doctype html>",
-            '<html lang="en">',
-            "<body>",
-            f"<h1>{html.escape(title)}</h1>",
-        ]
+        """
+        Export to HTML, similar to export_html, but then convert to Markdown
+        using markdownify, and finally save to file.
+        """
+        parts = []
         for d, c in entries:
-            parts.append(
-                f"<article><header><time>{html.escape(d)}</time></header><section>{c}</section></article>"
-            )
-        parts.append("</body></html>")
-
-        # Convert html to markdown
-        md_items = []
-        for item in parts:
-            md_items.append(md(item, heading_style="ATX"))
+            parts.append(f"# {d}")
+            parts.append(c)
 
         with open(file_path, "w", encoding="utf-8") as f:
-            f.write("\n".join(md_items))
+            f.write("\n".join(parts))
 
     def export_sql(self, file_path: str) -> None:
         """
@@ -468,21 +426,6 @@ class DBManager:
         cur.execute("SELECT sqlcipher_export('backup')")
         cur.execute("DETACH DATABASE backup")
 
-    def export_by_extension(self, file_path: str) -> None:
-        entries = self.get_all_entries()
-        ext = os.path.splitext(file_path)[1].lower()
-
-        if ext == ".json":
-            self.export_json(entries, file_path)
-        elif ext == ".csv":
-            self.export_csv(entries, file_path)
-        elif ext == ".txt":
-            self.export_txt(entries, file_path)
-        elif ext in {".html", ".htm"}:
-            self.export_html(entries, file_path)
-        else:
-            raise ValueError(f"Unsupported extension: {ext}")
-
     def compact(self) -> None:
         """
         Runs VACUUM on the db.

bouquin/find_bar.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import (
+    QShortcut,
+    QTextCursor,
+    QTextCharFormat,
+    QTextDocument,
+)
+from PySide6.QtWidgets import (
+    QWidget,
+    QHBoxLayout,
+    QLineEdit,
+    QLabel,
+    QPushButton,
+    QCheckBox,
+    QTextEdit,
+)
+
+
+class FindBar(QWidget):
+    """Widget for finding text in the Editor"""
+
+    # emitted when the bar is hidden (Esc/✕), so caller can refocus editor
+    closed = Signal()
+
+    def __init__(
+        self,
+        editor: QTextEdit,
+        shortcut_parent: QWidget | None = None,
+        parent: QWidget | None = None,
+    ):
+
+        super().__init__(parent)
+
+        # store how to get the current editor
+        self._editor_getter = editor if callable(editor) else (lambda: editor)
+        self.shortcut_parent = shortcut_parent
+
+        # UI (build ONCE)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(6, 0, 6, 0)
+
+        layout.addWidget(QLabel("Find:"))
+
+        self.edit = QLineEdit(self)
+        self.edit.setPlaceholderText("Type to search")
+        layout.addWidget(self.edit)
+
+        self.case = QCheckBox("Match case", self)
+        layout.addWidget(self.case)
+
+        self.prevBtn = QPushButton("Prev", self)
+        self.nextBtn = QPushButton("Next", self)
+        self.closeBtn = QPushButton("✕", self)
+        self.closeBtn.setFlat(True)
+        layout.addWidget(self.prevBtn)
+        layout.addWidget(self.nextBtn)
+        layout.addWidget(self.closeBtn)
+
+        self.setVisible(False)
+
+        # Shortcut (press Esc to hide bar)
+        sp = (
+            self.shortcut_parent
+            if self.shortcut_parent is not None
+            else (self.parent() or self)
+        )
+        QShortcut(Qt.Key_Escape, sp, activated=self._maybe_hide)
+
+        # Signals (connect ONCE)
+        self.edit.returnPressed.connect(self.find_next)
+        self.edit.textChanged.connect(self._update_highlight)
+        self.case.toggled.connect(self._update_highlight)
+        self.nextBtn.clicked.connect(self.find_next)
+        self.prevBtn.clicked.connect(self.find_prev)
+        self.closeBtn.clicked.connect(self.hide_bar)
+
+    @property
+    def editor(self) -> QTextEdit | None:
+        """Get the current editor"""
+        return self._editor_getter()
+
+    # ----- Public API -----
+
+    def show_bar(self):
+        """Show the bar, seed with current selection if sensible, focus the line edit."""
+        if not self.editor:
+            return
+        tc = self.editor.textCursor()
+        sel = tc.selectedText().strip()
+        if sel and "\u2029" not in sel:  # ignore multi-paragraph selections
+            self.edit.setText(sel)
+        self.setVisible(True)
+        self.edit.setFocus(Qt.ShortcutFocusReason)
+        self.edit.selectAll()
+        self._update_highlight()
+
+    def hide_bar(self):
+        self.setVisible(False)
+        self._clear_highlight()
+        self.closed.emit()
+
+    def refresh(self):
+        """Recompute highlights"""
+        self._update_highlight()
+
+    # ----- Internals -----
+
+    def _maybe_hide(self):
+        if self.isVisible():
+            self.hide_bar()
+
+    def _flags(self, backward: bool = False) -> QTextDocument.FindFlags:
+        flags = QTextDocument.FindFlags()
+        if backward:
+            flags |= QTextDocument.FindBackward
+        if self.case.isChecked():
+            flags |= QTextDocument.FindCaseSensitively
+        return flags
+
+    def find_next(self):
+        if not self.editor:
+            return
+        txt = self.edit.text()
+        if not txt:
+            return
+        # If current selection == query, bump caret to the end so we don't re-match it.
+        c = self.editor.textCursor()
+        if c.hasSelection():
+            sel = c.selectedText()
+            same = (
+                (sel == txt)
+                if self.case.isChecked()
+                else (sel.casefold() == txt.casefold())
+            )
+            if same:
+                end = max(c.position(), c.anchor())
+                c.setPosition(end, QTextCursor.MoveAnchor)
+                self.editor.setTextCursor(c)
+        if not self.editor.find(txt, self._flags(False)):
+            cur = self.editor.textCursor()
+            cur.movePosition(QTextCursor.Start)
+            self.editor.setTextCursor(cur)
+            self.editor.find(txt, self._flags(False))
+        self.editor.ensureCursorVisible()
+        self._update_highlight()
+
+    def find_prev(self):
+        if not self.editor:
+            return
+        txt = self.edit.text()
+        if not txt:
+            return
+        # If current selection == query, bump caret to the start so we don't re-match it.
+        c = self.editor.textCursor()
+        if c.hasSelection():
+            sel = c.selectedText()
+            same = (
+                (sel == txt)
+                if self.case.isChecked()
+                else (sel.casefold() == txt.casefold())
+            )
+            if same:
+                start = min(c.position(), c.anchor())
+                c.setPosition(start, QTextCursor.MoveAnchor)
+                self.editor.setTextCursor(c)
+        if not self.editor.find(txt, self._flags(True)):
+            cur = self.editor.textCursor()
+            cur.movePosition(QTextCursor.End)
+            self.editor.setTextCursor(cur)
+            self.editor.find(txt, self._flags(True))
+        self.editor.ensureCursorVisible()
+        self._update_highlight()
+
+    def _update_highlight(self):
+        if not self.editor:
+            return
+        txt = self.edit.text()
+        if not txt:
+            self._clear_highlight()
+            return
+
+        doc = self.editor.document()
+        flags = self._flags(False)
+        cur = QTextCursor(doc)
+        cur.movePosition(QTextCursor.Start)
+
+        fmt = QTextCharFormat()
+        hl = self.palette().highlight().color()
+        hl.setAlpha(90)
+        fmt.setBackground(hl)
+
+        selections = []
+        while True:
+            cur = doc.find(txt, cur, flags)
+            if cur.isNull():
+                break
+            sel = QTextEdit.ExtraSelection()
+            sel.cursor = cur
+            sel.format = fmt
+            selections.append(sel)
+
+        self.editor.setExtraSelections(selections)
+
+    def _clear_highlight(self):
+        if self.editor:
+            self.editor.setExtraSelections([])

bouquin/history_dialog.py

@@ -16,31 +16,33 @@ from PySide6.QtWidgets import (
 )
 
 
-def _html_to_text(s: str) -> str:
-    """Lightweight HTML→text for diff (keeps paragraphs/line breaks)."""
-    IMG_RE = re.compile(r"(?is)<img\b[^>]*>")
-    STYLE_SCRIPT_RE = re.compile(r"(?is)<(script|style)[^>]*>.*?</\1>")
-    COMMENT_RE = re.compile(r"<!--.*?-->", re.S)
-    BR_RE = re.compile(r"(?i)<br\s*/?>")
-    BLOCK_END_RE = re.compile(r"(?i)</(p|div|section|article|li|h[1-6])\s*>")
-    TAG_RE = re.compile(r"<[^>]+>")
-    MULTINL_RE = re.compile(r"\n{3,}")
-
-    s = IMG_RE.sub("[ Image changed - see Preview pane ]", s)
-    s = STYLE_SCRIPT_RE.sub("", s)
-    s = COMMENT_RE.sub("", s)
-    s = BR_RE.sub("\n", s)
-    s = BLOCK_END_RE.sub("\n", s)
-    s = TAG_RE.sub("", s)
-    s = _html.unescape(s)
-    s = MULTINL_RE.sub("\n\n", s)
+def _markdown_to_text(s: str) -> str:
+    """Convert markdown to plain text for diff comparison."""
+    # Remove images
+    s = re.sub(r"!\[.*?\]\(.*?\)", "[ Image ]", s)
+    # Remove inline code formatting
+    s = re.sub(r"`([^`]+)`", r"\1", s)
+    # Remove bold/italic markers
+    s = re.sub(r"\*\*([^*]+)\*\*", r"\1", s)
+    s = re.sub(r"__([^_]+)__", r"\1", s)
+    s = re.sub(r"\*([^*]+)\*", r"\1", s)
+    s = re.sub(r"_([^_]+)_", r"\1", s)
+    # Remove strikethrough
+    s = re.sub(r"~~([^~]+)~~", r"\1", s)
+    # Remove heading markers
+    s = re.sub(r"^#{1,6}\s+", "", s, flags=re.MULTILINE)
+    # Remove list markers
+    s = re.sub(r"^\s*[-*+]\s+", "", s, flags=re.MULTILINE)
+    s = re.sub(r"^\s*\d+\.\s+", "", s, flags=re.MULTILINE)
+    # Remove checkbox markers
+    s = re.sub(r"^\s*-\s*\[[x ☐☑]\]\s+", "", s, flags=re.MULTILINE)
     return s.strip()
 
 
-def _colored_unified_diff_html(old_html: str, new_html: str) -> str:
+def _colored_unified_diff_html(old_md: str, new_md: str) -> str:
     """Return HTML with colored unified diff (+ green, - red, context gray)."""
-    a = _html_to_text(old_html).splitlines()
-    b = _html_to_text(new_html).splitlines()
+    a = _markdown_to_text(old_md).splitlines()
+    b = _markdown_to_text(new_md).splitlines()
     ud = difflib.unified_diff(a, b, fromfile="current", tofile="selected", lineterm="")
     lines = []
     for line in ud:
@@ -116,9 +118,9 @@ class HistoryDialog(QDialog):
         return local.strftime("%Y-%m-%d %H:%M:%S %Z")
 
     def _load_versions(self):
-        self._versions = self._db.list_versions(
-            self._date
-        )  # [{id,version_no,created_at,note,is_current}]
+        # [{id,version_no,created_at,note,is_current}]
+        self._versions = self._db.list_versions(self._date)
+
         self._current_id = next(
             (v["id"] for v in self._versions if v["is_current"]), None
         )
@@ -150,13 +152,12 @@ class HistoryDialog(QDialog):
             self.btn_revert.setEnabled(False)
             return
         sel_id = item.data(Qt.UserRole)
-        # Preview selected as HTML
         sel = self._db.get_version(version_id=sel_id)
-        self.preview.setHtml(sel["content"])
+        self.preview.setMarkdown(sel["content"])
         # Diff vs current (textual diff)
         cur = self._db.get_version(version_id=self._current_id)
         self.diff.setHtml(_colored_unified_diff_html(cur["content"], sel["content"]))
-        # Enable revert only if selecting a non-current
+        # Enable revert only if selecting a non-current version
         self.btn_revert.setEnabled(sel_id != self._current_id)
 
     @Slot()
@@ -167,7 +168,7 @@ class HistoryDialog(QDialog):
         sel_id = item.data(Qt.UserRole)
         if sel_id == self._current_id:
             return
-        # Flip head pointer
+        # Flip head pointer to the older version
         try:
             self._db.revert_to_version(self._date, version_id=sel_id)
         except Exception as e:

bouquin/key_prompt.py

@@ -17,6 +17,12 @@ class KeyPrompt(QDialog):
         title: str = "Enter key",
         message: str = "Enter key",
     ):
+        """
+        Prompt the user for the key required to decrypt the database.
+
+        Used when opening the app, unlocking the idle locked screen,
+        or when rekeying.
+        """
         super().__init__(parent)
         self.setWindowTitle(title)
         v = QVBoxLayout(self)

bouquin/lock_overlay.py

@@ -7,6 +7,9 @@ from PySide6.QtWidgets import QWidget, QVBoxLayout, QLabel, QPushButton
 
 class LockOverlay(QWidget):
     def __init__(self, parent: QWidget, on_unlock: callable):
+        """
+        Widget that 'locks' the screen after a configured idle time.
+        """
         super().__init__(parent)
         self.setObjectName("LockOverlay")
         self.setAttribute(Qt.WA_StyledBackground, True)
@@ -39,6 +42,9 @@ class LockOverlay(QWidget):
         self.hide()
 
     def _is_dark(self, pal: QPalette) -> bool:
+        """
+        Detect if dark mode is in use.
+        """
         c = pal.color(QPalette.Window)
         luma = 0.2126 * c.redF() + 0.7152 * c.greenF() + 0.0722 * c.blueF()
         return luma < 0.5
@@ -58,7 +64,7 @@ class LockOverlay(QWidget):
 
                 self.setStyleSheet(
                     f"""
-#LockOverlay {{ background-color: rgb(0,0,0); }}   /* opaque, no transparency */
+#LockOverlay {{ background-color: rgb(0,0,0); }}
 #LockOverlay QLabel#lockLabel {{ color: {accent_hex}; font-weight: 600; }}
 
 #LockOverlay QPushButton#unlockButton {{
@@ -113,7 +119,7 @@ class LockOverlay(QWidget):
 
     def changeEvent(self, ev):
         super().changeEvent(ev)
-        # Only re-style on palette flips
+        # Only re-style on palette flips (user changed theme)
         if ev.type() in (QEvent.PaletteChange, QEvent.ApplicationPaletteChange):
             self._apply_overlay_style()