bouquin 0.1.7__tar.gz → 0.2.0.1__tar.gz

{bouquin-0.1.7 → bouquin-0.2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.1.7
+Version: 0.2.0.1
 Summary: Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
 Home-page: https://git.mig5.net/mig5/bouquin
 License: GPL-3.0-or-later
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 ## Introduction
 
-Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
+Bouquin ("Book-ahn") is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
 
 It uses [SQLCipher bindings](https://pypi.org/project/sqlcipher3-wheels) as a drop-in replacement
 for SQLite3. This means that the underlying database for the notebook is encrypted at rest.
@@ -37,25 +37,36 @@ There is deliberately no network connectivity or syncing intended.
 
 ![Screenshot of Bouquin](./screenshot.png)
 
+![Screenshot of Bouquin in dark mode](./screenshot_dark.png)
+
 ## Features
 
  * Data is encrypted at rest
  * Encryption key is prompted for and never stored, unless user chooses to via Settings
  * Every 'page' is linked to the calendar day
  * All changes are version controlled, with ability to view/diff versions and revert
- * Text is HTML with basic styling
+ * Text is Markdown with basic styling
+ * Images are supported
  * Search
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
  * Rekey the database (change the password)
- * Export the database to json, txt, html or csv
+ * Export the database to json, txt, html, csv, markdown or .sql (for sqlite3)
+ * Backup the database to encrypted SQLCipher format (which can then be loaded back in to a Bouquin)
+ * Dark and light themes
+ * Automatically generate checkboxes when typing 'TODO'
+ * Optionally automatically move unchecked checkboxes from yesterday to today, on startup
 
 
 ## How to install
 
 Make sure you have `libxcb-cursor0` installed (it may be called something else on non-Debian distributions).
 
+### From PyPi/pip
+
+ * `pip install bouquin`
+
 ### From source
 
  * Clone this repo or download the tarball from the releases page
@@ -67,15 +78,10 @@ Make sure you have `libxcb-cursor0` installed (it may be called something else o
 
  * Download the whl and run it
 
-### From PyPi/pip
-
- * `pip install bouquin`
-
-
 ## How to run the tests
 
  * Clone the repo
  * Ensure you have poetry installed
  * Run `poetry install --with test`
- * Run `poetry run pytest -vvv`
+ * Run `./tests.sh`
 

{bouquin-0.1.7 → bouquin-0.2.0.1}/README.md

@@ -3,7 +3,7 @@
 
 ## Introduction
 
-Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
+Bouquin ("Book-ahn") is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
 
 It uses [SQLCipher bindings](https://pypi.org/project/sqlcipher3-wheels) as a drop-in replacement
 for SQLite3. This means that the underlying database for the notebook is encrypted at rest.
@@ -17,25 +17,36 @@ There is deliberately no network connectivity or syncing intended.
 
 ![Screenshot of Bouquin](./screenshot.png)
 
+![Screenshot of Bouquin in dark mode](./screenshot_dark.png)
+
 ## Features
 
  * Data is encrypted at rest
  * Encryption key is prompted for and never stored, unless user chooses to via Settings
  * Every 'page' is linked to the calendar day
  * All changes are version controlled, with ability to view/diff versions and revert
- * Text is HTML with basic styling
+ * Text is Markdown with basic styling
+ * Images are supported
  * Search
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
  * Rekey the database (change the password)
- * Export the database to json, txt, html or csv
+ * Export the database to json, txt, html, csv, markdown or .sql (for sqlite3)
+ * Backup the database to encrypted SQLCipher format (which can then be loaded back in to a Bouquin)
+ * Dark and light themes
+ * Automatically generate checkboxes when typing 'TODO'
+ * Optionally automatically move unchecked checkboxes from yesterday to today, on startup
 
 
 ## How to install
 
 Make sure you have `libxcb-cursor0` installed (it may be called something else on non-Debian distributions).
 
+### From PyPi/pip
+
+ * `pip install bouquin`
+
 ### From source
 
  * Clone this repo or download the tarball from the releases page
@@ -47,14 +58,9 @@ Make sure you have `libxcb-cursor0` installed (it may be called something else o
 
  * Download the whl and run it
 
-### From PyPi/pip
-
- * `pip install bouquin`
-
-
 ## How to run the tests
 
  * Clone the repo
  * Ensure you have poetry installed
  * Run `poetry install --with test`
- * Run `poetry run pytest -vvv`
+ * Run `./tests.sh`

{bouquin-0.1.7 → bouquin-0.2.0.1}/bouquin/db.py

@@ -18,6 +18,8 @@ class DBConfig:
     path: Path
     key: str
     idle_minutes: int = 15  # 0 = never lock
+    theme: str = "system"
+    move_todos: bool = False
 
 
 class DBManager:
@@ -133,7 +135,7 @@ class DBManager:
             raise RuntimeError("Database is not connected")
         cur = self.conn.cursor()
         # Change the encryption key of the currently open database
-        cur.execute(f"PRAGMA rekey = '{new_key}';")
+        cur.execute(f"PRAGMA rekey = '{new_key}';").fetchone()
         self.conn.commit()
 
         # Close and reopen with the new key to verify and restore PRAGMAs
@@ -159,13 +161,6 @@ class DBManager:
         ).fetchone()
         return row[0] if row else ""
 
-    def upsert_entry(self, date_iso: str, content: str) -> None:
-        """
-        Insert or update an entry.
-        """
-        # Make a new version and set it as current
-        self.save_new_version(date_iso, content, note=None, set_current=True)
-
     def search_entries(self, text: str) -> list[str]:
         """
         Search for entries by term. This only works against the latest
@@ -261,68 +256,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(
@@ -346,20 +304,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)
@@ -373,6 +329,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
@@ -409,8 +369,11 @@ class DBManager:
                     f.write(separator)
 
     def export_html(
-        self, entries: Sequence[Entry], file_path: str, title: str = "Entries export"
+        self, entries: Sequence[Entry], file_path: str, title: str = "Bouquin export"
     ) -> None:
+        """
+        Export to HTML with a heading.
+        """
         parts = [
             "<!doctype html>",
             '<html lang="en">',
@@ -430,7 +393,45 @@ class DBManager:
         with open(file_path, "w", encoding="utf-8") as f:
             f.write("\n".join(parts))
 
+    def export_markdown(
+        self, entries: Sequence[Entry], file_path: str, title: str = "Bouquin export"
+    ) -> None:
+        """
+        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"# {d}")
+            parts.append(c)
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(parts))
+
+    def export_sql(self, file_path: str) -> None:
+        """
+        Exports the encrypted database as plaintext SQL.
+        """
+        cur = self.conn.cursor()
+        cur.execute(f"ATTACH DATABASE '{file_path}' AS plaintext KEY '';")
+        cur.execute("SELECT sqlcipher_export('plaintext')")
+        cur.execute("DETACH DATABASE plaintext")
+
+    def export_sqlcipher(self, file_path: str) -> None:
+        """
+        Exports the encrypted database as an encrypted database with the same key.
+        Intended for Bouquin-compatible backups.
+        """
+        cur = self.conn.cursor()
+        cur.execute(f"ATTACH DATABASE '{file_path}' AS backup KEY '{self.cfg.key}'")
+        cur.execute("SELECT sqlcipher_export('backup')")
+        cur.execute("DETACH DATABASE backup")
+
     def export_by_extension(self, file_path: str) -> None:
+        """
+        Fallback catch-all that runs one of the above functions based on
+        the extension of the file name that was chosen by the user.
+        """
         entries = self.get_all_entries()
         ext = os.path.splitext(file_path)[1].lower()
 
@@ -442,9 +443,23 @@ class DBManager:
             self.export_txt(entries, file_path)
         elif ext in {".html", ".htm"}:
             self.export_html(entries, file_path)
+        elif ext in {".sql", ".sqlite"}:
+            self.export_sql(file_path)
+        elif ext == ".md":
+            self.export_markdown(entries, file_path)
         else:
             raise ValueError(f"Unsupported extension: {ext}")
 
+    def compact(self) -> None:
+        """
+        Runs VACUUM on the db.
+        """
+        try:
+            cur = self.conn.cursor()
+            cur.execute("VACUUM")
+        except Exception as e:
+            print(f"Error: {e}")
+
     def close(self) -> None:
         if self.conn is not None:
             self.conn.close()

bouquin-0.2.0.1/bouquin/find_bar.py

@@ -0,0 +1,186 @@
+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"""
+
+    closed = (
+        Signal()
+    )  # emitted when the bar is hidden (Esc/✕), so caller can refocus editor
+
+    def __init__(
+        self,
+        editor: QTextEdit,
+        shortcut_parent: QWidget | None = None,
+        parent: QWidget | None = None,
+    ):
+        super().__init__(parent)
+        self.editor = editor
+
+        # UI
+        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 escape key to close findBar
+        sp = shortcut_parent if shortcut_parent is not None else (parent or self)
+        self._scEsc = QShortcut(Qt.Key_Escape, sp, activated=self._maybe_hide)
+
+        # Signals
+        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)
+
+    # ----- Public API -----
+
+    def show_bar(self):
+        """Show the bar, seed with current selection if sensible, focus the line edit."""
+        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):
+        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):
+        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):
+        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):
+        self.editor.setExtraSelections([])

{bouquin-0.1.7 → bouquin-0.2.0.1}/bouquin/history_dialog.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import difflib, re, html as _html
+from datetime import datetime
 from PySide6.QtCore import Qt, Slot
 from PySide6.QtWidgets import (
     QDialog,
@@ -15,29 +16,33 @@ from PySide6.QtWidgets import (
 )
 
 
-def _html_to_text(s: str) -> str:
-    """Lightweight HTML→text for diff (keeps paragraphs/line breaks)."""
-    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 = 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:
@@ -104,6 +109,14 @@ class HistoryDialog(QDialog):
         self._load_versions()
 
     # --- Data/UX helpers ---
+    def _fmt_local(self, iso_utc: str) -> str:
+        """
+        Convert UTC in the database to user's local tz
+        """
+        dt = datetime.fromisoformat(iso_utc.replace("Z", "+00:00"))
+        local = dt.astimezone()
+        return local.strftime("%Y-%m-%d %H:%M:%S %Z")
+
     def _load_versions(self):
         self._versions = self._db.list_versions(
             self._date
@@ -113,7 +126,7 @@ class HistoryDialog(QDialog):
         )
         self.list.clear()
         for v in self._versions:
-            label = f"v{v['version_no']} — {v['created_at']}"
+            label = f"v{v['version_no']} — {self._fmt_local(v['created_at'])}"
             if v.get("note"):
                 label += f"  ·  {v['note']}"
             if v["is_current"]:
@@ -139,13 +152,17 @@ class HistoryDialog(QDialog):
             self.btn_revert.setEnabled(False)
             return
         sel_id = item.data(Qt.UserRole)
-        # Preview selected as HTML
+        # Preview selected as plain text (markdown)
         sel = self._db.get_version(version_id=sel_id)
-        self.preview.setHtml(sel["content"])
+        # Show markdown as plain text with monospace font for better readability
+        self.preview.setPlainText(sel["content"])
+        self.preview.setStyleSheet(
+            "font-family: Consolas, Menlo, Monaco, monospace; font-size: 13px;"
+        )
         # 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()
@@ -156,24 +173,10 @@ class HistoryDialog(QDialog):
         sel_id = item.data(Qt.UserRole)
         if sel_id == self._current_id:
             return
-        sel = self._db.get_version(version_id=sel_id)
-        vno = sel["version_no"]
-        # Confirm
-        if (
-            QMessageBox.question(
-                self,
-                "Revert",
-                f"Revert {self._date} to version v{vno}?\n\nYou can always change your mind later.",
-                QMessageBox.Yes | QMessageBox.No,
-            )
-            != QMessageBox.Yes
-        ):
-            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:
             QMessageBox.critical(self, "Revert failed", str(e))
             return
-        QMessageBox.information(self, "Reverted", f"{self._date} is now at v{vno}.")
-        self.accept()  # let the caller refresh the editor
+        self.accept()