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

bouquin/db.py

@@ -257,68 +257,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 +305,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 +330,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 +372,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,6 +397,10 @@ class DBManager:
     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 = [
             "<!doctype html>",
             '<html lang="en">',
@@ -469,6 +441,10 @@ class DBManager:
         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()
 
@@ -480,6 +456,10 @@ 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}")
 

bouquin/editor.py

@@ -68,13 +68,161 @@ class Editor(QTextEdit):
         self._retint_anchors_to_palette()
 
         self._themes = theme_manager
+        self._apply_code_theme()  # set initial code colors
         # Refresh on theme change
         self._themes.themeChanged.connect(self._on_theme_changed)
+        self._themes.themeChanged.connect(
+            lambda _t: QTimer.singleShot(0, self._apply_code_theme)
+        )
 
         self._linkifying = False
         self.textChanged.connect(self._linkify_document)
         self.viewport().setMouseTracking(True)
 
+    # ---------------- Helpers ---------------- #
+
+    def _iter_frames(self, root=None):
+        """Depth-first traversal of all frames (including root if passed)."""
+        doc = self.document()
+        stack = [root or doc.rootFrame()]
+        while stack:
+            f = stack.pop()
+            yield f
+            it = f.begin()
+            while not it.atEnd():
+                cf = it.currentFrame()
+                if cf is not None:
+                    stack.append(cf)
+                it += 1
+
+    def _is_code_frame(self, frame, tolerant: bool = False) -> bool:
+        """
+        True if 'frame' is a code frame.
+        - tolerant=False: require our property marker
+        - tolerant=True: also accept legacy background or non-wrapping heuristic
+        """
+        ff = frame.frameFormat()
+        if ff.property(self._CODE_FRAME_PROP):
+            return True
+        if not tolerant:
+            return False
+
+        # Background colour check
+        bg = ff.background()
+        if bg.style() != Qt.NoBrush:
+            c = bg.color()
+            if c.isValid():
+                if (
+                    abs(c.red() - 245) <= 2
+                    and abs(c.green() - 245) <= 2
+                    and abs(c.blue() - 245) <= 2
+                ):
+                    return True
+                if (
+                    abs(c.red() - 43) <= 2
+                    and abs(c.green() - 43) <= 2
+                    and abs(c.blue() - 43) <= 2
+                ):
+                    return True
+
+        # Heuristic: mostly non-wrapping blocks
+        doc = self.document()
+        bc = QTextCursor(doc)
+        bc.setPosition(frame.firstPosition())
+        blocks = codeish = 0
+        while bc.position() < frame.lastPosition():
+            b = bc.block()
+            if not b.isValid():
+                break
+            blocks += 1
+            if b.blockFormat().nonBreakableLines():
+                codeish += 1
+            bc.setPosition(b.position() + b.length())
+        return blocks > 0 and (codeish / blocks) >= 0.6
+
+    def _nearest_code_frame(self, cursor, tolerant: bool = False):
+        """Walk up parents from the cursor and return the first code frame."""
+        f = cursor.currentFrame()
+        while f:
+            if self._is_code_frame(f, tolerant=tolerant):
+                return f
+            f = f.parentFrame()
+        return None
+
+    def _code_block_formats(self, fg: QColor | None = None):
+        """(QTextBlockFormat, QTextCharFormat) for code blocks."""
+        mono = QFontDatabase.systemFont(QFontDatabase.FixedFont)
+
+        bf = QTextBlockFormat()
+        bf.setTopMargin(0)
+        bf.setBottomMargin(0)
+        bf.setLeftMargin(12)
+        bf.setRightMargin(12)
+        bf.setNonBreakableLines(True)
+
+        cf = QTextCharFormat()
+        cf.setFont(mono)
+        cf.setFontFixedPitch(True)
+        if fg is not None:
+            cf.setForeground(fg)
+        return bf, cf
+
+    def _new_code_frame_format(self, bg: QColor) -> QTextFrameFormat:
+        """Standard frame format for code blocks."""
+        ff = QTextFrameFormat()
+        ff.setBackground(bg)
+        ff.setPadding(6)
+        ff.setBorder(0)
+        ff.setLeftMargin(0)
+        ff.setRightMargin(0)
+        ff.setTopMargin(0)
+        ff.setBottomMargin(0)
+        ff.setProperty(self._CODE_FRAME_PROP, True)
+        return ff
+
+    def _retint_code_frame(self, frame, bg: QColor, fg: QColor | None):
+        """Apply background to frame and standard code formats to all blocks inside."""
+        ff = frame.frameFormat()
+        ff.setBackground(bg)
+        frame.setFrameFormat(ff)
+
+        bf, cf = self._code_block_formats(fg)
+        doc = self.document()
+        bc = QTextCursor(doc)
+        bc.setPosition(frame.firstPosition())
+        while bc.position() < frame.lastPosition():
+            bc.select(QTextCursor.BlockUnderCursor)
+            bc.mergeBlockFormat(bf)
+            bc.mergeBlockCharFormat(cf)
+            if not bc.movePosition(QTextCursor.NextBlock):
+                break
+
+    def _safe_block_insertion_cursor(self):
+        """
+        Return a cursor positioned for inserting an inline object (like an image):
+        - not inside a code frame (moves to after frame if necessary)
+        - at a fresh paragraph (inserts a block if mid-line)
+        Also updates the editor's current cursor to that position.
+        """
+        c = QTextCursor(self.textCursor())
+        frame = self._nearest_code_frame(c, tolerant=False)  # strict: our frames only
+        if frame:
+            out = QTextCursor(self.document())
+            out.setPosition(frame.lastPosition())
+            self.setTextCursor(out)
+            c = self.textCursor()
+        if c.positionInBlock() != 0:
+            c.insertBlock()
+        return c
+
+    def _scale_to_viewport(self, img: QImage, ratio: float = 0.92) -> QImage:
+        """If the image is wider than viewport*ratio, scale it down proportionally."""
+        if self.viewport():
+            max_w = int(self.viewport().width() * ratio)
+            if img.width() > max_w:
+                return img.scaledToWidth(max_w, Qt.SmoothTransformation)
+        return img
+
     def _approx(self, a: float, b: float, eps: float = 0.5) -> bool:
         return abs(float(a) - float(b)) <= eps
 
@@ -91,16 +239,35 @@ class Editor(QTextEdit):
         nf.setFontWeight(QFont.Weight.Normal)
         self.mergeCurrentCharFormat(nf)
 
-    def _find_code_frame(self, cursor=None):
-        """Return the nearest ancestor frame that's one of our code frames, else None."""
-        if cursor is None:
-            cursor = self.textCursor()
-        f = cursor.currentFrame()
-        while f:
-            if f.frameFormat().property(self._CODE_FRAME_PROP):
-                return f
-            f = f.parentFrame()
-        return None
+    def _code_theme_colors(self):
+        """Return (bg, fg) for code blocks based on the effective palette."""
+        pal = QApplication.instance().palette()
+        # simple luminance check on the window color
+        win = pal.color(QPalette.Window)
+        is_dark = win.value() < 128
+        if is_dark:
+            bg = QColor(43, 43, 43)  # dark code background
+            fg = pal.windowText().color()  # readable on dark
+        else:
+            bg = QColor(245, 245, 245)  # light code background
+            fg = pal.text().color()  # readable on light
+        return bg, fg
+
+    def _apply_code_theme(self):
+        """Retint all code frames (even those reloaded from HTML) to match the current theme."""
+        bg, fg = self._code_theme_colors()
+        self._CODE_BG = bg  # used by future apply_code() calls
+
+        doc = self.document()
+        cur = QTextCursor(doc)
+        cur.beginEditBlock()
+        try:
+            for f in self._iter_frames(doc.rootFrame()):
+                if f is not doc.rootFrame() and self._is_code_frame(f, tolerant=True):
+                    self._retint_code_frame(f, bg, fg)
+        finally:
+            cur.endEditBlock()
+            self.viewport().update()
 
     def _trim_url_end(self, url: str) -> str:
         # strip common trailing punctuation not part of the URL
@@ -149,7 +316,7 @@ class Editor(QTextEdit):
                 fmt.setFontUnderline(True)
                 fmt.setForeground(self.palette().brush(QPalette.Link))
 
-                cur.mergeCharFormat(fmt)  # merge so we don’t clobber other styling
+                cur.mergeCharFormat(fmt)  # merge so we don't clobber other styling
 
             cur.endEditBlock()
         finally:
@@ -209,26 +376,12 @@ class Editor(QTextEdit):
             html = html.replace(f"src='{old}'", f"src='{data_url}'")
         return html
 
-    def _insert_qimage_at_cursor(self, img: QImage, autoscale=True):
-        c = self.textCursor()
-
-        # Don’t drop inside a code frame
-        frame = self._find_code_frame(c)
-        if frame:
-            out = QTextCursor(self.document())
-            out.setPosition(frame.lastPosition())
-            self.setTextCursor(out)
-            c = self.textCursor()
-
-        # Start a fresh paragraph if mid-line
-        if c.positionInBlock() != 0:
-            c.insertBlock()
-
-        if autoscale and self.viewport():
-            max_w = int(self.viewport().width() * 0.92)
-            if img.width() > max_w:
-                img = img.scaledToWidth(max_w, Qt.SmoothTransformation)
+    # ---------------- Image insertion & sizing (DRY’d) ---------------- #
 
+    def _insert_qimage_at_cursor(self, img: QImage, autoscale=True):
+        c = self._safe_block_insertion_cursor()
+        if autoscale:
+            img = self._scale_to_viewport(img)
         c.insertImage(img)
         c.insertBlock()  # one blank line after the image
 
@@ -338,6 +491,8 @@ class Editor(QTextEdit):
             return
         self._apply_image_size(tc, imgfmt, float(orig.width()), orig)
 
+    # ---------------- Context menu ---------------- #
+
     def contextMenuEvent(self, e):
         menu = self.createStandardContextMenu()
         tc, imgfmt, orig = self._image_info_at_cursor()
@@ -351,6 +506,8 @@ class Editor(QTextEdit):
             sub.addAction("Reset to original", self._reset_image_size)
         menu.exec(e.globalPos())
 
+    # ---------------- Clipboard / DnD ---------------- #
+
     def insertFromMimeData(self, source):
         # 1) Direct image from clipboard
         if source.hasImage():
@@ -398,7 +555,7 @@ class Editor(QTextEdit):
                     data = base64.b64decode(m.group(1))
                     img = QImage.fromData(data)
                     if not img.isNull():
-                        self._insert_qimage_at_cursor(self, img, autoscale=True)
+                        self._insert_qimage_at_cursor(img, autoscale=True)
                         return
                 except Exception:
                     pass  # fall through
@@ -412,19 +569,7 @@ class Editor(QTextEdit):
         Insert one or more images at the cursor. Large images can be auto-scaled
         to fit the viewport width while preserving aspect ratio.
         """
-        c = self.textCursor()
-
-        # Avoid dropping images inside a code frame
-        frame = self._find_code_frame(c)
-        if frame:
-            out = QTextCursor(self.document())
-            out.setPosition(frame.lastPosition())
-            self.setTextCursor(out)
-            c = self.textCursor()
-
-        # Ensure there's a paragraph break if we're mid-line
-        if c.positionInBlock() != 0:
-            c.insertBlock()
+        c = self._safe_block_insertion_cursor()
 
         for path in paths:
             reader = QImageReader(path)
@@ -432,14 +577,14 @@ class Editor(QTextEdit):
             if img.isNull():
                 continue
 
-            if autoscale and self.viewport():
-                max_w = int(self.viewport().width() * 0.92)  # ~92% of editor width
-                if img.width() > max_w:
-                    img = img.scaledToWidth(max_w, Qt.SmoothTransformation)
+            if autoscale:
+                img = self._scale_to_viewport(img)
 
             c.insertImage(img)
             c.insertBlock()  # put each image on its own line
 
+    # ---------------- Mouse & key handling ---------------- #
+
     def mouseReleaseEvent(self, e):
         if e.button() == Qt.LeftButton and (e.modifiers() & Qt.ControlModifier):
             href = self.anchorAt(e.pos())
@@ -510,7 +655,7 @@ class Editor(QTextEdit):
 
             # If we're on an empty line inside a code frame, consume Enter and jump out
             if c.block().length() == 1:
-                frame = self._find_code_frame(c)
+                frame = self._nearest_code_frame(c, tolerant=False)
                 if frame:
                     out = QTextCursor(self.document())
                     out.setPosition(frame.lastPosition())  # after the frame's contents
@@ -588,7 +733,7 @@ class Editor(QTextEdit):
 
     # ====== Checkbox core ======
     def _base_point_size_for_block(self, block) -> float:
-        # Try the block’s char format, then editor font
+        # Try the block's char format, then editor font
         sz = block.charFormat().fontPointSize()
         if sz <= 0:
             sz = self.fontPointSize()
@@ -697,14 +842,6 @@ class Editor(QTextEdit):
                 break
             b = b.next()
 
-    def toggle_current_checkbox_state(self):
-        """Tick/untick the current line if it starts with a checkbox."""
-        b = self.textCursor().block()
-        state, _ = self._checkbox_info_for_block(b)
-        if state is None:
-            return
-        self._set_block_checkbox_state(b, not state)
-
     @Slot()
     def apply_weight(self):
         cur = self.currentCharFormat()
@@ -744,46 +881,16 @@ class Editor(QTextEdit):
         if not c.hasSelection():
             c.select(QTextCursor.BlockUnderCursor)
 
-        # Wrap the selection in a single frame (no per-block padding/margins).
-        ff = QTextFrameFormat()
-        ff.setBackground(self._CODE_BG)
-        ff.setPadding(6)  # visual padding for the WHOLE block
-        ff.setBorder(0)
-        ff.setLeftMargin(0)
-        ff.setRightMargin(0)
-        ff.setTopMargin(0)
-        ff.setBottomMargin(0)
-        ff.setProperty(self._CODE_FRAME_PROP, True)
-
-        mono = QFontDatabase.systemFont(QFontDatabase.FixedFont)
+        ff = self._new_code_frame_format(self._CODE_BG)
 
         c.beginEditBlock()
         try:
             c.insertFrame(ff)  # with a selection, this wraps the selection
 
-            # Format all blocks inside the new frame: zero vertical margins, mono font, no wrapping
-            frame = self._find_code_frame(c)
-            bc = QTextCursor(self.document())
-            bc.setPosition(frame.firstPosition())
-
-            while bc.position() < frame.lastPosition():
-                bc.select(QTextCursor.BlockUnderCursor)
-
-                bf = QTextBlockFormat()
-                bf.setTopMargin(0)
-                bf.setBottomMargin(0)
-                bf.setLeftMargin(12)
-                bf.setRightMargin(12)
-                bf.setNonBreakableLines(True)
-
-                cf = QTextCharFormat()
-                cf.setFont(mono)
-                cf.setFontFixedPitch(True)
-
-                bc.mergeBlockFormat(bf)
-                bc.mergeBlockCharFormat(cf)
-
-                bc.setPosition(bc.block().position() + bc.block().length())
+            # Format all blocks inside the new frame (keep fg=None on creation)
+            frame = self._nearest_code_frame(c, tolerant=False)
+            if frame:
+                self._retint_code_frame(frame, self._CODE_BG, fg=None)
         finally:
             c.endEditBlock()
 
@@ -855,6 +962,7 @@ class Editor(QTextEdit):
     def _on_theme_changed(self, _theme: Theme):
         # Defer one event-loop tick so widgets have the new palette
         QTimer.singleShot(0, self._retint_anchors_to_palette)
+        QTimer.singleShot(0, self._apply_code_theme)
 
     @Slot()
     def _retint_anchors_to_palette(self, *_):
@@ -874,10 +982,13 @@ class Editor(QTextEdit):
                     if fmt.isAnchor():
                         new_fmt = QTextCharFormat(fmt)
                         new_fmt.setForeground(link_brush)  # force palette link color
-                        cur.setPosition(frag.position())
-                        cur.setPosition(
-                            frag.position() + frag.length(), QTextCursor.KeepAnchor
-                        )
+                        start = frag.position()
+                        cur.setPosition(start)
+                        cur.movePosition(
+                            QTextCursor.NextCharacter,
+                            QTextCursor.KeepAnchor,
+                            frag.length(),
+                        )  # select exactly this fragment
                         cur.setCharFormat(new_fmt)
                 it += 1
             block = block.next()
@@ -895,3 +1006,4 @@ class Editor(QTextEdit):
 
         # Ensure anchors adopt the palette color on startup
         self._retint_anchors_to_palette()
+        self._apply_code_theme()

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/history_dialog.py

@@ -156,7 +156,7 @@ class HistoryDialog(QDialog):
         # 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 +167,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()
 

bouquin/main_window.py

@@ -24,8 +24,10 @@ from PySide6.QtGui import (
     QDesktopServices,
     QFont,
     QGuiApplication,
+    QKeySequence,
     QPalette,
     QTextCharFormat,
+    QTextCursor,
     QTextListFormat,
 )
 from PySide6.QtWidgets import (
@@ -43,6 +45,7 @@ from PySide6.QtWidgets import (
 
 from .db import DBManager
 from .editor import Editor
+from .find_bar import FindBar
 from .history_dialog import HistoryDialog
 from .key_prompt import KeyPrompt
 from .lock_overlay import LockOverlay
@@ -121,7 +124,7 @@ class MainWindow(QMainWindow):
         split = QSplitter()
         split.addWidget(left_panel)
         split.addWidget(self.editor)
-        split.setStretchFactor(1, 1)  # editor grows
+        split.setStretchFactor(1, 1)
 
         container = QWidget()
         lay = QVBoxLayout(container)
@@ -146,8 +149,23 @@ class MainWindow(QMainWindow):
 
         QApplication.instance().installEventFilter(self)
 
+        # Focus on the editor
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.editor.setFocusPolicy(Qt.StrongFocus)
+        self.toolBar.setFocusPolicy(Qt.NoFocus)
+        for w in self.toolBar.findChildren(QWidget):
+            w.setFocusPolicy(Qt.NoFocus)
+        QGuiApplication.instance().applicationStateChanged.connect(
+            self._on_app_state_changed
+        )
+
         # Status bar for feedback
         self.statusBar().showMessage("Ready", 800)
+        # Add findBar and add it to the statusBar
+        self.findBar = FindBar(self.editor, shortcut_parent=self, parent=self)
+        self.statusBar().addPermanentWidget(self.findBar)
+        # When the findBar closes, put the caret back in the editor
+        self.findBar.closed.connect(self._focus_editor_now)
 
         # Menu bar (File)
         mb = self.menuBar()
@@ -202,6 +220,24 @@ class MainWindow(QMainWindow):
         nav_menu.addAction(act_today)
         self.addAction(act_today)
 
+        act_find = QAction("Find on page", self)
+        act_find.setShortcut(QKeySequence.Find)
+        act_find.triggered.connect(self.findBar.show_bar)
+        nav_menu.addAction(act_find)
+        self.addAction(act_find)
+
+        act_find_next = QAction("Find Next", self)
+        act_find_next.setShortcut(QKeySequence.FindNext)
+        act_find_next.triggered.connect(self.findBar.find_next)
+        nav_menu.addAction(act_find_next)
+        self.addAction(act_find_next)
+
+        act_find_prev = QAction("Find Previous", self)
+        act_find_prev.setShortcut(QKeySequence.FindPrevious)
+        act_find_prev.triggered.connect(self.findBar.find_prev)
+        nav_menu.addAction(act_find_prev)
+        self.addAction(act_find_prev)
+
         # Help menu with drop-down
         help_menu = mb.addMenu("&Help")
         act_docs = QAction("Documentation", self)
@@ -281,7 +317,7 @@ class MainWindow(QMainWindow):
         if hasattr(self, "_lock_overlay"):
             self._lock_overlay._apply_overlay_style()
         self._apply_calendar_text_colors()
-        self._apply_link_css()  # Reapply link styles based on the current theme
+        self._apply_link_css()
         self._apply_search_highlights(getattr(self, "_search_highlighted_dates", set()))
         self.calendar.update()
         self.editor.viewport().update()
@@ -298,7 +334,6 @@ class MainWindow(QMainWindow):
             css = ""  # Default to no custom styling for links (system or light theme)
 
         try:
-            # Apply to the editor (QTextEdit or any other relevant widgets)
             self.editor.document().setDefaultStyleSheet(css)
         except Exception:
             pass
@@ -347,7 +382,6 @@ class MainWindow(QMainWindow):
             self.calendar.setPalette(app_pal)
             self.calendar.setStyleSheet("")
 
-        # Keep weekend text color in sync with the current palette
         self._apply_calendar_text_colors()
         self.calendar.update()
 
@@ -483,18 +517,16 @@ class MainWindow(QMainWindow):
                 # Inject the extra_data before the closing </body></html>
                 modified = re.sub(r"(<\/body><\/html>)", extra_data_html + r"\1", text)
                 text = modified
-                self.editor.setHtml(text)
+                # Force a save now so we don't lose it.
+                self._set_editor_html_preserve_view(text)
                 self._dirty = True
                 self._save_date(date_iso, True)
 
-            print("end")
         except Exception as e:
             QMessageBox.critical(self, "Read Error", str(e))
             return
 
-        self.editor.blockSignals(True)
-        self.editor.setHtml(text)
-        self.editor.blockSignals(False)
+        self._set_editor_html_preserve_view(text)
 
         self._dirty = False
         # track which date the editor currently represents
@@ -708,7 +740,7 @@ class MainWindow(QMainWindow):
             QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
         )
         r = screen.availableGeometry()
-        # Center the window in that screen’s available area
+        # Center the window in that screen's available area
         self.move(r.center() - self.rect().center())
 
     # ----------------- Export handler ----------------- #
@@ -837,7 +869,7 @@ If you want an encrypted backup, choose Backup instead of Export.
             return
         if minutes == 0:
             self._idle_timer.stop()
-            # If you’re currently locked, unlock when user disables the timer:
+            # If currently locked, unlock when user disables the timer:
             if getattr(self, "_locked", False):
                 try:
                     self._locked = False
@@ -853,9 +885,14 @@ If you want an encrypted backup, choose Backup instead of Export.
     def eventFilter(self, obj, event):
         if event.type() == QEvent.KeyPress and not self._locked:
             self._idle_timer.start()
+        if event.type() in (QEvent.ApplicationActivate, QEvent.WindowActivate):
+            QTimer.singleShot(0, self._focus_editor_now)
         return super().eventFilter(obj, event)
 
     def _enter_lock(self):
+        """
+        Trigger the lock overlay and disable widgets
+        """
         if self._locked:
             return
         self._locked = True
@@ -871,6 +908,10 @@ If you want an encrypted backup, choose Backup instead of Export.
 
     @Slot()
     def _on_unlock_clicked(self):
+        """
+        Prompt for key to unlock screen
+        If successful, re-enable widgets
+        """
         try:
             ok = self._prompt_for_key_until_valid(first_time=False)
         except Exception as e:
@@ -887,6 +928,7 @@ If you want an encrypted backup, choose Backup instead of Export.
             if tb:
                 tb.setEnabled(True)
             self._idle_timer.start()
+            QTimer.singleShot(0, self._focus_editor_now)
 
     # ----------------- Close handlers ----------------- #
     def closeEvent(self, event):
@@ -902,3 +944,65 @@ If you want an encrypted backup, choose Backup instead of Export.
         except Exception:
             pass
         super().closeEvent(event)
+
+    # ----------------- Below logic helps focus the editor ----------------- #
+
+    def _focus_editor_now(self):
+        """Give focus to the editor and ensure the caret is visible."""
+        if getattr(self, "_locked", False):
+            return
+        if not self.isActiveWindow():
+            return
+        # Belt-and-suspenders: do it now and once more on the next tick
+        self.editor.setFocus(Qt.ActiveWindowFocusReason)
+        self.editor.ensureCursorVisible()
+        QTimer.singleShot(
+            0,
+            lambda: (
+                self.editor.setFocus(Qt.ActiveWindowFocusReason),
+                self.editor.ensureCursorVisible(),
+            ),
+        )
+
+    def _on_app_state_changed(self, state):
+        # Called on macOS/Wayland/Windows when the whole app re-activates
+        if state == Qt.ApplicationActive and self.isActiveWindow():
+            QTimer.singleShot(0, self._focus_editor_now)
+
+    def changeEvent(self, ev):
+        # Called on some platforms when the window's activation state flips
+        super().changeEvent(ev)
+        if ev.type() == QEvent.ActivationChange and self.isActiveWindow():
+            QTimer.singleShot(0, self._focus_editor_now)
+
+    def _set_editor_html_preserve_view(self, html: str):
+        ed = self.editor
+
+        # Save caret/selection and scroll
+        cur = ed.textCursor()
+        old_pos, old_anchor = cur.position(), cur.anchor()
+        v = ed.verticalScrollBar().value()
+        h = ed.horizontalScrollBar().value()
+
+        # Only touch the doc if it actually changed
+        ed.blockSignals(True)
+        if ed.toHtml() != html:
+            ed.setHtml(html)
+        ed.blockSignals(False)
+
+        # Restore scroll first
+        ed.verticalScrollBar().setValue(v)
+        ed.horizontalScrollBar().setValue(h)
+
+        # Restore caret/selection
+        cur = ed.textCursor()
+        cur.setPosition(old_anchor)
+        mode = (
+            QTextCursor.KeepAnchor if old_anchor != old_pos else QTextCursor.MoveAnchor
+        )
+        cur.setPosition(old_pos, mode)
+        ed.setTextCursor(cur)
+
+        # Refresh highlights if the theme changed
+        if hasattr(self, "findBar"):
+            self.findBar.refresh()

bouquin/save_dialog.py

@@ -18,6 +18,9 @@ class SaveDialog(QDialog):
         title: str = "Enter a name for this version",
         message: str = "Enter a name for this version?",
     ):
+        """
+        Used for explicitly saving a new version of a page.
+        """
         super().__init__(parent)
         self.setWindowTitle(title)
         v = QVBoxLayout(self)

bouquin/search.py

@@ -70,7 +70,6 @@ class Search(QWidget):
         try:
             rows: Iterable[Row] = self._db.search_entries(q)
         except Exception:
-            # be quiet on DB errors here; caller can surface if desired
             rows = []
 
         self._populate_results(q, rows)

bouquin/settings_dialog.py

@@ -246,7 +246,7 @@ class SettingsDialog(QDialog):
         )
 
         save_db_config(self._cfg)
-        self.parent().themes.apply(selected_theme)
+        self.parent().themes.set(selected_theme)
         self.accept()
 
     def _change_key(self):

bouquin/theme.py

@@ -49,7 +49,7 @@ class ThemeManager(QObject):
             scheme = getattr(hints, "colorScheme", None)
             if callable(scheme):
                 scheme = hints.colorScheme()
-            # 0=Light, 1=Dark in newer Qt; fall back to Light
+            # 0=Light, 1=Dark; fall back to Light
             theme = Theme.DARK if scheme == 1 else Theme.LIGHT
 
         # Always use Fusion so palette applies consistently cross-platform
@@ -58,7 +58,6 @@ class ThemeManager(QObject):
         if theme == Theme.DARK:
             pal = self._dark_palette()
             self._app.setPalette(pal)
-            # keep stylesheet empty unless you need widget-specific tweaks
             self._app.setStyleSheet("")
         else:
             pal = self._light_palette()

bouquin/toolbar.py

@@ -140,6 +140,11 @@ class ToolBar(QToolBar):
         for a in (self.actAlignL, self.actAlignC, self.actAlignR):
             a.setActionGroup(self.grpAlign)
 
+        self.grpLists = QActionGroup(self)
+        self.grpLists.setExclusive(True)
+        for a in (self.actBullets, self.actNumbers, self.actCheckboxes):
+            a.setActionGroup(self.grpLists)
+
         # Add actions
         self.addActions(
             [

{bouquin-0.1.10.dist-info → bouquin-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.1.10
+Version: 0.1.12
 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
@@ -38,6 +38,8 @@ 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
@@ -51,8 +53,11 @@ There is deliberately no network connectivity or syncing intended.
  * 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, csv or .sql (for sqlite3)
+ * 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
@@ -79,5 +84,5 @@ Make sure you have `libxcb-cursor0` installed (it may be called something else o
  * Clone the repo
  * Ensure you have poetry installed
  * Run `poetry install --with test`
- * Run `poetry run pytest -vvvv --cov=bouquin`
+ * Run `./tests.sh`
 

bouquin-0.1.12.dist-info/RECORD

@@ -0,0 +1,21 @@
+bouquin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+bouquin/db.py,sha256=b39sofZZe4Uw54quYgjcWeF6jNFe0xekBT7fpIP5ySs,16910
+bouquin/editor.py,sha256=62p6yoXsqCdlKiwgatjnD606lpsPbynlcnifT03gHW0,36529
+bouquin/find_bar.py,sha256=RwBbQzfgBXDefpACQoheHH1XJNH-w08Snhk1_o2OmD4,5783
+bouquin/history_dialog.py,sha256=PcbKxR-xXxPryydWK5MRMmOC0Zc8SUcoPSkktMdFuFo,6204
+bouquin/key_prompt.py,sha256=oQhLDOQv1QUr_ImA9Zu78JkDpVqPbZZJdhu0c_5Cq5U,1266
+bouquin/lock_overlay.py,sha256=d1xoBMx2CSNk0zP5V6k65UqJCC4aiIrwNlfDld49ymA,4197
+bouquin/main.py,sha256=lBOMS7THgHb4CAJVj8NRYABtNAEez9jlL0wI1oOtfT4,611
+bouquin/main_window.py,sha256=xJzArxoFBpGshzB0Lgg570YhDSVtCbfnEmm_wr3EFwc,37703
+bouquin/save_dialog.py,sha256=YUkZ8kL1hja15D8qv68yY2zPyjBAJZsDQbp6Y6EvDbA,1023
+bouquin/search.py,sha256=qOPxW8Q8bb6Y0Yf0D0w5wBbPw4wVLvvwrymTeJWEWJc,7027
+bouquin/settings.py,sha256=F3WLkk2G_By3ppZsRbrnq3PtL2Zav7aA-mIegvGTc8Y,1128
+bouquin/settings_dialog.py,sha256=YQHYjn3y2sgJGtkkApADxAodojDfLvnZYeQmynXLkos,10699
+bouquin/theme.py,sha256=6ODq9oKLAk7lnvW9uGRMIIjfhf70SgPivLYh3ZN671M,3489
+bouquin/toolbar.py,sha256=ejjFLZGa5UFldvI01ragkQtA7fTMwYPA3TjRfSZT06A,8301
+bouquin-0.1.12.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+bouquin-0.1.12.dist-info/METADATA,sha256=MyNgd331GomD5IzWWY8oVWbU1Ez08bPSq6XGD4CU6Hw,3064
+bouquin-0.1.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+bouquin-0.1.12.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
+bouquin-0.1.12.dist-info/RECORD,,

bouquin-0.1.10.dist-info/RECORD

@@ -1,20 +0,0 @@
-bouquin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-bouquin/db.py,sha256=Ukh37u397QS_BuH-BJOJUF_F9Q9t3iCOBIf7O4Tqims,17699
-bouquin/editor.py,sha256=IkczFheXi5QMUGWqFpdRD1VQxzKRWAusUZz_sP29vV8,32301
-bouquin/history_dialog.py,sha256=Z3BO60HD-vO9KQ84s0ccpzVWs0X898GzzHfjqARQPqg,6175
-bouquin/key_prompt.py,sha256=N5UxgDDnVAaoAIs9AqoydPSRjJ4Likda4-ejlE-lr-Y,1076
-bouquin/lock_overlay.py,sha256=8Q9NG8ejaGRZ6Tmc5uB6532JWgb3lLO5TQj718CraPA,4052
-bouquin/main.py,sha256=lBOMS7THgHb4CAJVj8NRYABtNAEez9jlL0wI1oOtfT4,611
-bouquin/main_window.py,sha256=am6EksRbExZQjOlyFMK7-TEwf5w2NCtgFhMVGbWXXvw,33853
-bouquin/save_dialog.py,sha256=nPLNWeImJZamNg53qE7_aeMK_p16aOiry0G4VvJsIWY,939
-bouquin/search.py,sha256=6ygbXck21iwA3RUM6yLIuxUr7AsLI4UYOc7H30XwsZw,7099
-bouquin/settings.py,sha256=F3WLkk2G_By3ppZsRbrnq3PtL2Zav7aA-mIegvGTc8Y,1128
-bouquin/settings_dialog.py,sha256=apqCjrvKsZWZrMxDTF0EK-6Dehw6tvUgXdVzmkMxsM0,10701
-bouquin/theme.py,sha256=rjiAJCjoJbKrsDJmbTPxWFLv_WxzPfWJB08bj5cNW7I,3576
-bouquin/toolbar.py,sha256=3FH-hNdOD64C6v78IdFTf4nAdtEdOWnqhMrs4ZYdEow,8099
-bouquin-0.1.10.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-bouquin-0.1.10.dist-info/METADATA,sha256=3C8lmSuzl006oXC7oaCN5_7R0tAu0y5UdbKV3h5aDHo,2848
-bouquin-0.1.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-bouquin-0.1.10.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
-bouquin-0.1.10.dist-info/RECORD,,